Resolving comments

Author: jahnvi480

mssql_python/__init__.py

@@ -6,6 +6,7 @@
 import threading
 import locale
 import sys
+import types
 
 # Exceptions
 # https://www.python.org/dev/peps/pep-0249/#exceptions
@@ -41,13 +42,8 @@ def __init__(self):
 def get_settings():
     """Return the global settings object"""
     with _settings_lock:
-        _settings.lowercase = bool(lowercase)
-        _settings.native_uuid = bool(native_uuid)
         return _settings
 
-lowercase = _settings.lowercase  # Default is False
-native_uuid = _settings.native_uuid  # Default is False
-
 # Set the initial decimal separator in C++
 from .ddbc_bindings import DDBCSetDecimalSeparator
 DDBCSetDecimalSeparator(_settings.decimal_separator)
@@ -172,33 +168,6 @@ def pooling(max_size=100, idle_timeout=600, enabled=True):
 
 _original_module_setattr = sys.modules[__name__].__setattr__
 
-def _custom_setattr(name, value):
-    if name == 'lowercase':
-        # Strict boolean type check for lowercase
-        if not isinstance(value, bool):
-            raise ValueError("lowercase must be a boolean value (True or False)")
-        
-        with _settings_lock:
-            _settings.lowercase = value
-            # Update the module's lowercase variable
-            _original_module_setattr(name, _settings.lowercase)
-    elif name == 'native_uuid':
-
-        # Strict boolean type check for native_uuid
-        if not isinstance(value, bool):
-            raise ValueError("native_uuid must be a boolean value (True or False)")
-        
-        with _settings_lock:
-            _settings.native_uuid = value
-            # Update the module's native_uuid variable
-            _original_module_setattr(name, _settings.native_uuid)
-    else:
-        _original_module_setattr(name, value)
-
-# Replace the module's __setattr__ with our custom version
-sys.modules[__name__].__setattr__ = _custom_setattr
-
-
 # Export SQL constants at module level
 SQL_CHAR = ConstantsDDBC.SQL_CHAR.value
 SQL_VARCHAR = ConstantsDDBC.SQL_VARCHAR.value
