FEAT: Perf Improvement

[gargsaumya]

Work Item / Issue Reference

AB#39793

GitHub Issue: #<ISSUE_NUMBER>

---

Summary

1. Large result sets (100K+ rows) improved by up to ~2×
2. Very large result sets (~1.2M rows) improved by 1.4× to 1.7×
3. Complex joins and aggregation workloads improved by ~40–45%
4. General query workloads now operate at parity or better compared to pyodbc

This pull request introduces several performance and correctness improvements to the MSSQL Python driver, focusing on efficient row conversion, cursor behavior, and pybind object handling. The most significant changes include caching output converters and column maps for rows, enforcing forward-only cursor semantics, and optimizing Python type/class lookups in the C++ extension layer.

Row conversion and cursor improvements:

• Added caching of column name maps and output converter maps in the Cursor class, so that row and column conversions are computed only once per result set, improving performance for large queries. This affects fetchone, fetchmany, and fetchall methods, as well as execution logic. [1] [2] [3] [4] [5] [6]
• Changed the cursor's scroll behavior to explicitly reject absolute positioning for forward-only cursors, and implemented relative scrolling using repeated fetches to match pyodbc's behavior.

C++ extension (pybind) optimizations:

• Introduced a PythonObjectCache namespace to cache commonly used Python classes (datetime, date, time, decimal, uuid), reducing repeated module imports and attribute lookups throughout the C++ codebase. All parameter binding and result conversion logic now uses this cache. [1] [2] [3] [4] [5] [6] [7]
• Added caching of the decimal separator in the result set conversion logic to avoid repeated system calls during data retrieval.

Cursor semantics and configuration:

• Updated statement execution logic in the C++ layer to always configure cursors as forward-only, ensuring consistent behavior and compatibility with the Python cursor implementation. [1] [2]

These changes collectively improve performance and reliability when fetching large result sets, ensure correct cursor behavior, and make the C++ extension more efficient in its interaction with Python objects.

[Copilot]

Pull Request Overview

This PR implements performance optimizations for database row fetching operations with a focus on reducing repeated operations and memory allocations. The key changes optimize the Row object initialization, introduce Python object caching in C++ bindings, and modify the cursor type from static to forward-only.

• Refactored Row initialization to accept pre-built column and converter maps, reducing redundant computation
• Added PythonObjectCache namespace in C++ to cache frequently used Python class imports (datetime, decimal, UUID)
• Changed cursor type from SQL_CURSOR_STATIC to SQL_CURSOR_FORWARD_ONLY for better performance
• Optimized batch fetching by pre-allocating rows and using direct list indexing instead of append operations

Reviewed Changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 8 comments.

File	Description
mssql_python/row.py	Refactored Row initialization to accept pre-built column/converter maps and added optimized converter application method
mssql_python/pybind/ddbc_bindings.cpp	Added PythonObjectCache for frequently imported classes, optimized decimal separator handling, changed cursor type to forward-only, and optimized batch fetch operations with pre-allocation
mssql_python/cursor.py	Added caching of column maps and converter maps, updated Row instantiation calls, and added scrolling validation check

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[sumitmsft]

I've identified some tests:

• Execute queries with different schemas on same cursor; verify no stale column mappings between executions.
• Close cursor and verify _cached_column_map and _cached_converter_map are cleared to prevent memory leaks.
• Execute same query 10,000 times; verify memory doesn't grow unboundedly (should stay < 50MB).
• Execute stored procedure with multiple result sets; verify each set gets correct column mapping, not cached from previous.
• Mock missing datetime module during cache init; verify graceful error (not segfault) with meaningful message.
• Query datetime/decimal/uuid types; verify no NULL pointer dereference if cache initialization failed.
• Simulate datetime succeeds but decimal fails during cache init; verify fallback or clear error, not undefined behavior.
• Query NULL datetime, date, time, decimal, uuid; verify converters handle NULL without crashes.
• Test decimals: 0.00, -0.00, 999999999.99, 0.0000000001; verify correct conversion with cached converters.
• Test SQL Server min/max datetime (1753-01-01, 9999-12-31); verify cached datetime converter handles boundaries.
• Execute SELECT on table, ALTER table add column, SELECT again on same cursor; verify cache invalidation.
• Call cursor.tables() then execute SELECT; verify column/converter cache doesn't mix metadata with data.
• Execute 3 queries with integers, strings, then datetime on same cursor; verify converter cache updates correctly.
• Execute invalid query causing error, then valid query; verify cache state recovered, not corrupted.
• Start large fetch, kill connection mid-fetch; verify graceful error and cache cleanup (no memory leak).

Let's see if they can be incorporated.