Addition - Execute Transaction

Author: abhinavminhas

QueryDB/DBContext.cs

@@ -190,6 +190,57 @@ public int ExecuteCommand(string sqlStatement)
             return -1;
         }
 
+        /// <summary>
+        /// Executes multiple SQL statements within a transaction, ensuring that all statements are executed together.
+        /// </summary>
+        /// <param name="sqlStatements">A list of SQL statements to execute.</param>
+        /// <returns>
+        /// Returns <c>true</c> if all statements are executed successfully and the transaction is committed;
+        /// <c>false</c> if any statement fails and the transaction is rolled back.
+        /// </returns>
+        public bool ExecuteTransaction(List<string> sqlStatements)
+        {
+            foreach(var sqlStatement in sqlStatements)
+            {
+                if (Regex.IsMatch(sqlStatement, "^\\s*SELECT\\s+.*", RegexOptions.IgnoreCase | RegexOptions.Singleline, TimeSpan.FromSeconds(5)))
+                    throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedSelectExecuteTransaction,
+                        QueryDBExceptions.ErrorType.UnsupportedCommand, QueryDBExceptions.AdditionalInfo.UnsupportedSelectExecuteTransaction);
+            }
+            if (Database.Equals(DB.MSSQL))
+            {
+                using (var msSqlDBConnection = GetSqlServerConnection())
+                {
+                    var _systemAdapter = new MSSQL.Adapter();
+                    return _systemAdapter.ExecuteTransaction(sqlStatements, msSqlDBConnection.SqlConnection);
+                }
+            }
+            else if (Database.Equals(DB.MySQL))
+            {
+                using (var mySqlDBConnection = GetMySqlConnection())
+                {
+                    var _systemAdapter = new MySQL.Adapter();
+                    return _systemAdapter.ExecuteTransaction(sqlStatements, mySqlDBConnection.MySqlConnection);
+                }
+            }
+            else if (Database.Equals(DB.Oracle))
+            {
+                using (var oracleDBConnection = GetOracleConnection())
+                {
+                    var _systemAdapter = new Oracle.Adapter();
+                    return _systemAdapter.ExecuteTransaction(sqlStatements, oracleDBConnection.OracleConnection);
+                }
+            }
+            else if (Database.Equals(DB.PostgreSQL))
+            {
+                using (var postgreSqlDBConnection = GetPostgreSqlConnection())
+                {
+                    var _systemAdapter = new PostgreSQL.Adapter();
+                    return _systemAdapter.ExecuteTransaction(sqlStatements, postgreSqlDBConnection.PostgreSQLConnection);
+                }
+            }
+            return false;
+        }
+
         /// <summary>
         /// Gets 'SQL Server' connection.
         /// </summary>

QueryDB/Exceptions/QueryDBException.cs

@@ -62,9 +62,14 @@ internal static class ErrorType
         internal static class ErrorMessage
         {
             /// <summary>
-            /// Error message indicating that SELECT queries are not supported.
+            /// Error message indicating that SELECT queries are not supported in 'ExecuteCommand'.
             /// </summary>
             internal static readonly string UnsupportedSelectExecuteCommand = "SELECT queries are not supported here.";
+
+            /// <summary>
+            /// Error message indicating that SELECT queries are not supported in 'ExecuteTransaction'.
+            /// </summary>
+            internal static readonly string UnsupportedSelectExecuteTransaction = "SELECT queries are not supported here.";
         }
 
         /// <summary>
@@ -76,6 +81,11 @@ internal static class AdditionalInfo
             /// Additional information about unsupported SELECT queries in 'ExecuteCommand'.
             /// </summary>
             internal static readonly string UnsupportedSelectExecuteCommand = "'ExecuteCommand' doesn't support SELECT queries.";
+
+            /// <summary>
+            /// Additional information about unsupported SELECT queries in 'ExecuteTransaction'.
+            /// </summary>
+            internal static readonly string UnsupportedSelectExecuteTransaction = "'ExecuteTransaction' doesn't support SELECT queries.";
         }
     }
 }

QueryDB/IDBContext.cs

@@ -31,5 +31,15 @@ interface IDBContext
         /// <param name="sqlStatement">SQL statement as command.</param>
         /// <returns>The number of rows affected.</returns>
         int ExecuteCommand(string sqlStatement);
+
+        /// <summary>
+        /// Executes multiple SQL statements within a transaction, ensuring that all statements are executed together.
+        /// </summary>
+        /// <param name="sqlStatements">A list of SQL statements to execute.</param>
+        /// <returns>
+        /// Returns <c>true</c> if all statements are executed successfully and the transaction is committed;
+        /// <c>false</c> if any statement fails and the transaction is rolled back.
+        /// </returns>
+        bool ExecuteTransaction(List<string> sqlStatements);
     }
 }

