Merge branch 'main' of https://github.com/microsoft/mssql-python into bewithgaurav/universal_codecov

Author: bewithgaurav

PyPI_Description.md

@@ -39,20 +39,15 @@ PyBind11 provides:
 
 We are currently in **Public Preview**.
 
-## What's new in v0.10.0
-
-- **SUSE Linux Support:** Added full support for SUSE and openSUSE distributions alongside existing other Linux distros support, broadening enterprise Linux compatibility.
-- **Context Manager Support:** Implemented Python `with` statement support for Connection and Cursor classes with automatic transaction management and resource cleanup.
-- **Large Text Streaming:** Added Data At Execution (DAE) support for streaming large text parameters (`NVARCHAR(MAX)`, `VARCHAR(MAX)`), eliminating memory constraints for bulk text `execute()` operations.
-  - `VARBINARY(MAX)` support to follow alongwith streaming support for fetch operations.
-- **Enhanced Unicode Handling:** Improved emoji and international character support with robust UTF-16 encoding for reliable multilingual data processing.
-- **PyODBC Compatibility:** Enhanced API compatibility with pyodbc including:
-  - DB-API 2.0 exception classes: `Warning`, `Error`, `InterfaceError`, `DatabaseError`, `DataError`, `OperationalError`, `IntegrityError`, `InternalError`, `ProgrammingError`, `NotSupportedError`
-  - Context manager support with `with` statements for Connection and Cursor
-  - Encoding configuration APIs: `setencoding()`, `getencoding()`, `setdecoding()`, `getdecoding()`
-  - Cursor navigation APIs: `next()`, `__iter__()`, `scroll()`, `skip()`, `fetchval()`
-  - Cursor attributes: `rownumber`, `messages`
-  - Additional methods: `cursor.commit()`, `cursor.rollback()`, `table()`
+## What's new in v0.11.0
+
+- **Database Metadata & Introspection:** Added comprehensive `getInfo()` method and extensive catalog APIs (`SQLGetTypeInfo`, `SQLProcedures`, `SQLForeignKeys`, `SQLColumns`) for complete database schema discovery and introspection capabilities.
+- **Advanced Parameter Management:** Implemented `setinputsizes()` with SQL type constants and enhanced parameter validation through the `SQLTypes` class for precise type control in parameterized queries.
+- **Large Data Streaming Enhancements:** Extended streaming support to VARBINARY(MAX) and VARCHAR(MAX) across all fetch operations (`fetchone`, `fetchmany`, `fetchall`) with improved chunked retrieval for efficient memory usage.
+- **Output Data Conversion System:** Introduced flexible output converter framework with `add_output_converter()`, `remove_output_converter()`, and related methods for customizable data transformations during result fetching.
+- **Connection-Level Execute:** Added direct `execute()` method to Connection class for streamlined query execution without explicit cursor management.
+- **Financial Data Type Support:** Comprehensive support for SQL Server MONEY and SMALLMONEY types with proper boundary value handling and decimal precision.
+- **Enhanced Configuration APIs:** Added connection timeout control, decimal separator configuration (`getDecimalSeperator()`, `setDecimalSeperator()`), and improved global variable management.
 
 For more information, please visit the project link on Github: https://github.com/microsoft/mssql-python
 

mssql_python/__init__.py

@@ -180,3 +180,28 @@ def _custom_setattr(name, value):
 
 # Replace the module's __setattr__ with our custom version
 sys.modules[__name__].__setattr__ = _custom_setattr
+
+
+# Export SQL constants at module level
+SQL_CHAR = ConstantsDDBC.SQL_CHAR.value
+SQL_VARCHAR = ConstantsDDBC.SQL_VARCHAR.value
+SQL_LONGVARCHAR = ConstantsDDBC.SQL_LONGVARCHAR.value
+SQL_WCHAR = ConstantsDDBC.SQL_WCHAR.value
+SQL_WVARCHAR = ConstantsDDBC.SQL_WVARCHAR.value
+SQL_WLONGVARCHAR = ConstantsDDBC.SQL_WLONGVARCHAR.value
+SQL_DECIMAL = ConstantsDDBC.SQL_DECIMAL.value
+SQL_NUMERIC = ConstantsDDBC.SQL_NUMERIC.value
+SQL_BIT = ConstantsDDBC.SQL_BIT.value
+SQL_TINYINT = ConstantsDDBC.SQL_TINYINT.value
+SQL_SMALLINT = ConstantsDDBC.SQL_SMALLINT.value
+SQL_INTEGER = ConstantsDDBC.SQL_INTEGER.value
+SQL_BIGINT = ConstantsDDBC.SQL_BIGINT.value
+SQL_REAL = ConstantsDDBC.SQL_REAL.value
+SQL_FLOAT = ConstantsDDBC.SQL_FLOAT.value
+SQL_DOUBLE = ConstantsDDBC.SQL_DOUBLE.value
+SQL_BINARY = ConstantsDDBC.SQL_BINARY.value
+SQL_VARBINARY = ConstantsDDBC.SQL_VARBINARY.value
+SQL_LONGVARBINARY = ConstantsDDBC.SQL_LONGVARBINARY.value
+SQL_DATE = ConstantsDDBC.SQL_DATE.value
+SQL_TIME = ConstantsDDBC.SQL_TIME.value
+SQL_TIMESTAMP = ConstantsDDBC.SQL_TIMESTAMP.value

