581                     info.paramSQLType = SQL_BIGINT;
  582                     info.paramCType = SQL_C_SBIGINT;
  583                     info.columnSize = 19;
  584                 }
! 585             } else {
! 586                 PyErr_Clear();
! 587                 info.paramSQLType = SQL_BIGINT;
! 588                 info.paramCType = SQL_C_SBIGINT;
! 589                 info.columnSize = 19;
  590             }
  591             info.decimalDigits = 0;
  592             continue;
  593         }

  2359 
  2360 // ---------------------------------------------------------------------------
  2361 // SQLExecuteFast — single C++ pipeline: DetectParamTypes → BindParameters → SQLExecute
  2362 // No ParamInfo objects cross the pybind11 boundary.
! 2363 //
! 2364 // Always uses SQLPrepare (not ExecDirect) because parameterized queries
  2365 // benefit from prepared plan reuse, and the fast path is only invoked
  2366 // when parameters are present. The use_prepare flag from the caller is
! 2367 // acknowledged but overridden — this is a perf-only code path.
! 2368 // ---------------------------------------------------------------------------
! 2369 SQLRETURN SQLExecuteFast_wrap(const SqlHandlePtr statementHandle,
! 2370                               const std::u16string& query,
  2371                               py::list params,
  2372                               py::list is_stmt_prepared,
  2373                               bool /*use_prepare*/,
  2374                               const py::dict& encoding_settings) {

  2384                            (SQLPOINTER)SQL_CURSOR_FORWARD_ONLY, 0);
  2385         SQLSetStmtAttr_ptr(hStmt, SQL_ATTR_CONCURRENCY,
  2386                            (SQLPOINTER)SQL_CONCUR_READ_ONLY, 0);
  2387     }
! 2388 
! 2389     // The encoding-settings dict has the form {"encoding": str, "ctype": int}.
! 2390     // Note: the Python layer's SQL_C_CHAR constant is numerically -8, the same
! 2391     // as ODBC's SQL_C_WCHAR. As a result, the only path that genuinely uses
! 2392     // byte-level character encoding is when the user explicitly opts in via
! 2393     // setencoding(..., ctype=mssql_python.SQL_CHAR) (which sends ctype=1, the
! 2394     // real ODBC SQL_CHAR). We default to utf-8 and only honor the dict's
! 2395     // encoding when ctype == 1 (real ODBC SQL_CHAR). Otherwise the user's
! 2396     // "encoding" value is meant for the wide-char path and we leave it alone.
! 2397     std::string charEncoding = "utf-8";
! 2398     if (encoding_settings.contains("ctype") && encoding_settings.contains("encoding")) {
! 2399         int ctype = encoding_settings["ctype"].cast<int>();
! 2400         if (ctype == SQL_C_CHAR /* real ODBC value: 1 */) {
! 2401             charEncoding = encoding_settings["encoding"].cast<std::string>();
! 2402         }
! 2403     }
! 2404 
! 2405     // The cursor.py caller always passes a fresh `list(actual_params)` so this
  2406     // function is free to mutate slots in place. Even so, every site below uses
  2407     // PyList_SetItem (which decrefs the old slot before stealing the new ref),
  2408     // so the function is safe regardless of who owns the list.

  2419         }
  2420         if (!SQL_SUCCEEDED(rc)) return rc;
  2421         is_stmt_prepared[0] = py::bool_(true);
  2422     }
! 2423 
! 2424     // DetectParamTypes + BindParameters in one shot — ParamInfo stays in C++
  2425     std::vector<ParamInfo> paramInfos = DetectParamTypes(params);
  2426     std::vector<std::shared_ptr<void>> paramBuffers;
  2427     rc = BindParameters(*statementHandle, hStmt, params, paramInfos, paramBuffers, charEncoding);
  2428     if (!SQL_SUCCEEDED(rc)) return rc;

  2448             const ParamInfo* matchedInfo = nullptr;
  2449             for (auto& info : paramInfos) {
  2450                 if (reinterpret_cast<SQLPOINTER>(const_cast<ParamInfo*>(&info)) == paramToken) {
  2451                     matchedInfo = &info;
! 2452                     break;
! 2453                 }
! 2454             }
  2455             if (!matchedInfo) {
  2456                 ThrowStdException("SQLExecuteFast: unrecognized paramToken from SQLParamData");
  2457             }
  2458             const py::object& pyObj = matchedInfo->dataPtr;

  2460                 py::gil_scoped_release release;
  2461                 SQLPutData_ptr(hStmt, nullptr, 0);
  2462                 continue;
  2463             }
! 2464 
! 2465             if (py::isinstance<py::str>(pyObj)) {
! 2466                 if (matchedInfo->paramCType == SQL_C_WCHAR) {
! 2467                     std::u16string u16 = pyObj.cast<std::u16string>();
! 2468                     const SQLWCHAR* dataPtr = reinterpretU16stringAsSqlWChar(u16);
  2469                     size_t totalChars = u16.size();
  2470                     size_t chunkChars = DAE_CHUNK_SIZE / sizeof(SQLWCHAR);
  2471                     for (size_t offset = 0; offset < totalChars; offset += chunkChars) {
! 2472                         size_t len = std::min(chunkChars, totalChars - offset);
  2473                         {
  2474                             py::gil_scoped_release release;
  2475                             rc = SQLPutData_ptr(hStmt, (SQLPOINTER)(dataPtr + offset),
  2476                                                 static_cast<SQLLEN>(len * sizeof(SQLWCHAR)));

  2474                             py::gil_scoped_release release;
  2475                             rc = SQLPutData_ptr(hStmt, (SQLPOINTER)(dataPtr + offset),
  2476                                                 static_cast<SQLLEN>(len * sizeof(SQLWCHAR)));
  2477                         }
! 2478                         if (!SQL_SUCCEEDED(rc)) return rc;
  2479                     }
  2480                 } else if (matchedInfo->paramCType == SQL_C_CHAR) {
  2481                     std::string encodedStr;
  2482                     py::object encoded = pyObj.attr("encode")(charEncoding, "strict");

  2494                         if (!SQL_SUCCEEDED(rc)) return rc;
  2495                     }
  2496                 } else {
  2497                     ThrowStdException("SQLExecuteFast: unsupported C type for str in DAE");
! 2498                 }
  2499             } else if (py::isinstance<py::bytes>(pyObj) ||
  2500                        py::isinstance<py::bytearray>(pyObj)) {
  2501                 py::bytes b = pyObj.cast<py::bytes>();
  2502                 std::string s = b;

  2510                         rc = SQLPutData_ptr(hStmt, (SQLPOINTER)(dataPtr + offset),
  2511                                             static_cast<SQLLEN>(len));
  2512                     }
  2513                     if (!SQL_SUCCEEDED(rc)) return rc;
! 2514                 }
! 2515             } else {
! 2516                 ThrowStdException("SQLExecuteFast: DAE only supported for str or bytes");
! 2517             }
  2518         }
  2519         if (!SQL_SUCCEEDED(rc) && rc != SQL_NO_DATA) return rc;
  2520     }

  2523 
  2524     // Preserve the execute return code (e.g. SQL_SUCCESS_WITH_INFO) — don't
  2525     // let the SQLFreeStmt return value clobber what the caller needs to see.
  2526     SQLRETURN exec_rc = rc;
! 2527     SQLFreeStmt_ptr(hStmt, SQL_RESET_PARAMS);
  2528     return exec_rc;
  2529 }
  2530 
  2531 SQLRETURN BindParameterArray(SqlHandle& handle, SQLHANDLE hStmt, const py::list& columnwise_params,