QueryDB/MSSQL/Adapter.cs

@@ -42,6 +42,33 @@ internal SqlCommand GetSqlCommand(string cmdText, SqlConnection connection, Comm
             return sqlCommand;
         }
 
+        /// <summary>
+        /// Creates and returns a new SQL command associated with the specified connection and transaction.
+        /// </summary>
+        /// <param name="cmdText">The SQL command text to execute.</param>
+        /// <param name="connection">The SQL database connection.</param>
+        /// <param name="transaction">The SQL transaction within which the command should be executed.</param>
+        /// <returns>A new <see cref="SqlCommand"/> instance configured with the provided connection and transaction.</returns>
+        internal SqlCommand GetSqlCommand(string cmdText, SqlConnection connection, SqlTransaction transaction)
+        {
+            if (connection.State != ConnectionState.Open)
+                connection.Open();
+            var sqlCommand = new SqlCommand(cmdText, connection, transaction);
+            return sqlCommand;
+        }
+
+        /// <summary>
+        /// Initiates and returns a new SQL transaction for the specified database connection.
+        /// </summary>
+        /// <param name="connection">The SQL database connection.</param>
+        /// <returns>A new <see cref="SqlTransaction"/> associated with the provided connection.</returns>
+        internal SqlTransaction GetSqlTransaction(SqlConnection connection)
+        {
+            connection.Open();
+            var sqlTransaction = connection.BeginTransaction();
+            return sqlTransaction;
+        }
+
         /// <summary>
         /// Retrieves records for 'Select' queries from the database.
         /// Converts column names to keys holding values, with multiple database rows returned into a list.
@@ -113,5 +140,43 @@ internal int ExecuteCommand(string sqlStatement, SqlConnection connection)
                 return sqlCommand.ExecuteNonQuery();
             }
         }
+
+        /// <summary>
+        /// Executes multiple SQL statements within a transaction to ensure atomicity.
+        /// </summary>
+        /// <param name="sqlStatements">A list of SQL statements to execute.</param>
+        /// <param name="connection">The SQL database connection.</param>
+        /// <returns>
+        /// Returns <c>true</c> if the transaction is committed successfully; 
+        /// otherwise, <c>false</c> if an error occurs and the transaction is rolled back.
+        /// </returns>
+        /// <exception cref="Exception">
+        /// Logs and handles exceptions if any SQL command execution fails.
+        /// </exception>
+        
+        internal bool ExecuteTransaction(List<string> sqlStatements, SqlConnection connection)
+        {
+            using (SqlTransaction transaction = GetSqlTransaction(connection))
+            {
+                try
+                {
+                    foreach (var sqlStatement in sqlStatements)
+                    {
+                        using (var sqlCommand = GetSqlCommand(sqlStatement, connection, transaction))
+                        {
+                            sqlCommand.ExecuteNonQuery();
+                        }
+                    }
+                    transaction.Commit();
+                    return true;
+                }
+                catch (Exception ex)
+                {
+                    transaction.Rollback();
+                    Console.WriteLine($"Transaction rolled back due to error: {ex.Message}");
+                    return false;
+                }
+            }
+        }
     }
 }

QueryDB/MySQL/Adapter.cs

@@ -42,6 +42,33 @@ internal MySqlCommand GetMySqlCommand(string cmdText, MySqlConnection connection
             return sqlCommand;
         }
 
+        /// <summary>
+        /// Creates and returns a new MySQL command associated with the specified connection and transaction.
+        /// </summary>
+        /// <param name="cmdText">The SQL command text to execute.</param>
+        /// <param name="connection">The MySQL database connection.</param>
+        /// <param name="transaction">The MySQL transaction within which the command should be executed.</param>
+        /// <returns>A new <see cref="MySqlCommand"/> instance configured with the provided connection and transaction.</returns>
+        internal MySqlCommand GetMySqlCommand(string cmdText, MySqlConnection connection, MySqlTransaction transaction)
+        {
+            if (connection.State != ConnectionState.Open)
+                connection.Open();
+            var sqlCommand = new MySqlCommand(cmdText, connection, transaction);
+            return sqlCommand;
+        }
+
+        /// <summary>
+        /// Initiates and returns a new MySQL transaction for the given database connection.
+        /// </summary>
+        /// <param name="connection">The MySQL database connection.</param>
+        /// <returns>A new <see cref="MySqlTransaction"/> associated with the provided connection.</returns>
+        internal MySqlTransaction GetMySqlTransaction(MySqlConnection connection)
+        {
+            connection.Open();
+            var mySqlTransaction = connection.BeginTransaction();
+            return mySqlTransaction;
+        }
+
         /// <summary>
         /// Retrieves records for 'Select' queries from the database.
         /// Converts column names to keys holding values, with multiple database rows returned into a list.