mssql_python/connection.py

@@ -66,6 +66,7 @@ def _validate_encoding(encoding: str) -> bool:
     ProgrammingError,
     NotSupportedError,
 )
+from mssql_python.constants import GetInfoConstants
 
 
 class Connection:
@@ -121,7 +122,7 @@ class Connection:
     ProgrammingError = ProgrammingError
     NotSupportedError = NotSupportedError
 
-    def __init__(self, connection_str: str = "", autocommit: bool = False, attrs_before: dict = None, **kwargs) -> None:
+    def __init__(self, connection_str: str = "", autocommit: bool = False, attrs_before: dict = None, timeout: int = 0, **kwargs) -> None:
         """
         Initialize the connection object with the specified connection string and parameters.
 
@@ -180,6 +181,7 @@ def __init__(self, connection_str: str = "", autocommit: bool = False, attrs_bef
                 self._attrs_before.update(connection_result[1])
 
         self._closed = False
+        self._timeout = timeout
 
         # Using WeakSet which automatically removes cursors when they are no longer in use
         # It is a set that holds weak references to its elements.
@@ -236,6 +238,39 @@ def _construct_connection_string(self, connection_str: str = "", **kwargs) -> st
 
         return conn_str
 
+    @property
+    def timeout(self) -> int:
+        """
+        Get the current query timeout setting in seconds.
+        
+        Returns:
+            int: The timeout value in seconds. Zero means no timeout (wait indefinitely).
+        """
+        return self._timeout
+    
+    @timeout.setter
+    def timeout(self, value: int) -> None:
+        """
+        Set the query timeout for all operations performed by this connection.
+        
+        Args:
+            value (int): The timeout value in seconds. Zero means no timeout.
+            
+        Returns:
+            None
+            
+        Note:
+            This timeout applies to all cursors created from this connection.
+            It cannot be changed for individual cursors or SQL statements.
+            If a query timeout occurs, an OperationalError exception will be raised.
+        """
+        if not isinstance(value, int):
+            raise TypeError("Timeout must be an integer")
+        if value < 0:
+            raise ValueError("Timeout cannot be negative")
+        self._timeout = value
+        log('info', f"Query timeout set to {value} seconds")
+
     @property
     def autocommit(self) -> bool:
         """
@@ -510,6 +545,30 @@ def getdecoding(self, sqltype):
 
         return self._decoding_settings[sqltype].copy()
 
+    @property
+    def searchescape(self):
+        """
+        The ODBC search pattern escape character, as returned by 
+        SQLGetInfo(SQL_SEARCH_PATTERN_ESCAPE), used to escape special characters 
+        such as '%' and '_' in LIKE clauses. These are driver specific.
+        
+        Returns:
+            str: The search pattern escape character (usually '\' or another character)
+        """
+        if not hasattr(self, '_searchescape'):
+            try:
+                escape_char = self.getinfo(GetInfoConstants.SQL_SEARCH_PATTERN_ESCAPE.value)
+                # Some drivers might return this as an integer memory address
+                # or other non-string format, so ensure we have a string
+                if not isinstance(escape_char, str):
+                    escape_char = '\\'  # Default to backslash if not a string
+                self._searchescape = escape_char
+            except Exception as e:
+                # Log the exception for debugging, but do not expose sensitive info
+                log('warning', f"Failed to retrieve search escape character, using default '\\'. Exception: {type(e).__name__}")
+                self._searchescape = '\\'
+        return self._searchescape
+
     def cursor(self) -> Cursor:
         """
         Return a new Cursor object using the connection.
@@ -533,7 +592,7 @@ def cursor(self) -> Cursor:
                 ddbc_error="Cannot create cursor on closed connection",
             )
 
-        cursor = Cursor(self)
+        cursor = Cursor(self, timeout=self._timeout)
         self._cursors.add(cursor)  # Track the cursor
         return cursor
 
@@ -790,6 +849,30 @@ def batch_execute(self, statements, params=None, reuse_cursor=None, auto_close=F
             log('debug', "Automatically closed cursor after batch execution")
 
         return results, cursor
+    
+    def getinfo(self, info_type):
+        """
+        Return general information about the driver and data source.
+        
+        Args:
+            info_type (int): The type of information to return. See the ODBC
+                             SQLGetInfo documentation for the supported values.
+        
+        Returns:
+            The requested information. The type of the returned value depends
+            on the information requested. It will be a string, integer, or boolean.
+        
+        Raises:
+            DatabaseError: If there is an error retrieving the information.
+            InterfaceError: If the connection is closed.
+        """
+        if self._closed:
+            raise InterfaceError(
+                driver_error="Cannot get info on closed connection",
+                ddbc_error="Cannot get info on closed connection",
+            )
+        
+        return self._conn.get_info(info_type)
 
     def commit(self) -> None:
         """