Merge branch 'saumya/uuid' into saumya/uuid-executemany

Author: gargsaumya

PyPI_Description.md

@@ -39,20 +39,15 @@ PyBind11 provides:
 
 We are currently in **Public Preview**.
 
-## What's new in v0.10.0
-
-- **SUSE Linux Support:** Added full support for SUSE and openSUSE distributions alongside existing other Linux distros support, broadening enterprise Linux compatibility.
-- **Context Manager Support:** Implemented Python `with` statement support for Connection and Cursor classes with automatic transaction management and resource cleanup.
-- **Large Text Streaming:** Added Data At Execution (DAE) support for streaming large text parameters (`NVARCHAR(MAX)`, `VARCHAR(MAX)`), eliminating memory constraints for bulk text `execute()` operations.
-  - `VARBINARY(MAX)` support to follow alongwith streaming support for fetch operations.
-- **Enhanced Unicode Handling:** Improved emoji and international character support with robust UTF-16 encoding for reliable multilingual data processing.
-- **PyODBC Compatibility:** Enhanced API compatibility with pyodbc including:
-  - DB-API 2.0 exception classes: `Warning`, `Error`, `InterfaceError`, `DatabaseError`, `DataError`, `OperationalError`, `IntegrityError`, `InternalError`, `ProgrammingError`, `NotSupportedError`
-  - Context manager support with `with` statements for Connection and Cursor
-  - Encoding configuration APIs: `setencoding()`, `getencoding()`, `setdecoding()`, `getdecoding()`
-  - Cursor navigation APIs: `next()`, `__iter__()`, `scroll()`, `skip()`, `fetchval()`
-  - Cursor attributes: `rownumber`, `messages`
-  - Additional methods: `cursor.commit()`, `cursor.rollback()`, `table()`
+## What's new in v0.11.0
+
+- **Database Metadata & Introspection:** Added comprehensive `getInfo()` method and extensive catalog APIs (`SQLGetTypeInfo`, `SQLProcedures`, `SQLForeignKeys`, `SQLColumns`) for complete database schema discovery and introspection capabilities.
+- **Advanced Parameter Management:** Implemented `setinputsizes()` with SQL type constants and enhanced parameter validation through the `SQLTypes` class for precise type control in parameterized queries.
+- **Large Data Streaming Enhancements:** Extended streaming support to VARBINARY(MAX) and VARCHAR(MAX) across all fetch operations (`fetchone`, `fetchmany`, `fetchall`) with improved chunked retrieval for efficient memory usage.
+- **Output Data Conversion System:** Introduced flexible output converter framework with `add_output_converter()`, `remove_output_converter()`, and related methods for customizable data transformations during result fetching.
+- **Connection-Level Execute:** Added direct `execute()` method to Connection class for streamlined query execution without explicit cursor management.
+- **Financial Data Type Support:** Comprehensive support for SQL Server MONEY and SMALLMONEY types with proper boundary value handling and decimal precision.
+- **Enhanced Configuration APIs:** Added connection timeout control, decimal separator configuration (`getDecimalSeperator()`, `setDecimalSeperator()`), and improved global variable management.
 
 For more information, please visit the project link on Github: https://github.com/microsoft/mssql-python
 

mssql_python/cursor.py

@@ -338,6 +338,16 @@ def _map_sql_type(self, param, parameters_list, i, min_val=None, max_val=None):
                     parameters_list[i].scale,
                     False,
                 )
+            
+        if isinstance(param, uuid.UUID):
+            parameters_list[i] = param.bytes_le
+            return (
+                ddbc_sql_const.SQL_GUID.value,
+                ddbc_sql_const.SQL_C_GUID.value,
+                16,
+                0,
+                False,
+            )
 
         if isinstance(param, str):
             if (
@@ -352,6 +362,20 @@ def _map_sql_type(self, param, parameters_list, i, min_val=None, max_val=None):
                     0,
                     False,
                 )
+            
+            try:
+                val = uuid.UUID(param)
+                parameters_list[i] = val.bytes_le
+                return (
+                    ddbc_sql_const.SQL_GUID.value,
+                    ddbc_sql_const.SQL_C_GUID.value,
+                    16,
+                    0,
+                    False
+                )
+            except ValueError:
+                pass
+
 
             # Attempt to parse as date, datetime, datetime2, timestamp, smalldatetime or time
             if self._parse_date(param):

mssql_python/pybind/ddbc_bindings.cpp

