FIX: NULL parameter type mapping for VARBINARY columns (#458) (#466)

### Work Item / Issue Reference  
<!-- 
IMPORTANT: Please follow the PR template guidelines below.
For mssql-python maintainers: Insert your ADO Work Item ID below 
For external contributors: Insert Github Issue number below
Only one reference is required - either GitHub issue OR ADO Work Item.
-->

<!-- mssql-python maintainers: ADO Work Item -->
>
[AB#42894](https://sqlclientdrivers.visualstudio.com/c6d89619-62de-46a0-8b46-70b92a84d85e/_workitems/edit/42894)

<!-- External contributors: GitHub Issue -->
> GitHub Issue: #458 

-------------------------------------------------------------------
### Summary   
<!-- Insert your summary of changes below. Minimum 10 characters
required. -->
This pull request makes a targeted fix to the parameter type mapping
logic for NULL values in the `mssql_python/cursor.py` file. The change
improves compatibility and prevents implicit conversion errors when
executing queries with NULL parameters.

Parameter mapping improvement:

* Changed the mapping for NULL parameters in the `_map_sql_type`
function to use `SQL_UNKNOWN_TYPE` instead of `SQL_VARCHAR`, allowing
the driver to correctly determine the column type and avoid conversion
errors.

<!-- 
### PR Title Guide

> For feature requests
FEAT: (short-description)

> For non-feature requests like test case updates, config updates ,
dependency updates etc
CHORE: (short-description) 

> For Fix requests
FIX: (short-description)

> For doc update requests 
DOC: (short-description)

> For Formatting, indentation, or styling update
STYLE: (short-description)

> For Refactor, without any feature changes
REFACTOR: (short-description)

> For release related changes, without any feature changes
RELEASE: #<RELEASE_VERSION> (short-description) 

### Contribution Guidelines

External contributors:
- Create a GitHub issue first:
https://github.com/microsoft/mssql-python/issues/new
- Link the GitHub issue in the "GitHub Issue" section above
- Follow the PR title format and provide a meaningful summary

mssql-python maintainers:
- Create an ADO Work Item following internal processes
- Link the ADO Work Item in the "ADO Work Item" section above  
- Follow the PR title format and provide a meaningful summary
-->

---------

Co-authored-by: Jahnvi Thakkar <61936179+jahnvi480@users.noreply.github.com>

Author: gargsaumya

mssql_python/cursor.py

@@ -396,7 +396,7 @@ def _map_sql_type(  # pylint: disable=too-many-arguments,too-many-positional-arg
         if param is None:
             logger.debug("_map_sql_type: NULL parameter - index=%d", i)
             return (
-                ddbc_sql_const.SQL_VARCHAR.value,
+                ddbc_sql_const.SQL_UNKNOWN_TYPE.value,
                 ddbc_sql_const.SQL_C_DEFAULT.value,
                 1,
                 0,
@@ -2208,6 +2208,16 @@ def executemany(  # pylint: disable=too-many-locals,too-many-branches,too-many-s
                     min_val=min_val,
                     max_val=max_val,
                 )
+
+                # For executemany with all-NULL columns, SQL_UNKNOWN_TYPE doesn't work
+                # with array binding. Fall back to SQL_VARCHAR as a safe default.
+                if (
+                    sample_value is None
+                    and paraminfo.paramSQLType == ddbc_sql_const.SQL_UNKNOWN_TYPE.value
+                ):
+                    paraminfo.paramSQLType = ddbc_sql_const.SQL_VARCHAR.value
+                    paraminfo.columnSize = 1
+
                 # Special handling for binary data in auto-detected types
                 if paraminfo.paramSQLType in (
                     ddbc_sql_const.SQL_BINARY.value,

mssql_python/pybind/ddbc_bindings.cpp

@@ -471,14 +471,21 @@ SQLRETURN BindParameters(SQLHANDLE hStmt, const py::list& params,
                         hStmt, static_cast<SQLUSMALLINT>(paramIndex + 1), &describedType,
                         &describedSize, &describedDigits, &nullable);
                     if (!SQL_SUCCEEDED(rc)) {
-                        LOG("BindParameters: SQLDescribeParam failed for "
-                            "param[%d] (NULL parameter) - SQLRETURN=%d",
-                            paramIndex, rc);
-                        return rc;
+                        // SQLDescribeParam can fail for generic SELECT statements where
+                        // no table column is referenced. Fall back to SQL_VARCHAR as a safe
+                        // default.
+                        LOG_WARNING("BindParameters: SQLDescribeParam failed for "
+                                    "param[%d] (NULL parameter) - SQLRETURN=%d, falling back to "
+                                    "SQL_VARCHAR",
+                                    paramIndex, rc);
+                        sqlType = SQL_VARCHAR;
+                        columnSize = 1;
+                        decimalDigits = 0;
+                    } else {
+                        sqlType = describedType;
+                        columnSize = describedSize;
+                        decimalDigits = describedDigits;
                     }
-                    sqlType = describedType;
-                    columnSize = describedSize;
-                    decimalDigits = describedDigits;
                 }
                 dataPtr = nullptr;
                 strLenOrIndPtr = AllocateParamBuffer<SQLLEN>(paramBuffers);
@@ -4048,7 +4055,8 @@ size_t calculateRowSize(py::list& columnNames, SQLUSMALLINT numCols) {
                 break;
             case SQL_SS_UDT:
                 rowSize += (static_cast<SQLLEN>(columnSize) == SQL_NO_TOTAL || columnSize == 0)
-                               ? SQL_MAX_LOB_SIZE : columnSize;
+                               ? SQL_MAX_LOB_SIZE
+                               : columnSize;
                 break;
             case SQL_BINARY:
             case SQL_VARBINARY:
@@ -4112,8 +4120,7 @@ SQLRETURN FetchMany_wrap(SqlHandlePtr StatementHandle, py::list& rows, int fetch
 
         if ((dataType == SQL_WVARCHAR || dataType == SQL_WLONGVARCHAR || dataType == SQL_VARCHAR ||
              dataType == SQL_LONGVARCHAR || dataType == SQL_VARBINARY ||
-             dataType == SQL_LONGVARBINARY || dataType == SQL_SS_XML ||
-             dataType == SQL_SS_UDT) &&
+             dataType == SQL_LONGVARBINARY || dataType == SQL_SS_XML || dataType == SQL_SS_UDT) &&
             (columnSize == 0 || columnSize == SQL_NO_TOTAL || columnSize > SQL_MAX_LOB_SIZE)) {
             lobColumns.push_back(i + 1);  // 1-based
         }
@@ -4252,8 +4259,7 @@ SQLRETURN FetchAll_wrap(SqlHandlePtr StatementHandle, py::list& rows,
 
         if ((dataType == SQL_WVARCHAR || dataType == SQL_WLONGVARCHAR || dataType == SQL_VARCHAR ||
              dataType == SQL_LONGVARCHAR || dataType == SQL_VARBINARY ||
-             dataType == SQL_LONGVARBINARY || dataType == SQL_SS_XML ||
-             dataType == SQL_SS_UDT) &&
+             dataType == SQL_LONGVARBINARY || dataType == SQL_SS_XML || dataType == SQL_SS_UDT) &&
             (columnSize == 0 || columnSize == SQL_NO_TOTAL || columnSize > SQL_MAX_LOB_SIZE)) {
             lobColumns.push_back(i + 1);  // 1-based
         }

tests/test_004_cursor.py

@@ -658,6 +658,23 @@ def test_varbinary_full_capacity(cursor, db_connection):
         db_connection.commit()
 
 
+def test_execute_none_into_varbinary_column(cursor, db_connection):
+    from mssql_python.constants import ConstantsDDBC
+
+    drop_table_if_exists(cursor, "#test_varbinary_null")
+    try:
+        cursor.execute("CREATE TABLE #test_varbinary_null (data VARBINARY(100))")
+        db_connection.commit()
+        cursor.setinputsizes([(ConstantsDDBC.SQL_VARBINARY.value, 100, 0)])
+        cursor.execute("INSERT INTO #test_varbinary_null (data) VALUES (?)", None)
+        db_connection.commit()
+        cursor.execute("SELECT data FROM #test_varbinary_null")
+        row = cursor.fetchone()
+        assert row[0] is None
+    finally:
+        drop_table_if_exists(cursor, "#test_varbinary_null")
+
+
 def test_varbinary_max(cursor, db_connection):
     """Test SQL_VARBINARY with MAX length"""
     try: