also fixes the github issue #241

Author: gargsaumya

mssql_python/cursor.py

@@ -319,6 +319,16 @@ def _map_sql_type(self, param, parameters_list, i):
                     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 (
@@ -333,6 +343,20 @@ def _map_sql_type(self, param, parameters_list, i):
                     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):
@@ -426,15 +450,6 @@ def _map_sql_type(self, param, parameters_list, i):
                 False,
             )
 
-        if isinstance(param, uuid.UUID):
-            return (
-                ddbc_sql_const.SQL_GUID.value,
-                ddbc_sql_const.SQL_C_GUID.value,
-                16,
-                0,
-                False,
-            )
-
         if isinstance(param, datetime.datetime):
             return (
                 ddbc_sql_const.SQL_TIMESTAMP.value,

mssql_python/pybind/ddbc_bindings.cpp

@@ -484,27 +484,28 @@ SQLRETURN BindParameters(SQLHANDLE hStmt, const py::list& params,
                 break;
             }
             case SQL_C_GUID: {
-                py::object uuid_obj = param;
-                py::object uuid_cls = py::module_::import("uuid").attr("UUID");
-                if (!py::isinstance(uuid_obj, uuid_cls)) {
+                if (!py::isinstance<py::bytes>(param)) {
                     ThrowStdException(MakeParamMismatchErrorStr(paramInfo.paramCType, paramIndex));
                 }
-                py::bytes uuid_bytes = uuid_obj.attr("bytes").cast<py::bytes>();
+                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.");
                 }
-                const unsigned char* b = reinterpret_cast<const unsigned char*>(PyBytes_AS_STRING(uuid_bytes.ptr()));
                 SQLGUID* guid_data_ptr = AllocateParamBuffer<SQLGUID>(paramBuffers);
-                guid_data_ptr->Data1 = (static_cast<uint32_t>(b[3]) << 24) |
-                                    (static_cast<uint32_t>(b[2]) << 16) |
-                                    (static_cast<uint32_t>(b[1]) << 8) |
-                                    static_cast<uint32_t>(b[0]);
-                guid_data_ptr->Data2 = (static_cast<uint16_t>(b[5]) << 8) |
-                                    static_cast<uint16_t>(b[4]);
-                guid_data_ptr->Data3 = (static_cast<uint16_t>(b[7]) << 8) |
-                                    static_cast<uint16_t>(b[6]);
-                std::memcpy(guid_data_ptr->Data4, &b[8], 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) |
+                    (static_cast<uint16_t>(uuid_data[4]));
+                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);
                 strLenOrIndPtr = AllocateParamBuffer<SQLLEN>(paramBuffers);
@@ -2240,7 +2241,8 @@ SQLRETURN SQLGetData_wrap(SqlHandlePtr StatementHandle, SQLUSMALLINT colCount, p
                     std::memcpy(&guid_bytes[8], guidValue.Data4, sizeof(guidValue.Data4));
 
                     py::bytes py_guid_bytes(guid_bytes.data(), guid_bytes.size());
-                    py::object uuid_obj = py::module_::import("uuid").attr("UUID")(py::arg("bytes") = py_guid_bytes);
+                    py::object uuid_module = py::module_::import("uuid");
+                    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());
@@ -2622,10 +2624,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));
-
-                    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);