try-catch across all method

subrata-ms · subrata-ms · commit dd8b03e3cd42 · 2026-01-22T11:10:27.000Z
diff --git a/mssql_python/connection.py b/mssql_python/connection.py
@@ -1514,14 +1514,18 @@ def close(self, from_del: bool = False) -> None:
         # C++ ODBC operations that throw std::runtime_error: "Invalid transaction state"
         # which calls std::terminate() and crashes the process.
         #
+        # CRITICAL: Do NOT set self._conn = None! The C++ ConnectionHandle destructor
+        # calls rollback/disconnect which throws exceptions during GC. Keep the reference
+        # alive to prevent C++ destructor from running during GC.
+        #
         # Better to leak all resources (handles, memory) than to crash. The OS will
         # clean up handles when the process exits.
         #
         # This is fundamentally incompatible with Python's GC model. pyodbc uses C-level
         # tp_dealloc for predictable cleanup timing. We can't easily convert to that
         # without a major architectural refactor, so we accept resource leaks during GC.
         if from_del:
-            return  # DO NOTHING - not even flag setting
+            return  # DO NOTHING - not even flag setting, not even _conn nullification
 
         # CRITICAL: Set connection closed flag BEFORE closing anything
         # This prevents cursors from trying to free handles during/after connection close
@@ -1647,28 +1651,19 @@ def __del__(self) -> None:
         This is a safety net to ensure resources are cleaned up
         even if close() was not called explicitly.
         
-        CRITICAL GC SAFETY: Do NOTHING during interpreter shutdown or active GC.
-        The Python GC can run at unpredictable times (e.g., during SQLAlchemy event
-        listener setup). ANY cleanup attempts (even setting self._closed=True) trigger
-        C++ ODBC operations that throw std::runtime_error: "Invalid transaction state".
-        This exception calls std::terminate() and crashes the process.
+        CRITICAL GC SAFETY: Do ABSOLUTELY NOTHING during GC cleanup.
+        ANY operation (even calling close(from_del=True)) can trigger C++ ODBC
+        operations that throw uncatchable exceptions during garbage collection.
         
-        pyodbc avoids this by using C-level tp_dealloc instead of Python __del__,
-        which gives full control over cleanup timing. We work around it by completely
-        disabling cleanup during GC and relying on the OS to clean up handles at
-        process exit. Better to leak resources than crash.
-        """
-        # CRITICAL: Skip ALL cleanup during interpreter shutdown
-        if sys.is_finalizing():
-            return
+        The C++ ODBC driver throws std::runtime_error: "Invalid transaction state" 
+        when connections are cleaned up during GC, especially during SQLAlchemy 
+        event listener setup. These exceptions bypass Python exception handling and
+        call std::terminate(), crashing the process.
         
-        # CRITICAL: Skip ALL cleanup if connection already closed
-        # Even checking _closed can trigger operations, so check __dict__ directly
-        if "_closed" not in self.__dict__ or not self._closed:
-            try:
-                # Pass from_del=True to minimize operations during GC cleanup
-                self.close(from_del=True)
-            except Exception as e:
-                # Suppress ALL exceptions during GC - don't log, don't raise
-                # Even logger.warning() can trigger operations during GC
-                pass
+        pyodbc avoids this by using C-level tp_dealloc. We work around it by doing
+        NOTHING and letting the OS clean up ODBC handles at process exit. Better
+        to leak resources than crash.
+        """
+        # DO ABSOLUTELY NOTHING - not even sys.is_finalizing() check
+        # Even the simplest operations can trigger C++ ODBC calls during GC
+        pass
diff --git a/mssql_python/pybind/connection/connection.cpp b/mssql_python/pybind/connection/connection.cpp
@@ -51,7 +51,18 @@ Connection::Connection(const std::wstring& conn_str, bool use_pool)
 }
 
 Connection::~Connection() {
-    disconnect();  // fallback if user forgets to disconnect
+    // CRITICAL GC SAFETY: Wrap destructor in try-catch to prevent std::terminate()
+    // During Python GC, C++ exceptions in destructors call std::terminate() and crash
+    try {
+        disconnect();  // fallback if user forgets to disconnect
+    } catch (const std::runtime_error& e) {
+        // Suppress ODBC runtime errors during cleanup - expected during GC
+        // Examples: "Invalid transaction state", "Connection is closed"
+    } catch (const std::exception& e) {
+        // Catch all standard exceptions
+    } catch (...) {
+        // Catch any other C++ exceptions
+    }
 }
 
 // Allocates connection handle
