pyodbc 5.0.1__tar.gz → 5.2.0__tar.gz

{pyodbc-5.0.1/src/pyodbc.egg-info → pyodbc-5.2.0}/PKG-INFO

@@ -1,16 +1,16 @@
 Metadata-Version: 2.1
 Name: pyodbc
-Version: 5.0.1
+Version: 5.2.0
 Summary: DB API Module for ODBC
 Home-page: https://github.com/mkleehammer/pyodbc
 Maintainer: Michael Kleehammer
 Maintainer-email: michael@kleehammer.com
-License: MIT
+License: MIT-0
 Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: System Administrators
-Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: OSI Approved :: MIT No Attribution License (MIT-0)
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX
 Classifier: Programming Language :: Python

{pyodbc-5.0.1 → pyodbc-5.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyodbc"
-version = "5.0.1"
+version = "5.2.0"
 
 requires-python = ">=3.8"
 # This is used by the GitHub action that builds release artifacts using cibuildwheel.
@@ -10,7 +10,7 @@ requires-python = ">=3.8"
 
 description = "DB API module for ODBC"
 readme = "README.md"
-license = {text = "MIT License"}
+license = {text = "MIT-0 License"}
 
 authors = [{name = "Michael Kleehammer", email="michael@kleehammer.com"}]
 
@@ -22,7 +22,7 @@ maintainers = [{name = "Michael Kleehammer", email="michael@kleehammer.com"}]
 classifiers=['Development Status :: 5 - Production/Stable',
              'Intended Audience :: Developers',
              'Intended Audience :: System Administrators',
-             'License :: OSI Approved :: MIT License',
+             'License :: OSI Approved :: MIT No Attribution License (MIT-0)',
              'Operating System :: Microsoft :: Windows',
              'Operating System :: POSIX',
              'Programming Language :: Python',

{pyodbc-5.0.1 → pyodbc-5.2.0}/setup.py

@@ -55,12 +55,12 @@ def main():
         packages=[''],
         package_dir={'': 'src'},
         package_data={'': ['pyodbc.pyi']},  # places pyodbc.pyi alongside pyodbc.{platform}.{pyd|so} in site-packages
-        license='MIT',
+        license='MIT-0',
         python_requires='>=3.8',
         classifiers=['Development Status :: 5 - Production/Stable',
                      'Intended Audience :: Developers',
                      'Intended Audience :: System Administrators',
-                     'License :: OSI Approved :: MIT License',
+                     'License :: OSI Approved :: MIT No Attribution License (MIT-0)',
                      'Operating System :: Microsoft :: Windows',
                      'Operating System :: POSIX',
                      'Programming Language :: Python',

{pyodbc-5.0.1 → pyodbc-5.2.0}/src/connection.cpp

@@ -59,7 +59,7 @@ static char* StrDup(const char* text) {
 }
 
 
-static bool Connect(PyObject* pConnectString, HDBC hdbc, long timeout, Object& encoding)
+static bool Connect(PyObject* pConnectString, HDBC hdbc, long timeout, PyObject* encoding)
 {
     assert(PyUnicode_Check(pConnectString));
 
@@ -170,7 +170,7 @@ static bool ApplyPreconnAttrs(HDBC hdbc, SQLINTEGER ikey, PyObject *value, char
 }
 
 PyObject* Connection_New(PyObject* pConnectString, bool fAutoCommit, long timeout, bool fReadOnly,
-                         PyObject* attrs_before, Object& encoding)
+                         PyObject* attrs_before, PyObject* encoding)
 {
     //
     // Allocate HDBC and connect
@@ -196,7 +196,7 @@ PyObject* Connection_New(PyObject* pConnectString, bool fAutoCommit, long timeou
         PyObject* value = 0;
 
         Object encodingholder;
-        char *strencoding = encoding.Get() ?
+        char *strencoding = (encoding != 0) ?
             (PyUnicode_Check(encoding) ? PyBytes_AsString(encodingholder = PyCodec_Encode(encoding, "utf-8", "strict")) :
              PyBytes_Check(encoding) ? PyBytes_AsString(encoding) : 0) : 0;
 

{pyodbc-5.0.1 → pyodbc-5.2.0}/src/connection.h

@@ -104,7 +104,7 @@ struct Connection
  * exception is set and zero is returned.
  */
 PyObject* Connection_New(PyObject* pConnectString, bool fAutoCommit, long timeout, bool fReadOnly,
-                         PyObject* attrs_before, Object& encoding);
+                         PyObject* attrs_before, PyObject* encoding);
 
 /*
  * Used by the Cursor to implement commit and rollback.

{pyodbc-5.0.1 → pyodbc-5.2.0}/src/cursor.cpp

@@ -577,7 +577,7 @@ static bool PrepareResults(Cursor* cur, int cCols)
 }
 
 
-static int GetDiagRecs(Cursor* cur)
+int GetDiagRecs(Cursor* cur)
 {
     // Retrieves all diagnostic records from the cursor and assigns them to the "messages" attribute.
 
@@ -873,8 +873,6 @@ static PyObject* execute(Cursor* cur, PyObject* pSql, PyObject* params, bool ski
                         Py_XDECREF(prevParam->pObject);
                         newParam.BufferLength = newParam.StrLen_or_Ind;
                         newParam.StrLen_or_Ind = SQL_DATA_AT_EXEC;
-                        Py_INCREF(cell);
-                        newParam.pObject = cell;
                         *prevParam = newParam;
                         if(prevParam->ParameterValuePtr == &newParam.Data)
                         {

{pyodbc-5.0.1 → pyodbc-5.2.0}/src/cursor.h

@@ -156,6 +156,8 @@ struct Cursor
     PyObject* messages;
 };
 
+int GetDiagRecs(Cursor* cur);
+
 void Cursor_init();
 
 Cursor* Cursor_New(Connection* cnxn);

{pyodbc-5.0.1 → pyodbc-5.2.0}/src/dbspecific.h

@@ -11,6 +11,7 @@
 // SQL Server
 
 
+#define SQL_SS_VARIANT -150     // SQL Server 2008 SQL_VARIANT type
 #define SQL_SS_XML -152         // SQL Server 2005 XML type
 #define SQL_DB2_DECFLOAT -360   // IBM DB/2 DECFLOAT type
 #define SQL_DB2_XML -370        // IBM DB/2 XML type

{pyodbc-5.0.1 → pyodbc-5.2.0}/src/getdata.cpp

@@ -38,6 +38,7 @@ void GetData_init()
 }
 
 static byte* ReallocOrFreeBuffer(byte* pb, Py_ssize_t cbNeed);
+PyObject *GetData_SqlVariant(Cursor *cur, Py_ssize_t iCol);
 
 inline bool IsBinaryType(SQLSMALLINT sqltype)
 {
@@ -534,28 +535,30 @@ static PyObject* GetDataTimestamp(Cursor* cur, Py_ssize_t iCol)
 
     switch (cur->colinfos[iCol].sql_type)
     {
-		case SQL_TYPE_TIME:
-		{
-			int micros = (int)(value.fraction / 1000); // nanos --> micros
-			return PyTime_FromTime(value.hour, value.minute, value.second, micros);
-		}
-
-		case SQL_TYPE_DATE:
-			return PyDate_FromDate(value.year, value.month, value.day);
-
-		case SQL_TYPE_TIMESTAMP:
-		{
-			if (value.year < 1)
-			{
-				value.year = 1;
-			}
-			else if (value.year > 9999)
-			{
-				value.year = 9999;
-			}
-		}
+        case SQL_TYPE_TIME:
+        {
+            int micros = (int)(value.fraction / 1000); // nanos --> micros
+            return PyTime_FromTime(value.hour, value.minute, value.second, micros);
+        }
+
+        case SQL_TYPE_DATE:
+        case SQL_DATE:
+            return PyDate_FromDate(value.year, value.month, value.day);
+
+        case SQL_TYPE_TIMESTAMP:
+        case SQL_TIMESTAMP:
+        {
+            if (value.year < 1)
+            {
+                value.year = 1;
+            }
+            else if (value.year > 9999)
+            {
+                value.year = 9999;
+            }
+        }
     }
-	
+
 
     int micros = (int)(value.fraction / 1000); // nanos --> micros
 
@@ -645,6 +648,7 @@ PyObject* PythonTypeFromSqlType(Cursor* cur, SQLSMALLINT type)
         break;
 
     case SQL_TYPE_DATE:
+    case SQL_DATE:
         pytype = (PyObject*)PyDateTimeAPI->DateType;
         break;
 
@@ -654,6 +658,7 @@ PyObject* PythonTypeFromSqlType(Cursor* cur, SQLSMALLINT type)
         break;
 
     case SQL_TYPE_TIMESTAMP:
+    case SQL_TIMESTAMP:
         pytype = (PyObject*)PyDateTimeAPI->DateTimeType;
         break;
 
@@ -744,15 +749,55 @@ PyObject* GetData(Cursor* cur, Py_ssize_t iCol)
         return GetDataDouble(cur, iCol);
 
 
+    case SQL_DATE:
     case SQL_TYPE_DATE:
     case SQL_TYPE_TIME:
+    case SQL_TIMESTAMP:
     case SQL_TYPE_TIMESTAMP:
         return GetDataTimestamp(cur, iCol);
 
     case SQL_SS_TIME2:
         return GetSqlServerTime(cur, iCol);
+
+    case SQL_SS_VARIANT:
+        return GetData_SqlVariant(cur, iCol);
     }
 
     return RaiseErrorV("HY106", ProgrammingError, "ODBC SQL type %d is not yet supported.  column-index=%zd  type=%d",
                        (int)pinfo->sql_type, iCol, (int)pinfo->sql_type);
 }
+
+PyObject *GetData_SqlVariant(Cursor *cur, Py_ssize_t iCol) {
+    char pBuff;
+
+    SQLLEN indicator, variantType;
+    SQLRETURN retcode;
+
+    PyObject *decodeResult;
+
+    // Call SQLGetData on the current column with a data length of 0. According to MS, this makes
+    // the ODBC driver read the sql_variant header which contains the underlying data type
+    pBuff = 0;
+    indicator = 0;
+    retcode = SQLGetData(cur->hstmt, static_cast<SQLSMALLINT>(iCol + 1), SQL_C_BINARY,
+                                    &pBuff, 0, &indicator);
+    if (!SQL_SUCCEEDED(retcode))
+        return RaiseErrorFromHandle(cur->cnxn, "SQLGetData", cur->cnxn->hdbc, cur->hstmt);
+
+    // Get the SQL_CA_SS_VARIANT_TYPE field for the column which will contain the underlying data type
+    variantType = 0;
+    retcode = SQLColAttribute(cur->hstmt, iCol + 1, SQL_CA_SS_VARIANT_TYPE, NULL, 0, NULL, &variantType);
+    if (!SQL_SUCCEEDED(retcode))
+        return RaiseErrorFromHandle(cur->cnxn, "SQLColAttribute", cur->cnxn->hdbc, cur->hstmt);
+
+    // Replace the original SQL_VARIANT data type with the underlying data type then call GetData() again
+    cur->colinfos[iCol].sql_type = static_cast<SQLSMALLINT>(variantType);
+    decodeResult = GetData(cur, iCol);
+
+    // Restore the original SQL_VARIANT data type so that the next decode will call this method again
+    cur->colinfos[iCol].sql_type = static_cast<SQLSMALLINT>(SQL_SS_VARIANT);
+
+    return decodeResult;
+
+    // NOTE: we don't free the hstmt here as it's managed by the cursor
+}

{pyodbc-5.0.1 → pyodbc-5.2.0}/src/params.cpp

@@ -247,8 +247,13 @@ static int PyToCType(Cursor *cur, unsigned char **outbuf, PyObject *cell, ParamI
             pNum->precision = (SQLCHAR)pi->ColumnSize;
             pNum->scale = (SQLCHAR)pi->DecimalDigits;
             pNum->sign = _PyLong_Sign(cell) >= 0;
-            if (_PyLong_AsByteArray((PyLongObject*)absVal, pNum->val, sizeof(pNum->val), 1, 0))
+#if PY_VERSION_HEX < 0x030D0000
+            if (_PyLong_AsByteArray((PyLongObject*)absVal, pNum->val, sizeof(pNum->val), 1, 0)) {
+#else
+            if (_PyLong_AsByteArray((PyLongObject*)absVal, pNum->val, sizeof(pNum->val), 1, 0, 1)) {
+#endif
                 goto NumericOverflow;
+            }
             Py_XDECREF(absVal);
             *outbuf += pi->BufferLength;
             ind = sizeof(SQL_NUMERIC_STRUCT);
@@ -477,7 +482,12 @@ static int PyToCType(Cursor *cur, unsigned char **outbuf, PyObject *cell, ParamI
         pNum->precision = (SQLCHAR)pi->ColumnSize;
         pNum->scale = (SQLCHAR)pi->DecimalDigits;
 
+
+#if PY_VERSION_HEX < 0x030D0000
         int ret = _PyLong_AsByteArray((PyLongObject*)digitLong, pNum->val, sizeof(pNum->val), 1, 0);
+#else
+        int ret = _PyLong_AsByteArray((PyLongObject*)digitLong, pNum->val, sizeof(pNum->val), 1, 0, 1);
+#endif
         Py_XDECREF(digitLong);
         if (ret)
         {
@@ -1266,6 +1276,7 @@ bool BindParameter(Cursor* cur, Py_ssize_t index, ParamInfo& info)
             {
                 // Bind the TVP's columns --- all need to use DAE
                 PyObject *param = PySequence_GetItem(row, i);
+                Py_XDECREF(param);
                 GetParameterInfo(cur, i, param, info.nested[i], true);
                 info.nested[i].BufferLength = info.nested[i].StrLen_or_Ind;
                 info.nested[i].StrLen_or_Ind = SQL_DATA_AT_EXEC;
@@ -1674,6 +1685,11 @@ bool ExecuteMulti(Cursor* cur, PyObject* pSql, PyObject* paramArrayObj)
             goto ErrorRet8;
         }
 
+        if (rc == SQL_SUCCESS_WITH_INFO)
+        {
+            GetDiagRecs(cur);
+        }
+
         // TODO: Refactor into ProcessDAEParams() ?
         while (rc == SQL_NEED_DATA)
         {

{pyodbc-5.0.1 → pyodbc-5.2.0/src/pyodbc.egg-info}/PKG-INFO

@@ -1,16 +1,16 @@
 Metadata-Version: 2.1
 Name: pyodbc
-Version: 5.0.1
+Version: 5.2.0
 Summary: DB API Module for ODBC
 Home-page: https://github.com/mkleehammer/pyodbc
 Maintainer: Michael Kleehammer
 Maintainer-email: michael@kleehammer.com
-License: MIT
+License: MIT-0
 Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: System Administrators
-Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: OSI Approved :: MIT No Attribution License (MIT-0)
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX
 Classifier: Programming Language :: Python

{pyodbc-5.0.1 → pyodbc-5.2.0}/src/pyodbc.h

@@ -76,6 +76,10 @@ typedef unsigned long long UINT64;
 #define SQL_CA_SS_CATALOG_NAME 1225
 #endif
 
+#ifndef SQL_CA_SS_VARIANT_TYPE
+#define SQL_CA_SS_VARIANT_TYPE 1215
+#endif
+
 inline bool IsSet(DWORD grf, DWORD flags)
 {
     return (grf & flags) == flags;
@@ -117,7 +121,7 @@ inline void DebugTrace(const char* szFmt, ...) { UNUSED(szFmt); }
 
 // issue #880: entry missing from iODBC sqltypes.h
 #ifndef BYTE
-  typedef unsigned char		BYTE;
+  typedef unsigned char BYTE;
 #endif
 bool PyMem_Realloc(BYTE** pp, size_t newlen);
 // A wrapper around realloc with a safer interface.  If it is successful, *pp is updated to the

{pyodbc-5.0.1 → pyodbc-5.2.0}/src/pyodbc.pyi

@@ -60,6 +60,7 @@ SQL_TYPE_DATE: int
 SQL_TYPE_TIME: int
 SQL_TYPE_TIMESTAMP: int
 SQL_SS_TIME2: int
+SQL_SS_VARIANT: int
 SQL_SS_XML: int
 SQL_INTERVAL_MONTH: int
 SQL_INTERVAL_YEAR: int
@@ -497,11 +498,13 @@ class Connection:
         ...
 
     def commit(self) -> None:
-        """Commit all SQL statements executed on the connection since the last commit/rollback."""
+        """Commit all pending transactions since the last commit/rollback.  This includes
+        all SQL statements executed from ALL cursors created on this connection."""
         ...
 
     def rollback(self) -> None:
-        """Rollback all SQL statements executed on the connection since the last commit/rollback."""
+        """Rollback all pending transactions since the last commit/rollback.  This includes
+        all SQL statements executed from ALL cursors created on this connection."""
         ...
 
     def close(self) -> None:
@@ -695,17 +698,17 @@ class Cursor:
         ...
 
     def commit(self) -> None:
-        """Commit all SQL statements executed on the parent connection since the last
-        commit/rollback.  Note, this affects ALL cursors on the parent connection.
-        Hence, consider calling commit() on the parent Connection object instead.
-        """
+        """A convenience function for executing a commit on the parent connection.
+        Commits all pending transactions on the parent connection since the last
+        commit/rollback.  This includes all SQL statements executed from ALL cursors
+        created on the parent connection, not just this cursor."""
         ...
 
     def rollback(self) -> None:
-        """Rollback all SQL statements executed on the parent connection since the last
-        commit/rollback.  Note, this affects ALL cursors on the parent connection.
-        Hence, consider calling rollback() on the parent Connection object instead.
-        """
+        """A convenience function for executing a rollback on the parent connection.
+        Rolls back all pending transactions on the parent connection since the last
+        commit/rollback.  This includes all SQL statements executed from ALL cursors
+        created on the parent connection, not just this cursor."""
         ...
 
     def cancel(self) -> None:
@@ -985,7 +988,7 @@ def connect(connstring: Optional[str] = None,
             encoding: str = 'utf-16le',
             readonly: bool = False,
             timeout: int = 0,
-            attrs_before: Optional[Dict[int, Any]] = None,
+            attrs_before: Optional[Dict[int, Union[int, bytes, bytearray, str, Sequence[str]]]] = None,
             **kwargs: Any) -> Connection:
     """Create a new ODBC connection to a database.  See the Wiki for details:
     https://github.com/mkleehammer/pyodbc/wiki/The-pyodbc-Module#connect

{pyodbc-5.0.1 → pyodbc-5.2.0}/src/pyodbcdbg.cpp

@@ -34,6 +34,7 @@ const char* SqlTypeName(SQLSMALLINT n)
         _MAKESTR(SQL_TYPE_TIME);
         _MAKESTR(SQL_TYPE_TIMESTAMP);
         _MAKESTR(SQL_SS_TIME2);
+        _MAKESTR(SQL_SS_VARIANT);
         _MAKESTR(SQL_SS_XML);
         _MAKESTR(SQL_BINARY);
         _MAKESTR(SQL_VARBINARY);

{pyodbc-5.0.1 → pyodbc-5.2.0}/src/pyodbcmodule.cpp

@@ -399,7 +399,7 @@ static PyObject* mod_connect(PyObject* self, PyObject* args, PyObject* kwargs)
     int fAutoCommit = 0;
     int fReadOnly = 0;
     long timeout = 0;
-    Object encoding;
+    PyObject* encoding = 0;
 
     Object attrs_before; // Optional connect attrs set before connecting
 
@@ -865,6 +865,7 @@ static const ConstantDef aConstants[] = {
     MAKECONST(SQL_TYPE_TIME),
     MAKECONST(SQL_TYPE_TIMESTAMP),
     MAKECONST(SQL_SS_TIME2),
+    MAKECONST(SQL_SS_VARIANT),
     MAKECONST(SQL_SS_XML),
     MAKECONST(SQL_INTERVAL_MONTH),
     MAKECONST(SQL_INTERVAL_YEAR),

{pyodbc-5.0.1 → pyodbc-5.2.0}/tests/postgresql_test.py

@@ -593,3 +593,30 @@ def test_output_conversion(cursor: pyodbc.Cursor):
     cursor.connection.add_output_converter(pyodbc.SQL_WVARCHAR, None)
     value = cursor.execute("select v from t1").fetchone()[0]
     assert value == '123.45'
+
+
+def test_refcount_encoding():
+    """
+    Ensure we handle the reference count to `encoding` properly.  In the past we freed a
+    borrowed reference.  This would cause a segfault.
+    """
+    # https://github.com/mkleehammer/pyodbc/issues/1343
+    import sys
+    encoding = 'utf-16le'
+    count_before = sys.getrefcount(encoding)
+
+    def _test():
+        # I've moved this into a function so the exception's stack trace will be freed under
+        # the covers when we leave the function.  Otherwise we'd have a 2nd reference to
+        # `encoding` in the stack trace of the exception.
+        try:
+            cnxn = pyodbc.connect(CNXNSTR, encoding=encoding)
+        except:
+            pass
+
+    for i in range(10):
+        _test()
+
+    count_after = sys.getrefcount(encoding)
+
+    assert count_after == count_before

{pyodbc-5.0.1 → pyodbc-5.2.0}/tests/sqlserver_test.py

@@ -1072,10 +1072,9 @@ def test_cursor_messages_with_print(cursor: pyodbc.Cursor):
     """
     assert not cursor.messages
 
-    # SQL Server PRINT statements are never more than 8000 characters
-    # https://docs.microsoft.com/en-us/sql/t-sql/language-elements/print-transact-sql#remarks
-    for msg in ('hello world', 'ABCDEFGHIJ' * 800):
-        cursor.execute(f"PRINT '{msg}'")
+    # ascii / extended ascii / unicode / beyond BMP unicode
+    for msg in ('hello world', 'a \xeb a', 'b \u0394 b', 'c \U0001F31C c'):
+        cursor.execute(f"PRINT N'{msg}'")  # note, unicode literal
         messages = cursor.messages
         assert isinstance(messages, list)
         assert len(messages) == 1
@@ -1086,6 +1085,31 @@ def test_cursor_messages_with_print(cursor: pyodbc.Cursor):
         assert '[01000] (0)' == messages[0][0]
         assert messages[0][1].endswith(msg)
 
+    # maximum size message
+    # SQL Server PRINT statements are never more than 8000 characters
+    # https://docs.microsoft.com/en-us/sql/t-sql/language-elements/print-transact-sql#remarks
+    msg = 'ABCDEFGH' * 1000
+    cursor.execute(f"PRINT '{msg}'")  # note, plain ascii literal
+    messages = cursor.messages
+    assert len(messages) == 1
+    assert messages[0][1].endswith(msg)
+
+
+def test_cursor_messages_with_fast_executemany(cursor: pyodbc.Cursor):
+    """
+    Ensure the Cursor.messages attribute is set with fast_executemany=True.
+    """
+    cursor.execute("create table t2(id1 int, id2 int)")
+    cursor.commit()
+
+    cursor.fast_executemany = True
+    cursor.executemany(
+        "print 'hello';insert into t2(id1, id2) values (?, ?)",
+        [(10, 11), (20, 21)],
+    )
+    assert len(cursor.messages) == 2
+    assert all(m[1].endswith('hello') for m in cursor.messages)
+
 
 def test_cursor_messages_with_stored_proc(cursor: pyodbc.Cursor):
     """
@@ -1590,6 +1614,44 @@ def test_tvp_diffschema(cursor: pyodbc.Cursor):
     _test_tvp(cursor, True)
 
 
+@pytest.mark.skipif(SQLSERVER_YEAR < 2000, reason='sql_variant not supported until 2000')
+def test_sql_variant(cursor: pyodbc.Cursor):
+    """
+    Tests decoding of the sql_variant data type as performed by the GetData_SqlVariant() method.
+    """
+
+    cursor.execute("create table t1 (a sql_variant)")
+
+    # insert a number of values of disparate types. this is not exhaustive as not all
+    # types that can be contained within a sql_variant field are supported by pyodbc
+    cursor.execute("insert into t1 values (456.7)")
+    cursor.execute("insert into t1 values ('a string')")
+    cursor.execute("insert into t1 values (CAST('2024-06-03' AS DATE))")
+    cursor.execute("insert into t1 values (CAST('2024-06-03 23:46:03.000' AS DATETIME))")
+    cursor.execute("insert into t1 values (CAST('binary data' AS VARBINARY(200)))")
+    cursor.execute(
+        "insert into t1 values (CAST('0592b437-745f-4b2c-a997-97022c624cf6' AS UNIQUEIDENTIFIER))"
+    )
+
+    # select all of the values we inserted and ensure they have the correct types
+    results = [record[0] for record in cursor.execute("select a from t1").fetchall()]
+    for index, assertion_tuple in enumerate(
+        [
+            (Decimal, Decimal("456.7")),
+            (str, "a string"),
+            (date, date(2024, 6, 3)),
+            (datetime, datetime(2024, 6, 3, 23, 46, 3)),
+            (bytes, b'binary data'),
+            (uuid.UUID, uuid.UUID("0592b437-745f-4b2c-a997-97022c624cf6"))
+        ]
+    ):
+        # pylint: disable=unidiomatic-typecheck
+        expected_type, expected_value = assertion_tuple
+
+        assert type(results[index]) == expected_type
+        assert results[index] == expected_value
+
+
 def get_sqlserver_version(cursor: pyodbc.Cursor):
 
     """