@@ -113,5 +140,42 @@ internal int ExecuteCommand(string sqlStatement, MySqlConnection connection)
                 return sqlCommand.ExecuteNonQuery();
             }
         }
+
+        /// <summary>
+        /// Executes multiple SQL statements within a MySQL transaction to ensure atomicity.
+        /// </summary>
+        /// <param name="sqlStatements">A list of SQL statements to execute.</param>
+        /// <param name="connection">The MySQL database connection.</param>
+        /// <returns>
+        /// Returns <c>true</c> if the transaction is committed successfully; 
+        /// otherwise, <c>false</c> if an error occurs and the transaction is rolled back.
+        /// </returns>
+        /// <exception cref="Exception">
+        /// Logs and handles exceptions if any SQL command execution fails.
+        /// </exception>
+        internal bool ExecuteTransaction(List<string> sqlStatements, MySqlConnection connection)
+        {
+            using (MySqlTransaction transaction = GetMySqlTransaction(connection))
+            {
+                try
+                {
+                    foreach (var sqlStatement in sqlStatements)
+                    {
+                        using (var sqlCommand = GetMySqlCommand(sqlStatement, connection, transaction))
+                        {
+                            sqlCommand.ExecuteNonQuery();
+                        }
+                    }
+                    transaction.Commit();
+                    return true;
+                }
+                catch (Exception ex)
+                {
+                    transaction.Rollback();
+                    Console.WriteLine($"Transaction rolled back due to error: {ex.Message}");
+                    return false;
+                }
+            }
+        }
     }
 }

QueryDB/Oracle/Adapter.cs

@@ -37,11 +37,36 @@ internal OracleDataReader GetOracleReader(string cmdText, OracleConnection conne
         /// <returns>A configured <see cref="OracleCommand"/> instance.</returns>
         internal OracleCommand GetOracleCommand(string cmdText, OracleConnection connection, CommandType commandType)
         {
-            connection.Open();
             var sqlCommand = new OracleCommand(cmdText, connection) { CommandType = commandType };
             return sqlCommand;
         }
 
+        /// <summary>
+        /// Creates and returns a new Oracle command associated with the specified connection.
+        /// </summary>
+        /// <param name="cmdText">The SQL command text to execute.</param>
+        /// <param name="connection">The Oracle database connection.</param>
+        /// <returns>A new <see cref="OracleCommand"/> instance configured with the provided connection.</returns>
+        internal OracleCommand GetOracleCommand(string cmdText, OracleConnection connection)
+        {
+            if (connection.State != ConnectionState.Open)
+                connection.Open();
+            var sqlCommand = new OracleCommand(cmdText, connection);
+            return sqlCommand;
+        }
+
+        /// <summary>
+        /// Initiates and returns a new Oracle transaction for the specified database connection.
+        /// </summary>
+        /// <param name="connection">The Oracle database connection.</param>
+        /// <returns>A new <see cref="OracleTransaction"/> associated with the provided connection.</returns>
+        internal OracleTransaction GetOracleTransaction(OracleConnection connection)
+        {
+            connection.Open();
+            var oracleTransaction = connection.BeginTransaction();
+            return oracleTransaction;
+        }
+
         /// <summary>
         /// Retrieves records for 'Select' queries from the database.
         /// Converts column names to keys holding values, with multiple database rows returned into a list.
@@ -120,5 +145,43 @@ internal int ExecuteCommand(string sqlStatement, OracleConnection connection)
                 return sqlCommand.ExecuteNonQuery();
             }
         }
+
+        /// <summary>
+        /// Executes multiple SQL statements within an Oracle transaction to ensure atomicity.
+        /// </summary>
+        /// <param name="sqlStatements">A list of SQL statements to execute.</param>
+        /// <param name="connection">The Oracle database connection.</param>
+        /// <returns>
+        /// Returns <c>true</c> if the transaction is committed successfully; 
+        /// otherwise, <c>false</c> if an error occurs and the transaction is rolled back.
+        /// </returns>
+        /// <exception cref="Exception">
+        /// Logs and handles exceptions if any SQL command execution fails.
+        /// </exception>
+        internal bool ExecuteTransaction(List<string> sqlStatements, OracleConnection connection)
+        {
+            using (OracleTransaction transaction = GetOracleTransaction(connection))
+            {
+                try
+                {
+                    foreach (var sqlStatement in sqlStatements)
+                    {
+                        using (var sqlCommand = GetOracleCommand(sqlStatement, connection))
+                        {
+                            sqlCommand.Transaction = transaction;
+                            sqlCommand.ExecuteNonQuery();
+                        }
+                    }
+                    transaction.Commit();
+                    return true;
+                }
+                catch (Exception ex)
+                {
+                    transaction.Rollback();
+                    Console.WriteLine($"Transaction rolled back due to error: {ex.Message}");
+                    return false;
+                }
+            }
+        }
     }
 }