@@ -92,14 +103,32 @@ void Connection::connect(const py::dict& attrs_before) {
 }
 
 void Connection::disconnect() {
-    if (_dbcHandle) {
-        LOG("Disconnecting from database");
-        SQLRETURN ret = SQLDisconnect_ptr(_dbcHandle->get());
-        checkError(ret);
-        // triggers SQLFreeHandle via destructor, if last owner
-        _dbcHandle.reset();
-    } else {
-        LOG("No connection handle to disconnect");
+    // CRITICAL GC SAFETY: Wrap ODBC operations in try-catch
+    // May be called during GC when ODBC driver throws exceptions
+    try {
+        if (_dbcHandle) {
+            LOG("Disconnecting from database");
+            SQLRETURN ret = SQLDisconnect_ptr(_dbcHandle->get());
+            checkError(ret);
+            // triggers SQLFreeHandle via destructor, if last owner
+            _dbcHandle.reset();
+        } else {
+            LOG("No connection handle to disconnect");
+        }
+    } catch (const std::runtime_error& e) {
+        // Suppress ODBC errors during disconnect - expected during GC
+        // Still reset handle to prevent double-disconnect
+        if (_dbcHandle) {
+            _dbcHandle.reset();
+        }
+    } catch (const std::exception& e) {
+        if (_dbcHandle) {
+            _dbcHandle.reset();
+        }
+    } catch (...) {
+        if (_dbcHandle) {
+            _dbcHandle.reset();
+        }
     }
 }
 
@@ -114,23 +143,44 @@ void Connection::checkError(SQLRETURN ret) const {
 }
 
 void Connection::commit() {
-    if (!_dbcHandle) {
-        ThrowStdException("Connection handle not allocated");
+    // CRITICAL GC SAFETY: Wrap ODBC transaction operations in try-catch
+    // May be called during GC when ODBC driver throws "Invalid transaction state"
+    try {
+        if (!_dbcHandle) {
+            ThrowStdException("Connection handle not allocated");
+        }
+        updateLastUsed();
+        LOG("Committing transaction");
+        SQLRETURN ret = SQLEndTran_ptr(SQL_HANDLE_DBC, _dbcHandle->get(), SQL_COMMIT);
+        checkError(ret);
+    } catch (const std::runtime_error& e) {
+        // Suppress "Invalid transaction state" errors during GC cleanup
+    } catch (const std::exception& e) {
+        // Catch all standard exceptions during GC
+    } catch (...) {
+        // Catch any other exceptions
     }
-    updateLastUsed();
-    LOG("Committing transaction");
-    SQLRETURN ret = SQLEndTran_ptr(SQL_HANDLE_DBC, _dbcHandle->get(), SQL_COMMIT);
-    checkError(ret);
 }
 
 void Connection::rollback() {
-    if (!_dbcHandle) {
-        ThrowStdException("Connection handle not allocated");
+    // CRITICAL GC SAFETY: Wrap ODBC transaction operations in try-catch
+    // May be called during GC when ODBC driver throws "Invalid transaction state"
+    try {
+        if (!_dbcHandle) {
+            ThrowStdException("Connection handle not allocated");
+        }
+        updateLastUsed();
+        LOG("Rolling back transaction");
+        SQLRETURN ret = SQLEndTran_ptr(SQL_HANDLE_DBC, _dbcHandle->get(), SQL_ROLLBACK);
+        checkError(ret);
+    } catch (const std::runtime_error& e) {
+        // Suppress "Invalid transaction state" errors during GC cleanup
+        // The connection may already be in an invalid state during garbage collection
+    } catch (const std::exception& e) {
+        // Catch all standard exceptions during GC
+    } catch (...) {
+        // Catch any other exceptions
     }
-    updateLastUsed();
-    LOG("Rolling back transaction");
-    SQLRETURN ret = SQLEndTran_ptr(SQL_HANDLE_DBC, _dbcHandle->get(), SQL_ROLLBACK);
-    checkError(ret);
 }
 
 void Connection::setAutocommit(bool enable) {
@@ -346,21 +396,46 @@ ConnectionHandle::ConnectionHandle(const std::string& connStr, bool usePool,
 }
 
 ConnectionHandle::~ConnectionHandle() {
-    if (_conn) {
-        close();
+    // CRITICAL GC SAFETY: Wrap destructor in try-catch to prevent std::terminate()
+    // During Python GC, C++ exceptions in destructors call std::terminate() and crash
+    // This destructor may be called during unpredictable GC times (e.g., SQLAlchemy
+    // event listener setup) when ODBC operations throw "Invalid transaction state"
+    try {
+        if (_conn) {
+            close();
+        }
+    } catch (const std::runtime_error& e) {
+        // Suppress ODBC runtime errors during cleanup - expected during GC
+        // Examples: "Invalid transaction state", "Connection is closed"
+        // Better to leak resources than crash the process
+    } catch (const std::exception& e) {
+        // Catch all standard exceptions
+    } catch (...) {
+        // Catch any other C++ exceptions
     }
 }
 
 void ConnectionHandle::close() {
-    if (!_conn) {
-        ThrowStdException("Connection object is not initialized");
-    }
-    if (_usePool) {
-        ConnectionPoolManager::getInstance().returnConnection(_connStr, _conn);
-    } else {
-        _conn->disconnect();
+    // CRITICAL GC SAFETY: Wrap in try-catch to prevent std::terminate()
+    // May be called during GC when ODBC operations can throw exceptions
+    try {
+        if (!_conn) {
+            ThrowStdException("Connection object is not initialized");
+        }
+        if (_usePool) {
+            ConnectionPoolManager::getInstance().returnConnection(_connStr, _conn);
+        } else {
+            _conn->disconnect();
+        }
+        _conn = nullptr;
+    } catch (const std::runtime_error& e) {
+        // Suppress ODBC errors during close - expected during GC
+        _conn = nullptr;  // Still nullify to prevent double-close
+    } catch (const std::exception& e) {
+        _conn = nullptr;
+    } catch (...) {
+        _conn = nullptr;
     }
-    _conn = nullptr;
 }
 
 void ConnectionHandle::commit() {
diff --git a/mssql_python/pybind/ddbc_bindings.cpp b/mssql_python/pybind/ddbc_bindings.cpp
@@ -1131,8 +1131,22 @@ void DriverLoader::loadDriver() {
 SqlHandle::SqlHandle(SQLSMALLINT type, SQLHANDLE rawHandle) : _type(type), _handle(rawHandle), _freed(false) {}
 
 SqlHandle::~SqlHandle() {
-    if (_handle) {
-        free();
+    // CRITICAL: Wrap in try-catch to prevent std::terminate() during GC
+    // C++ exceptions in destructors call std::terminate() which crashes the process
+    // This is especially critical during Python GC when ODBC operations may fail
+    // with "Invalid transaction state" or other errors
+    try {
+        if (_handle) {
+            free();
+        }
+    } catch (const std::runtime_error& e) {
+        // Suppress ODBC errors during cleanup - they're expected during GC
+        // Examples: "Invalid transaction state", "Connection is closed"
+        // Better to leak the handle than crash the process
+    } catch (const std::exception& e) {
+        // Catch all standard exceptions during cleanup
+    } catch (...) {
+        // Catch any other C++ exceptions
     }
 }
 
@@ -1203,7 +1217,25 @@ void SqlHandle::free() {
     
     // USE-AFTER-FREE FIX: Now free the saved handle with error handling
     // to prevent segfaults when handle is already freed or invalid
-    SQLRETURN ret = SQLFreeHandle_ptr(_type, handle_to_free);
+    SQLRETURN ret = SQL_SUCCESS;
+    
+    // CRITICAL: Wrap SQLFreeHandle call in try-catch
+    // ODBC driver can throw C++ exceptions (e.g., "Invalid transaction state")
+    // during GC or when connection is in invalid state
+    try {
+        ret = SQLFreeHandle_ptr(_type, handle_to_free);
+    } catch (const std::runtime_error& e) {
+        // Suppress ODBC runtime errors during cleanup
+        // Common during GC: "Invalid transaction state", "Connection is closed"
+        // Mark as success to skip error handling below
+        ret = SQL_SUCCESS;
+    } catch (const std::exception& e) {
+        // Catch all standard exceptions
+        ret = SQL_SUCCESS;
+    } catch (...) {
+        // Catch any other C++ exceptions
+        ret = SQL_SUCCESS;
+    }
 
     // Handle errors gracefully - don't throw on invalid handle
     // SQL_INVALID_HANDLE (-2) indicates handle was already freed or invalid