@@ -510,22 +510,21 @@ SQLRETURN BindParameters(SQLHANDLE hStmt, const py::list& params,
                 py::bytes uuid_bytes = param.cast<py::bytes>();
                 const unsigned char* uuid_data = reinterpret_cast<const unsigned char*>(PyBytes_AS_STRING(uuid_bytes.ptr()));
                 if (PyBytes_GET_SIZE(uuid_bytes.ptr()) != 16) {
+                    LOG("Invalid UUID parameter at index {}: expected 16 bytes, got {} bytes, type {}", paramIndex, PyBytes_GET_SIZE(uuid_bytes.ptr()), paramInfo.paramCType);
                     ThrowStdException("UUID binary data must be exactly 16 bytes long.");
                 }
                 SQLGUID* guid_data_ptr = AllocateParamBuffer<SQLGUID>(paramBuffers);
-
-                guid_data_ptr->Data1 = 
-                    (static_cast<uint32_t>(uuid_data[3]) << 24) | 
-                    (static_cast<uint32_t>(uuid_data[2]) << 16) | 
-                    (static_cast<uint32_t>(uuid_data[1]) << 8)  | 
+                guid_data_ptr->Data1 =
+                    (static_cast<uint32_t>(uuid_data[3]) << 24) |
+                    (static_cast<uint32_t>(uuid_data[2]) << 16) |
+                    (static_cast<uint32_t>(uuid_data[1]) << 8)  |
                     (static_cast<uint32_t>(uuid_data[0]));
-                guid_data_ptr->Data2 = 
-                    (static_cast<uint16_t>(uuid_data[5]) << 8) | 
+                guid_data_ptr->Data2 =
+                    (static_cast<uint16_t>(uuid_data[5]) << 8) |
                     (static_cast<uint16_t>(uuid_data[4]));
-                guid_data_ptr->Data3 = 
-                    (static_cast<uint16_t>(uuid_data[7]) << 8) | 
+                guid_data_ptr->Data3 =
+                    (static_cast<uint16_t>(uuid_data[7]) << 8) |
                     (static_cast<uint16_t>(uuid_data[6]));
-
                 std::memcpy(guid_data_ptr->Data4, &uuid_data[8], 8);
                 dataPtr = static_cast<void*>(guid_data_ptr);
                 bufferLength = sizeof(SQLGUID);
@@ -2635,7 +2634,7 @@ SQLRETURN SQLGetData_wrap(SqlHandlePtr StatementHandle, SQLUSMALLINT colCount, p
 
                     py::bytes py_guid_bytes(guid_bytes.data(), guid_bytes.size());
                     py::object uuid_module = py::module_::import("uuid");
-                    py::object uuid_obj = uuid_module.attr("UUID")(py_guid_bytes);
+                    py::object uuid_obj = uuid_module.attr("UUID")(py::arg("bytes")=py_guid_bytes);
                     row.append(uuid_obj);
                 } else if (indicator == SQL_NULL_DATA) {
                     row.append(py::none());
@@ -3030,11 +3029,18 @@ SQLRETURN FetchBatchData(SQLHSTMT hStmt, ColumnBuffers& buffers, py::list& colum
                 }
                 case SQL_GUID: {
                     SQLGUID* guidValue = &buffers.guidBuffers[col - 1][i];
-                    std::vector<char> guid_bytes(16);
-                    std::memcpy(guid_bytes.data(), guidValue, sizeof(SQLGUID));
-
-                    // Convert the raw C++ byte vector to a Python bytes object
-                    py::bytes py_guid_bytes(guid_bytes.data(), guid_bytes.size());
+                    uint8_t reordered[16];
+                    reordered[0] = ((char*)&guidValue->Data1)[3];
+                    reordered[1] = ((char*)&guidValue->Data1)[2];
+                    reordered[2] = ((char*)&guidValue->Data1)[1];
+                    reordered[3] = ((char*)&guidValue->Data1)[0];
+                    reordered[4] = ((char*)&guidValue->Data2)[1];
+                    reordered[5] = ((char*)&guidValue->Data2)[0];
+                    reordered[6] = ((char*)&guidValue->Data3)[1];
+                    reordered[7] = ((char*)&guidValue->Data3)[0];
+                    std::memcpy(reordered + 8, guidValue->Data4, 8);
+
+                    py::bytes py_guid_bytes(reinterpret_cast<char*>(reordered), 16);
                     py::dict kwargs;
                     kwargs["bytes"] = py_guid_bytes;
                     py::object uuid_obj = py::module_::import("uuid").attr("UUID")(**kwargs);

setup.py

@@ -83,7 +83,7 @@ def finalize_options(self):
 
 setup(
     name='mssql-python',
-    version='0.10.0',
+    version='0.11.0',
     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',