FIX: Fix precision loss when binding large Decimal values to SQL_NUMERIC_STRUCT (#287)

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

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

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

-------------------------------------------------------------------
### Summary   
<!-- Insert your summary of changes below. Minimum 10 characters
required. -->
This pull request significantly improves the handling of SQL Server
NUMERIC/DECIMAL values in both the Python and C++ layers, addressing
precision, scale, and binary representation for high-precision decimals.
It also introduces a comprehensive suite of tests to validate numeric
roundtrip, edge cases, and boundary conditions. The changes ensure
compliance with SQL Server's maximum precision (38 digits), robust
conversion between Python decimals and SQL binary formats, and better
test coverage for numeric types.

### Numeric Data Handling Improvements

* The `_get_numeric_data` method in `cursor.py` now correctly calculates
the binary representation of decimal values, supporting up to 38 digits
of precision, and constructs the byte array for SQL Server
compatibility. The restriction on precision is raised from 15 to 38
digits.
[[1]](diffhunk://#diff-deceea46ae01082ce8400e14fa02f4b7585afb7b5ed9885338b66494f5f38280L198-R199)
[[2]](diffhunk://#diff-deceea46ae01082ce8400e14fa02f4b7585afb7b5ed9885338b66494f5f38280L218-R223)
[[3]](diffhunk://#diff-deceea46ae01082ce8400e14fa02f4b7585afb7b5ed9885338b66494f5f38280L232-R251)
* The C++ `NumericData` struct now stores the value as a binary string
(16 bytes) instead of a 64-bit integer, allowing support for
high-precision numerics. Related memory handling is updated for
parameter binding.
[[1]](diffhunk://#diff-dde2297345718ec449a14e7dff91b7bb2342b008ecc071f562233646d71144a1R24)
[[2]](diffhunk://#diff-dde2297345718ec449a14e7dff91b7bb2342b008ecc071f562233646d71144a1L59-R65)
[[3]](diffhunk://#diff-dde2297345718ec449a14e7dff91b7bb2342b008ecc071f562233646d71144a1L560-R564)
[[4]](diffhunk://#diff-dde2297345718ec449a14e7dff91b7bb2342b008ecc071f562233646d71144a1L2055-R2065)
[[5]](diffhunk://#diff-dde2297345718ec449a14e7dff91b7bb2342b008ecc071f562233646d71144a1L3797-R3801)

### Test Suite Expansion and Refactoring

* Old numeric tests were removed and replaced with a new, thorough set
of tests covering roundtrip for basic, high-precision, negative, zero,
small, boundary, NULL, fetchmany, and executemany scenarios for numeric
values. This ensures that all critical cases are validated.
[[1]](diffhunk://#diff-82594712308ff34afa8b067af67db231e9a1372ef474da3db121e14e4d418f69L1643-L1658)
[[2]](diffhunk://#diff-82594712308ff34afa8b067af67db231e9a1372ef474da3db121e14e4d418f69L1724-L1765)
[[3]](diffhunk://#diff-82594712308ff34afa8b067af67db231e9a1372ef474da3db121e14e4d418f69R11348-R11564)

---

These changes collectively make the library more robust and compliant
with SQL Server's numeric type requirements, and the expanded tests will
help catch future regressions.
<!-- 
### 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
-->

Author: gargsaumya

mssql_python/cursor.py

@@ -195,7 +195,8 @@ def _get_numeric_data(self, param):
             the numeric data.
         """
         decimal_as_tuple = param.as_tuple()
-        num_digits = len(decimal_as_tuple.digits)
+        digits_tuple = decimal_as_tuple.digits
+        num_digits = len(digits_tuple)
         exponent = decimal_as_tuple.exponent
 
         # Calculate the SQL precision & scale
@@ -215,12 +216,11 @@ def _get_numeric_data(self, param):
             precision = exponent * -1
             scale = exponent * -1
 
-        # TODO: Revisit this check, do we want this restriction?
-        if precision > 15:
+        if precision > 38:
             raise ValueError(
                 "Precision of the numeric value is too high - "
                 + str(param)
-                + ". Should be less than or equal to 15"
+                + ". Should be less than or equal to 38"
             )
         Numeric_Data = ddbc_bindings.NumericData
         numeric_data = Numeric_Data()
@@ -229,12 +229,26 @@ def _get_numeric_data(self, param):
         numeric_data.sign = 1 if decimal_as_tuple.sign == 0 else 0
         # strip decimal point from param & convert the significant digits to integer
         # Ex: 12.34 ---> 1234
-        val = str(param)
-        if "." in val or "-" in val:
-            val = val.replace(".", "")
-            val = val.replace("-", "")
-        val = int(val)
-        numeric_data.val = val
+        int_str = ''.join(str(d) for d in digits_tuple)
+        if exponent > 0:
+            int_str = int_str + ('0' * exponent)
+        elif exponent < 0:
+            if -exponent > num_digits:
+                int_str = ('0' * (-exponent - num_digits)) + int_str
+
+        if int_str == '':
+            int_str = '0'
+
+        # Convert decimal base-10 string to python int, then to 16 little-endian bytes
+        big_int = int(int_str)
+        byte_array = bytearray(16)  # SQL_MAX_NUMERIC_LEN
+        for i in range(16):
+            byte_array[i] = big_int & 0xFF
+            big_int >>= 8
+            if big_int == 0:
+                break
+
+        numeric_data.val = bytes(byte_array)
         return numeric_data
 
     def _map_sql_type(self, param, parameters_list, i, min_val=None, max_val=None):
@@ -307,7 +321,27 @@ def _map_sql_type(self, param, parameters_list, i, min_val=None, max_val=None):
             )
 
         if isinstance(param, decimal.Decimal):
-        # Detect MONEY / SMALLMONEY range
+            # First check precision limit for all decimal values
+            decimal_as_tuple = param.as_tuple()
+            digits_tuple = decimal_as_tuple.digits
+            num_digits = len(digits_tuple)
+            exponent = decimal_as_tuple.exponent
+
+            # Calculate the SQL precision (same logic as _get_numeric_data)
+            if exponent >= 0:
+                precision = num_digits + exponent
+            elif (-1 * exponent) <= num_digits:
+                precision = num_digits
+            else:
+                precision = exponent * -1
+
+            if precision > 38:
+                raise ValueError(
+                    f"Precision of the numeric value is too high. "
+                    f"The maximum precision supported by SQL Server is 38, but got {precision}."
+                )
+
+            # Detect MONEY / SMALLMONEY range
             if SMALLMONEY_MIN  <= param <= SMALLMONEY_MAX:
                 # smallmoney
                 parameters_list[i] = str(param)

mssql_python/pybind/ddbc_bindings.cpp

@@ -21,6 +21,7 @@
 #define SQL_SS_TIMESTAMPOFFSET (-155)
 #define SQL_C_SS_TIMESTAMPOFFSET (0x4001)
 #define MAX_DIGITS_IN_NUMERIC 64
+#define SQL_MAX_NUMERIC_LEN 16
 #define SQL_SS_XML (-152)
 
 #define STRINGIFY_FOR_CASE(x) \
@@ -57,12 +58,18 @@ struct NumericData {
     SQLCHAR precision;
     SQLSCHAR scale;
     SQLCHAR sign;  // 1=pos, 0=neg
-    std::uint64_t val; // 123.45 -> 12345
+    std::string val; // 123.45 -> 12345
 
-    NumericData() : precision(0), scale(0), sign(0), val(0) {}
+    NumericData() : precision(0), scale(0), sign(0), val(SQL_MAX_NUMERIC_LEN, '\0') {}
 
-    NumericData(SQLCHAR precision, SQLSCHAR scale, SQLCHAR sign, std::uint64_t value)
-        : precision(precision), scale(scale), sign(sign), val(value) {}
+    NumericData(SQLCHAR precision, SQLSCHAR scale, SQLCHAR sign, const std::string& valueBytes)
+        : precision(precision), scale(scale), sign(sign), val(SQL_MAX_NUMERIC_LEN, '\0') {
+        if (valueBytes.size() > SQL_MAX_NUMERIC_LEN) {
+            throw std::runtime_error("NumericData valueBytes size exceeds SQL_MAX_NUMERIC_LEN (16)");
+        }
+        // Copy binary data to buffer, remaining bytes stay zero-padded
+        std::memcpy(&val[0], valueBytes.data(), valueBytes.size());
+    }
 };
 
 // Struct to hold the DateTimeOffset structure
@@ -558,9 +565,10 @@ SQLRETURN BindParameters(SQLHANDLE hStmt, const py::list& params,
                 decimalPtr->sign = decimalParam.sign;
                 // Convert the integer decimalParam.val to char array
                 std::memset(static_cast<void*>(decimalPtr->val), 0, sizeof(decimalPtr->val));
-                std::memcpy(static_cast<void*>(decimalPtr->val),
-			    reinterpret_cast<char*>(&decimalParam.val),
-                            sizeof(decimalParam.val));
+                size_t copyLen = std::min(decimalParam.val.size(), sizeof(decimalPtr->val));
+                if (copyLen > 0) {
+                    std::memcpy(decimalPtr->val, decimalParam.val.data(), copyLen);
+                }
                 dataPtr = static_cast<void*>(decimalPtr);
                 break;
             }
@@ -2051,15 +2059,17 @@ SQLRETURN BindParameterArray(SQLHANDLE hStmt,
                             throw std::runtime_error(MakeParamMismatchErrorStr(info.paramCType, paramIndex));
                         }
                         NumericData decimalParam = element.cast<NumericData>();
-                        LOG("Received numeric parameter at [%zu]: precision=%d, scale=%d, sign=%d, val=%lld",
-                            i, decimalParam.precision, decimalParam.scale, decimalParam.sign, decimalParam.val);
-                        numericArray[i].precision = decimalParam.precision;
-                        numericArray[i].scale = decimalParam.scale;
-                        numericArray[i].sign = decimalParam.sign;
-                        std::memset(numericArray[i].val, 0, sizeof(numericArray[i].val));
-                        std::memcpy(numericArray[i].val,
-                                    reinterpret_cast<const char*>(&decimalParam.val),
-                                    std::min(sizeof(decimalParam.val), sizeof(numericArray[i].val)));
+                        LOG("Received numeric parameter at [%zu]: precision=%d, scale=%d, sign=%d, val=%s",
+                            i, decimalParam.precision, decimalParam.scale, decimalParam.sign, decimalParam.val.c_str());
+                        SQL_NUMERIC_STRUCT& target = numericArray[i];
+                        std::memset(&target, 0, sizeof(SQL_NUMERIC_STRUCT));
+                        target.precision = decimalParam.precision;
+                        target.scale = decimalParam.scale;
+                        target.sign = decimalParam.sign;
+                        size_t copyLen = std::min(decimalParam.val.size(), sizeof(target.val));
+                        if (copyLen > 0) {
+                            std::memcpy(target.val, decimalParam.val.data(), copyLen);
+                        }
                         strLenOrIndArray[i] = sizeof(SQL_NUMERIC_STRUCT);
                     }
                     dataPtr = numericArray;
@@ -3800,7 +3810,7 @@ PYBIND11_MODULE(ddbc_bindings, m) {
     // Define numeric data class
     py::class_<NumericData>(m, "NumericData")
         .def(py::init<>())
-        .def(py::init<SQLCHAR, SQLSCHAR, SQLCHAR, std::uint64_t>())
+        .def(py::init<SQLCHAR, SQLSCHAR, SQLCHAR, const std::string&>())
         .def_readwrite("precision", &NumericData::precision)
         .def_readwrite("scale", &NumericData::scale)
         .def_readwrite("sign", &NumericData::sign)