restored other files

Author: bewithgaurav

eng/pipelines/test-pipeline.yml

@@ -65,5 +65,5 @@ jobs:
   - task: PublishCodeCoverageResults@1
     inputs:
       codeCoverageTool: 'Cobertura'
-      summaryFileLocation: '$(System.DefaultWorkingDirectory)/**/coverage.xml'
+      summaryFileLocation: 'coverage.xml'
     displayName: 'Publish code coverage results'

main.py

@@ -12,31 +12,10 @@
 
 cursor = conn.cursor()
 cursor.execute("SELECT database_id, name from sys.databases;")
-row = cursor.fetchmany(1)
-print(row)
+rows = cursor.fetchall()
 
-cursor.execute("DROP TABLE IF EXISTS main_single_column")
-
-# cursor.execute("CREATE TABLE main_single_column (float_column FLOAT)")
-# cursor.executemany("INSERT INTO main_single_column (float_column) VALUES (?)", [[12.34], [1.234], [0.125], [0.0125], [0.00125], [23243243232.432432432], [0.247985732852735032750973209750]])
-# cursor.execute("SELECT * FROM main_single_column")
-# row = cursor.fetchall()
-# print(row)
-# print(len(row))
-
-import time
-cursor.execute("CREATE TABLE main_single_column (decimal_column NUMERIC(10, 4))")
-# time.sleep(45)
-
-cursor.execute("INSERT INTO main_single_column (decimal_column) VALUES (?)", [decimal.Decimal(123.45).quantize(decimal.Decimal('0.00'))])
-cursor.execute("SELECT * FROM main_single_column")
-row = cursor.fetchone()[0]
-
-print(row)
-print(row.val)
-print(row.precision)
-print(row.scale)
-print(row.sign)
+for row in rows:
+    print(f"Database ID: {row[0]}, Name: {row[1]}")
 
 cursor.close()
 conn.close()

mssql_python/connection.py

@@ -53,8 +53,8 @@ def __init__(self, connection_str: str, autocommit: bool = False, **kwargs) -> N
         preparing it for further operations such as connecting to the 
         database, executing queries, etc.
         """
-        self.henv = ctypes.c_void_p()
-        self.hdbc = ctypes.c_void_p()
+        self.henv = None
+        self.hdbc = None
         self.connection_str = self._construct_connection_string(
             connection_str, **kwargs
         )
@@ -95,6 +95,15 @@ def _construct_connection_string(self, connection_str: str, **kwargs) -> str:
             conn_str += f"{key}={value};"
         return conn_str
 
+    def _is_closed(self) -> bool:
+        """
+        Check if the connection is closed.
+
+        Returns:
+            bool: True if the connection is closed, False otherwise.
+        """
+        return self.hdbc is None
+
     def _initializer(self) -> None:
         """
         Initialize the environment and connection handles.
@@ -113,52 +122,48 @@ def _allocate_environment_handle(self):
         """
         Allocate the environment handle.
         """
