Revert "FEAT: Support for Native_UUID Attribute (#282)"

This reverts commit 10a8815.

Author: gargsaumya

mssql_python/__init__.py

@@ -3,16 +3,104 @@
 Licensed under the MIT license.
 This module initializes the mssql_python package.
 """
-
-import sys
-import types
-from typing import Dict
-
-# Import settings from helpers to avoid circular imports
-from .helpers import Settings, get_settings, _settings, _settings_lock
+import threading
+import locale
 
 # Exceptions
 # https://www.python.org/dev/peps/pep-0249/#exceptions
+
+# GLOBALS
+# Read-Only
+apilevel = "2.0"
+paramstyle = "qmark"
+threadsafety = 1
+
+# Initialize the locale setting only once at module import time
+# This avoids thread-safety issues with locale
+_DEFAULT_DECIMAL_SEPARATOR = "."
+try:
+    # Get the locale setting once during module initialization
+    _locale_separator = locale.localeconv()['decimal_point']
+    if _locale_separator and len(_locale_separator) == 1:
+        _DEFAULT_DECIMAL_SEPARATOR = _locale_separator
+except (AttributeError, KeyError, TypeError, ValueError):
+    pass  # Keep the default "." if locale access fails
+
+class Settings:
+    def __init__(self):
+        self.lowercase = False
+        # Use the pre-determined separator - no locale access here
+        self.decimal_separator = _DEFAULT_DECIMAL_SEPARATOR
+
+# Global settings instance
+_settings = Settings()
+_settings_lock = threading.Lock()
+
+def get_settings():
+    """Return the global settings object"""
+    with _settings_lock:
+        _settings.lowercase = lowercase
+        return _settings
+
+lowercase = _settings.lowercase  # Default is False
+
+# Set the initial decimal separator in C++
+from .ddbc_bindings import DDBCSetDecimalSeparator
+DDBCSetDecimalSeparator(_settings.decimal_separator)
+
+# New functions for decimal separator control
+def setDecimalSeparator(separator):
+    """
+    Sets the decimal separator character used when parsing NUMERIC/DECIMAL values 
+    from the database, e.g. the "." in "1,234.56".
+    
+    The default is to use the current locale's "decimal_point" value when the module
+    was first imported, or "." if the locale is not available. This function overrides 
+    the default.
+    
+    Args:
+        separator (str): The character to use as decimal separator
+        
+    Raises:
+        ValueError: If the separator is not a single character string
+    """
+    # Type validation
+    if not isinstance(separator, str):
+        raise ValueError("Decimal separator must be a string")
+    
+    # Length validation
+    if len(separator) == 0:
+        raise ValueError("Decimal separator cannot be empty")
+        
+    if len(separator) > 1:
+        raise ValueError("Decimal separator must be a single character")
+    
+    # Character validation
+    if separator.isspace():
+        raise ValueError("Whitespace characters are not allowed as decimal separators")
+        
+    # Check for specific disallowed characters
+    if separator in ['\t', '\n', '\r', '\v', '\f']:
+        raise ValueError(f"Control character '{repr(separator)}' is not allowed as a decimal separator")
+    
+    # Set in Python side settings
+    _settings.decimal_separator = separator
+    
+    # Update the C++ side
+    from .ddbc_bindings import DDBCSetDecimalSeparator
+    DDBCSetDecimalSeparator(separator)
+
+def getDecimalSeparator():
+    """
+    Returns the decimal separator character used when parsing NUMERIC/DECIMAL values
+    from the database.
+    
+    Returns:
+        str: The current decimal separator character
+    """
+    return _settings.decimal_separator
+
+# Import necessary modules
 from .exceptions import (
     Warning,
     Error,
@@ -174,9 +262,22 @@ def pooling(max_size: int = 100, idle_timeout: int = 600, enabled: bool = True)
     else:
         PoolingManager.enable(max_size, idle_timeout)
 
-
+import sys
 _original_module_setattr = sys.modules[__name__].__setattr__
 
+def _custom_setattr(name, value):
+    if name == 'lowercase':
+        with _settings_lock:
+            _settings.lowercase = bool(value)
+            # Update the module's lowercase variable
+            _original_module_setattr(name, _settings.lowercase)
+    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_VARCHAR: int = ConstantsDDBC.SQL_VARCHAR.value
 SQL_LONGVARCHAR: int = ConstantsDDBC.SQL_LONGVARCHAR.value
@@ -250,52 +351,3 @@ def get_info_constants() -> Dict[str, int]:
         dict: Dictionary mapping constant names to their integer values
     """
     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) -> bool:
