implementing c++ connection class apis

Author: Saumya Garg

mssql_python/pybind/connection/connection.cpp

@@ -12,43 +12,98 @@
 // This class wraps low-level ODBC operations like connect/disconnect,
 // transaction control, and autocommit configuration.
 //-------------------------------------------------------------------------------------------------
-Connection::Connection(const std::wstring& conn_str) : _conn_str(conn_str) {}
+Connection::Connection(const std::wstring& conn_str, bool autocommit) : _conn_str(conn_str) , _autocommit(autocommit) {}
 
 Connection::~Connection() {
-    LOG("Connection destructor called");
-    close();    // Ensure the connection is closed when the object is destroyed.
+    close(); // Ensure the connection is closed when the object is destroyed.
 }
 
 SQLRETURN Connection::connect() {
-    LOG("Connecting to MSSQL");
-    // to be added 
+    SQLHANDLE env = nullptr;
+    SQLHANDLE dbc = nullptr;
+
+    LOG("Allocate SQL Handle");
+    if (!SQLAllocHandle_ptr) {
+        LOG("Function pointer not initialized. Loading the driver.");
+        DriverLoader::getInstance().loadDriver();
+    }
+    SQLRETURN ret = SQLAllocHandle_ptr(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env);
+    if (!SQL_SUCCEEDED(ret)) {
+        LOG("Failed to allocate environment handle");
+        throw std::runtime_error("Failed to allocate environment handle");
+    }
+    _env_handle = std::make_shared<SqlHandle>(SQL_HANDLE_ENV, env);
+
+    ret =  SQLSetEnvAttr_ptr(env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3_80, 0);
+    if (!SQL_SUCCEEDED(ret)) {
+        LOG("Failed to set environment attribute");
+        throw std::runtime_error("Failed to set environment attribute");
+    }
+
+    LOG("Allocate SQL Connection Handle");
+    ret = SQLAllocHandle_ptr(SQL_HANDLE_DBC, env, &dbc);
+    if (!SQL_SUCCEEDED(ret)) {
+        LOG("Failed to allocate connection handle");
+        throw std::runtime_error("Failed to allocate connection handle");
+    }
+    _dbc_handle = std::make_shared<SqlHandle>(SQL_HANDLE_DBC, dbc);
+
+    ret = SQLDriverConnect_ptr(dbc, nullptr,
+                                         (SQLWCHAR*)_conn_str.c_str(), SQL_NTS,
+                                         nullptr, 0, nullptr, SQL_DRIVER_NOPROMPT);
+    if (!SQL_SUCCEEDED(ret)) {
+        LOG("Failed to connect to database");
+    }
+    else {
+        LOG("Connected to database successfully");
+    }
+    return ret;
 }
 
 SQLRETURN Connection::close() {
     LOG("Disconnect from MSSQL");
-    // to be added
-}
-
-SQLRETURN Connection::commit() {
-    LOG("Committing transaction");
-    // to be added
-}
+    if (!SQLDisconnect_ptr) {
+        LOG("Function pointer not initialized. Loading the driver.");
+        DriverLoader::getInstance().loadDriver();
+    }
 
-SQLRETURN Connection::rollback() {
-    LOG("Rolling back transaction");
-    // to be added
+    return SQLDisconnect_ptr(_dbc_handle->get());
 }
 
 SQLRETURN Connection::end_transaction(SQLSMALLINT completion_type) {
-    // to be added
+    LOG(completion_type == SQL_COMMIT ? "End SQL Transaction (Commit)" : "End SQL Transaction (Rollback)");
+    if (!SQLEndTran_ptr) {
+        LOG("Function pointer not initialized. Loading the driver.");
+        DriverLoader::getInstance().loadDriver();
+    }
+    return SQLEndTran_ptr(_dbc_handle->type(), _dbc_handle->get(), completion_type);
 }
 
 SQLRETURN Connection::set_autocommit(bool enable) {
-    LOG("Setting autocommit mode");
-    // to be added
+    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.");
+    }
+    return ret;
 }
 
 bool Connection::get_autocommit() const {
-    LOG("Getting autocommit mode");
-    // to be added
+    LOG("Get SQL Connection Attribute");
+    SQLINTEGER value;
+    SQLINTEGER string_length;
+    SQLGetConnectAttr_ptr(_dbc_handle->get(), SQL_ATTR_AUTOCOMMIT, &value, sizeof(value), &string_length);
+    
+    return value == SQL_AUTOCOMMIT_ON;
 }
+
+SqlHandlePtr Connection::alloc_statement_handle() {
+    LOG("Allocating statement handle");
+    SQLHANDLE stmt = nullptr;
+    SQLRETURN ret = SQLAllocHandle_ptr(SQL_HANDLE_STMT, _dbc_handle->get(), &stmt);
+    if (!SQL_SUCCEEDED(ret)) {
+        throw std::runtime_error("Failed to allocate statement handle");
+    }
+    return std::make_shared<SqlHandle>(SQL_HANDLE_STMT, stmt);
+}

mssql_python/pybind/connection/connection.h

@@ -15,7 +15,7 @@
 
 class Connection {
 public:
-    Connection(const std::wstring& conn_str);
+    Connection(const std::wstring& conn_str, bool autocommit = false);
     ~Connection();
 
     // Establish the connection using the stored connection string.
@@ -24,12 +24,6 @@ class Connection {
     // Close the connection and free resources.
     SQLRETURN close();
 
-    // Commit the current transaction.
-    SQLRETURN commit();
-
-    // Rollback the current transaction.
-    SQLRETURN rollback();
-
     // End the transaction with the specified completion type.
     SQLRETURN end_transaction(SQLSMALLINT completion_type);
 
@@ -39,13 +33,14 @@ class Connection {
     //  Check whether autocommit is enabled.
     bool get_autocommit() const;
 
+    SqlHandlePtr alloc_statement_handle(); // Will later be moved to cursor c++ class
+
 private:
 
     std::wstring _conn_str;     // Connection string
     SqlHandlePtr _env_handle;   // Environment handle
     SqlHandlePtr _dbc_handle;   // Connection handle
 
     bool _autocommit = false;
-    std::shared_ptr<Connection> _conn; 
 };
 #endif // CONNECTION_H