FIX: Ensure graceful cleanup of connection pooling to avoid application hang (#120)

### ADO Work Item Reference  
<!-- Insert your ADO Work Item ID below (e.g. AB#37452) -->
>
[AB#37851](https://sqlclientdrivers.visualstudio.com/c6d89619-62de-46a0-8b46-70b92a84d85e/_workitems/edit/37851)
-------------------------------------------------------------------
### Summary   
<!-- Insert your Copilot Generated Summary below -->  
This pull request introduces enhancements to the connection pooling
system in the `mssql_python` module, focusing on resource cleanup during
application shutdown. The key changes include adding functionality to
close all connection pools gracefully and ensuring pooling is disabled
automatically when the program exits.

### Enhancements to connection pooling:

* **Automatic resource cleanup on shutdown**:
- Added an `atexit` hook in `mssql_python/pooling.py` to call
`ddbc_bindings.close_pooling()` when the program exits, ensuring
connection pools are closed properly.

* **New `close` method for `ConnectionPool`**:
- Implemented a method in `connection_pool.cpp` to close all connections
in a pool, releasing resources safely. Connections are disconnected in a
loop, and exceptions during disconnection are logged.
  - Declared the new `close` method in `connection_pool.h`.

* **New `closePools` method for `ConnectionPoolManager`**:
- Added functionality in `connection_pool.cpp` to iterate through all
pools managed by `ConnectionPoolManager` and close them. The `_pools`
map is cleared afterward.
  - Declared the `closePools` method in `connection_pool.h`.

### Integration with Python bindings:

* **Python binding for `close_pooling`**:
- Added a new Python-accessible function `close_pooling` in
`ddbc_bindings.cpp`, which invokes `ConnectionPoolManager::closePools()`
to close all connection pools from the Python layer.

These changes improve the robustness of the connection pooling system by
ensuring resources are properly released during shutdown, preventing
potential memory leaks or dangling connections.

<!-- 
### 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/pooling.py

@@ -1,4 +1,5 @@
 # mssql_python/pooling.py
+import atexit
 from mssql_python import ddbc_bindings
 import threading
 
@@ -27,3 +28,8 @@ def enable(cls, max_size=100, idle_timeout=600):
     @classmethod
     def is_enabled(cls):
         return cls._enabled
+
+    @atexit.register
+    def shutdown_pooling():
+        if PoolingManager.is_enabled():
+            ddbc_bindings.close_pooling()

mssql_python/pybind/connection/connection_pool.cpp

@@ -83,6 +83,25 @@ void ConnectionPool::release(std::shared_ptr<Connection> conn) {
     }
 }
 
+void ConnectionPool::close() {
+    std::vector<std::shared_ptr<Connection>> to_close;
+    {
+        std::lock_guard<std::mutex> lock(_mutex);
+        while (!_pool.empty()) {
+            to_close.push_back(_pool.front());
+            _pool.pop_front();
+        }
+        _current_size = 0;
+    }
+    for (auto& conn : to_close) {
+        try {
+            conn->disconnect();
+        } catch (const std::exception& ex) {
+            LOG("ConnectionPool::close: disconnect failed: {}", ex.what());
+        }
+    }
+}
+
 ConnectionPoolManager& ConnectionPoolManager::getInstance() {
     static ConnectionPoolManager manager;
     return manager;
@@ -110,4 +129,14 @@ void ConnectionPoolManager::configure(int max_size, int idle_timeout_secs) {
     std::lock_guard<std::mutex> lock(_manager_mutex);
     _default_max_size = max_size;
     _default_idle_secs = idle_timeout_secs;
-}
+}
+
+void ConnectionPoolManager::closePools() {
+    std::lock_guard<std::mutex> lock(_manager_mutex);
+    for (auto& [conn_str, pool] : _pools) {
+        if (pool) {
+            pool->close();
+        }
+    }
+    _pools.clear();
+}

mssql_python/pybind/connection/connection_pool.h

@@ -24,6 +24,9 @@ class ConnectionPool {
     // Returns a connection to the pool for reuse
     void release(std::shared_ptr<Connection> conn);
 
+    // Closes all connections in the pool, releasing resources
+    void close();
+
 private:
     size_t _max_size;       // Maximum number of connections allowed
     int _idle_timeout_secs; // Idle time before connections are considered stale
@@ -46,6 +49,9 @@ class ConnectionPoolManager {
     // Returns a connection to its original pool
     void returnConnection(const std::wstring& conn_str, std::shared_ptr<Connection> conn);
 
+    // Closes all pools and their connections
+    void closePools();
+
 private:
     ConnectionPoolManager() = default;    
     ~ConnectionPoolManager() = default;

mssql_python/pybind/ddbc_bindings.cpp

@@ -2109,6 +2109,7 @@ PYBIND11_MODULE(ddbc_bindings, m) {
         .def("get_autocommit", &ConnectionHandle::getAutocommit)
         .def("alloc_statement_handle", &ConnectionHandle::allocStatementHandle);
     m.def("enable_pooling", &enable_pooling, "Enable global connection pooling");
+    m.def("close_pooling", []() {ConnectionPoolManager::getInstance().closePools();});
     m.def("DDBCSQLExecDirect", &SQLExecDirect_wrap, "Execute a SQL query directly");
     m.def("DDBCSQLExecute", &SQLExecute_wrap, "Prepare and execute T-SQL statements");
     m.def("DDBCSQLRowCount", &SQLRowCount_wrap,