-        """Get the native UUID setting."""
-        return _settings.native_uuid
-
-    @native_uuid.setter
-    def native_uuid(self, value: bool) -> None:
-        """Set the native UUID setting."""
-        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) -> bool:
-        """Get the lowercase setting."""
-        return _settings.lowercase
-
-    @lowercase.setter
-    def lowercase(self, value: bool) -> None:
-        """Set the lowercase setting."""
-        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: types.ModuleType = sys.modules[__name__]
-new_module: _MSSQLModule = _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: bool = _settings.lowercase
-native_uuid: bool = _settings.native_uuid

mssql_python/cursor.py

@@ -1125,40 +1125,29 @@ def execute(  # pylint: disable=too-many-locals,too-many-branches,too-many-state
         # 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:  # pylint: disable=broad-exception-caught
             # If describe fails, it's likely there are no results (e.g., for INSERT)
             self.description = None
-
+        
         # Reset rownumber for new result set (only for SELECT statements)
         if self.description:  # If we have column descriptions, it's likely a SELECT
-            # Capture settings snapshot for this result set
-            settings = get_settings()
-            self._settings_snapshot = {  # pylint: disable=attribute-defined-outside-init
-                "lowercase": settings.lowercase,
-                "native_uuid": settings.native_uuid,
-            }
-            # 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 = []  # pylint: disable=attribute-defined-outside-init
-            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:
             self.rowcount = ddbc_bindings.DDBCSQLRowCount(self.hstmt)
             self._clear_rownumber()
 
+        # After successful execution, initialize description if there are results
+        column_metadata = []
+        try:
+            ddbc_bindings.DDBCSQLDescribeCol(self.hstmt, column_metadata)
+            self._initialize_description(column_metadata)
+        except Exception as e:
+            # If describe fails, it's likely there are no results (e.g., for INSERT)
+            self.description = None
+        
         self._reset_inputsizes()  # Reset input sizes after execution
         # Return self for method chaining
         return self
@@ -1970,10 +1959,9 @@ def fetchone(self) -> Union[None, Row]:
             self.rowcount = self._next_row_index
 
             # Create and return a Row object, passing column name map if available
-            column_map = getattr(self, "_column_name_map", None)
-            settings_snapshot = getattr(self, "_settings_snapshot", None)
-            return Row(self, self.description, row_data, column_map, settings_snapshot)
-        except Exception as e:  # pylint: disable=broad-exception-caught
+            column_map = getattr(self, '_column_name_map', None)
+            return Row(self, self.description, row_data, column_map)
+        except Exception as e:
             # On error, don't increment rownumber - rethrow the error
             raise e
 
@@ -2019,9 +2007,8 @@ def fetchmany(self, size: Optional[int] = None) -> List[Row]:
 
             # Convert raw data to Row objects
             column_map = getattr(self, "_column_name_map", None)
-            settings_snapshot = getattr(self, "_settings_snapshot", None)
             return [
-                Row(self, self.description, row_data, column_map, settings_snapshot)
+                Row(self, self.description, row_data, column_map)
                 for row_data in rows_data
             ]
         except Exception as e:  # pylint: disable=broad-exception-caught
@@ -2060,9 +2047,8 @@ def fetchall(self) -> List[Row]:
 
             # Convert raw data to Row objects
             column_map = getattr(self, "_column_name_map", None)
-            settings_snapshot = getattr(self, "_settings_snapshot", None)
             return [
-                Row(self, self.description, row_data, column_map, settings_snapshot)
+                Row(self, self.description, row_data, column_map)
                 for row_data in rows_data
             ]
         except Exception as e:  # pylint: disable=broad-exception-caught