cleanup

Author: gargsaumya

mssql_python/pybind/ddbc_bindings.cpp

@@ -2948,6 +2948,11 @@ SQLSMALLINT MapVariantCTypeToSQLType(SQLLEN variantCType) {
         case SQL_C_STINYINT:
             return SQL_TINYINT;
         default:
+            // Unknown C type code - fallback to WVARCHAR for string conversion
+            // Note: SQL Server enforces sql_variant restrictions at INSERT time, preventing
+            // invalid types (text, ntext, image, timestamp, xml, MAX types, nested variants,
+            // spatial types, hierarchyid, UDTs) from being stored. By the time we fetch data,
+            // only valid base types exist. This default handles unmapped/future type codes.
             return SQL_WVARCHAR;
     }
 }
@@ -2990,15 +2995,27 @@ SQLRETURN SQLGetData_wrap(SqlHandlePtr StatementHandle, SQLUSMALLINT colCount, p
             continue;
         }
 
-        // Preprocess sql_variant: detect underlying type and handle NULL
+        // Preprocess sql_variant: detect underlying type to route to correct conversion logic
         SQLSMALLINT effectiveDataType = dataType;
         if (dataType == SQL_SS_VARIANT) {
+            // For sql_variant, we MUST call SQLGetData with SQL_C_BINARY (NULL buffer, len=0)
+            // first. This serves two purposes:
+            // 1. Detects NULL values via the indicator parameter
+            // 2. Initializes the variant metadata in the ODBC driver, which is required for
+            //    SQLColAttribute(SQL_CA_SS_VARIANT_TYPE) to return the correct underlying C type.
+            //    Without this probe call, SQLColAttribute returns incorrect type codes.
             SQLLEN indicator;
             ret = SQLGetData_ptr(hStmt, i, SQL_C_BINARY, NULL, 0, &indicator);
+            if (!SQL_SUCCEEDED(ret)) {
+                LOG("SQLGetData: Failed to probe sql_variant column %d - SQLRETURN=%d", i, ret);
+                row.append(py::none());
+                continue;
+            }
             if (indicator == SQL_NULL_DATA) {
                 row.append(py::none());
                 continue;
             }
+            // Now retrieve the underlying C type
             SQLLEN variantCType = 0;
             ret =
                 SQLColAttribute_ptr(hStmt, i, SQL_CA_SS_VARIANT_TYPE, NULL, 0, NULL, &variantCType);
@@ -3008,6 +3025,8 @@ SQLRETURN SQLGetData_wrap(SqlHandlePtr StatementHandle, SQLUSMALLINT colCount, p
                 continue;
             }
             effectiveDataType = MapVariantCTypeToSQLType(variantCType);
+            LOG("SQLGetData: sql_variant column %d has variantCType=%ld, mapped to SQL type %d", i,
+                (long)variantCType, effectiveDataType);
         }
 
         switch (effectiveDataType) {

tests/test_019_sql_variant.py

@@ -49,14 +49,16 @@ def variant_test_table(cursor, db_connection):
     table_name = "#pytest_sql_variant"
     drop_table_if_exists(cursor, table_name)
 
-    cursor.execute(f"""
+    cursor.execute(
+        f"""
         CREATE TABLE {table_name} (
             id INT PRIMARY KEY,
             variant_col SQL_VARIANT,
             base_type NVARCHAR(50),  -- What SQL type is stored in variant
             description NVARCHAR(100)
         )
-    """)
+    """
+    )
     db_connection.commit()
 
     # Insert test data with explicit CAST for each SQL base type
@@ -102,10 +104,12 @@ def variant_test_table(cursor, db_connection):
     ]
 
     for row in test_data:
-        cursor.execute(f"""
+        cursor.execute(
+            f"""
             INSERT INTO {table_name} (id, variant_col, base_type, description)
             VALUES ({row[0]}, {row[1]}, '{row[2]}', '{row[3]}')
-        """)
+        """
+        )
 
     # Also test implicit type conversion (what SQL Server chooses)
     cursor.execute(f"INSERT INTO {table_name} VALUES (20, 123, 'int', 'Implicit int literal')")
@@ -205,7 +209,7 @@ def test_sql_variant_float(cursor, variant_test_table):
 
 
 def test_sql_variant_decimal(cursor, variant_test_table):
-    """Test sql_vari with DECIMAL base type returns Python Decimal"""
+    """Test sql_variant with DECIMAL base type returns Python Decimal"""
     cursor.execute(f"SELECT id, variant_col, base_type FROM {variant_test_table} WHERE id = 7")
     row = cursor.fetchone()
 
@@ -496,12 +500,14 @@ def test_sql_variant_large_dataset(cursor, db_connection):
     table_name = "#pytest_sql_variant_large"
     drop_table_if_exists(cursor, table_name)
 
-    cursor.execute(f"""
+    cursor.execute(
+        f"""
         CREATE TABLE {table_name} (
             id INT PRIMARY KEY,
             variant_col SQL_VARIANT
         )
-    """)
+    """
+    )
     db_connection.commit()
 
     # Insert 100 rows with explicit CAST for each type