FEAT: Perf Improvement

benchmarks/perf-benchmarking.py

@@ -32,6 +32,7 @@
 if not CONN_STR:
     print("Error: The environment variable DB_CONNECTION_STRING is not set. Please set it to a valid SQL Server connection string and try again.")
     sys.exit(1)
+
 # Ensure pyodbc connection string has ODBC driver specified
 if CONN_STR and 'Driver=' not in CONN_STR:
     CONN_STR = f"Driver={{ODBC Driver 18 for SQL Server}};{CONN_STR}"

mssql_python/__init__.py

@@ -12,6 +12,8 @@
 
 # Exceptions
 # https://www.python.org/dev/peps/pep-0249/#exceptions
+
+# Import necessary modules
 from .exceptions import (
     Warning,
     Error,
@@ -175,6 +177,19 @@ def pooling(max_size: int = 100, idle_timeout: int = 600, enabled: bool = True)
 
 _original_module_setattr = sys.modules[__name__].__setattr__
 
+def _custom_setattr(name, value):
+    if name == 'lowercase':
+        with _settings_lock:
+            _settings.lowercase = bool(value)
+            # Update the module's lowercase variable
+            _original_module_setattr(name, _settings.lowercase)
+    else:
+        _original_module_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_VARCHAR: int = ConstantsDDBC.SQL_VARCHAR.value
 SQL_LONGVARCHAR: int = ConstantsDDBC.SQL_LONGVARCHAR.value
@@ -281,4 +296,4 @@ def lowercase(self, value: bool) -> None:
 sys.modules[__name__] = new_module
 
 # Initialize property values
-lowercase: bool = _settings.lowercase
+lowercase: bool = _settings.lowercase

mssql_python/cursor.py

@@ -121,18 +121,14 @@ def __init__(self, connection: "Connection", timeout: int = 0) -> None:
         # Therefore, it must be a list with exactly one bool element.
 
         # rownumber attribute
-        self._rownumber: int = (
-            -1
-        )  # DB-API extension: last returned row index, -1 before first
-        self._next_row_index: int = (
-            0  # internal: index of the next row the driver will return (0-based)
-        )
-        self._has_result_set: bool = False  # Track if we have an active result set
-        self._skip_increment_for_next_fetch: bool = (
-            False  # Track if we need to skip incrementing the row index
-        )
-
-        self.messages: List[str] = []  # Store diagnostic messages
+        self._rownumber = -1  # DB-API extension: last returned row index, -1 before first
+
+        self._cached_column_map = None
+        self._cached_converter_map = None
+        self._next_row_index = 0  # internal: index of the next row the driver will return (0-based)
+        self._has_result_set = False  # Track if we have an active result set
+        self._skip_increment_for_next_fetch = False  # Track if we need to skip incrementing the row index
+        self.messages = []  # Store diagnostic messages
 
     def _is_unicode_string(self, param: str) -> bool:
         """
@@ -823,7 +819,57 @@ def _initialize_description(self, column_metadata: Optional[Any] = None) -> None
             )
         self.description = description
 
-    def _map_data_type(self, sql_type: int) -> type:
+    def _build_converter_map(self):
+        """
+        Build a pre-computed converter map for output converters.
+        Returns a list where each element is either a converter function or None.
+        This eliminates the need to look up converters for every row.
+        """
+        if not self.description or not hasattr(self.connection, '_output_converters') or not self.connection._output_converters:
+            return None
+
+        converter_map = []
+
+        for desc in self.description:
+            if desc is None:
+                converter_map.append(None)
+                continue
+            sql_type = desc[1]
+            converter = self.connection.get_output_converter(sql_type)
+            # If no converter found for the SQL type, try the WVARCHAR converter as a fallback
+            if converter is None:
+                from mssql_python.constants import ConstantsDDBC
+                converter = self.connection.get_output_converter(ConstantsDDBC.SQL_WVARCHAR.value)
+
+            converter_map.append(converter)
+
+        return converter_map
+
+    def _get_column_and_converter_maps(self):
+        """
+        Get column map and converter map for Row construction (thread-safe).
+        This centralizes the column map building logic to eliminate duplication
+        and ensure thread-safe lazy initialization.
+
+        Returns:
+            tuple: (column_map, converter_map)
+        """
+        # Thread-safe lazy initialization of column map
+        column_map = self._cached_column_map
+        if column_map is None and self.description:
+            # Build column map locally first, then assign to cache
+            column_map = {col_desc[0]: i for i, col_desc in enumerate(self.description)}
+            self._cached_column_map = column_map
+
+        # Fallback to legacy column name map if no cached map
+        column_map = column_map or getattr(self, '_column_name_map', None)
+
+        # Get cached converter map
+        converter_map = getattr(self, '_cached_converter_map', None)
+
+        return column_map, converter_map
+
+    def _map_data_type(self, sql_type):
         """
         Map SQL data type to Python data type.
 
@@ -1135,9 +1181,14 @@ def execute(  # pylint: disable=too-many-locals,too-many-branches,too-many-state
         if self.description:  # If we have column descriptions, it's likely a SELECT
             self.rowcount = -1
             self._reset_rownumber()
+            # Pre-build column map and converter map
+            self._cached_column_map = {col_desc[0]: i for i, col_desc in enumerate(self.description)}
+            self._cached_converter_map = self._build_converter_map()
         else:
             self.rowcount = ddbc_bindings.DDBCSQLRowCount(self.hstmt)
             self._clear_rownumber()
+            self._cached_column_map = None
+            self._cached_converter_map = None
 
         # After successful execution, initialize description if there are results
         column_metadata = []
@@ -1957,11 +2008,11 @@ def fetchone(self) -> Union[None, Row]:
                 self._increment_rownumber()
 
             self.rowcount = self._next_row_index
-
-            # Create and return a Row object, passing column name map if available
-            column_map = getattr(self, "_column_name_map", None)
-            return Row(self, self.description, row_data, column_map)
-        except Exception as e:  # pylint: disable=broad-exception-caught
+            
+            # Get column and converter maps
+            column_map, converter_map = self._get_column_and_converter_maps()
+            return Row(row_data, column_map, cursor=self, converter_map=converter_map)
+        except Exception as e:
             # On error, don't increment rownumber - rethrow the error
             raise e
 
@@ -2004,14 +2055,13 @@ def fetchmany(self, size: Optional[int] = None) -> List[Row]:
                 self.rowcount = 0
             else:
                 self.rowcount = self._next_row_index
-
+
+            # Get column and converter maps
+            column_map, converter_map = self._get_column_and_converter_maps()
+
             # Convert raw data to Row objects
-            column_map = getattr(self, "_column_name_map", None)
-            return [
-                Row(self, self.description, row_data, column_map)
-                for row_data in rows_data
-            ]
-        except Exception as e:  # pylint: disable=broad-exception-caught
+            return [Row(row_data, column_map, cursor=self, converter_map=converter_map) for row_data in rows_data]
+        except Exception as e:
             # On error, don't increment rownumber - rethrow the error
             raise e
 
@@ -2044,14 +2094,13 @@ def fetchall(self) -> List[Row]:
                 self.rowcount = 0
             else:
                 self.rowcount = self._next_row_index
-
+
+            # Get column and converter maps
+            column_map, converter_map = self._get_column_and_converter_maps()
+
             # Convert raw data to Row objects
-            column_map = getattr(self, "_column_name_map", None)
-            return [
-                Row(self, self.description, row_data, column_map)
-                for row_data in rows_data
-            ]
-        except Exception as e:  # pylint: disable=broad-exception-caught
+            return [Row(row_data, column_map, cursor=self, converter_map=converter_map) for row_data in rows_data]
+        except Exception as e:
             # On error, don't increment rownumber - rethrow the error
             raise e
 
@@ -2070,16 +2119,35 @@ def nextset(self) -> Union[bool, None]:
         # Clear messages per DBAPI
         self.messages = []
 
+        # Clear cached column and converter maps for the new result set
+        self._cached_column_map = None
+        self._cached_converter_map = None
+
         # Skip to the next result set
         ret = ddbc_bindings.DDBCSQLMoreResults(self.hstmt)
         check_error(ddbc_sql_const.SQL_HANDLE_STMT.value, self.hstmt, ret)
 
         if ret == ddbc_sql_const.SQL_NO_DATA.value:
             self._clear_rownumber()
+            self.description = None
             return False
 
         self._reset_rownumber()
 
+        # Initialize description for the new result set
+        column_metadata = []
+        try:
+            ddbc_bindings.DDBCSQLDescribeCol(self.hstmt, column_metadata)
+            self._initialize_description(column_metadata)
+
+            # Pre-build column map and converter map for the new result set
+            if self.description:
+                self._cached_column_map = {col_desc[0]: i for i, col_desc in enumerate(self.description)}
+                self._cached_converter_map = self._build_converter_map()
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            # If describe fails, there might be no results in this result set
+            self.description = None
+
         return True
 
     def __enter__(self):
@@ -2252,58 +2320,34 @@ def scroll(self, value: int, mode: str = "relative") -> None:  # pylint: disable
 
         row_data: list = []
 
-        # Absolute special cases
+        # Absolute positioning not supported with forward-only cursors
         if mode == "absolute":
-            if value == -1:
-                # Before first
-                ddbc_bindings.DDBCSQLFetchScroll(
-                    self.hstmt, ddbc_sql_const.SQL_FETCH_ABSOLUTE.value, 0, row_data
-                )
-                self._rownumber = -1
-                self._next_row_index = 0
-                return
-            if value == 0:
-                # Before first, but tests want rownumber==0 pre and post the next fetch
-                ddbc_bindings.DDBCSQLFetchScroll(
-                    self.hstmt, ddbc_sql_const.SQL_FETCH_ABSOLUTE.value, 0, row_data
-                )
-                self._rownumber = 0
-                self._next_row_index = 0
-                self._skip_increment_for_next_fetch = True
-                return
+            raise NotSupportedError(
+                "Absolute positioning not supported",
+                "Forward-only cursors do not support absolute positioning"
+            )
 
         try:
             if mode == "relative":
                 if value == 0:
                     return
-                ret = ddbc_bindings.DDBCSQLFetchScroll(
-                    self.hstmt, ddbc_sql_const.SQL_FETCH_RELATIVE.value, value, row_data
-                )
-                if ret == ddbc_sql_const.SQL_NO_DATA.value:
-                    raise IndexError(
-                        "Cannot scroll to specified position: end of result set reached"
+
+                # For forward-only cursors, use multiple SQL_FETCH_NEXT calls
+                # This matches pyodbc's approach for skip operations
+                for i in range(value):
+                    ret = ddbc_bindings.DDBCSQLFetchScroll(
+                        self.hstmt, ddbc_sql_const.SQL_FETCH_NEXT.value, 0, row_data
                     )
-                # Consume N rows; last-returned index advances by N
+                    if ret == ddbc_sql_const.SQL_NO_DATA.value:
+                        raise IndexError(
+                            "Cannot scroll to specified position: end of result set reached"
+                        )
+
+                # Update position tracking
                 self._rownumber = self._rownumber + value
                 self._next_row_index = self._rownumber + 1
                 return
 
-            # absolute(k>0): map Python k (0-based next row) to ODBC ABSOLUTE k (1-based),
-            # intentionally passing k so ODBC fetches row #k (1-based), i.e., 0-based (k-1),
-            # leaving the NEXT fetch to return 0-based index k.
-            ret = ddbc_bindings.DDBCSQLFetchScroll(
-                self.hstmt, ddbc_sql_const.SQL_FETCH_ABSOLUTE.value, value, row_data
-            )
-            if ret == ddbc_sql_const.SQL_NO_DATA.value:
-                raise IndexError(
-                    f"Cannot scroll to position {value}: end of result set reached"
-                )
-
-            # Tests expect rownumber == value after absolute(value)
-            # Next fetch should return row index 'value'
-            self._rownumber = value
-            self._next_row_index = value
-
         except Exception as e:  # pylint: disable=broad-exception-caught
             if isinstance(e, (IndexError, NotSupportedError)):
                 raise
@@ -2457,4 +2501,5 @@ def setoutputsize(self, size: int, column: Optional[int] = None) -> None:
             This method is a no-op in this implementation as buffer sizes
             are managed automatically by the underlying driver.
         """
-        # This is a no-op - buffer sizes are managed automatically
+        # This is a no-op - buffer sizes are managed automatically
+

mssql_python/helpers.py

@@ -343,4 +343,4 @@ def __init__(self) -> None:
 def get_settings() -> Settings:
     """Return the global settings object"""
     with _settings_lock:
-        return _settings
+        return _settings