Merge branch 'main' into saumya/numeric-precision-loss

Author: gargsaumya

PyPI_Description.md

@@ -39,12 +39,12 @@ PyBind11 provides:
 
 We are currently in **Public Preview**.
 
-## What's new in v0.13.0
+## What's new in v0.13.1
 
-- **Enhanced Batch Operations:** Complete support for UNIQUEIDENTIFIER and DATETIMEOFFSET in `executemany()` operations with automatic type inference, enabling efficient bulk inserts of complex data types including UUIDs and timezone-aware datetimes.
-- **Streaming Large Values:** Robust handling of large objects (NVARCHAR/VARCHAR/VARBINARY(MAX)) in `executemany()` with automatic Data-At-Execution detection and fallback, supporting streaming inserts and fetches for massive datasets.
-- **Improved Cursor Reliability:** Enhanced `cursor.rowcount` accuracy across all fetch operations, including proper handling of empty result sets and consistent behavior for SELECT, INSERT, and UPDATE operations.
-- **Critical Stability Fixes:** Resolved memory leaks with secure token buffer handling, fixed resource cleanup to prevent segmentation faults during Python shutdown, and corrected type inference bugs in batch operations.
+- **Authentication Reliability:** Fixed token handling for Microsoft Entra ID authentication to ensure stable and reliable connections.
+- **Timezone Preservation:** Removed forced UTC conversion for `datetimeoffset` values, preserving original timezone information in Python `datetime` objects for accurate cross-timezone data handling.
+- **Connection Pooling Stability:** Enhanced pool shutdown mechanism with proper tracking to prevent resource leaks and ensure cleanup operations execute reliably.
+- **Predictable Type Handling:** Refined UUID string parameter handling to prevent automatic type coercion, ensuring strings are processed as intended.
 
 For more information, please visit the project link on Github: https://github.com/microsoft/mssql-python
 

mssql_python/pybind/connection/connection.cpp

@@ -173,7 +173,7 @@ SQLRETURN Connection::setAttribute(SQLINTEGER attribute, py::object value) {
     LOG("Setting SQL attribute");
     SQLPOINTER ptr = nullptr;
     SQLINTEGER length = 0;
-    std::string buffer; // to hold sensitive data temporarily
+    static std::string buffer; // to hold sensitive data temporarily
 
     if (py::isinstance<py::int_>(value)) {
         int intValue = value.cast<int>();
@@ -196,10 +196,6 @@ SQLRETURN Connection::setAttribute(SQLINTEGER attribute, py::object value) {
         LOG("Set attribute successfully");
     }
 
-    // Zero out sensitive data if used
-    if (!buffer.empty()) {
-        std::fill(buffer.begin(), buffer.end(), static_cast<char>(0));
-    }
     return ret;
 }
 
@@ -383,4 +379,4 @@ py::object ConnectionHandle::getInfo(SQLUSMALLINT infoType) const {
         ThrowStdException("Connection object is not initialized");
     }
     return _conn->getInfo(infoType);
-}
+}

mssql_python/pybind/ddbc_bindings.cpp

@@ -2809,7 +2809,6 @@ SQLRETURN SQLGetData_wrap(SqlHandlePtr StatementHandle, SQLUSMALLINT colCount, p
                         microseconds,
                         tzinfo
                     );
