PERF: Add C++ DetectParamTypes + SQLExecuteFast pipeline

[bewithgaurav]

Work Item / Issue Reference

AB#44979

GitHub Issue: #500

---

Summary

This pull request refactors the parameter handling logic in the execute method of mssql_python/cursor.py to introduce a more efficient "fast path" for parameter binding and execution. The new approach allows the code to skip Python-side type detection and binding when there are no inputsizes overrides, delegating the entire process to the C++ layer for better performance. The slow path is retained for cases where inputsizes are set.

Performance improvements and code simplification:

• Added a "fast path" execution branch that uses DDBCSQLExecuteFast to handle parameter type detection, binding, and execution entirely in C++ when there are no inputsizes overrides, improving performance for common cases. (F783d0c6L1471)
• Removed the unconditional creation of the Python-side parameter type list and its associated logic from the main execution path, now only used in the "slow path" when inputsizes are present. [1] [2]
• Retained the existing Python-side type detection and parameter binding logic as a fallback for cases where inputsizes overrides are specified, ensuring compatibility with advanced usage. (F783d0c6L1471)

[github-actions]

📊 Code Coverage Report

🔥 Diff Coverage 91%

🎯 Overall Coverage 79%

📈 Total Lines Covered: 7147 out of 9037 📁 Project: mssql-python

---

Diff Coverage

Diff: main...HEAD, staged and unstaged changes

• mssql_python/cursor.py (100%)
• mssql_python/pybind/ddbc_bindings.cpp (91.5%): Missing lines 553-557,576,2492-2493,2577-2578,2581-2584,2610-2627,2645-2646

Summary

• Total: 410 lines
• Missing: 34 lines
• Coverage: 91%

mssql_python/pybind/ddbc_bindings.cpp

Lines 549-561

  549                     info.paramCType = SQL_C_SBIGINT;
  550                     info.columnSize = 19;
  551                 }
  552             } else {
! 553                 PyErr_Clear();
! 554                 info.paramSQLType = SQL_BIGINT;
! 555                 info.paramCType = SQL_C_SBIGINT;
! 556                 info.columnSize = 19;
! 557             }
  558             info.decimalDigits = 0;
  559             continue;
  560         }

---

Lines 572-580

  572         if (PyUnicode_Check(obj)) {
  573             Py_ssize_t length = PyUnicode_GET_LENGTH(obj);
  574             unsigned int kind = PyUnicode_KIND(obj);
  575 
! 576             Py_ssize_t utf16_len;
  577             if (kind <= PyUnicode_2BYTE_KIND) {
  578                 utf16_len = length;
  579             } else {
  580                 utf16_len = 0;

---

Lines 2488-2497

  2488                               py::list is_stmt_prepared,
  2489                               bool /*use_prepare*/,
  2490                               const py::dict& encoding_settings) {
  2491     if (!statementHandle || !statementHandle->get()) {
! 2492         return SQL_INVALID_HANDLE;
! 2493     }
  2494 
  2495     SQLHANDLE hStmt = statementHandle->get();
  2496 
  2497     // Configure forward-only / read-only cursor (matches slow path semantics).

---

Lines 2573-2588

  2573                     break;
  2574                 }
  2575             }
  2576             if (!matchedInfo) {
! 2577                 ThrowStdException("SQLExecuteFast: unrecognized paramToken from SQLParamData");
! 2578             }
  2579             const py::object& pyObj = matchedInfo->dataPtr;
  2580             if (pyObj.is_none()) {
! 2581                 py::gil_scoped_release release;
! 2582                 SQLPutData_ptr(hStmt, nullptr, 0);
! 2583                 continue;
! 2584             }
  2585 
  2586             if (py::isinstance<py::str>(pyObj)) {
  2587                 if (matchedInfo->paramCType == SQL_C_WCHAR) {
  2588                     std::wstring wstr = pyObj.cast<std::wstring>();

---

Lines 2606-2631

  2606                         }
  2607                         if (!SQL_SUCCEEDED(rc)) return rc;
  2608                     }
  2609                 } else if (matchedInfo->paramCType == SQL_C_CHAR) {
! 2610                     std::string encodedStr;
! 2611                     py::object encoded = pyObj.attr("encode")(charEncoding, "strict");
! 2612                     encodedStr = encoded.cast<std::string>();
! 2613                     const char* dataPtr = encodedStr.data();
! 2614                     size_t totalBytes = encodedStr.size();
! 2615                     for (size_t offset = 0; offset < totalBytes; offset += DAE_CHUNK_SIZE) {
! 2616                         size_t len = std::min(static_cast<size_t>(DAE_CHUNK_SIZE),
! 2617                                               totalBytes - offset);
! 2618                         {
! 2619                             py::gil_scoped_release release;
! 2620                             rc = SQLPutData_ptr(hStmt, (SQLPOINTER)(dataPtr + offset),
! 2621                                                 static_cast<SQLLEN>(len));
! 2622                         }
! 2623                         if (!SQL_SUCCEEDED(rc)) return rc;
! 2624                     }
! 2625                 } else {
! 2626                     ThrowStdException("SQLExecuteFast: unsupported C type for str in DAE");
! 2627                 }
  2628             } else if (py::isinstance<py::bytes>(pyObj) ||
  2629                        py::isinstance<py::bytearray>(pyObj)) {
  2630                 py::bytes b = pyObj.cast<py::bytes>();
  2631                 std::string s = b;

---

Lines 2641-2650

  2641                     }
  2642                     if (!SQL_SUCCEEDED(rc)) return rc;
  2643                 }
  2644             } else {
! 2645                 ThrowStdException("SQLExecuteFast: DAE only supported for str or bytes");
! 2646             }
  2647         }
  2648         if (!SQL_SUCCEEDED(rc) && rc != SQL_NO_DATA) return rc;
  2649     }

---

---

📋 Files Needing Attention

📉 Files with overall lowest coverage (click to expand)

mssql_python.pybind.logger_bridge.cpp: 59.2%
mssql_python.pybind.ddbc_bindings.h: 67.9%
mssql_python.row.py: 70.5%
mssql_python.pybind.logger_bridge.hpp: 70.8%
mssql_python.pybind.ddbc_bindings.cpp: 74.6%
mssql_python.pybind.connection.connection.cpp: 76.2%
mssql_python.__init__.py: 77.3%
mssql_python.ddbc_bindings.py: 79.6%
mssql_python.pybind.connection.connection_pool.cpp: 79.6%
mssql_python.connection.py: 85.3%

---

🔗 Quick Links

⚙️ Build Summary	📋 Coverage Details
View Azure DevOps Build	Browse Full Coverage Report