Merged PR 5238: Feat: Connection properties

#### AI description  (iteration 1)
#### PR Classification
New feature

#### PR Summary
This pull request adds new connection properties to the `Connection` class and updates the `connect` function to support these properties.
- `mssql_python/connection.py`: Added new parameters to the `Connection` class constructor and implemented methods to handle these parameters.
- `mssql_python/db_connection.py`: Updated the `connect` function to accept and pass new connection parameters.
- `mssql_python/constants.py`: Added new ODBC constants for connection attributes.
- `README.md`: Removed outdated build status badges.

Related work items: #33534

Author: bewithgaurav

README.md

@@ -1,6 +1,6 @@
 # MSSQL-Python
 
-This repository contains the source code for the MSSQL-Python project, which provides Python bindings for the Microsoft SQL Server ODBC driver using `pybind11`. The project includes a C++ extension module that wraps the ODBC API and exposes it to Python, allowing for efficient database interactions.
+This repository contains the source code for the MSSQL-Python project, which provides Python bindings for the Microsoft SQL Server driver using `pybind11`. The project includes a C++ extension module that wraps the DDBC API and exposes it to Python, allowing for efficient database interactions.
 
 ## Build Status (`main`)
 

mssql_python/connection.py

@@ -26,45 +26,81 @@ class Connection:
         close() -> None:
     """
 
-    def __init__(self, connection_str: str, autocommit: bool = True) -> None:
+    def __init__(self, connection_str: str, autocommit: bool = False, **kwargs) -> None:
         """
-        Initialize the connection object with the specified connection string.
+        Initialize the connection object with the specified connection string and parameters.
 
         Args:
-            connection_str (str): The connection_str to connect to.
-
+            - connection_str (str): The connection string to connect to.
+            - autocommit (bool): If True, causes a commit to be performed after each SQL statement.
+            **kwargs: Additional key/value pairs for the connection string.
+            Not including below properties since we are driver doesn't support this:
+            
         Returns:
             None
 
         Raises:
-            ValueError: If the connection_str is invalid or connection fails.
+            ValueError: If the connection string is invalid or connection fails.
 
         This method sets up the initial state for the connection object, 
         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.connection_str = add_driver_to_connection_str(connection_str)
+        self.connection_str = self._construct_connection_string(connection_str, **kwargs)
         self._initializer()
         self._autocommit = autocommit
         self.setautocommit(autocommit)
 
+    def _construct_connection_string(self, connection_str: str, **kwargs) -> str:
+        """
+        Construct the connection string by concatenating the connection string with key/value pairs from kwargs.
+
+        Args:
+            connection_str (str): The base connection string.
+            **kwargs: Additional key/value pairs for the connection string.
+
+        Returns:
+            str: The constructed connection string.
+        """
+        # Add the driver attribute to the connection string
+        conn_str = add_driver_to_connection_str(connection_str)
+        # Add additional key-value pairs to the connection string
+        for key, value in kwargs.items():
+            if key.lower() == "host":
+                key = "Server"
+            elif key.lower() == "user":
+                key = "Uid"
+            elif key.lower() == "password":
+                key = "Pwd"
+            elif key.lower() == "database":
+                key = "Database"
+            elif key.lower() == "encrypt":
+                key = "Encrypt"
+            elif key.lower() == "trust_server_certificate":
+                key = "TrustServerCertificate"
+            else:
+                continue
+            conn_str += f"{key}={value};"
+        return conn_str
+
     def _initializer(self) -> None:
         """
-        Initialize the ODBC environment and connection handles.
+        Initialize the environment and connection handles.
 
-        This method is responsible for setting up the ODBC environment and connection
+        This method is responsible for setting up the environment and connection
         handles, allocating memory for them, and setting the necessary attributes.
         It should be called before establishing a connection to the database.
         """
         self._allocate_environment_handle()
         self._set_environment_attributes()
         self._allocate_connection_handle()
+        self._set_connection_attributes()
         self._connect_to_db()
 
     def _allocate_environment_handle(self):
         """
-        Allocate the ODBC environment handle.
+        Allocate the environment handle.
         """
         ret = ddbc_bindings.DDBCSQLAllocHandle(
             odbc_sql_const.SQL_HANDLE_ENV.value, #SQL environment handle type
@@ -75,7 +111,7 @@ def _allocate_environment_handle(self):
 
     def _set_environment_attributes(self):
         """
-        Set the ODBC environment attributes.
+        Set the environment attributes.
         """
         ret = ddbc_bindings.DDBCSQLSetEnvAttr(
             self.henv.value,  # Environment handle
@@ -87,7 +123,7 @@ def _set_environment_attributes(self):
 
     def _allocate_connection_handle(self):
         """
-        Allocate the ODBC connection handle.
+        Allocate the connection handle.
         """
         ret = ddbc_bindings.DDBCSQLAllocHandle(
             odbc_sql_const.SQL_HANDLE_DBC.value, # SQL connection handle type
@@ -96,6 +132,19 @@ def _allocate_connection_handle(self):
         )
         check_error(odbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc.value, ret)
 
+    def _set_connection_attributes(self):
+        """
+        Set the connection attributes before connecting.
+        """
+        if self.autocommit:
+            ret = ddbc_bindings.DDBCSQLSetConnectAttr(
+                self.hdbc.value,
+                odbc_sql_const.SQL_ATTR_AUTOCOMMIT.value,
+                odbc_sql_const.SQL_AUTOCOMMIT_ON.value,
+                0
+            )
+            check_error(odbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc.value, ret)
+
     def _connect_to_db(self) -> None:
         """
         Establish a connection to the database.
@@ -133,8 +182,9 @@ def autocommit(self) -> bool:
         )
         check_error(odbc_sql_const.SQL_HANDLE_DBC.value, self.hdbc.value, autocommit_mode)
         return autocommit_mode == odbc_sql_const.SQL_AUTOCOMMIT_ON.value
-        
-    def setautocommit(self, value: bool) -> None:
+
+    @autocommit.setter
+    def autocommit(self, value: bool) -> None:
         """
         Set the autocommit mode of the connection.
         Args:
@@ -155,6 +205,18 @@ def setautocommit(self, value: bool) -> None:
         if ENABLE_LOGGING:
             logger.info("Autocommit mode set to %s.", value)
 
+    def setautocommit(self, value: bool = True) -> None:
+        """
+        Set the autocommit mode of the connection.
+        Args:
+            value (bool): True to enable autocommit, False to disable it.
+        Returns:
+            None
+        Raises:
+            DatabaseError: If there is an error while setting the autocommit mode.
+        """
+        self.autocommit = value
+
     def cursor(self) -> Cursor:
         """
         Return a new Cursor object using the connection.

mssql_python/constants.py

@@ -17,13 +17,13 @@ class ConstantsODBC(Enum):
     SQL_ATTR_ODBC_VERSION = 200
     SQL_ATTR_ASYNC_ENABLE = 4
     SQL_ATTR_ASYNC_STMT_EVENT = 29
-    SQL_ATTR_AUTOCOMMIT = 102
     SQL_ERROR = -1
     SQL_INVALID_HANDLE = -2
     SQL_NULL_HANDLE = 0
     SQL_OV_ODBC3 = 3
     SQL_COMMIT = 0
     SQL_ROLLBACK = 1
+    SQL_ATTR_AUTOCOMMIT = 102
     SQL_SMALLINT = 5
     SQL_CHAR = 1
     SQL_WCHAR = -8

mssql_python/db_connection.py

@@ -1,12 +1,22 @@
 from mssql_python.exceptions import DatabaseError, InterfaceError
 from mssql_python.connection import Connection
 
-def connect(connection_str: str) -> Connection:
+def connect(connection_str: str, autocommit: bool = True, **kwargs) -> Connection:
     """
     Constructor for creating a connection to the database.
 
     Args:
-        connection_str (str): The connection_str to connect to.
+        connection_str (str): The connection string to connect to.
+        autocommit (bool): If True, causes a commit to be performed after each SQL statement.
+    TODO: Add the following parameters to the function signature:
+        timeout (int): The timeout for the connection attempt, in seconds.
+        readonly (bool): If True, the connection is set to read-only.
+        attrs_before (dict): A dictionary of connection attributes to set before connecting.
+    Keyword Args:
+        **kwargs: Additional key/value pairs for the connection string.
+    Below attributes are not implemented in the internal driver:
+    - encoding (str): The encoding for the connection string.
+    - ansi (bool): If True, indicates the driver does not support Unicode.
 
     Returns:
         Connection: A new connection object to interact with the database.
@@ -19,5 +29,9 @@ def connect(connection_str: str) -> Connection:
     be used to perform database operations such as executing queries, committing
     transactions, and closing the connection.
     """
-    conn = Connection(connection_str)
-    return conn
+    conn = Connection(
+        connection_str, 
+        autocommit=autocommit,
+        **kwargs
+    )
+    return conn

mssql_python/error_handling.py

@@ -1,4 +1,3 @@
-from mssql_python.constants import ConstantsODBC
 from mssql_python import ddbc_bindings
 from mssql_python.exceptions import raise_exception
 from mssql_python.logging_config import get_logger, ENABLE_LOGGING

mssql_python/helpers.py

@@ -30,27 +30,65 @@ def test_connection(db_connection):
     cursor = db_connection.cursor()
     assert cursor is not None, "Database connection failed - Cursor cannot be None"
 
+
+def test_construct_connection_string(db_connection):
+    # Check if the connection string is constructed correctly with kwargs
+    conn_str = db_connection._construct_connection_string("",host="localhost", user="me", password="mypwd", database="mydb", encrypt="yes", trust_server_certificate="yes")
+    assert "Server=localhost;" in conn_str, "Connection string should contain 'Server=localhost;'"
+    assert "Uid=me;" in conn_str, "Connection string should contain 'Uid=me;'"
+    assert "Pwd=mypwd;" in conn_str, "Connection string should contain 'Pwd=mypwd;'"
+    assert "Database=mydb;" in conn_str, "Connection string should contain 'Database=mydb;'"
+    assert "Encrypt=yes;" in conn_str, "Connection string should contain 'Encrypt=yes;'"
+    assert "TrustServerCertificate=yes;" in conn_str, "Connection string should contain 'TrustServerCertificate=yes;'"
+    assert "APP=MSSQL-Python" in conn_str, "Connection string should contain 'APP=MSSQL-Python'"
+    assert "Driver={ODBC Driver 18 for SQL Server}" in conn_str, "Connection string should contain 'Driver={ODBC Driver 18 for SQL Server}'"
+    assert "Driver={ODBC Driver 18 for SQL Server};;APP=MSSQL-Python;Server=localhost;Uid=me;Pwd=mypwd;Database=mydb;Encrypt=yes;TrustServerCertificate=yes;" == conn_str, "Connection string is incorrect"
+
 def test_autocommit_default(db_connection):
     assert db_connection.autocommit is True, "Autocommit should be True by default"
 
-# def test_autocommit_property(db_connection):
-#     db_connection.autocommit = True
-#     assert db_connection.autocommit is True, "Autocommit should be True"
-#     # Create a new cursor to check if the autocommit property is set in the server
-#     cursor = db_connection.cursor()
-#     cursor.execute("DBCC USEROPTIONS;")
-#     result = cursor.fetchall()
-#     implicit_transactions_status = any(option[0] == 'implicit_transactions' and option[1] == 'SET' for option in result)
-#     assert not implicit_transactions_status, "Autocommit failed: Implicit transactions should be off"
-
-#     db_connection.autocommit = False
-#     assert db_connection.autocommit is False, "Autocommit should be False"
-#     cursor.execute("DBCC USEROPTIONS;")
-#     result = cursor.fetchall()
-#     implicit_transactions_status = any(option[0] == 'implicit_transactions' and option[1] == 'SET' for option in result)
-#     assert implicit_transactions_status, "Autocommit failed: Implicit transactions should be on"
+def test_autocommit_setter(db_connection):
+    db_connection.autocommit = True
+    cursor = db_connection.cursor()
+    # Make a transaction and check if it is autocommited
+    drop_table_if_exists(cursor, "pytest_test_autocommit")
+    try:
+        cursor.execute("CREATE TABLE pytest_test_autocommit (id INT PRIMARY KEY, value VARCHAR(50));")
+        cursor.execute("INSERT INTO pytest_test_autocommit (id, value) VALUES (1, 'test');")
+        cursor.execute("SELECT * FROM pytest_test_autocommit WHERE id = 1;")
+        result = cursor.fetchone()
+        assert result is not None, "Autocommit failed: No data found"
+        assert result[1] == 'test', "Autocommit failed: Incorrect data"
+    except Exception as e:
+        pytest.fail(f"Autocommit failed: {e}")
+    finally:
+        cursor.execute("DROP TABLE pytest_test_autocommit;")
+        db_connection.commit()
+    assert db_connection.autocommit is True, "Autocommit should be True"
+    
+    db_connection.autocommit = False
+    cursor = db_connection.cursor()
+    # Make a transaction and check if it is not autocommited
+    drop_table_if_exists(cursor, "pytest_test_autocommit")
+    try:
+        cursor.execute("CREATE TABLE pytest_test_autocommit (id INT PRIMARY KEY, value VARCHAR(50));")
+        cursor.execute("INSERT INTO pytest_test_autocommit (id, value) VALUES (1, 'test');")
+        cursor.execute("SELECT * FROM pytest_test_autocommit WHERE id = 1;")
+        result = cursor.fetchone()
+        assert result is not None, "Autocommit failed: No data found"
+        assert result[1] == 'test', "Autocommit failed: Incorrect data"
+        db_connection.commit()
+        cursor.execute("SELECT * FROM pytest_test_autocommit WHERE id = 1;")
+        result = cursor.fetchone()
+        assert result is not None, "Autocommit failed: No data found after commit"
+        assert result[1] == 'test', "Autocommit failed: Incorrect data after commit"
+    except Exception as e:
+        pytest.fail(f"Autocommit failed: {e}")
+    finally:
+        cursor.execute("DROP TABLE pytest_test_autocommit;")
+        db_connection.commit()
 
-def test_set_autcommit(db_connection):
+def test_set_autocommit(db_connection):
     db_connection.setautocommit(True)
     assert db_connection.autocommit is True, "Autocommit should be True"
     db_connection.setautocommit(False)