-                    py_dt = py_dt.attr("astimezone")(datetime.attr("timezone").attr("utc"));
                     row.append(py_dt);
                 } else {
                     LOG("Error fetching DATETIMEOFFSET for column {}, ret={}", i, ret);
@@ -3322,7 +3321,6 @@ SQLRETURN FetchBatchData(SQLHSTMT hStmt, ColumnBuffers& buffers, py::list& colum
                             dtoValue.fraction / 1000,  // ns → µs
                             tzinfo
                         );
-                        py_dt = py_dt.attr("astimezone")(datetime.attr("timezone").attr("utc"));
                         row.append(py_dt);
                     } else {
                         row.append(py::none());

setup.py

@@ -83,7 +83,7 @@ def finalize_options(self):
 
 setup(
     name='mssql-python',
-    version='0.13.0',
+    version='0.13.1',
     description='A Python library for interacting with Microsoft SQL Server',
     long_description=open('PyPI_Description.md', encoding='utf-8').read(),
     long_description_content_type='text/markdown',

tests/test_004_cursor.py

@@ -7829,12 +7829,7 @@ def test_datetimeoffset_read_write(cursor, db_connection):
             assert row is not None
             fetched_id, fetched_dt = row
             assert fetched_dt.tzinfo is not None
-            expected_utc = dt.astimezone(timezone.utc)
-            fetched_utc = fetched_dt.astimezone(timezone.utc)
-            # Ignore sub-microsecond differences
-            expected_utc = expected_utc.replace(microsecond=int(expected_utc.microsecond / 1000) * 1000)
-            fetched_utc = fetched_utc.replace(microsecond=int(fetched_utc.microsecond / 1000) * 1000)
-            assert fetched_utc == expected_utc
+            assert fetched_dt == dt
     finally:
         cursor.execute("DROP TABLE IF EXISTS #pytest_datetimeoffset_read_write;")
         db_connection.commit()
@@ -7868,12 +7863,7 @@ def test_datetimeoffset_max_min_offsets(cursor, db_connection):
             assert fetched_id == expected_id, f"ID mismatch: expected {expected_id}, got {fetched_id}"
             assert fetched_dt.tzinfo is not None, f"Fetched datetime object is naive for id {fetched_id}"
 
-            # Compare in UTC to avoid offset differences
-            expected_utc = expected_dt.astimezone(timezone.utc).replace(tzinfo=None)
-            fetched_utc = fetched_dt.astimezone(timezone.utc).replace(tzinfo=None)
-            assert fetched_utc == expected_utc, (
-                f"Value mismatch for id {expected_id}: expected UTC {expected_utc}, got {fetched_utc}"
-            )
+            assert fetched_dt == expected_dt, f"Value mismatch for id {expected_id}: expected {expected_dt}, got {fetched_dt}"
 
     finally:
         cursor.execute("DROP TABLE IF EXISTS #pytest_datetimeoffset_read_write;")
@@ -7928,12 +7918,7 @@ def test_datetimeoffset_dst_transitions(cursor, db_connection):
             assert fetched_id == expected_id, f"ID mismatch: expected {expected_id}, got {fetched_id}"
             assert fetched_dt.tzinfo is not None, f"Fetched datetime object is naive for id {fetched_id}"
 
-            # Compare UTC time to avoid issues due to offsets changing in DST
-            expected_utc = expected_dt.astimezone(timezone.utc).replace(tzinfo=None)
-            fetched_utc = fetched_dt.astimezone(timezone.utc).replace(tzinfo=None)
-            assert fetched_utc == expected_utc, (
-                f"Value mismatch for id {expected_id}: expected UTC {expected_utc}, got {fetched_utc}"
-            )
+            assert fetched_dt == expected_dt, f"Value mismatch for id {expected_id}: expected {expected_dt}, got {fetched_dt}"
 
     finally:
         cursor.execute("DROP TABLE IF EXISTS #pytest_datetimeoffset_dst_transitions;")
@@ -8010,17 +7995,7 @@ def test_datetimeoffset_executemany(cursor, db_connection):
             fetched_id, fetched_dto = rows[i]
             assert fetched_dto.tzinfo is not None, "Fetched datetime object is naive."
 
-            expected_utc = python_dt.astimezone(timezone.utc).replace(tzinfo=None)
-            fetched_utc = fetched_dto.astimezone(timezone.utc).replace(tzinfo=None)
-
-            # Round microseconds to nearest millisecond for comparison
-            expected_utc = expected_utc.replace(microsecond=int(expected_utc.microsecond / 1000) * 1000)
-            fetched_utc = fetched_utc.replace(microsecond=int(fetched_utc.microsecond / 1000) * 1000)
-
-            assert fetched_utc == expected_utc, (
-                f"Value mismatch for test case {i}. "
-                f"Expected UTC: {expected_utc}, Got UTC: {fetched_utc}"
-            )
+            assert fetched_dto == python_dt, f"Value mismatch for id {fetched_id}: expected {python_dt}, got {fetched_dto}"
     finally:
         cursor.execute("IF OBJECT_ID('tempdb..#pytest_dto', 'U') IS NOT NULL DROP TABLE #pytest_dto;")
         db_connection.commit()
@@ -8086,13 +8061,44 @@ def test_datetimeoffset_extreme_offsets(cursor, db_connection):
         for i, dt in enumerate(extreme_offsets):
             _, fetched = rows[i]
             assert fetched.tzinfo is not None
-            # Round-trip comparison via UTC
-            expected_utc = dt.astimezone(timezone.utc).replace(tzinfo=None)
-            fetched_utc = fetched.astimezone(timezone.utc).replace(tzinfo=None)
-            assert expected_utc == fetched_utc, f"Extreme offset round-trip failed for {dt.tzinfo}"
+            assert fetched == dt, f"Value mismatch for id {i}: expected {dt}, got {fetched}"
     finally:
         cursor.execute("IF OBJECT_ID('tempdb..#pytest_dto', 'U') IS NOT NULL DROP TABLE #pytest_dto;")
         db_connection.commit()
+        
+def test_datetimeoffset_native_vs_string_simple(cursor, db_connection):
+    """
+    Replicates the user's testing scenario: fetch DATETIMEOFFSET as native datetime
+    and as string using CONVERT(nvarchar(35), ..., 121).
+    """
+    try:
+        cursor.execute("CREATE TABLE #pytest_dto_user_test (id INT PRIMARY KEY, Systime DATETIMEOFFSET);")
+        db_connection.commit()
+
+        # Insert rows similar to user's example
+        test_rows = [
+            (1, datetime(2025, 5, 14, 12, 35, 52, 501000, tzinfo=timezone(timedelta(hours=1)))),
+            (2, datetime(2025, 5, 14, 15, 20, 30, 123000, tzinfo=timezone(timedelta(hours=-5))))
+        ]
+
+        for i, dt in test_rows:
+            cursor.execute("INSERT INTO #pytest_dto_user_test (id, Systime) VALUES (?, ?);", i, dt)
+        db_connection.commit()
+
+        # Native fetch (like the user's first execute)
+        cursor.execute("SELECT Systime FROM #pytest_dto_user_test WHERE id=1;")
+        dt_native = cursor.fetchone()[0]
+        assert dt_native.tzinfo is not None
+        assert dt_native == test_rows[0][1]
+
+        # String fetch (like the user's convert to nvarchar)
+        cursor.execute("SELECT CONVERT(nvarchar(35), Systime, 121) FROM #pytest_dto_user_test WHERE id=1;")
+        dt_str = cursor.fetchone()[0]
+        assert dt_str.endswith("+01:00")  # original offset preserved
+
+    finally:
+        cursor.execute("DROP TABLE IF EXISTS #pytest_dto_user_test;")
+        db_connection.commit()
 
 def test_lowercase_attribute(cursor, db_connection):
     """Test that the lowercase attribute properly converts column names to lowercase"""