@@ -274,3 +243,45 @@ def get_info_constants():
     """
     return {name: member.value for name, member in GetInfoConstants.__members__.items()}
 
+# Create a custom module class that uses properties instead of __setattr__
+class _MSSQLModule(types.ModuleType):
+    @property
+    def native_uuid(self):
+        return _settings.native_uuid
+
+    @native_uuid.setter
+    def native_uuid(self, value):
+        if not isinstance(value, bool):
+            raise ValueError("native_uuid must be a boolean value")
+        with _settings_lock:
+            _settings.native_uuid = value
+
+    @property
+    def lowercase(self):
+        return _settings.lowercase
+
+    @lowercase.setter
+    def lowercase(self, value):
+        if not isinstance(value, bool):
+            raise ValueError("lowercase must be a boolean value")
+        with _settings_lock:
+            _settings.lowercase = value
+
+# Replace the current module with our custom module class
+old_module = sys.modules[__name__]
+new_module = _MSSQLModule(__name__)
+
+# Copy all existing attributes to the new module
+for attr_name in dir(old_module):
+    if attr_name != "__class__":
+        try:
+            setattr(new_module, attr_name, getattr(old_module, attr_name))
+        except AttributeError:
+            pass
+
+# Replace the module in sys.modules
+sys.modules[__name__] = new_module
+
+# Initialize property values
+lowercase = _settings.lowercase
+native_uuid = _settings.native_uuid

mssql_python/cursor.py

@@ -1000,6 +1000,8 @@ def execute(
         # After successful execution, initialize description if there are results
         column_metadata = []
         try:
+            # ODBC specification guarantees that column metadata is available immediately after
+            # a successful SQLExecute/SQLExecDirect for the first result set
             ddbc_bindings.DDBCSQLDescribeCol(self.hstmt, column_metadata)
             self._initialize_description(column_metadata)
         except Exception as e:
@@ -1014,11 +1016,15 @@ def execute(
                 'lowercase': settings.lowercase,
                 'native_uuid': settings.native_uuid
             }
-            # Identify UUID columns (SQL_GUID = -11)
+            # Identify UUID columns based on Python type in description[1]
+            # This relies on _map_data_type correctly mapping SQL_GUID to uuid.UUID
             self._uuid_indices = []
             for i, desc in enumerate(self.description):
                 if desc and desc[1] == uuid.UUID:  # Column type code at index 1
                     self._uuid_indices.append(i)
+                # Verify we have complete description tuples (7 items per PEP-249)
+                elif desc and len(desc) != 7:
+                    log('warning', f"Column description at index {i} has incorrect tuple length: {len(desc)}")
             self.rowcount = -1
             self._reset_rownumber()
         else:

mssql_python/row.py

@@ -1,4 +1,5 @@
 from mssql_python import get_settings
+from mssql_python.constants import ConstantsDDBC
 import uuid
 
 class Row:
@@ -122,6 +123,18 @@ def _apply_output_converters(self, values):
 
         converted_values = list(values)
 
+        # Map SQL type codes to appropriate byte sizes
+        int_size_map = {
+            # SQL_TINYINT
+            ConstantsDDBC.SQL_TINYINT.value: 1,
+            # SQL_SMALLINT
+            ConstantsDDBC.SQL_SMALLINT.value: 2,
+            # SQL_INTEGER
+            ConstantsDDBC.SQL_INTEGER.value: 4,
+            # SQL_BIGINT
+            ConstantsDDBC.SQL_BIGINT.value: 8
+        }
+        
         for i, (value, desc) in enumerate(zip(values, self._description)):
             if desc is None or value is None:
                 continue
@@ -135,7 +148,6 @@ def _apply_output_converters(self, values):
             # If no converter found for the SQL type but the value is a string or bytes,
             # try the WVARCHAR converter as a fallback
             if converter is None and isinstance(value, (str, bytes)):
-                from mssql_python.constants import ConstantsDDBC
                 converter = self._cursor.connection.get_output_converter(ConstantsDDBC.SQL_WVARCHAR.value)
 
             # If we found a converter, apply it
@@ -148,18 +160,26 @@ def _apply_output_converters(self, values):
                         value_bytes = value.encode('utf-16-le')
                         converted_values[i] = converter(value_bytes)
                     elif isinstance(value, int):
-                        # For integers, we'll convert to bytes
-                        value_bytes = value.to_bytes(8, byteorder='little')
-                        converted_values[i] = converter(value_bytes)
+                        # Get appropriate byte size for this integer type
+                        byte_size = int_size_map.get(sql_type, 8)
+                        try:
+                            # Use signed=True to properly handle negative values
+                            value_bytes = value.to_bytes(byte_size, byteorder='little', signed=True)
+                            converted_values[i] = converter(value_bytes)
+                        except OverflowError as e:
+                            # Log specific overflow error with details to help diagnose the issue
+                            if hasattr(self._cursor, 'log'):
+                                self._cursor.log('warning', 
+                                    f'Integer overflow: value {value} does not fit in {byte_size} bytes for SQL type {sql_type}')
+                            # Keep the original value in this case
                     else:
                         # Pass the value directly for other types
                         converted_values[i] = converter(value)
                 except Exception as e:
                     # Log the exception for debugging without leaking sensitive data
                     if hasattr(self._cursor, 'log'):
-                        self._cursor.log('debug', f'Exception occurred in output converter: {type(e).__name__}', exc_info=True)
+                        self._cursor.log('warning', f'Exception in output converter: {type(e).__name__} for SQL type {sql_type}')
                     # If conversion fails, keep the original value
-                    pass
 
         return converted_values
 

tests/test_001_globals.py

@@ -14,7 +14,7 @@
 import random
 
 # Import global variables from the repository
-from mssql_python import apilevel, threadsafety, paramstyle, lowercase, getDecimalSeparator, setDecimalSeparator
+from mssql_python import apilevel, threadsafety, paramstyle, lowercase, getDecimalSeparator, setDecimalSeparator, native_uuid
 
 def test_apilevel():
     # Check if apilevel has the expected value
@@ -553,4 +553,57 @@ def separator_reader_worker():
     finally:
         # Always make sure to clean up
         stop_event.set()
-        setDecimalSeparator(original_separator)
+        setDecimalSeparator(original_separator)
+
+def test_native_uuid_type_validation():
+    """Test that native_uuid only accepts boolean values"""
+    # Save original value
+    original = mssql_python.native_uuid
+    
+    try:
+        # Test valid values
+        mssql_python.native_uuid = True
+        assert mssql_python.native_uuid is True
+        
+        mssql_python.native_uuid = False
+        assert mssql_python.native_uuid is False
+        
+        # Test invalid types
+        invalid_values = [
+            1, 0, "True", "False", None, [], {}, 
+            "yes", "no", "t", "f"
+        ]
+        
+        for value in invalid_values:
+            with pytest.raises(ValueError, match="native_uuid must be a boolean value"):
+                mssql_python.native_uuid = value
+                
+    finally:
+        # Restore original value
+        mssql_python.native_uuid = original
+
+def test_lowercase_type_validation():
+    """Test that lowercase only accepts boolean values"""
+    # Save original value
+    original = mssql_python.lowercase
+    
+    try:
+        # Test valid values
+        mssql_python.lowercase = True
+        assert mssql_python.lowercase is True
+        
+        mssql_python.lowercase = False
+        assert mssql_python.lowercase is False
+        
+        # Test invalid types
+        invalid_values = [
+            1, 0, "True", "False", None, [], {}, 
+            "yes", "no", "t", "f"
+        ]
+        
+        for value in invalid_values:
+            with pytest.raises(ValueError, match="lowercase must be a boolean value"):
+                mssql_python.lowercase = value
+    finally:
+        # Restore original value
+        mssql_python.lowercase = original