Fix executemany SQL_C_NUMERIC mismatch and bulkcopy Row acceptance (GH-609)

Bug 1: executemany auto-detection path set paramCType=SQL_C_NUMERIC for
Decimal values outside the MONEY range, but the conversion loop converts
all Decimals to strings. The C extension then received strings where it
expected NumericData structs, raising RuntimeError. Fixed by overriding
SQL_C_NUMERIC to SQL_C_CHAR in the auto-detection path, matching the
existing GH-503 fix in the setinputsizes path.

Bug 2: bulkcopy passed Row objects directly to mssql_py_core which expects
native tuples. Added _ensure_tuples() wrapper to auto-convert Row/list
objects to tuples.

Fixes #609

Author: jahnvi480

mssql_python/cursor.py

@@ -2344,6 +2344,20 @@ def executemany(  # pylint: disable=too-many-locals,too-many-branches,too-many-s
                     paraminfo.paramSQLType = ddbc_sql_const.SQL_VARCHAR.value
                     paraminfo.columnSize = 1
 
+                # Override DECIMAL/NUMERIC to use SQL_C_CHAR string binding.
+                # _map_sql_type may return SQL_C_NUMERIC (expecting NumericData structs)
+                # but the conversion loop below converts all Decimal values to strings.
+                # The C type must match the actual data to avoid:
+                #   RuntimeError: Parameter's object type does not match parameter's C type
+                if paraminfo.paramSQLType in (
+                    ddbc_sql_const.SQL_DECIMAL.value,
+                    ddbc_sql_const.SQL_NUMERIC.value,
+                ):
+                    paraminfo.paramCType = ddbc_sql_const.SQL_C_CHAR.value
+                    # Ensure columnSize accommodates the longest string representation
+                    if max_decimal_len > paraminfo.columnSize:
+                        paraminfo.columnSize = max_decimal_len
+
                 # Correct column size for Decimal columns sent as SQL_VARCHAR (GH-557).
                 # The sample value's formatted string may be shorter than another
                 # row's (e.g. positive sample "1.0" = 3 chars vs negative "-0.1" = 4).
@@ -2997,11 +3011,28 @@ def bulkcopy(
             )
             pycore_cursor = pycore_connection.cursor()
 
+            # Auto-convert Row/list objects to tuples for the Rust layer.
+            # mssql_py_core expects native tuples; Row objects (from fetchmany)
+            # are iterable but fail the strict type check in Rust.
+            def _ensure_tuples(iterable):
+                from mssql_python.row import Row
+
+                for item in iterable:
+                    if isinstance(item, tuple):
+                        yield item
+                    elif isinstance(item, (list, Row)):
+                        yield tuple(item)
+                    else:
+                        raise TypeError(
+                            f"bulkcopy data rows must be tuples, lists, or Row objects, "
+                            f"got {type(item).__name__}"
+                        )
+
             # Call bulkcopy with explicit keyword arguments
             # The API signature: bulkcopy(table_name, data_source, batch_size=0, timeout=30, ...)
             result = pycore_cursor.bulkcopy(
                 table_name,
-                iter(data),
+                _ensure_tuples(data),
                 batch_size=batch_size,
                 timeout=timeout,
                 column_mappings=column_mappings,

tests/test_001_globals.py

@@ -1059,3 +1059,164 @@ def test_row_string_key_case_insensitive_with_lowercase():
     # Non-existent attribute raises AttributeError
     with pytest.raises(AttributeError):
         row.nonexistent
+
+
+# ---------------------------------------------------------
+# GH-609: Unit tests for executemany SQL_C_NUMERIC mismatch
+# ---------------------------------------------------------
+import decimal as _decimal
+from mssql_python.cursor import Cursor, MONEY_MAX
+from mssql_python.constants import ConstantsDDBC as _C
+
+
+def _make_bare_cursor():
+    """Create a Cursor instance without a connection for unit testing."""
+    cur = Cursor.__new__(Cursor)
+    cur._inputsizes = None
+    return cur
+
+
+def test_compute_column_type_large_decimal():
+    """_compute_column_type picks the highest-precision Decimal as sample."""
+    cur = _make_bare_cursor()
+    column = [
+        _decimal.Decimal("100.50"),
+        _decimal.Decimal("999999999999999999.123456"),  # > MONEY_MAX
+        _decimal.Decimal("200.75"),
+    ]
+    sample, _, _, max_dec_len = cur._compute_column_type(column)
+    assert isinstance(sample, _decimal.Decimal)
+    assert sample > MONEY_MAX
+    assert max_dec_len > 0
+
+
+def test_map_sql_type_decimal_outside_money_returns_numeric():
+    """_map_sql_type returns SQL_C_NUMERIC for Decimal outside MONEY range.
+
+    This C type expects NumericData structs, but executemany's conversion
+    loop converts Decimals to strings — creating a mismatch that the
+    GH-609 override in executemany must correct.
+    """
+    cur = _make_bare_cursor()
+    val = _decimal.Decimal("999999999999999999.123456")
+    dummy_row = [val]
+    sql_type, c_type, _, _, _ = cur._map_sql_type(val, dummy_row, 0)
+    assert sql_type == _C.SQL_NUMERIC.value
+    assert c_type == _C.SQL_C_NUMERIC.value
+
+    # The executemany conversion loop would turn this into a string,
+    # confirming the override to SQL_C_CHAR is necessary.
+    assert isinstance(format(val, "f"), str)
+
+
+def test_map_sql_type_decimal_in_money_returns_varchar():
+    """_map_sql_type returns SQL_VARCHAR for Decimal within MONEY range."""
+    cur = _make_bare_cursor()
+    val = _decimal.Decimal("100.50")
+    dummy_row = [val]
+    sql_type, c_type, _, _, _ = cur._map_sql_type(val, dummy_row, 0)
+    assert sql_type == _C.SQL_VARCHAR.value
+    assert c_type == _C.SQL_C_CHAR.value
+
+
+def test_executemany_numeric_override_needed():
+    """The executemany auto-detection path must override SQL_C_NUMERIC to SQL_C_CHAR (GH-609).
+
+    Verifies the full type-detection pipeline that executemany uses: when a
+    column of large Decimals is detected, _create_parameter_types_list returns
+    SQL_C_NUMERIC, but the override in executemany must change it to SQL_C_CHAR
+    since the conversion loop converts all Decimals to strings.
+    """
+    from mssql_python import ddbc_bindings
+
+    cur = _make_bare_cursor()
+    data = [
+        (_decimal.Decimal("100.50"),),
+        (_decimal.Decimal("999999999999999999.123456"),),
+    ]
+
+    # Step 1: type detection (same as executemany's auto-detection path)
+    column = [row[0] for row in data]
+    sample_value, min_val, max_val, max_decimal_len = cur._compute_column_type(column)
+    dummy_row = list(data[0])
+    paraminfo = cur._create_parameter_types_list(
+        sample_value,
+        ddbc_bindings.ParamInfo,
+        dummy_row,
+        0,
+        min_val=min_val,
+        max_val=max_val,
+    )
+
+    # Before the fix: C type would be SQL_C_NUMERIC (mismatch with string data)
+    assert paraminfo.paramSQLType == _C.SQL_NUMERIC.value
+    original_c_type = paraminfo.paramCType
+
+    # Step 2: apply the GH-609 override (same logic as cursor.py executemany)
+    if paraminfo.paramSQLType in (_C.SQL_DECIMAL.value, _C.SQL_NUMERIC.value):
+        paraminfo.paramCType = _C.SQL_C_CHAR.value
+        if max_decimal_len > paraminfo.columnSize:
+            paraminfo.columnSize = max_decimal_len
+
+    # After the fix: C type is SQL_C_CHAR, matching the string conversion
+    assert paraminfo.paramCType == _C.SQL_C_CHAR.value
+    assert original_c_type == _C.SQL_C_NUMERIC.value  # confirms override was needed
+    assert paraminfo.columnSize >= max_decimal_len
+
+
+def test_executemany_decimal_numeric_override_coverage(monkeypatch):
+    """Call the real executemany method to cover the GH-609 override lines.
+
+    Mocks only the I/O boundaries (_check_closed, _reset_cursor, SQLExecuteMany)
+    so the entire type-detection and conversion pipeline runs for real.
+    """
+    from unittest.mock import MagicMock
+    from mssql_python import ddbc_bindings
+    from mssql_python.cursor import Cursor
+
+    cur = Cursor.__new__(Cursor)
+    cur._inputsizes = None
+    cur._timeout = 0
+    cur.closed = False
+    cur.hstmt = MagicMock()
+    cur.messages = []
+    cur.is_stmt_prepared = [False]
+    cur._connection = MagicMock()
+    cur._connection._encoding = "utf-8"
+    cur._connection._conn = MagicMock()
+
+    # Capture what gets passed to SQLExecuteMany
+    captured = {}
+
+    def fake_sql_execute_many(hstmt, op, col_params, param_types, row_count, enc):
+        captured["parameters_type"] = param_types
+        captured["columnwise_params"] = col_params
+        captured["row_count"] = row_count
+        return 0  # SQL_SUCCESS
+
+    monkeypatch.setattr(cur, "_check_closed", lambda: None)
+    monkeypatch.setattr(cur, "_reset_cursor", lambda: None)
+    monkeypatch.setattr(ddbc_bindings, "SQLExecuteMany", fake_sql_execute_many)
+    monkeypatch.setattr(ddbc_bindings, "DDBCSQLGetAllDiagRecords", lambda h: [])
+    monkeypatch.setattr(ddbc_bindings, "DDBCSQLRowCount", lambda h: 2)
+
+    data = [
+        (_decimal.Decimal("100.50"),),
+        (_decimal.Decimal("999999999999999999.123456"),),
+    ]
+    cur.executemany("INSERT INTO t VALUES (?)", data)
+
+    # Verify the GH-609 override was applied inside the real executemany
+    pt = captured["parameters_type"]
+    assert len(pt) == 1
+    assert pt[0].paramSQLType == _C.SQL_NUMERIC.value
+    assert (
+        pt[0].paramCType == _C.SQL_C_CHAR.value
+    ), f"Expected SQL_C_CHAR ({_C.SQL_C_CHAR.value}), got {pt[0].paramCType}"
+
+    # Verify values were converted to strings (not NumericData structs)
+    col_values = captured["columnwise_params"][0]
+    for val in col_values:
+        assert val is None or isinstance(
+            val, str
+        ), f"Expected str, got {type(val).__name__}: {val!r}"

tests/test_004_cursor.py

@@ -16239,3 +16239,103 @@ def test_long_print_message(cursor, message_len):
     msg = cursor.messages[0][1]
     # SQL Server truncates at 8000 characters
     assert msg.endswith("a" * min(8000, message_len)), msg
+
+
+# ---------------------------------------------------------
+# GH-609: executemany with Decimal values outside MONEY range
+# ---------------------------------------------------------
+def test_executemany_decimal_outside_money_range(cursor, db_connection):
+    """Test executemany with Decimal values exceeding the MONEY range (GH-609).
+
+    When a batch contains Decimal values outside ±922,337,203,685,477.5807,
+    _map_sql_type returns SQL_C_NUMERIC (expecting NumericData structs), but
+    the conversion loop converts all Decimals to strings. Without the GH-609
+    fix, this mismatch causes:
+        RuntimeError: Parameter's object type does not match parameter's C type
+
+    Also exercises separate batches (customer scenario: most batches have
+    in-MONEY-range values, one batch exceeds the range).
+    """
+    try:
+        cursor.execute("CREATE TABLE #pytest_gh609 (val DECIMAL(38, 6))")
+
+        # Batch 1: all values inside MONEY range
+        batch1 = [(decimal.Decimal("100.50"),), (decimal.Decimal("200.75"),)]
+        cursor.executemany("INSERT INTO #pytest_gh609 VALUES (?)", batch1)
+
+        # Batch 2: mix of inside and outside MONEY range
+        batch2 = [
+            (decimal.Decimal("0.000001"),),
+            (decimal.Decimal("999999999999999999.123456"),),  # exceeds MONEY_MAX
+            (decimal.Decimal("-999999999999999999.654321"),),  # exceeds MONEY_MIN
+        ]
+        cursor.executemany("INSERT INTO #pytest_gh609 VALUES (?)", batch2)
+        db_connection.commit()
+
+        cursor.execute("SELECT val FROM #pytest_gh609 ORDER BY val")
+        rows = [row[0] for row in cursor.fetchall()]
+        assert len(rows) == 5
+        assert rows[0] == decimal.Decimal("-999999999999999999.654321")
+        assert rows[-1] == decimal.Decimal("999999999999999999.123456")
+    finally:
+        cursor.execute("DROP TABLE IF EXISTS #pytest_gh609")
+        db_connection.commit()
+
+
+def test_executemany_decimal_with_nulls_outside_money(cursor, db_connection):
+    """Test executemany with NULL + large Decimal values outside MONEY range (GH-609)."""
+    try:
+        cursor.execute("CREATE TABLE #pytest_gh609_nulls (val DECIMAL(38, 10))")
+        data = [
+            (None,),
+            (decimal.Decimal("12345678901234567890.1234567890"),),
+            (None,),
+            (decimal.Decimal("-12345678901234567890.1234567890"),),
+        ]
+        cursor.executemany("INSERT INTO #pytest_gh609_nulls VALUES (?)", data)
+        db_connection.commit()
+
+        cursor.execute("SELECT val FROM #pytest_gh609_nulls WHERE val IS NOT NULL ORDER BY val")
+        rows = [row[0] for row in cursor.fetchall()]
+        assert len(rows) == 2
+        assert rows[0] == decimal.Decimal("-12345678901234567890.1234567890")
+        assert rows[1] == decimal.Decimal("12345678901234567890.1234567890")
+
+        cursor.execute("SELECT COUNT(*) FROM #pytest_gh609_nulls WHERE val IS NULL")
+        assert cursor.fetchone()[0] == 2
+    finally:
+        cursor.execute("DROP TABLE IF EXISTS #pytest_gh609_nulls")
+        db_connection.commit()
+
+
+def test_executemany_multi_column_with_large_decimal(cursor, db_connection):
+    """Test executemany with multiple columns including large Decimal (GH-609).
+
+    Mirrors the customer's scenario: a table with many columns where one
+    NUMERIC column has values outside the MONEY range.
+    """
+    try:
+        cursor.execute("""
+            CREATE TABLE #pytest_gh609_multi (
+                id INT,
+                name NVARCHAR(100),
+                amount DECIMAL(38, 6),
+                description VARCHAR(200)
+            )
+        """)
+        data = [
+            (1, "row1", decimal.Decimal("999999999999999999.123456"), "test"),
+            (2, "row2", decimal.Decimal("50.0"), "small"),
+            (3, "row3", decimal.Decimal("-999999999999999999.654321"), "negative large"),
+        ]
+        cursor.executemany("INSERT INTO #pytest_gh609_multi VALUES (?, ?, ?, ?)", data)
+        db_connection.commit()
+
+        cursor.execute("SELECT id, amount FROM #pytest_gh609_multi ORDER BY id")
+        rows = cursor.fetchall()
+        assert len(rows) == 3
+        assert rows[0][1] == decimal.Decimal("999999999999999999.123456")
+        assert rows[2][1] == decimal.Decimal("-999999999999999999.654321")
+    finally:
+        cursor.execute("DROP TABLE IF EXISTS #pytest_gh609_multi")
+        db_connection.commit()