-        ret = ddbc_bindings.DDBCSQLAllocHandle(
+        ret, handle = ddbc_bindings.DDBCSQLAllocHandle(
             ddbc_sql_const.SQL_HANDLE_ENV.value,  # SQL environment handle type
-            0,  # SQL input handle
-            ctypes.cast(
-                ctypes.pointer(self.henv), ctypes.c_void_p
-            ).value,  # SQL output handle pointer
+            None
         )
-        check_error(ddbc_sql_const.SQL_HANDLE_ENV.value, self.henv.value, ret)
+        check_error(ddbc_sql_const.SQL_HANDLE_ENV.value, handle, ret)
+        self.henv = handle
 
     def _set_environment_attributes(self):
         """
         Set the environment attributes.
         """
         ret = ddbc_bindings.DDBCSQLSetEnvAttr(
-            self.henv.value,  # Environment handle
+            self.henv,  # Use the wrapper class
             ddbc_sql_const.SQL_ATTR_DDBC_VERSION.value,  # Attribute
             ddbc_sql_const.SQL_OV_DDBC3_80.value,  # String Length
             0,  # Null-terminated string
         )
-        check_error(ddbc_sql_const.SQL_HANDLE_ENV.value, self.henv.value, ret)
+        check_error(ddbc_sql_const.SQL_HANDLE_ENV.value, self.henv, ret)
 
     def _allocate_connection_handle(self):
         """
         Allocate the connection handle.
         """
-        ret = ddbc_bindings.DDBCSQLAllocHandle(
+        ret, handle = ddbc_bindings.DDBCSQLAllocHandle(
             ddbc_sql_const.SQL_HANDLE_DBC.value,  # SQL connection handle type
-            self.henv.value,  # SQL environment handle
-            ctypes.cast(
-                ctypes.pointer(self.hdbc), ctypes.c_void_p
-            ).value,  # SQL output handle pointer
+            self.henv
         )
-        check_error(ddbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc.value, ret)
+        check_error(ddbc_sql_const.SQL_HANDLE_DBC.value, handle, ret)
+        self.hdbc = handle
 
     def _set_connection_attributes(self):
         """
         Set the connection attributes before connecting.
         """
         if self.autocommit:
             ret = ddbc_bindings.DDBCSQLSetConnectAttr(
-                self.hdbc.value,
+                self.hdbc,  # Using the wrapper class
                 ddbc_sql_const.SQL_ATTR_AUTOCOMMIT.value,
                 ddbc_sql_const.SQL_AUTOCOMMIT_ON.value,
-                0,
+                0
             )
-            check_error(ddbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc.value, ret)
+            check_error(ddbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc, ret)
 
     def _connect_to_db(self) -> None:
         """
@@ -176,11 +181,11 @@ def _connect_to_db(self) -> None:
         if ENABLE_LOGGING:
             logger.info("Connecting to the database")
         ret = ddbc_bindings.DDBCSQLDriverConnect(
-            self.hdbc.value,  # Connection handle
+            self.hdbc,  # Connection handle (wrapper)
             0,  # Window handle
             self.connection_str,  # Connection string
         )
-        check_error(ddbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc.value, ret)
+        check_error(ddbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc, ret)
         if ENABLE_LOGGING:
             logger.info("Connection established successfully.")
 
@@ -192,11 +197,11 @@ def autocommit(self) -> bool:
             bool: True if autocommit is enabled, False otherwise.
         """
         autocommit_mode = ddbc_bindings.DDBCSQLGetConnectionAttr(
-            self.hdbc.value,  # Connection handle
+            self.hdbc,  # Connection handle (wrapper)
             ddbc_sql_const.SQL_ATTR_AUTOCOMMIT.value,  # Attribute
         )
         check_error(
-            ddbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc.value, autocommit_mode
+            ddbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc, autocommit_mode
         )
         return autocommit_mode == ddbc_sql_const.SQL_AUTOCOMMIT_ON.value
 
@@ -212,7 +217,7 @@ def autocommit(self, value: bool) -> None:
             DatabaseError: If there is an error while setting the autocommit mode.
         """
         ret = ddbc_bindings.DDBCSQLSetConnectAttr(
-            self.hdbc.value,  # Connection handle
+            self.hdbc,  # Connection handle
             ddbc_sql_const.SQL_ATTR_AUTOCOMMIT.value,  # Attribute
             (
                 ddbc_sql_const.SQL_AUTOCOMMIT_ON.value
@@ -221,7 +226,7 @@ def autocommit(self, value: bool) -> None:
             ),  # Value
             0,  # String length
         )
-        check_error(ddbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc.value, ret)
+        check_error(ddbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc, ret)
         self._autocommit = value
         if ENABLE_LOGGING:
             logger.info("Autocommit mode set to %s.", value)
@@ -253,6 +258,9 @@ def cursor(self) -> Cursor:
             DatabaseError: If there is an error while creating the cursor.
             InterfaceError: If there is an error related to the database interface.
         """
+        if self._is_closed():
+            # Cannot create a cursor if the connection is closed
+            raise Exception("Connection is closed. Cannot create cursor.")
         return Cursor(self)
 
     def commit(self) -> None:
@@ -267,13 +275,17 @@ def commit(self) -> None:
         Raises:
             DatabaseError: If there is an error while committing the transaction.
         """
+        if self._is_closed():
+            # Cannot commit if the connection is closed
+            raise Exception("Connection is closed. Cannot commit.")
+
         # Commit the current transaction
         ret = ddbc_bindings.DDBCSQLEndTran(
             ddbc_sql_const.SQL_HANDLE_DBC.value,  # Handle type
-            self.hdbc.value,  # Connection handle
+            self.hdbc,  # Connection handle (wrapper)
             ddbc_sql_const.SQL_COMMIT.value,  # Commit the transaction
         )
-        check_error(ddbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc.value, ret)
+        check_error(ddbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc, ret)
         if ENABLE_LOGGING:
             logger.info("Transaction committed successfully.")
 
@@ -288,13 +300,17 @@ def rollback(self) -> None:
         Raises:
             DatabaseError: If there is an error while rolling back the transaction.
         """
+        if self._is_closed():
+            # Cannot roll back if the connection is closed
+            raise Exception("Connection is closed. Cannot roll back.")
+
         # Roll back the current transaction
         ret = ddbc_bindings.DDBCSQLEndTran(
             ddbc_sql_const.SQL_HANDLE_DBC.value,  # Handle type
-            self.hdbc.value,  # Connection handle
+            self.hdbc,  # Connection handle (wrapper)
             ddbc_sql_const.SQL_ROLLBACK.value,  # Roll back the transaction
         )
-        check_error(ddbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc.value, ret)
+        check_error(ddbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc, ret)
         if ENABLE_LOGGING:
             logger.info("Transaction rolled back successfully.")
 
@@ -311,15 +327,16 @@ def close(self) -> None:
         Raises:
             DatabaseError: If there is an error while closing the connection.
         """
+        if self._is_closed():
+            # Connection is already closed
+            return
         # Disconnect from the database
-        ret = ddbc_bindings.DDBCSQLDisconnect(self.hdbc.value)
-        check_error(ddbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc.value, ret)
+        ret = ddbc_bindings.DDBCSQLDisconnect(self.hdbc)
+        check_error(ddbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc, ret)
 
-        # Free the connection handle
-        ret = ddbc_bindings.DDBCSQLFreeHandle(
-            ddbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc.value
-        )
-        check_error(ddbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc.value, ret)
+        # Set the reference to None to trigger destructor
+        self.hdbc.free()
+        self.hdbc = None
 
         if ENABLE_LOGGING:
             logger.info("Connection closed successfully.")