minor updates

Author: gargsaumya

mssql_python/pybind/connection/connection.cpp

@@ -7,148 +7,120 @@
 #include "connection.h"
 #include <iostream>
 
+SqlHandlePtr Connection::_envHandle = nullptr;
 //-------------------------------------------------------------------------------------------------
 // Implements the Connection class declared in connection.h.
 // This class wraps low-level ODBC operations like connect/disconnect,
 // transaction control, and autocommit configuration.
 //-------------------------------------------------------------------------------------------------
 Connection::Connection(const std::wstring& conn_str, bool autocommit)
-    : _conn_str(conn_str) , _autocommit(autocommit) {}
+    : _connStr(conn_str) , _autocommit(autocommit) {
+    if (!_envHandle) {
+        LOG("Allocating environment handle");
+        SQLHANDLE env = nullptr;
+        if (!SQLAllocHandle_ptr) {
+            LOG("Function pointers not initialized, loading driver");
+            DriverLoader::getInstance().loadDriver();
+        }
+        SQLRETURN ret = SQLAllocHandle_ptr(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env);
+        if (!SQL_SUCCEEDED(ret)) {
+            throw std::runtime_error("Failed to allocate environment handle");
+        }
+        _envHandle = std::make_shared<SqlHandle>(SQL_HANDLE_ENV, env);
 
-Connection::~Connection() {
-    close();    // Ensure the connection is closed when the object is destroyed.
+        LOG("Setting environment attributes");
+        ret = SQLSetEnvAttr_ptr(_envHandle->get(), SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3_80, 0);
+        if (!SQL_SUCCEEDED(ret)) {
+            throw std::runtime_error("Failed to set environment attribute");
+        }
+    }
+    allocateDbcHandle();
 }
 
-SQLRETURN Connection::connect() {
-    allocDbcHandle();
-    return connectToDb();
+Connection::~Connection() {
+    disconnect();
 }
 
 // Allocates DBC handle
-void Connection::allocDbcHandle() {
+void Connection::allocateDbcHandle() {
     SQLHANDLE dbc = nullptr;
     LOG("Allocate SQL Connection Handle");
-    SQLRETURN ret = SQLAllocHandle_ptr(SQL_HANDLE_DBC, getSharedEnvHandle()->get(), &dbc);
+    SQLRETURN ret = SQLAllocHandle_ptr(SQL_HANDLE_DBC, _envHandle->get(), &dbc);
     if (!SQL_SUCCEEDED(ret)) {
         throw std::runtime_error("Failed to allocate connection handle");
     }
-    _dbc_handle = std::make_shared<SqlHandle>(SQL_HANDLE_DBC, dbc);
+    _dbcHandle = std::make_shared<SqlHandle>(SQL_HANDLE_DBC, dbc);
 }
 
-// Connects to the database
-SQLRETURN Connection::connectToDb() {
+void Connection::connect() {
     LOG("Connecting to database");
-    SQLRETURN ret = SQLDriverConnect_ptr(_dbc_handle->get(), nullptr,
-                                         (SQLWCHAR*)_conn_str.c_str(), SQL_NTS,
-                                         nullptr, 0, nullptr, SQL_DRIVER_NOPROMPT);
-    if (!SQL_SUCCEEDED(ret)) {
-        throw std::runtime_error("Failed to connect to database");
-    }
-    LOG("Connected to database successfully");
-    return ret;
+    SQLRETURN ret = SQLDriverConnect_ptr(
+        _dbcHandle->get(), nullptr,
+        (SQLWCHAR*)_connStr.c_str(), SQL_NTS,
+        nullptr, 0, nullptr, SQL_DRIVER_NOPROMPT);
+    checkError(ret, "SQLDriverConnect failed");
+    setAutocommit(_autocommit);
 }
 
-SQLRETURN Connection::close() {
-    if (!_dbc_handle) {
-        LOG("No connection handle to close");
-        return SQL_SUCCESS;
-    }
-    LOG("Disconnect from MSSQL");
-    if (!SQLDisconnect_ptr) {
-        LOG("Function pointer not initialized. Loading the driver.");
-        DriverLoader::getInstance().loadDriver();
+void Connection::disconnect() {
+    if (_dbcHandle) {
+        SQLDisconnect_ptr(_dbcHandle->get());
     }
-
-    SQLRETURN ret = SQLDisconnect_ptr(_dbc_handle->get());
-    _dbc_handle.reset();
-    return ret;
 }
 
-SQLRETURN Connection::commit() {
-    if (!_dbc_handle) {
-        throw std::runtime_error("Connection handle not allocated");
+void Connection::checkError(SQLRETURN ret, const std::string& msg) {
+    if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) {
+        throw std::runtime_error("[ODBC Error] " + msg);
     }
+}
+
+void Connection::commit() {
     LOG("Committing transaction");
-    SQLRETURN ret = SQLEndTran_ptr(SQL_HANDLE_DBC, _dbc_handle->get(), SQL_COMMIT);
-    if (!SQL_SUCCEEDED(ret)) {
-        throw std::runtime_error("Failed to commit transaction");
-    }
-    return ret;
+    SQLRETURN ret = SQLEndTran_ptr(SQL_HANDLE_DBC, _dbcHandle->get(), SQL_COMMIT);
+    checkError(ret, "Failed to commit transaction");
 }
 
-SQLRETURN Connection::rollback() {
-    if (!_dbc_handle) {
+void Connection::rollback() {
+    if (!_dbcHandle) {
         throw std::runtime_error("Connection handle not allocated");
     }
     LOG("Rolling back transaction");
-    SQLRETURN ret = SQLEndTran_ptr(SQL_HANDLE_DBC, _dbc_handle->get(), SQL_ROLLBACK);
-    if (!SQL_SUCCEEDED(ret)) {
-        throw std::runtime_error("Failed to rollback transaction");
-    }
-    return ret;
+    SQLRETURN ret = SQLEndTran_ptr(SQL_HANDLE_DBC, _dbcHandle->get(), SQL_ROLLBACK);
+    checkError(ret, "Failed to rollback transaction");
 }
 
-SQLRETURN Connection::setAutocommit(bool enable) {
-    if (!_dbc_handle) {
+void Connection::setAutocommit(bool enable) {
+    if (!_dbcHandle) {
         throw std::runtime_error("Connection handle not allocated");
     }
     SQLINTEGER value = enable ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF;
     LOG("Set SQL Connection Attribute");
-    SQLRETURN ret = SQLSetConnectAttr_ptr(_dbc_handle->get(), SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)value, 0);
-    if (!SQL_SUCCEEDED(ret)) {
-        throw std::runtime_error("Failed to set autocommit mode.");
-    }
+    SQLRETURN ret = SQLSetConnectAttr_ptr(_dbcHandle->get(), SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)value, 0);
+    checkError(ret, "Failed to set autocommit attribute");
     _autocommit = enable;
-    return ret;
 }
 
 bool Connection::getAutocommit() const {
-    if (!_dbc_handle) {
+    if (!_dbcHandle) {
         throw std::runtime_error("Connection handle not allocated");
     }
     LOG("Get SQL Connection Attribute");
     SQLINTEGER value;
     SQLINTEGER string_length;
-    SQLGetConnectAttr_ptr(_dbc_handle->get(), SQL_ATTR_AUTOCOMMIT, &value, sizeof(value), &string_length);
+    SQLGetConnectAttr_ptr(_dbcHandle->get(), SQL_ATTR_AUTOCOMMIT, &value, sizeof(value), &string_length);
 
     return value == SQL_AUTOCOMMIT_ON;
 }
 
 SqlHandlePtr Connection::allocStatementHandle() {
-    if (!_dbc_handle) {
+    if (!_dbcHandle) {
         throw std::runtime_error("Connection handle not allocated");
     }
     LOG("Allocating statement handle");
     SQLHANDLE stmt = nullptr;
-    SQLRETURN ret = SQLAllocHandle_ptr(SQL_HANDLE_STMT, _dbc_handle->get(), &stmt);
+    SQLRETURN ret = SQLAllocHandle_ptr(SQL_HANDLE_STMT, _dbcHandle->get(), &stmt);
     if (!SQL_SUCCEEDED(ret)) {
         throw std::runtime_error("Failed to allocate statement handle");
     }
     return std::make_shared<SqlHandle>(SQL_HANDLE_STMT, stmt);
 }
-
-SqlHandlePtr Connection::getSharedEnvHandle() {
-    static std::once_flag flag;
-    static SqlHandlePtr env_handle;
-
-    std::call_once(flag, []() {
-        LOG("Allocating environment handle");
-        SQLHANDLE env = nullptr;
-        if (!SQLAllocHandle_ptr) {
-            LOG("Function pointers not initialized, loading driver");
-            DriverLoader::getInstance().loadDriver();
-        }
-        SQLRETURN ret = SQLAllocHandle_ptr(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env);
-        if (!SQL_SUCCEEDED(ret)) {
-            throw std::runtime_error("Failed to allocate environment handle");
-        }
-        env_handle = std::make_shared<SqlHandle>(SQL_HANDLE_ENV, env);
-
-        LOG("Setting environment attributes");
-        ret = SQLSetEnvAttr_ptr(env_handle->get(), SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3_80, 0);
-        if (!SQL_SUCCEEDED(ret)) {
-            throw std::runtime_error("Failed to set environment attribute");
-        }
-    });
-    return env_handle;
-}

mssql_python/pybind/connection/connection.h

@@ -4,9 +4,7 @@
 // INFO|TODO - Note that is file is Windows specific right now. Making it arch agnostic will be
 //             taken up in future.
 
-#ifndef CONNECTION_H
-#define CONNECTION_H
-
+#pragma once
 #include "ddbc_bindings.h"
 
 // Represents a single ODBC database connection.
@@ -19,19 +17,19 @@ class Connection {
     ~Connection();
 
     // Establish the connection using the stored connection string.
-    SQLRETURN connect();
+    void connect();
 
-    // Close the connection and free resources.
-    SQLRETURN close();
+    // Disconnect and free the connection handle.
+    void disconnect();
 
     // Commit the current transaction.
-    SQLRETURN commit();
+    void commit();
 
     // Rollback the current transaction.
-    SQLRETURN rollback();
+    void rollback();
 
     // Enable or disable autocommit mode.
-    SQLRETURN setAutocommit(bool value);
+    void setAutocommit(bool value);
 
     //  Check whether autocommit is enabled.
     bool getAutocommit() const;
@@ -40,14 +38,13 @@ class Connection {
     SqlHandlePtr allocStatementHandle();
 
 private:
-    void allocDbcHandle();
-    SQLRETURN connectToDb();
+    void allocateDbcHandle();
+    void checkError(SQLRETURN ret, const std::string& msg);
 
-    std::wstring _conn_str;
-    SqlHandlePtr _dbc_handle;
-    bool _autocommit = false;
+    std::wstring _connStr;
+    bool _usePool = false;
+    bool _autocommit = true;
+    SqlHandlePtr _dbcHandle;
 
-    static SqlHandlePtr getSharedEnvHandle();
+    static SqlHandlePtr _envHandle;
 };
-
-#endif // CONNECTION_H