PERF: Native C++ parameter detection and execute pipeline

mssql_python/cursor.py

@@ -982,6 +982,14 @@ def _create_parameter_types_list(  # pylint: disable=too-many-arguments,too-many
     ) -> Tuple[int, int, int, int, bool]:
         """
         Maps parameter types for the given parameter.
+
+        Python-side type detection. The standard execute() path no longer calls this —
+        DetectParamTypes does the same job in C++ without crossing the pybind11
+        boundary per parameter. Two callers remain: the legacy execute() branch used
+        when setinputsizes overrides are active, and executemany(). The former goes
+        away once setinputsizes is handled natively; the latter needs its own
+        native columnwise detection before this can be deleted outright.
+
         Args:
             parameter: parameter to bind.
         Returns:
@@ -1487,11 +1495,6 @@ def execute(  # pylint: disable=too-many-locals,too-many-branches,too-many-state
         # Getting encoding setting
         encoding_settings = self._get_encoding_settings()
 
-        # Apply timeout if set (non-zero)
-        logger.debug("execute: Creating parameter type list")
-        param_info = ddbc_bindings.ParamInfo
-        parameters_type = []
-
         # Validate that inputsizes matches parameter count if both are present
         if parameters and self._inputsizes:
             if len(self._inputsizes) != len(parameters):
@@ -1503,11 +1506,6 @@ def execute(  # pylint: disable=too-many-locals,too-many-branches,too-many-state
                     Warning,
                 )
 
-        if parameters:
-            for i, param in enumerate(parameters):
-                paraminfo = self._create_parameter_types_list(param, param_info, parameters, i)
-                parameters_type.append(paraminfo)
-
         # Prepare caching: skip SQLPrepare when re-executing the same SQL
         # with parameters. The HSTMT is reused via _soft_reset_cursor, so the
         # server-side plan from the previous SQLPrepare is still valid.
@@ -1516,30 +1514,64 @@ def execute(  # pylint: disable=too-many-locals,too-many-branches,too-many-state
             self.is_stmt_prepared = [False]
         effective_use_prepare = use_prepare and not same_sql
 
-        if logger.isEnabledFor(logging.DEBUG):
-            for i, param in enumerate(parameters):
-                logger.debug(
-                    """Parameter number: %s, Parameter: %s,
-                    Param Python Type: %s, ParamInfo: %s, %s, %s, %s, %s""",
-                    i + 1,
-                    param,
-                    str(type(param)),
-                    parameters_type[i].paramSQLType,
-                    parameters_type[i].paramCType,
-                    parameters_type[i].columnSize,
-                    parameters_type[i].decimalDigits,
-                    parameters_type[i].inputOutputType,
-                )
-
-        ret = ddbc_bindings.DDBCSQLExecute(
-            self.hstmt,
-            operation,
-            parameters,
-            parameters_type,
-            self.is_stmt_prepared,
-            effective_use_prepare,
-            encoding_settings,
+        # Standard path: when no inputsizes override, type detection + bind + execute
+        # all happen in C++ via DDBCSQLExecute. ParamInfo never crosses the pybind11
+        # boundary. This is the path ~99% of calls take.
+        use_standard_execute = parameters and not (
+            self._inputsizes and any(s is not None for s in self._inputsizes)
         )
+
+        if use_standard_execute:
+            ret = ddbc_bindings.DDBCSQLExecute(
+                self.hstmt,
+                operation,
+                parameters,
+                self.is_stmt_prepared,
+                effective_use_prepare,
+                encoding_settings,
+            )
+        else:
+            # LEGACY PATH — slated for removal in a future optimization round.
+            #
+            # Kept only for setinputsizes() callers, where the user's explicit type
+            # overrides have to be honoured instead of C++ detecting types itself.
+            # Type detection happens in Python here, so every parameter round-trips
+            # through pybind11 as a ParamInfo object, which is what makes it slow.
+            # Once setinputsizes overrides are handled natively, this branch and
+            # DDBCSQLExecuteLegacy both go away.
+            parameters_type = []
+            if parameters:
+                param_info = ddbc_bindings.ParamInfo
+                for i, param in enumerate(parameters):
+                    paraminfo = self._create_parameter_types_list(param, param_info, parameters, i)
+                    parameters_type.append(paraminfo)
+
+            if logger.isEnabledFor(logging.DEBUG):
+                for i, param in enumerate(parameters):
+                    logger.debug(
+                        """Parameter number: %s, Parameter: %s,
+                        Param Python Type: %s, ParamInfo: %s, %s, %s, %s, %s""",
+                        i + 1,
+                        param,
+                        str(type(param)),
+                        parameters_type[i].paramSQLType,
+                        parameters_type[i].paramCType,
+                        parameters_type[i].columnSize,
+                        parameters_type[i].decimalDigits,
+                        parameters_type[i].inputOutputType,
+                    )
+
+            # Legacy binding: accepts the pre-built ParamInfo list from Python.
+            # Goes away with the branch above.
+            ret = ddbc_bindings.DDBCSQLExecuteLegacy(
+                self.hstmt,
+                operation,
+                parameters,
+                parameters_type,
+                self.is_stmt_prepared,
+                effective_use_prepare,
+                encoding_settings,
+            )
         # Check return code
         try: