Merge branch 'main' of https://github.com/microsoft/mssql-python into bewithgaurav/universal_codecov

Author: bewithgaurav

PyPI_Description.md

@@ -1,14 +1,46 @@
 # mssql-python
 
-This is a new Python driver for Microsoft SQL Server currently in Public Preview phase.
+mssql-python is a new first-party SQL Server driver for Python that has all of the benefits of a fresh start while preserving a familiar experience for developers.
+
+## What makes mssql-python different?
+
+### Powered by DDBC – Direct Database Connectivity
+
+Most Python SQL Server drivers, including pyodbc, route calls through the Driver Manager, which has slightly different implementations across Windows, macOS, and Linux. This results in inconsistent behavior and capabilities across platforms. Additionally, the Driver Manager must be installed separately, creating friction for both new developers and when deploying applications to servers.
+
+At the heart of the driver is DDBC (Direct Database Connectivity) — a lightweight, high-performance C++ layer that replaces the platform’s Driver Manager.
+
+Key Advantages:
+
+- Provides a consistent, cross-platform backend that handles connections, statements, and memory directly.
+- Interfaces directly with the native SQL Server drivers.
+- Integrates with the same TDS core library that powers the ODBC driver.
+
+### Why is this architecture important?
+
+By simplifying the architecture, DDBC delivers:
+
+- Consistency across platforms
+- Lower function call overhead
+- Zero external dependencies on Windows (`pip install mssql-python` is all you need)
+- Full control over connections, memory, and statement handling
+
+### Built with PyBind11 + Modern C++ for Performance and Safety
+
+To expose the DDBC engine to Python, mssql-python uses PyBind11 – a modern C++ binding library, instead of ctypes. With ctypes, every call between Python and the ODBC driver involved costly type conversions, manual pointer management, resulting in slow and potentially unsafe code.
+
+PyBind11 provides:
+
+- Native-speed execution with automatic type conversions
+- Memory-safe bindings
+- Clean and Pythonic API, while performance-critical logic remains in robust, maintainable C++.
 
 ## Public Preview Release
 
-We are making progress - The Public Preview of our driver is now available! This marks a significant milestone in our development journey. While we saw a few early adopters of our public preview release, we are introducing the following functionalities to support your applications in a more robust and reliable manner.
+We are currently in **Public Preview**.
 
-### What's Included:
+## What's new in v0.10.0
 
-- Everything from previous releases
 - **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.
@@ -26,11 +58,6 @@ For more information, please visit the project link on Github: https://github.co
 
 If you have any feedback, questions or need support please mail us at [email protected].
 
-### What's Next:
-
-As we continue to develop and refine the driver, you can expect regular updates that will introduce new features, optimizations, and bug fixes. We encourage you to contribute, provide feedback and report any issues you encounter, as this will help us improve the driver for the final release.
-
-### Stay Tuned:
+## What's Next
 
-We appreciate your interest and support in this project. Stay tuned for more updates and enhancements as we work towards delivering a robust and fully-featured driver in coming months.
-Thank you for being a part of our journey!
+As we continue to develop and refine the driver, you can expect regular updates that will introduce new features, optimizations, and bug fixes. We encourage you to contribute, provide feedback and report any issues you encounter, as this will help us improve the driver ahead of General Availability.

mssql_python/__init__.py

@@ -3,9 +3,104 @@
 Licensed under the MIT license.
 This module initializes the mssql_python package.
 """
+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,
@@ -52,12 +147,6 @@
 SQL_WCHAR = ConstantsDDBC.SQL_WCHAR.value
 SQL_WMETADATA = -99
 
-# GLOBALS
-# Read-Only
-apilevel = "2.0"
-paramstyle = "qmark"
-threadsafety = 1
-
 from .pooling import PoolingManager
 def pooling(max_size=100, idle_timeout=600, enabled=True):
 #     """
@@ -76,3 +165,18 @@ def pooling(max_size=100, idle_timeout=600, enabled=True):
         PoolingManager.disable()
     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