FEAT: Add Default Connection Pooling with User Opt-out Support (#118)

### ADO Work Item Reference  
<!-- Insert your ADO Work Item ID below (e.g. AB#37452) -->
>
[AB#37846](https://sqlclientdrivers.visualstudio.com/c6d89619-62de-46a0-8b46-70b92a84d85e/_workitems/edit/37846)
-------------------------------------------------------------------
### Summary   
<!-- Insert your Copilot Generated Summary below -->  
This pull request introduces enhancements to the connection pooling
mechanism in the `mssql_python` package. Key changes include adding an
option to explicitly disable pooling, auto-enabling pooling if not
configured by the user, and introducing an initialization state to track
whether pooling has been set up.

### Connection pooling enhancements:

*
[`mssql_python/__init__.py`](diffhunk://#diff-d95f3a67986de29f30453416b1b4c34e6a43207e9a33e2b1b80ef0c378b0a538L57-R61):
Updated the `pooling` function to include an `enabled` parameter,
allowing explicit disabling of pooling. Added logic to disable pooling
when `enabled=False`.
[[1]](diffhunk://#diff-d95f3a67986de29f30453416b1b4c34e6a43207e9a33e2b1b80ef0c378b0a538L57-R61)
[[2]](diffhunk://#diff-d95f3a67986de29f30453416b1b4c34e6a43207e9a33e2b1b80ef0c378b0a538R70-R72)
*
[`mssql_python/connection.py`](diffhunk://#diff-29bb94de45aae51c23a6426d40133c28e4161e68769e08d046059c7186264e90R61-R63):
Added logic to auto-enable pooling during connection initialization if
the user has not explicitly configured pooling.

### Pooling manager improvements:

*
[`mssql_python/pooling.py`](diffhunk://#diff-e51a48b4bd1555a5e32a6d20c9c6331f6a6d99e309185b418d0c2c6fe2e26541R7):
Introduced `_initialized` state in `PoolingManager` to track whether
pooling has been configured. Added `disable` method to explicitly
disable pooling and updated `enable` method to set `_initialized` to
`True`. Added `is_initialized` method to check initialization state.
[[1]](diffhunk://#diff-e51a48b4bd1555a5e32a6d20c9c6331f6a6d99e309185b418d0c2c6fe2e26541R7)
[[2]](diffhunk://#diff-e51a48b4bd1555a5e32a6d20c9c6331f6a6d99e309185b418d0c2c6fe2e26541R27-R41)

<!-- 
### PR Title Guide

> For feature requests
FEAT: (short-description)

> For non-feature requests like test case updates, config updates ,
dependency updates etc
CHORE: (short-description) 

> For Fix requests
FIX: (short-description)

> For doc update requests 
DOC: (short-description)

> For Formatting, indentation, or styling update
STYLE: (short-description)

> For Refactor, without any feature changes
REFACTOR: (short-description)

> For release related changes, without any feature changes
RELEASE: #<RELEASE_VERSION> (short-description) 
-->

Author: gargsaumya

mssql_python/__init__.py

@@ -54,16 +54,21 @@
 threadsafety = 1
 
 from .pooling import PoolingManager
-def pooling(max_size=100, idle_timeout=600):
+def pooling(max_size=100, idle_timeout=600, enabled=True):
 #     """
 #     Enable connection pooling with the specified parameters.
-    
+#     By default:
+#         - If not explicitly called, pooling will be auto-enabled with default values.
+
 #     Args:
 #         max_size (int): Maximum number of connections in the pool.
 #         idle_timeout (int): Time in seconds before idle connections are closed.
 
 #     Returns:
 #         None
 #     """
-    PoolingManager.enable(max_size, idle_timeout) 
+    if not enabled:
+        PoolingManager.disable()
+    else:
+        PoolingManager.enable(max_size, idle_timeout)
 

mssql_python/connection.py

@@ -58,6 +58,9 @@ def __init__(self, connection_str: str = "", autocommit: bool = False, attrs_bef
             connection_str, **kwargs
         )
         self._attrs_before = attrs_before or {}
+        # Auto-enable pooling if user never called
+        if not PoolingManager.is_initialized():
+            PoolingManager.enable()
         self._pooling = PoolingManager.is_enabled()
         self._conn = ddbc_bindings.Connection(self.connection_str, self._pooling, self._attrs_before)
         self.setautocommit(autocommit)

mssql_python/pooling.py

@@ -5,6 +5,7 @@
 
 class PoolingManager:
     _enabled = False
+    _initialized = False 
     _lock = threading.Lock()
     _config = {
         "max_size": 100,
@@ -24,12 +25,23 @@ def enable(cls, max_size=100, idle_timeout=600):
             cls._config["max_size"] = max_size
             cls._config["idle_timeout"] = idle_timeout
             cls._enabled = True
+            cls._initialized = True
+
+    @classmethod
+    def disable(cls):
+        with cls._lock:
+            cls._enabled = False
+            cls._initialized = True
 
     @classmethod
     def is_enabled(cls):
         return cls._enabled
 
-    @atexit.register
-    def shutdown_pooling():
-        if PoolingManager.is_enabled():
-            ddbc_bindings.close_pooling()
+    @classmethod
+    def is_initialized(cls):
+        return cls._initialized
+    
+@atexit.register
+def shutdown_pooling():
+    if PoolingManager.is_enabled():
+        ddbc_bindings.close_pooling()