From aa62bf6b5ddfaedbaa1122f3df78661627d95637 Mon Sep 17 00:00:00 2001 From: abhinavminhas Date: Sun, 2 Mar 2025 23:46:59 +1100 Subject: [PATCH 01/14] Make adapters sealed --- QueryDB/MSSQL/Adapter.cs | 2 +- QueryDB/MySQL/Adapter.cs | 2 +- QueryDB/Oracle/Adapter.cs | 2 +- QueryDB/PostgreSQL/Adapter.cs | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/QueryDB/MSSQL/Adapter.cs b/QueryDB/MSSQL/Adapter.cs index 8d1b025..89b0d5c 100644 --- a/QueryDB/MSSQL/Adapter.cs +++ b/QueryDB/MSSQL/Adapter.cs @@ -10,7 +10,7 @@ namespace QueryDB.MSSQL /// /// 'SQL Server' adapter. /// - internal class Adapter + internal sealed class Adapter { #region Synchronous diff --git a/QueryDB/MySQL/Adapter.cs b/QueryDB/MySQL/Adapter.cs index d26e39c..b30793b 100644 --- a/QueryDB/MySQL/Adapter.cs +++ b/QueryDB/MySQL/Adapter.cs @@ -10,7 +10,7 @@ namespace QueryDB.MySQL /// /// 'MySQL' adapter. /// - internal class Adapter + internal sealed class Adapter { #region Synchronous diff --git a/QueryDB/Oracle/Adapter.cs b/QueryDB/Oracle/Adapter.cs index 82e9764..80cbf38 100644 --- a/QueryDB/Oracle/Adapter.cs +++ b/QueryDB/Oracle/Adapter.cs @@ -10,7 +10,7 @@ namespace QueryDB.Oracle /// /// 'Oracle' adapter. /// - internal class Adapter + internal sealed class Adapter { #region Synchronous diff --git a/QueryDB/PostgreSQL/Adapter.cs b/QueryDB/PostgreSQL/Adapter.cs index 7c13feb..19eff9c 100644 --- a/QueryDB/PostgreSQL/Adapter.cs +++ b/QueryDB/PostgreSQL/Adapter.cs @@ -10,7 +10,7 @@ namespace QueryDB.PostgreSQL /// /// 'PostgreSQL' adapter. /// - internal class Adapter + internal sealed class Adapter { #region Synchronous From 46c517e4cd725c73a3e6c0b9bc6b4276ac12a7b9 Mon Sep 17 00:00:00 2001 From: abhinavminhas Date: Mon, 3 Mar 2025 00:55:09 +1100 Subject: [PATCH 02/14] Fetch Data - Unsupported Commands --- QueryDB.Core.Tests/MSSQLTests.cs | 148 ++++++++++++++++++++++++++ QueryDB.Core.Tests/MySQLTests.cs | 148 ++++++++++++++++++++++++++ QueryDB.Core.Tests/OracleTests.cs | 148 ++++++++++++++++++++++++++ QueryDB.Core.Tests/PostgreSQLTests.cs | 148 ++++++++++++++++++++++++++ QueryDB/DBContext.cs | 12 +++ 5 files changed, 604 insertions(+) diff --git a/QueryDB.Core.Tests/MSSQLTests.cs b/QueryDB.Core.Tests/MSSQLTests.cs index 7a569fd..0231ae2 100644 --- a/QueryDB.Core.Tests/MSSQLTests.cs +++ b/QueryDB.Core.Tests/MSSQLTests.cs @@ -173,6 +173,43 @@ public void Test_MSSQL_FetchData_Dictionary_DataTypes_Check() Assert.AreEqual("XmlData", dataType.ReferenceData["Xml_Column"]); } + [TestMethod] + [TestCategory(DB_TESTS), TestCategory(MSSQL_TESTS)] + public void Test_MSSQL_FetchData_Dictionary_UnsupportedCommands() + { + var sqlStatements = new List + { + Queries.MSSQLQueries.TestDB.DDL.Create_Table, + Queries.MSSQLQueries.TestDB.DDL.Alter_Table, + Queries.MSSQLQueries.TestDB.DDL.Comment_Table, + Queries.MSSQLQueries.TestDB.DDL.Truncate_Table, + Queries.MSSQLQueries.TestDB.DDL.Drop_Table, + + Queries.MSSQLQueries.TestDB.DML.InsertSql, + Queries.MSSQLQueries.TestDB.DML.UpdateSql, + Queries.MSSQLQueries.TestDB.DML.DeleteSql, + + Queries.MSSQLQueries.TestDB.DCL.GrantSql_Command_Table_User, + Queries.MSSQLQueries.TestDB.DCL.RevokeSql_Command_Table_User + }; + + foreach (var sqlStatement in sqlStatements) + { + try + { + var dbContext = new DBContext(DB.MSSQL, MSSQLConnectionString); + dbContext.FetchData(sqlStatement); + Assert.Fail("No Exception"); + } + catch (QueryDBException ex) + { + Assert.AreEqual("Only SELECT queries are supported here.", ex.Message); + Assert.AreEqual("UnsupportedCommand", ex.ErrorType); + Assert.AreEqual("'FetchData' only supports SELECT queries that return result set.", ex.AdditionalInfo); + } + } + } + #endregion #region Fetch Data Async Tests - << Task> FetchDataAsync(string selectSql, bool upperCaseKeys = false) >> @@ -316,6 +353,43 @@ public async Task Test_MSSQL_FetchDataAsync_Dictionary_DataTypes_Check() Assert.AreEqual("XmlData", dataType.ReferenceData["Xml_Column"]); } + [TestMethod] + [TestCategory(DB_TESTS), TestCategory(MSSQL_TESTS)] + public async Task Test_MSSQL_FetchDataAsync_Dictionary_UnsupportedCommands() + { + var sqlStatements = new List + { + Queries.MSSQLQueries.TestDB.DDL.Create_Table, + Queries.MSSQLQueries.TestDB.DDL.Alter_Table, + Queries.MSSQLQueries.TestDB.DDL.Comment_Table, + Queries.MSSQLQueries.TestDB.DDL.Truncate_Table, + Queries.MSSQLQueries.TestDB.DDL.Drop_Table, + + Queries.MSSQLQueries.TestDB.DML.InsertSql, + Queries.MSSQLQueries.TestDB.DML.UpdateSql, + Queries.MSSQLQueries.TestDB.DML.DeleteSql, + + Queries.MSSQLQueries.TestDB.DCL.GrantSql_Command_Table_User, + Queries.MSSQLQueries.TestDB.DCL.RevokeSql_Command_Table_User + }; + + foreach (var sqlStatement in sqlStatements) + { + try + { + var dbContext = new DBContext(DB.MSSQL, MSSQLConnectionString); + await dbContext.FetchDataAsync(sqlStatement); + Assert.Fail("No Exception"); + } + catch (QueryDBException ex) + { + Assert.AreEqual("Only SELECT queries are supported here.", ex.Message); + Assert.AreEqual("UnsupportedCommand", ex.ErrorType); + Assert.AreEqual("'FetchData' only supports SELECT queries that return result set.", ex.AdditionalInfo); + } + } + } + #endregion #region Fetch Data Tests - << List FetchData(string selectSql, bool strict = false) >> @@ -453,6 +527,43 @@ public void Test_MSSQL_FetchData_Entity_Strict_Error_Check() } } + [TestMethod] + [TestCategory(DB_TESTS), TestCategory(MSSQL_TESTS)] + public void Test_MSSQL_FetchData_Entity_UnsupportedCommands() + { + var sqlStatements = new List + { + Queries.MSSQLQueries.TestDB.DDL.Create_Table, + Queries.MSSQLQueries.TestDB.DDL.Alter_Table, + Queries.MSSQLQueries.TestDB.DDL.Comment_Table, + Queries.MSSQLQueries.TestDB.DDL.Truncate_Table, + Queries.MSSQLQueries.TestDB.DDL.Drop_Table, + + Queries.MSSQLQueries.TestDB.DML.InsertSql, + Queries.MSSQLQueries.TestDB.DML.UpdateSql, + Queries.MSSQLQueries.TestDB.DML.DeleteSql, + + Queries.MSSQLQueries.TestDB.DCL.GrantSql_Command_Table_User, + Queries.MSSQLQueries.TestDB.DCL.RevokeSql_Command_Table_User + }; + + foreach (var sqlStatement in sqlStatements) + { + try + { + var dbContext = new DBContext(DB.MSSQL, MSSQLConnectionString); + dbContext.FetchData(sqlStatement); + Assert.Fail("No Exception"); + } + catch (QueryDBException ex) + { + Assert.AreEqual("Only SELECT queries are supported here.", ex.Message); + Assert.AreEqual("UnsupportedCommand", ex.ErrorType); + Assert.AreEqual("'FetchData' only supports SELECT queries that return result set.", ex.AdditionalInfo); + } + } + } + #endregion #region Fetch Data Async Tests - << Task> FetchDataAsync(string selectSql, bool strict = false) >> @@ -590,6 +701,43 @@ public async Task Test_MSSQL_FetchDataAsync_Entity_Strict_Error_Check() } } + [TestMethod] + [TestCategory(DB_TESTS), TestCategory(MSSQL_TESTS)] + public async Task Test_MSSQL_FetchDataAsync_Entity_UnsupportedCommands() + { + var sqlStatements = new List + { + Queries.MSSQLQueries.TestDB.DDL.Create_Table, + Queries.MSSQLQueries.TestDB.DDL.Alter_Table, + Queries.MSSQLQueries.TestDB.DDL.Comment_Table, + Queries.MSSQLQueries.TestDB.DDL.Truncate_Table, + Queries.MSSQLQueries.TestDB.DDL.Drop_Table, + + Queries.MSSQLQueries.TestDB.DML.InsertSql, + Queries.MSSQLQueries.TestDB.DML.UpdateSql, + Queries.MSSQLQueries.TestDB.DML.DeleteSql, + + Queries.MSSQLQueries.TestDB.DCL.GrantSql_Command_Table_User, + Queries.MSSQLQueries.TestDB.DCL.RevokeSql_Command_Table_User + }; + + foreach (var sqlStatement in sqlStatements) + { + try + { + var dbContext = new DBContext(DB.MSSQL, MSSQLConnectionString); + await dbContext.FetchDataAsync(sqlStatement); + Assert.Fail("No Exception"); + } + catch (QueryDBException ex) + { + Assert.AreEqual("Only SELECT queries are supported here.", ex.Message); + Assert.AreEqual("UnsupportedCommand", ex.ErrorType); + Assert.AreEqual("'FetchData' only supports SELECT queries that return result set.", ex.AdditionalInfo); + } + } + } + #endregion #region Execute Scalar Tests - << string ExecuteScalar(string sqlStatement) >> diff --git a/QueryDB.Core.Tests/MySQLTests.cs b/QueryDB.Core.Tests/MySQLTests.cs index 6dd4469..e87f3e8 100644 --- a/QueryDB.Core.Tests/MySQLTests.cs +++ b/QueryDB.Core.Tests/MySQLTests.cs @@ -163,6 +163,43 @@ public void Test_MySQL_FetchData_Dictionary_DataTypes_Check() Assert.AreEqual("This is a varchar", dataType.ReferenceData["VarChar_Column"]); } + [TestMethod] + [TestCategory(DB_TESTS), TestCategory(MYSQL_TESTS)] + public void Test_MySQL_FetchData_Dictionary_UnsupportedCommands() + { + var sqlStatements = new List + { + Queries.MySQLQueries.TestDB.DDL.Create_Table, + Queries.MySQLQueries.TestDB.DDL.Alter_Table, + Queries.MySQLQueries.TestDB.DDL.Comment_Table, + Queries.MySQLQueries.TestDB.DDL.Truncate_Table, + Queries.MySQLQueries.TestDB.DDL.Drop_Table, + + Queries.MySQLQueries.TestDB.DML.InsertSql, + Queries.MySQLQueries.TestDB.DML.UpdateSql, + Queries.MySQLQueries.TestDB.DML.DeleteSql, + + Queries.MySQLQueries.TestDB.DCL.GrantSql_Command_Table_User, + Queries.MySQLQueries.TestDB.DCL.RevokeSql_Command_Table_User + }; + + foreach (var sqlStatement in sqlStatements) + { + try + { + var dbContext = new DBContext(DB.MySQL, MySQLConnectionString); + dbContext.FetchData(sqlStatement); + Assert.Fail("No Exception"); + } + catch (QueryDBException ex) + { + Assert.AreEqual("Only SELECT queries are supported here.", ex.Message); + Assert.AreEqual("UnsupportedCommand", ex.ErrorType); + Assert.AreEqual("'FetchData' only supports SELECT queries that return result set.", ex.AdditionalInfo); + } + } + } + #endregion #region Fetch Data Async Tests - << Task> FetchDataAsync(string selectSql, bool upperCaseKeys = false) >> @@ -296,6 +333,43 @@ public async Task Test_MySQL_FetchDataAsync_Dictionary_DataTypes_Check() Assert.AreEqual("This is a varchar", dataType.ReferenceData["VarChar_Column"]); } + [TestMethod] + [TestCategory(DB_TESTS), TestCategory(MYSQL_TESTS)] + public async Task Test_MySQL_FetchDataAsync_Dictionary_UnsupportedCommands() + { + var sqlStatements = new List + { + Queries.MySQLQueries.TestDB.DDL.Create_Table, + Queries.MySQLQueries.TestDB.DDL.Alter_Table, + Queries.MySQLQueries.TestDB.DDL.Comment_Table, + Queries.MySQLQueries.TestDB.DDL.Truncate_Table, + Queries.MySQLQueries.TestDB.DDL.Drop_Table, + + Queries.MySQLQueries.TestDB.DML.InsertSql, + Queries.MySQLQueries.TestDB.DML.UpdateSql, + Queries.MySQLQueries.TestDB.DML.DeleteSql, + + Queries.MySQLQueries.TestDB.DCL.GrantSql_Command_Table_User, + Queries.MySQLQueries.TestDB.DCL.RevokeSql_Command_Table_User + }; + + foreach (var sqlStatement in sqlStatements) + { + try + { + var dbContext = new DBContext(DB.MySQL, MySQLConnectionString); + await dbContext.FetchDataAsync(sqlStatement); + Assert.Fail("No Exception"); + } + catch (QueryDBException ex) + { + Assert.AreEqual("Only SELECT queries are supported here.", ex.Message); + Assert.AreEqual("UnsupportedCommand", ex.ErrorType); + Assert.AreEqual("'FetchData' only supports SELECT queries that return result set.", ex.AdditionalInfo); + } + } + } + #endregion #region Fetch Data Tests - << List FetchData(string selectSql, bool strict = false) >> @@ -423,6 +497,43 @@ public void Test_MySQL_FetchData_Entity_Strict_Error_Check() } } + [TestMethod] + [TestCategory(DB_TESTS), TestCategory(MYSQL_TESTS)] + public void Test_MySQL_FetchData_Entity_UnsupportedCommands() + { + var sqlStatements = new List + { + Queries.MySQLQueries.TestDB.DDL.Create_Table, + Queries.MySQLQueries.TestDB.DDL.Alter_Table, + Queries.MySQLQueries.TestDB.DDL.Comment_Table, + Queries.MySQLQueries.TestDB.DDL.Truncate_Table, + Queries.MySQLQueries.TestDB.DDL.Drop_Table, + + Queries.MySQLQueries.TestDB.DML.InsertSql, + Queries.MySQLQueries.TestDB.DML.UpdateSql, + Queries.MySQLQueries.TestDB.DML.DeleteSql, + + Queries.MySQLQueries.TestDB.DCL.GrantSql_Command_Table_User, + Queries.MySQLQueries.TestDB.DCL.RevokeSql_Command_Table_User + }; + + foreach (var sqlStatement in sqlStatements) + { + try + { + var dbContext = new DBContext(DB.MySQL, MySQLConnectionString); + dbContext.FetchData(sqlStatement); + Assert.Fail("No Exception"); + } + catch (QueryDBException ex) + { + Assert.AreEqual("Only SELECT queries are supported here.", ex.Message); + Assert.AreEqual("UnsupportedCommand", ex.ErrorType); + Assert.AreEqual("'FetchData' only supports SELECT queries that return result set.", ex.AdditionalInfo); + } + } + } + #endregion #region Fetch Data Async Tests - << List FetchData(string selectSql, bool strict = false) >> @@ -550,6 +661,43 @@ public async Task Test_MySQL_FetchDataAsync_Entity_Strict_Error_Check() } } + [TestMethod] + [TestCategory(DB_TESTS), TestCategory(MYSQL_TESTS)] + public async Task Test_MySQL_FetchDataAsync_Entity_UnsupportedCommands() + { + var sqlStatements = new List + { + Queries.MySQLQueries.TestDB.DDL.Create_Table, + Queries.MySQLQueries.TestDB.DDL.Alter_Table, + Queries.MySQLQueries.TestDB.DDL.Comment_Table, + Queries.MySQLQueries.TestDB.DDL.Truncate_Table, + Queries.MySQLQueries.TestDB.DDL.Drop_Table, + + Queries.MySQLQueries.TestDB.DML.InsertSql, + Queries.MySQLQueries.TestDB.DML.UpdateSql, + Queries.MySQLQueries.TestDB.DML.DeleteSql, + + Queries.MySQLQueries.TestDB.DCL.GrantSql_Command_Table_User, + Queries.MySQLQueries.TestDB.DCL.RevokeSql_Command_Table_User + }; + + foreach (var sqlStatement in sqlStatements) + { + try + { + var dbContext = new DBContext(DB.MySQL, MySQLConnectionString); + await dbContext.FetchDataAsync(sqlStatement); + Assert.Fail("No Exception"); + } + catch (QueryDBException ex) + { + Assert.AreEqual("Only SELECT queries are supported here.", ex.Message); + Assert.AreEqual("UnsupportedCommand", ex.ErrorType); + Assert.AreEqual("'FetchData' only supports SELECT queries that return result set.", ex.AdditionalInfo); + } + } + } + #endregion #region Execute Scalar Tests - << string ExecuteScalar(string sqlStatement) >> diff --git a/QueryDB.Core.Tests/OracleTests.cs b/QueryDB.Core.Tests/OracleTests.cs index d9c0e84..2f6bbdc 100644 --- a/QueryDB.Core.Tests/OracleTests.cs +++ b/QueryDB.Core.Tests/OracleTests.cs @@ -164,6 +164,43 @@ public void Test_Oracle_FetchData_Dictionary_DataTypes_Check() Assert.AreEqual("Sample VARCHAR2 data", dataType.ReferenceData["VARCHAR2_COLUMN"]); } + [TestMethod] + [TestCategory(DB_TESTS), TestCategory(ORACLE_TESTS)] + public void Test_Oracle_FetchData_Dictionary_UnsupportedCommands() + { + var sqlStatements = new List + { + Queries.OracleQueries.TestDB.DDL.Create_Table, + Queries.OracleQueries.TestDB.DDL.Alter_Table, + Queries.OracleQueries.TestDB.DDL.Comment_Table, + Queries.OracleQueries.TestDB.DDL.Truncate_Table, + Queries.OracleQueries.TestDB.DDL.Drop_Table, + + Queries.OracleQueries.TestDB.DML.InsertSql, + Queries.OracleQueries.TestDB.DML.UpdateSql, + Queries.OracleQueries.TestDB.DML.DeleteSql, + + Queries.OracleQueries.TestDB.DCL.GrantSql_Command_Table_User, + Queries.OracleQueries.TestDB.DCL.RevokeSql_Command_Table_User + }; + + foreach (var sqlStatement in sqlStatements) + { + try + { + var dbContext = new DBContext(DB.Oracle, OracleConnectionString); + dbContext.FetchData(sqlStatement); + Assert.Fail("No Exception"); + } + catch (QueryDBException ex) + { + Assert.AreEqual("Only SELECT queries are supported here.", ex.Message); + Assert.AreEqual("UnsupportedCommand", ex.ErrorType); + Assert.AreEqual("'FetchData' only supports SELECT queries that return result set.", ex.AdditionalInfo); + } + } + } + #endregion #region Fetch Data Async Tests - << List FetchData(string selectSql, bool upperCaseKeys = false) >> @@ -298,6 +335,43 @@ public async Task Test_Oracle_FetchDataAsync_Dictionary_DataTypes_Check() Assert.AreEqual("Sample VARCHAR2 data", dataType.ReferenceData["VARCHAR2_COLUMN"]); } + [TestMethod] + [TestCategory(DB_TESTS), TestCategory(ORACLE_TESTS)] + public async Task Test_Oracle_FetchDataAsync_Dictionary_UnsupportedCommands() + { + var sqlStatements = new List + { + Queries.OracleQueries.TestDB.DDL.Create_Table, + Queries.OracleQueries.TestDB.DDL.Alter_Table, + Queries.OracleQueries.TestDB.DDL.Comment_Table, + Queries.OracleQueries.TestDB.DDL.Truncate_Table, + Queries.OracleQueries.TestDB.DDL.Drop_Table, + + Queries.OracleQueries.TestDB.DML.InsertSql, + Queries.OracleQueries.TestDB.DML.UpdateSql, + Queries.OracleQueries.TestDB.DML.DeleteSql, + + Queries.OracleQueries.TestDB.DCL.GrantSql_Command_Table_User, + Queries.OracleQueries.TestDB.DCL.RevokeSql_Command_Table_User + }; + + foreach (var sqlStatement in sqlStatements) + { + try + { + var dbContext = new DBContext(DB.Oracle, OracleConnectionString); + await dbContext.FetchDataAsync(sqlStatement); + Assert.Fail("No Exception"); + } + catch (QueryDBException ex) + { + Assert.AreEqual("Only SELECT queries are supported here.", ex.Message); + Assert.AreEqual("UnsupportedCommand", ex.ErrorType); + Assert.AreEqual("'FetchData' only supports SELECT queries that return result set.", ex.AdditionalInfo); + } + } + } + #endregion #region Fetch Data Tests - << List FetchData(string selectSql, bool strict = false) >> @@ -426,6 +500,43 @@ public void Test_Oracle_FetchData_Entity_Strict_Error_Check() } } + [TestMethod] + [TestCategory(DB_TESTS), TestCategory(ORACLE_TESTS)] + public void Test_Oracle_FetchData_Entity_UnsupportedCommands() + { + var sqlStatements = new List + { + Queries.OracleQueries.TestDB.DDL.Create_Table, + Queries.OracleQueries.TestDB.DDL.Alter_Table, + Queries.OracleQueries.TestDB.DDL.Comment_Table, + Queries.OracleQueries.TestDB.DDL.Truncate_Table, + Queries.OracleQueries.TestDB.DDL.Drop_Table, + + Queries.OracleQueries.TestDB.DML.InsertSql, + Queries.OracleQueries.TestDB.DML.UpdateSql, + Queries.OracleQueries.TestDB.DML.DeleteSql, + + Queries.OracleQueries.TestDB.DCL.GrantSql_Command_Table_User, + Queries.OracleQueries.TestDB.DCL.RevokeSql_Command_Table_User + }; + + foreach (var sqlStatement in sqlStatements) + { + try + { + var dbContext = new DBContext(DB.Oracle, OracleConnectionString); + dbContext.FetchData(sqlStatement); + Assert.Fail("No Exception"); + } + catch (QueryDBException ex) + { + Assert.AreEqual("Only SELECT queries are supported here.", ex.Message); + Assert.AreEqual("UnsupportedCommand", ex.ErrorType); + Assert.AreEqual("'FetchData' only supports SELECT queries that return result set.", ex.AdditionalInfo); + } + } + } + #endregion #region Fetch Data Async Tests - << List FetchData(string selectSql, bool strict = false) >> @@ -554,6 +665,43 @@ public async Task Test_Oracle_FetchDataAsync_Entity_Strict_Error_Check() } } + [TestMethod] + [TestCategory(DB_TESTS), TestCategory(ORACLE_TESTS)] + public async Task Test_Oracle_FetchDataAsync_Entity_UnsupportedCommands() + { + var sqlStatements = new List + { + Queries.OracleQueries.TestDB.DDL.Create_Table, + Queries.OracleQueries.TestDB.DDL.Alter_Table, + Queries.OracleQueries.TestDB.DDL.Comment_Table, + Queries.OracleQueries.TestDB.DDL.Truncate_Table, + Queries.OracleQueries.TestDB.DDL.Drop_Table, + + Queries.OracleQueries.TestDB.DML.InsertSql, + Queries.OracleQueries.TestDB.DML.UpdateSql, + Queries.OracleQueries.TestDB.DML.DeleteSql, + + Queries.OracleQueries.TestDB.DCL.GrantSql_Command_Table_User, + Queries.OracleQueries.TestDB.DCL.RevokeSql_Command_Table_User + }; + + foreach (var sqlStatement in sqlStatements) + { + try + { + var dbContext = new DBContext(DB.Oracle, OracleConnectionString); + await dbContext.FetchDataAsync(sqlStatement); + Assert.Fail("No Exception"); + } + catch (QueryDBException ex) + { + Assert.AreEqual("Only SELECT queries are supported here.", ex.Message); + Assert.AreEqual("UnsupportedCommand", ex.ErrorType); + Assert.AreEqual("'FetchData' only supports SELECT queries that return result set.", ex.AdditionalInfo); + } + } + } + #endregion #region Execute Scalar Tests - << string ExecuteScalar(string sqlStatement) >> diff --git a/QueryDB.Core.Tests/PostgreSQLTests.cs b/QueryDB.Core.Tests/PostgreSQLTests.cs index cb04a28..72259be 100644 --- a/QueryDB.Core.Tests/PostgreSQLTests.cs +++ b/QueryDB.Core.Tests/PostgreSQLTests.cs @@ -160,6 +160,43 @@ public void Test_PostgreSQL_FetchData_Dictionary_DataTypes_Check() Assert.AreEqual("123e4567-e89b-12d3-a456-426614174000", dataType.ReferenceData["uuid_column"]); } + [TestMethod] + [TestCategory(DB_TESTS), TestCategory(POSTGRESQL_TESTS)] + public void Test_PostgreSQL_FetchData_Dictionary_UnsupportedCommands() + { + var sqlStatements = new List + { + Queries.PostgreSQLQueries.TestDB.DDL.Create_Table, + Queries.PostgreSQLQueries.TestDB.DDL.Alter_Table, + Queries.PostgreSQLQueries.TestDB.DDL.Comment_Table, + Queries.PostgreSQLQueries.TestDB.DDL.Truncate_Table, + Queries.PostgreSQLQueries.TestDB.DDL.Drop_Table, + + Queries.PostgreSQLQueries.TestDB.DML.InsertSql, + Queries.PostgreSQLQueries.TestDB.DML.UpdateSql, + Queries.PostgreSQLQueries.TestDB.DML.DeleteSql, + + Queries.PostgreSQLQueries.TestDB.DCL.GrantSql_Command_Table_User, + Queries.PostgreSQLQueries.TestDB.DCL.RevokeSql_Command_Table_User + }; + + foreach (var sqlStatement in sqlStatements) + { + try + { + var dbContext = new DBContext(DB.PostgreSQL, PostgreSQLConnectionString); + dbContext.FetchData(sqlStatement); + Assert.Fail("No Exception"); + } + catch (QueryDBException ex) + { + Assert.AreEqual("Only SELECT queries are supported here.", ex.Message); + Assert.AreEqual("UnsupportedCommand", ex.ErrorType); + Assert.AreEqual("'FetchData' only supports SELECT queries that return result set.", ex.AdditionalInfo); + } + } + } + #endregion #region Fetch Data Async Tests - << Task> FetchDataAsync(string selectSql, bool upperCaseKeys = false) >> @@ -290,6 +327,43 @@ public async Task Test_PostgreSQL_FetchDataAsync_Dictionary_DataTypes_Check() Assert.AreEqual("123e4567-e89b-12d3-a456-426614174000", dataType.ReferenceData["uuid_column"]); } + [TestMethod] + [TestCategory(DB_TESTS), TestCategory(POSTGRESQL_TESTS)] + public async Task Test_PostgreSQL_FetchDataAsync_Dictionary_UnsupportedCommands() + { + var sqlStatements = new List + { + Queries.PostgreSQLQueries.TestDB.DDL.Create_Table, + Queries.PostgreSQLQueries.TestDB.DDL.Alter_Table, + Queries.PostgreSQLQueries.TestDB.DDL.Comment_Table, + Queries.PostgreSQLQueries.TestDB.DDL.Truncate_Table, + Queries.PostgreSQLQueries.TestDB.DDL.Drop_Table, + + Queries.PostgreSQLQueries.TestDB.DML.InsertSql, + Queries.PostgreSQLQueries.TestDB.DML.UpdateSql, + Queries.PostgreSQLQueries.TestDB.DML.DeleteSql, + + Queries.PostgreSQLQueries.TestDB.DCL.GrantSql_Command_Table_User, + Queries.PostgreSQLQueries.TestDB.DCL.RevokeSql_Command_Table_User + }; + + foreach (var sqlStatement in sqlStatements) + { + try + { + var dbContext = new DBContext(DB.PostgreSQL, PostgreSQLConnectionString); + await dbContext.FetchDataAsync(sqlStatement); + Assert.Fail("No Exception"); + } + catch (QueryDBException ex) + { + Assert.AreEqual("Only SELECT queries are supported here.", ex.Message); + Assert.AreEqual("UnsupportedCommand", ex.ErrorType); + Assert.AreEqual("'FetchData' only supports SELECT queries that return result set.", ex.AdditionalInfo); + } + } + } + #endregion #region Fetch Data Tests - << List FetchData(string selectSql, bool strict = false) >> @@ -414,6 +488,43 @@ public void Test_PostgreSQL_FetchData_Entity_Strict_Error_Check() } } + [TestMethod] + [TestCategory(DB_TESTS), TestCategory(POSTGRESQL_TESTS)] + public void Test_PostgreSQL_FetchData_Entity_UnsupportedCommands() + { + var sqlStatements = new List + { + Queries.PostgreSQLQueries.TestDB.DDL.Create_Table, + Queries.PostgreSQLQueries.TestDB.DDL.Alter_Table, + Queries.PostgreSQLQueries.TestDB.DDL.Comment_Table, + Queries.PostgreSQLQueries.TestDB.DDL.Truncate_Table, + Queries.PostgreSQLQueries.TestDB.DDL.Drop_Table, + + Queries.PostgreSQLQueries.TestDB.DML.InsertSql, + Queries.PostgreSQLQueries.TestDB.DML.UpdateSql, + Queries.PostgreSQLQueries.TestDB.DML.DeleteSql, + + Queries.PostgreSQLQueries.TestDB.DCL.GrantSql_Command_Table_User, + Queries.PostgreSQLQueries.TestDB.DCL.RevokeSql_Command_Table_User + }; + + foreach (var sqlStatement in sqlStatements) + { + try + { + var dbContext = new DBContext(DB.PostgreSQL, PostgreSQLConnectionString); + dbContext.FetchData(sqlStatement); + Assert.Fail("No Exception"); + } + catch (QueryDBException ex) + { + Assert.AreEqual("Only SELECT queries are supported here.", ex.Message); + Assert.AreEqual("UnsupportedCommand", ex.ErrorType); + Assert.AreEqual("'FetchData' only supports SELECT queries that return result set.", ex.AdditionalInfo); + } + } + } + #endregion #region Fetch Data Async Tests - << Task> FetchDataAsync(string selectSql, bool strict = false) >> @@ -538,6 +649,43 @@ public async Task Test_PostgreSQL_FetchDataAsync_Entity_Strict_Error_Check() } } + [TestMethod] + [TestCategory(DB_TESTS), TestCategory(POSTGRESQL_TESTS)] + public async Task Test_PostgreSQL_FetchDataAsync_Entity_UnsupportedCommands() + { + var sqlStatements = new List + { + Queries.PostgreSQLQueries.TestDB.DDL.Create_Table, + Queries.PostgreSQLQueries.TestDB.DDL.Alter_Table, + Queries.PostgreSQLQueries.TestDB.DDL.Comment_Table, + Queries.PostgreSQLQueries.TestDB.DDL.Truncate_Table, + Queries.PostgreSQLQueries.TestDB.DDL.Drop_Table, + + Queries.PostgreSQLQueries.TestDB.DML.InsertSql, + Queries.PostgreSQLQueries.TestDB.DML.UpdateSql, + Queries.PostgreSQLQueries.TestDB.DML.DeleteSql, + + Queries.PostgreSQLQueries.TestDB.DCL.GrantSql_Command_Table_User, + Queries.PostgreSQLQueries.TestDB.DCL.RevokeSql_Command_Table_User + }; + + foreach (var sqlStatement in sqlStatements) + { + try + { + var dbContext = new DBContext(DB.PostgreSQL, PostgreSQLConnectionString); + await dbContext.FetchDataAsync(sqlStatement); + Assert.Fail("No Exception"); + } + catch (QueryDBException ex) + { + Assert.AreEqual("Only SELECT queries are supported here.", ex.Message); + Assert.AreEqual("UnsupportedCommand", ex.ErrorType); + Assert.AreEqual("'FetchData' only supports SELECT queries that return result set.", ex.AdditionalInfo); + } + } + } + #endregion #region Execute Scalar Tests - << string ExecuteScalar(string sqlStatement) >> diff --git a/QueryDB/DBContext.cs b/QueryDB/DBContext.cs index cc879fd..ff90111 100644 --- a/QueryDB/DBContext.cs +++ b/QueryDB/DBContext.cs @@ -66,6 +66,9 @@ public DBContext(DB database, string connectionString) /// List of with column names as keys holding values into a list for multiple rows of data. public List FetchData(string selectSql, bool upperCaseKeys = false) { + if (!Regex.IsMatch(selectSql, Utils.SelectQueryPattern, RegexOptions.IgnoreCase | RegexOptions.Singleline, TimeSpan.FromSeconds(5))) + throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedFetchDataCommand, + QueryDBExceptions.ErrorType.UnsupportedCommand, QueryDBExceptions.AdditionalInfo.UnsupportedFetchDataCommand); var dataList = new List(); if (Database.Equals(DB.MSSQL)) { @@ -111,6 +114,9 @@ public List FetchData(string selectSql, bool upperCaseKeys = fal /// List of data rows mapped into object of type . public List FetchData(string selectSql, bool strict = false) where T : new() { + if (!Regex.IsMatch(selectSql, Utils.SelectQueryPattern, RegexOptions.IgnoreCase | RegexOptions.Singleline, TimeSpan.FromSeconds(5))) + throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedFetchDataCommand, + QueryDBExceptions.ErrorType.UnsupportedCommand, QueryDBExceptions.AdditionalInfo.UnsupportedFetchDataCommand); var dataList = new List(); if (Database.Equals(DB.MSSQL)) { @@ -157,6 +163,9 @@ public List FetchData(string selectSql, bool upperCaseKeys = fal /// List of with column names as keys holding values into a list for multiple rows of data. public async Task> FetchDataAsync(string selectSql, bool upperCaseKeys = false) { + if (!Regex.IsMatch(selectSql, Utils.SelectQueryPattern, RegexOptions.IgnoreCase | RegexOptions.Singleline, TimeSpan.FromSeconds(5))) + throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedFetchDataCommand, + QueryDBExceptions.ErrorType.UnsupportedCommand, QueryDBExceptions.AdditionalInfo.UnsupportedFetchDataCommand); var dataList = new List(); if (Database.Equals(DB.MSSQL)) { @@ -202,6 +211,9 @@ public async Task> FetchDataAsync(string selectSql, bool up /// List of data rows mapped into object of type . public async Task> FetchDataAsync(string selectSql, bool strict = false) where T : new() { + if (!Regex.IsMatch(selectSql, Utils.SelectQueryPattern, RegexOptions.IgnoreCase | RegexOptions.Singleline, TimeSpan.FromSeconds(5))) + throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedFetchDataCommand, + QueryDBExceptions.ErrorType.UnsupportedCommand, QueryDBExceptions.AdditionalInfo.UnsupportedFetchDataCommand); var dataList = new List(); if (Database.Equals(DB.MSSQL)) { From 216230434ffb413d27a52e45231d4dbcfb5b8cc4 Mon Sep 17 00:00:00 2001 From: abhinavminhas Date: Mon, 3 Mar 2025 00:57:16 +1100 Subject: [PATCH 03/14] Fetch Data - Unsupported Commands --- QueryDB/Exceptions/QueryDBException.cs | 30 +++++++++++++++++--------- 1 file changed, 20 insertions(+), 10 deletions(-) diff --git a/QueryDB/Exceptions/QueryDBException.cs b/QueryDB/Exceptions/QueryDBException.cs index 7f09c07..e6d3a36 100644 --- a/QueryDB/Exceptions/QueryDBException.cs +++ b/QueryDB/Exceptions/QueryDBException.cs @@ -61,6 +61,16 @@ internal static class ErrorType /// internal static class ErrorMessage { + /// + /// Error message indicating that SELECT queries are only supported in 'FetchData'. + /// + internal static readonly string UnsupportedFetchDataCommand = "Only SELECT queries are supported here."; + + /// + /// Error message indicating that SELECT queries are only supported in 'ExecuteScalar'. + /// + internal static readonly string UnsupportedExecuteScalarCommand = "Only SELECT queries are supported here."; + /// /// Error message indicating that SELECT queries are not supported in 'ExecuteCommand'. /// @@ -70,11 +80,6 @@ internal static class ErrorMessage /// Error message indicating that SELECT queries are not supported in 'ExecuteTransaction'. /// internal static readonly string UnsupportedSelectExecuteTransaction = "SELECT queries are not supported here."; - - /// - /// Error message indicating that SELECT queries are only supported in 'ExecuteScalar'. - /// - internal static readonly string UnsupportedExecuteScalarCommand = "Only SELECT queries are supported here."; } /// @@ -82,6 +87,16 @@ internal static class ErrorMessage /// internal static class AdditionalInfo { + /// + /// Error message indicating that SELECT queries are only supported in 'FetchData'. + /// + internal static readonly string UnsupportedFetchDataCommand = "'FetchData' only supports SELECT queries that return result set."; + + /// + /// Error message indicating that SELECT queries are only supported in 'ExecuteScalar'. + /// + internal static readonly string UnsupportedExecuteScalarCommand = "'ExecuteScalar' only supports SELECT queries that have a scalar (single value) return."; + /// /// Additional information about unsupported SELECT queries in 'ExecuteCommand'. /// @@ -91,11 +106,6 @@ internal static class AdditionalInfo /// Additional information about unsupported SELECT queries in 'ExecuteTransaction'. /// internal static readonly string UnsupportedSelectExecuteTransaction = "'ExecuteTransaction' doesn't support SELECT queries."; - - /// - /// Error message indicating that SELECT queries are only supported in 'ExecuteScalar'. - /// - internal static readonly string UnsupportedExecuteScalarCommand = "'ExecuteScalar' only supports SELECT queries that have a scalar (single value) return."; } } } From 4cd2e4feae53b9495c42c29c80c5e684aebcc98d Mon Sep 17 00:00:00 2001 From: abhinavminhas Date: Sun, 16 Mar 2025 10:26:59 +1100 Subject: [PATCH 04/14] Fetch Data - Unsupported commands test updates --- QueryDB.Core.Tests/MySQLTests.cs | 38 ++++++++++++++++++++++---------- QueryDB.Core.Tests/Queries.cs | 2 +- 2 files changed, 27 insertions(+), 13 deletions(-) diff --git a/QueryDB.Core.Tests/MySQLTests.cs b/QueryDB.Core.Tests/MySQLTests.cs index e87f3e8..075021e 100644 --- a/QueryDB.Core.Tests/MySQLTests.cs +++ b/QueryDB.Core.Tests/MySQLTests.cs @@ -1325,7 +1325,11 @@ public void Test_MySQL_ExecuteCommand_DCL_Queries() var password = "Test@1234"; var table = "Agents"; var commands = "SELECT, UPDATE"; - var checkCommand = "SELECT"; + var checkCommands = new List() + { + "SELECT", + "UPDATE" + }; var createUser = string.Format(Queries.MySQLQueries.TestDB.DCL.CreateUserSql_User_Password, user, password); var grantSql = string.Format(Queries.MySQLQueries.TestDB.DCL.GrantSql_Command_Table_User, commands, table, user); @@ -1341,22 +1345,25 @@ public void Test_MySQL_ExecuteCommand_DCL_Queries() // Existing Permissions var data = dbContext.FetchData(verifyPermissions); - Assert.AreEqual(1, data.Count); - Assert.IsFalse(data.Any(data => data.ReferenceData.Values.Any(value => value.Contains(checkCommand)))); + Assert.AreEqual(0, data.Count); + foreach (var checkCommand in checkCommands) + Assert.IsFalse(data.Any(data => data.ReferenceData.Values.Any(value => value.Contains(checkCommand)))); // Grant result = dbContext.ExecuteCommand(grantSql); Assert.AreEqual(0, result); data = dbContext.FetchData(verifyPermissions); Assert.AreEqual(2, data.Count); - Assert.IsTrue(data.Any(data => data.ReferenceData.Values.Any(value => value.Contains(checkCommand)))); + foreach (var checkCommand in checkCommands) + Assert.IsTrue(data.Any(data => data.ReferenceData.Values.Any(value => value.Contains(checkCommand)))); // Revoke result = dbContext.ExecuteCommand(revokeSql); Assert.AreEqual(0, result); data = dbContext.FetchData(verifyPermissions); - Assert.AreEqual(1, data.Count); - Assert.IsFalse(data.Any(data => data.ReferenceData.Values.Any(value => value.Contains(checkCommand)))); + Assert.AreEqual(0, data.Count); + foreach (var checkCommand in checkCommands) + Assert.IsFalse(data.Any(data => data.ReferenceData.Values.Any(value => value.Contains(checkCommand)))); //Remove User result = dbContext.ExecuteCommand(removeUser); @@ -1488,7 +1495,11 @@ public async Task Test_MySQL_ExecuteCommandAsync_DCL_Queries() var password = "Test@1234"; var table = "Agents"; var commands = "SELECT, UPDATE"; - var checkCommand = "SELECT"; + var checkCommands = new List() + { + "SELECT", + "UPDATE" + }; var createUser = string.Format(Queries.MySQLQueries.TestDB.DCL.CreateUserSql_User_Password, user, password); var grantSql = string.Format(Queries.MySQLQueries.TestDB.DCL.GrantSql_Command_Table_User, commands, table, user); @@ -1504,22 +1515,25 @@ public async Task Test_MySQL_ExecuteCommandAsync_DCL_Queries() // Existing Permissions var data = await dbContext.FetchDataAsync(verifyPermissions); - Assert.AreEqual(1, data.Count); - Assert.IsFalse(data.Any(data => data.ReferenceData.Values.Any(value => value.Contains(checkCommand)))); + Assert.AreEqual(0, data.Count); + foreach (var checkCommand in checkCommands) + Assert.IsFalse(data.Any(data => data.ReferenceData.Values.Any(value => value.Contains(checkCommand)))); // Grant result = await dbContext.ExecuteCommandAsync(grantSql); Assert.AreEqual(0, result); data = await dbContext.FetchDataAsync(verifyPermissions); Assert.AreEqual(2, data.Count); - Assert.IsTrue(data.Any(data => data.ReferenceData.Values.Any(value => value.Contains(checkCommand)))); + foreach (var checkCommand in checkCommands) + Assert.IsTrue(data.Any(data => data.ReferenceData.Values.Any(value => value.Contains(checkCommand)))); // Revoke result = await dbContext.ExecuteCommandAsync(revokeSql); Assert.AreEqual(0, result); data = await dbContext.FetchDataAsync(verifyPermissions); - Assert.AreEqual(1, data.Count); - Assert.IsFalse(data.Any(data => data.ReferenceData.Values.Any(value => value.Contains(checkCommand)))); + Assert.AreEqual(0, data.Count); + foreach (var checkCommand in checkCommands) + Assert.IsFalse(data.Any(data => data.ReferenceData.Values.Any(value => value.Contains(checkCommand)))); //Remove User result = await dbContext.ExecuteCommandAsync(removeUser); diff --git a/QueryDB.Core.Tests/Queries.cs b/QueryDB.Core.Tests/Queries.cs index f526765..fefa722 100644 --- a/QueryDB.Core.Tests/Queries.cs +++ b/QueryDB.Core.Tests/Queries.cs @@ -125,7 +125,7 @@ internal static class DCL internal static string CreateUserSql_User_Password = @"CREATE USER '{0}' IDENTIFIED BY '{1}'"; internal static string GrantSql_Command_Table_User = @"GRANT {0} ON {1} TO '{2}'"; internal static string RevokeSql_Command_Table_User = @"REVOKE {0} ON {1} FROM '{2}'"; - internal static string VerifyPermission_User = @"SHOW GRANTS FOR '{0}'"; + internal static string VerifyPermission_User = "SELECT PRIVILEGE_TYPE FROM INFORMATION_SCHEMA.TABLE_PRIVILEGES WHERE GRANTEE = \"'test_user'@'%'\""; internal static string RemoveUserSql_User = "DROP USER '{0}'"; } } From ce1227992f2689c23e120d241fdd73e32fc368ec Mon Sep 17 00:00:00 2001 From: abhinavminhas Date: Sun, 16 Mar 2025 19:53:02 +1100 Subject: [PATCH 05/14] Readme update --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 81892d3..b542013 100644 --- a/README.md +++ b/README.md @@ -134,4 +134,4 @@ var statements = new List }; var dbContext = new DBContext(DB.MSSQL, MSSQLConnectionString); var result = dbContext.ExecuteTransaction(statements); ---- +``` \ No newline at end of file From 45370834f3215ddafc8acb6ff4500b30e6ca205d Mon Sep 17 00:00:00 2001 From: abhinavminhas Date: Sat, 26 Jul 2025 12:44:54 +1000 Subject: [PATCH 06/14] Docker yml update --- QueryDB.Core.Tests/Docker/docker-compose-oracle.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/QueryDB.Core.Tests/Docker/docker-compose-oracle.yml b/QueryDB.Core.Tests/Docker/docker-compose-oracle.yml index 7befd74..723961d 100644 --- a/QueryDB.Core.Tests/Docker/docker-compose-oracle.yml +++ b/QueryDB.Core.Tests/Docker/docker-compose-oracle.yml @@ -3,7 +3,7 @@ services: image: container-registry.oracle.com/database/express:21.3.0-xe container_name: oracle-db environment: - ORACLE_PWD: "Secret123456" + ORACLE_PWD: "" ports: - "1521:1521" volumes: From 8e8371de0554c9b897003dcdccb3b0aecd10540d Mon Sep 17 00:00:00 2001 From: abhinavminhas Date: Sat, 26 Jul 2025 13:59:41 +1000 Subject: [PATCH 07/14] Readme updates --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index b542013..6fb81c6 100644 --- a/README.md +++ b/README.md @@ -28,11 +28,11 @@ The package is available and can be downloaded using [nuget.org](https://www.nug Built on **.NET Standard 2.0** - ( [_Supported Versions_](https://learn.microsoft.com/en-us/dotnet/standard/net-standard?tabs=net-standard-2-0#tabpanel_1_net-standard-2-0:~:text=Select%20.NET%20Standard%20version) ) ## Features -- Retrieve data from the database. +- Retrieve data efficiently from the database. - Execute scalar queries (returning a single value). -- Execute non-query database commands (e.g. `INSERT`, `UPDATE`, `DELETE`). +- Execute non-query commands (e.g. `INSERT`, `UPDATE`, `DELETE`). - Execute transactions while maintaining atomicity. -- Support for Synchronous and Asynchronous operations. +- Support for both Synchronous and Asynchronous operations. ## Getting Started From 9748ca8f6e98539ef09ce95fe21b6c6d3ab0f1e7 Mon Sep 17 00:00:00 2001 From: abhinavminhas Date: Sat, 26 Jul 2025 20:33:56 +1000 Subject: [PATCH 08/14] Replace if with switch --- QueryDB/DBContext.cs | 734 +++++++++++++++++++++---------------------- 1 file changed, 358 insertions(+), 376 deletions(-) diff --git a/QueryDB/DBContext.cs b/QueryDB/DBContext.cs index ff90111..1cb7ffe 100644 --- a/QueryDB/DBContext.cs +++ b/QueryDB/DBContext.cs @@ -70,37 +70,36 @@ public List FetchData(string selectSql, bool upperCaseKeys = fal throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedFetchDataCommand, QueryDBExceptions.ErrorType.UnsupportedCommand, QueryDBExceptions.AdditionalInfo.UnsupportedFetchDataCommand); var dataList = new List(); - if (Database.Equals(DB.MSSQL)) - { - using (var msSqlDBConnection = GetSqlServerConnection()) - { - var _systemAdapter = new MSSQL.Adapter(); - dataList = _systemAdapter.FetchData(selectSql, msSqlDBConnection.SqlConnection, upperCaseKeys); - } - } - else if (Database.Equals(DB.MySQL)) - { - using (var mySqlDBConnection = GetMySqlConnection()) - { - var _systemAdapter = new MySQL.Adapter(); - dataList = _systemAdapter.FetchData(selectSql, mySqlDBConnection.MySqlConnection, upperCaseKeys); - } - } - else if (Database.Equals(DB.Oracle)) - { - using (var oracleDBConnection = GetOracleConnection()) - { - var _systemAdapter = new Oracle.Adapter(); - dataList = _systemAdapter.FetchData(selectSql, oracleDBConnection.OracleConnection, upperCaseKeys); - } - } - else if (Database.Equals(DB.PostgreSQL)) - { - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) - { - var _systemAdapter = new PostgreSQL.Adapter(); - dataList = _systemAdapter.FetchData(selectSql, postgreSqlDBConnection.PostgreSQLConnection, upperCaseKeys); - } + switch (Database) + { + case DB.MSSQL: + using (var msSqlDBConnection = GetSqlServerConnection()) + { + var _systemAdapter = new MSSQL.Adapter(); + dataList = _systemAdapter.FetchData(selectSql, msSqlDBConnection.SqlConnection, upperCaseKeys); + } + break; + case DB.MySQL: + using (var mySqlDBConnection = GetMySqlConnection()) + { + var _systemAdapter = new MySQL.Adapter(); + dataList = _systemAdapter.FetchData(selectSql, mySqlDBConnection.MySqlConnection, upperCaseKeys); + } + break; + case DB.Oracle: + using (var oracleDBConnection = GetOracleConnection()) + { + var _systemAdapter = new Oracle.Adapter(); + dataList = _systemAdapter.FetchData(selectSql, oracleDBConnection.OracleConnection, upperCaseKeys); + } + break; + case DB.PostgreSQL: + using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + { + var _systemAdapter = new PostgreSQL.Adapter(); + dataList = _systemAdapter.FetchData(selectSql, postgreSqlDBConnection.PostgreSQLConnection, upperCaseKeys); + } + break; } return dataList; } @@ -118,37 +117,36 @@ public List FetchData(string selectSql, bool upperCaseKeys = fal throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedFetchDataCommand, QueryDBExceptions.ErrorType.UnsupportedCommand, QueryDBExceptions.AdditionalInfo.UnsupportedFetchDataCommand); var dataList = new List(); - if (Database.Equals(DB.MSSQL)) - { - using (var msSqlDBConnection = GetSqlServerConnection()) - { - var _systemAdapter = new MSSQL.Adapter(); - dataList = _systemAdapter.FetchData(selectSql, msSqlDBConnection.SqlConnection, strict); - } - } - else if (Database.Equals(DB.MySQL)) - { - using (var mySqlDBConnection = GetMySqlConnection()) - { - var _systemAdapter = new MySQL.Adapter(); - dataList = _systemAdapter.FetchData(selectSql, mySqlDBConnection.MySqlConnection, strict); - } - } - else if (Database.Equals(DB.Oracle)) - { - using (var oracleDBConnection = GetOracleConnection()) - { - var _systemAdapter = new Oracle.Adapter(); - dataList = _systemAdapter.FetchData(selectSql, oracleDBConnection.OracleConnection, strict); - } - } - else if (Database.Equals(DB.PostgreSQL)) - { - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) - { - var _systemAdapter = new PostgreSQL.Adapter(); - dataList = _systemAdapter.FetchData(selectSql, postgreSqlDBConnection.PostgreSQLConnection, strict); - } + switch (Database) + { + case DB.MSSQL: + using (var msSqlDBConnection = GetSqlServerConnection()) + { + var _systemAdapter = new MSSQL.Adapter(); + dataList = _systemAdapter.FetchData(selectSql, msSqlDBConnection.SqlConnection, strict); + } + break; + case DB.MySQL: + using (var mySqlDBConnection = GetMySqlConnection()) + { + var _systemAdapter = new MySQL.Adapter(); + dataList = _systemAdapter.FetchData(selectSql, mySqlDBConnection.MySqlConnection, strict); + } + break; + case DB.Oracle: + using (var oracleDBConnection = GetOracleConnection()) + { + var _systemAdapter = new Oracle.Adapter(); + dataList = _systemAdapter.FetchData(selectSql, oracleDBConnection.OracleConnection, strict); + } + break; + case DB.PostgreSQL: + using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + { + var _systemAdapter = new PostgreSQL.Adapter(); + dataList = _systemAdapter.FetchData(selectSql, postgreSqlDBConnection.PostgreSQLConnection, strict); + } + break; } return dataList; } @@ -164,40 +162,39 @@ public List FetchData(string selectSql, bool upperCaseKeys = fal public async Task> FetchDataAsync(string selectSql, bool upperCaseKeys = false) { if (!Regex.IsMatch(selectSql, Utils.SelectQueryPattern, RegexOptions.IgnoreCase | RegexOptions.Singleline, TimeSpan.FromSeconds(5))) - throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedFetchDataCommand, + throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedFetchDataCommand, QueryDBExceptions.ErrorType.UnsupportedCommand, QueryDBExceptions.AdditionalInfo.UnsupportedFetchDataCommand); var dataList = new List(); - if (Database.Equals(DB.MSSQL)) - { - using (var msSqlDBConnection = GetSqlServerConnection()) - { - var _systemAdapter = new MSSQL.Adapter(); - dataList = await _systemAdapter.FetchDataAsync(selectSql, msSqlDBConnection.SqlConnection, upperCaseKeys); - } - } - else if (Database.Equals(DB.MySQL)) - { - using (var mySqlDBConnection = GetMySqlConnection()) - { - var _systemAdapter = new MySQL.Adapter(); - dataList = await _systemAdapter.FetchDataAsync(selectSql, mySqlDBConnection.MySqlConnection, upperCaseKeys); - } - } - else if (Database.Equals(DB.Oracle)) - { - using (var oracleDBConnection = GetOracleConnection()) - { - var _systemAdapter = new Oracle.Adapter(); - dataList = await _systemAdapter.FetchDataAsync(selectSql, oracleDBConnection.OracleConnection, upperCaseKeys); - } - } - else if (Database.Equals(DB.PostgreSQL)) - { - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) - { - var _systemAdapter = new PostgreSQL.Adapter(); - dataList = await _systemAdapter.FetchDataAsync(selectSql, postgreSqlDBConnection.PostgreSQLConnection, upperCaseKeys); - } + switch (Database) + { + case DB.MSSQL: + using (var msSqlDBConnection = GetSqlServerConnection()) + { + var _systemAdapter = new MSSQL.Adapter(); + dataList = await _systemAdapter.FetchDataAsync(selectSql, msSqlDBConnection.SqlConnection, upperCaseKeys); + } + break; + case DB.MySQL: + using (var mySqlDBConnection = GetMySqlConnection()) + { + var _systemAdapter = new MySQL.Adapter(); + dataList = await _systemAdapter.FetchDataAsync(selectSql, mySqlDBConnection.MySqlConnection, upperCaseKeys); + } + break; + case DB.Oracle: + using (var oracleDBConnection = GetOracleConnection()) + { + var _systemAdapter = new Oracle.Adapter(); + dataList = await _systemAdapter.FetchDataAsync(selectSql, oracleDBConnection.OracleConnection, upperCaseKeys); + } + break; + case DB.PostgreSQL: + using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + { + var _systemAdapter = new PostgreSQL.Adapter(); + dataList = await _systemAdapter.FetchDataAsync(selectSql, postgreSqlDBConnection.PostgreSQLConnection, upperCaseKeys); + } + break; } return dataList; } @@ -212,40 +209,39 @@ public async Task> FetchDataAsync(string selectSql, bool up public async Task> FetchDataAsync(string selectSql, bool strict = false) where T : new() { if (!Regex.IsMatch(selectSql, Utils.SelectQueryPattern, RegexOptions.IgnoreCase | RegexOptions.Singleline, TimeSpan.FromSeconds(5))) - throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedFetchDataCommand, + throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedFetchDataCommand, QueryDBExceptions.ErrorType.UnsupportedCommand, QueryDBExceptions.AdditionalInfo.UnsupportedFetchDataCommand); var dataList = new List(); - if (Database.Equals(DB.MSSQL)) - { - using (var msSqlDBConnection = GetSqlServerConnection()) - { - var _systemAdapter = new MSSQL.Adapter(); - dataList = await _systemAdapter.FetchDataAsync(selectSql, msSqlDBConnection.SqlConnection, strict); - } - } - else if (Database.Equals(DB.MySQL)) - { - using (var mySqlDBConnection = GetMySqlConnection()) - { - var _systemAdapter = new MySQL.Adapter(); - dataList = await _systemAdapter.FetchDataAsync(selectSql, mySqlDBConnection.MySqlConnection, strict); - } - } - else if (Database.Equals(DB.Oracle)) - { - using (var oracleDBConnection = GetOracleConnection()) - { - var _systemAdapter = new Oracle.Adapter(); - dataList = await _systemAdapter.FetchDataAsync(selectSql, oracleDBConnection.OracleConnection, strict); - } - } - else if (Database.Equals(DB.PostgreSQL)) - { - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) - { - var _systemAdapter = new PostgreSQL.Adapter(); - dataList = await _systemAdapter.FetchDataAsync(selectSql, postgreSqlDBConnection.PostgreSQLConnection, strict); - } + switch (Database) + { + case DB.MSSQL: + using (var msSqlDBConnection = GetSqlServerConnection()) + { + var _systemAdapter = new MSSQL.Adapter(); + dataList = await _systemAdapter.FetchDataAsync(selectSql, msSqlDBConnection.SqlConnection, strict); + } + break; + case DB.MySQL: + using (var mySqlDBConnection = GetMySqlConnection()) + { + var _systemAdapter = new MySQL.Adapter(); + dataList = await _systemAdapter.FetchDataAsync(selectSql, mySqlDBConnection.MySqlConnection, strict); + } + break; + case DB.Oracle: + using (var oracleDBConnection = GetOracleConnection()) + { + var _systemAdapter = new Oracle.Adapter(); + dataList = await _systemAdapter.FetchDataAsync(selectSql, oracleDBConnection.OracleConnection, strict); + } + break; + case DB.PostgreSQL: + using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + { + var _systemAdapter = new PostgreSQL.Adapter(); + dataList = await _systemAdapter.FetchDataAsync(selectSql, postgreSqlDBConnection.PostgreSQLConnection, strict); + } + break; } return dataList; } @@ -262,40 +258,39 @@ public async Task> FetchDataAsync(string selectSql, bool up public string ExecuteScalar(string sqlStatement) { if (!Regex.IsMatch(sqlStatement, Utils.SelectQueryPattern, RegexOptions.IgnoreCase | RegexOptions.Singleline, TimeSpan.FromSeconds(5))) - throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedExecuteScalarCommand, + throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedExecuteScalarCommand, QueryDBExceptions.ErrorType.UnsupportedCommand, QueryDBExceptions.AdditionalInfo.UnsupportedExecuteScalarCommand); var value = string.Empty; - if (Database.Equals(DB.MSSQL)) - { - using (var msSqlDBConnection = GetSqlServerConnection()) - { - var _systemAdapter = new MSSQL.Adapter(); - value = _systemAdapter.ExecuteScalar(sqlStatement, msSqlDBConnection.SqlConnection); - } - } - else if (Database.Equals(DB.MySQL)) - { - using (var mySqlDBConnection = GetMySqlConnection()) - { - var _systemAdapter = new MySQL.Adapter(); - value = _systemAdapter.ExecuteScalar(sqlStatement, mySqlDBConnection.MySqlConnection); - } - } - else if (Database.Equals(DB.Oracle)) - { - using (var oracleDBConnection = GetOracleConnection()) - { - var _systemAdapter = new Oracle.Adapter(); - value = _systemAdapter.ExecuteScalar(sqlStatement, oracleDBConnection.OracleConnection); - } - } - else if (Database.Equals(DB.PostgreSQL)) - { - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) - { - var _systemAdapter = new PostgreSQL.Adapter(); - value = _systemAdapter.ExecuteScalar(sqlStatement, postgreSqlDBConnection.PostgreSQLConnection); - } + switch (Database) + { + case DB.MSSQL: + using (var msSqlDBConnection = GetSqlServerConnection()) + { + var _systemAdapter = new MSSQL.Adapter(); + value = _systemAdapter.ExecuteScalar(sqlStatement, msSqlDBConnection.SqlConnection); + } + break; + case DB.MySQL: + using (var mySqlDBConnection = GetMySqlConnection()) + { + var _systemAdapter = new MySQL.Adapter(); + value = _systemAdapter.ExecuteScalar(sqlStatement, mySqlDBConnection.MySqlConnection); + } + break; + case DB.Oracle: + using (var oracleDBConnection = GetOracleConnection()) + { + var _systemAdapter = new Oracle.Adapter(); + value = _systemAdapter.ExecuteScalar(sqlStatement, oracleDBConnection.OracleConnection); + } + break; + case DB.PostgreSQL: + using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + { + var _systemAdapter = new PostgreSQL.Adapter(); + value = _systemAdapter.ExecuteScalar(sqlStatement, postgreSqlDBConnection.PostgreSQLConnection); + } + break; } return value; } @@ -313,40 +308,39 @@ public string ExecuteScalar(string sqlStatement) public T ExecuteScalar(string sqlStatement) { if (!Regex.IsMatch(sqlStatement, Utils.SelectQueryPattern, RegexOptions.IgnoreCase | RegexOptions.Singleline, TimeSpan.FromSeconds(5))) - throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedExecuteScalarCommand, + throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedExecuteScalarCommand, QueryDBExceptions.ErrorType.UnsupportedCommand, QueryDBExceptions.AdditionalInfo.UnsupportedExecuteScalarCommand); var value = default(T); - if (Database.Equals(DB.MSSQL)) - { - using (var msSqlDBConnection = GetSqlServerConnection()) - { - var _systemAdapter = new MSSQL.Adapter(); - value = _systemAdapter.ExecuteScalar(sqlStatement, msSqlDBConnection.SqlConnection); - } - } - else if (Database.Equals(DB.MySQL)) - { - using (var mySqlDBConnection = GetMySqlConnection()) - { - var _systemAdapter = new MySQL.Adapter(); - value = _systemAdapter.ExecuteScalar(sqlStatement, mySqlDBConnection.MySqlConnection); - } - } - else if (Database.Equals(DB.Oracle)) - { - using (var oracleDBConnection = GetOracleConnection()) - { - var _systemAdapter = new Oracle.Adapter(); - value = _systemAdapter.ExecuteScalar(sqlStatement, oracleDBConnection.OracleConnection); - } - } - else if (Database.Equals(DB.PostgreSQL)) - { - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) - { - var _systemAdapter = new PostgreSQL.Adapter(); - value = _systemAdapter.ExecuteScalar(sqlStatement, postgreSqlDBConnection.PostgreSQLConnection); - } + switch (Database) + { + case DB.MSSQL: + using (var msSqlDBConnection = GetSqlServerConnection()) + { + var _systemAdapter = new MSSQL.Adapter(); + value = _systemAdapter.ExecuteScalar(sqlStatement, msSqlDBConnection.SqlConnection); + } + break; + case DB.MySQL: + using (var mySqlDBConnection = GetMySqlConnection()) + { + var _systemAdapter = new MySQL.Adapter(); + value = _systemAdapter.ExecuteScalar(sqlStatement, mySqlDBConnection.MySqlConnection); + } + break; + case DB.Oracle: + using (var oracleDBConnection = GetOracleConnection()) + { + var _systemAdapter = new Oracle.Adapter(); + value = _systemAdapter.ExecuteScalar(sqlStatement, oracleDBConnection.OracleConnection); + } + break; + case DB.PostgreSQL: + using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + { + var _systemAdapter = new PostgreSQL.Adapter(); + value = _systemAdapter.ExecuteScalar(sqlStatement, postgreSqlDBConnection.PostgreSQLConnection); + } + break; } return value; } @@ -363,40 +357,39 @@ public T ExecuteScalar(string sqlStatement) public async Task ExecuteScalarAsync(string sqlStatement) { if (!Regex.IsMatch(sqlStatement, Utils.SelectQueryPattern, RegexOptions.IgnoreCase | RegexOptions.Singleline, TimeSpan.FromSeconds(5))) - throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedExecuteScalarCommand, + throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedExecuteScalarCommand, QueryDBExceptions.ErrorType.UnsupportedCommand, QueryDBExceptions.AdditionalInfo.UnsupportedExecuteScalarCommand); var value = string.Empty; - if (Database.Equals(DB.MSSQL)) - { - using (var msSqlDBConnection = GetSqlServerConnection()) - { - var _systemAdapter = new MSSQL.Adapter(); - value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, msSqlDBConnection.SqlConnection); - } - } - else if (Database.Equals(DB.MySQL)) - { - using (var mySqlDBConnection = GetMySqlConnection()) - { - var _systemAdapter = new MySQL.Adapter(); - value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, mySqlDBConnection.MySqlConnection); - } - } - else if (Database.Equals(DB.Oracle)) - { - using (var oracleDBConnection = GetOracleConnection()) - { - var _systemAdapter = new Oracle.Adapter(); - value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, oracleDBConnection.OracleConnection); - } - } - else if (Database.Equals(DB.PostgreSQL)) - { - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) - { - var _systemAdapter = new PostgreSQL.Adapter(); - value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, postgreSqlDBConnection.PostgreSQLConnection); - } + switch (Database) + { + case DB.MSSQL: + using (var msSqlDBConnection = GetSqlServerConnection()) + { + var _systemAdapter = new MSSQL.Adapter(); + value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, msSqlDBConnection.SqlConnection); + } + break; + case DB.MySQL: + using (var mySqlDBConnection = GetMySqlConnection()) + { + var _systemAdapter = new MySQL.Adapter(); + value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, mySqlDBConnection.MySqlConnection); + } + break; + case DB.Oracle: + using (var oracleDBConnection = GetOracleConnection()) + { + var _systemAdapter = new Oracle.Adapter(); + value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, oracleDBConnection.OracleConnection); + } + break; + case DB.PostgreSQL: + using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + { + var _systemAdapter = new PostgreSQL.Adapter(); + value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, postgreSqlDBConnection.PostgreSQLConnection); + } + break; } return value; } @@ -414,40 +407,39 @@ public async Task ExecuteScalarAsync(string sqlStatement) public async Task ExecuteScalarAsync(string sqlStatement) { if (!Regex.IsMatch(sqlStatement, Utils.SelectQueryPattern, RegexOptions.IgnoreCase | RegexOptions.Singleline, TimeSpan.FromSeconds(5))) - throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedExecuteScalarCommand, + throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedExecuteScalarCommand, QueryDBExceptions.ErrorType.UnsupportedCommand, QueryDBExceptions.AdditionalInfo.UnsupportedExecuteScalarCommand); var value = default(T); - if (Database.Equals(DB.MSSQL)) - { - using (var msSqlDBConnection = GetSqlServerConnection()) - { - var _systemAdapter = new MSSQL.Adapter(); - value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, msSqlDBConnection.SqlConnection); - } - } - else if (Database.Equals(DB.MySQL)) - { - using (var mySqlDBConnection = GetMySqlConnection()) - { - var _systemAdapter = new MySQL.Adapter(); - value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, mySqlDBConnection.MySqlConnection); - } - } - else if (Database.Equals(DB.Oracle)) - { - using (var oracleDBConnection = GetOracleConnection()) - { - var _systemAdapter = new Oracle.Adapter(); - value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, oracleDBConnection.OracleConnection); - } - } - else if (Database.Equals(DB.PostgreSQL)) - { - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) - { - var _systemAdapter = new PostgreSQL.Adapter(); - value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, postgreSqlDBConnection.PostgreSQLConnection); - } + switch (Database) + { + case DB.MSSQL: + using (var msSqlDBConnection = GetSqlServerConnection()) + { + var _systemAdapter = new MSSQL.Adapter(); + value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, msSqlDBConnection.SqlConnection); + } + break; + case DB.MySQL: + using (var mySqlDBConnection = GetMySqlConnection()) + { + var _systemAdapter = new MySQL.Adapter(); + value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, mySqlDBConnection.MySqlConnection); + } + break; + case DB.Oracle: + using (var oracleDBConnection = GetOracleConnection()) + { + var _systemAdapter = new Oracle.Adapter(); + value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, oracleDBConnection.OracleConnection); + } + break; + case DB.PostgreSQL: + using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + { + var _systemAdapter = new PostgreSQL.Adapter(); + value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, postgreSqlDBConnection.PostgreSQLConnection); + } + break; } return value; } @@ -460,41 +452,37 @@ public async Task ExecuteScalarAsync(string sqlStatement) public int ExecuteCommand(string sqlStatement) { if (Regex.IsMatch(sqlStatement, Utils.SelectQueryPattern, RegexOptions.IgnoreCase | RegexOptions.Singleline, TimeSpan.FromSeconds(5))) - throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedSelectExecuteCommand, + throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedSelectExecuteCommand, QueryDBExceptions.ErrorType.UnsupportedCommand, QueryDBExceptions.AdditionalInfo.UnsupportedSelectExecuteCommand); - if (Database.Equals(DB.MSSQL)) - { - using (var msSqlDBConnection = GetSqlServerConnection()) - { - var _systemAdapter = new MSSQL.Adapter(); - return _systemAdapter.ExecuteCommand(sqlStatement, msSqlDBConnection.SqlConnection); - } - } - else if (Database.Equals(DB.MySQL)) - { - using (var mySqlDBConnection = GetMySqlConnection()) - { - var _systemAdapter = new MySQL.Adapter(); - return _systemAdapter.ExecuteCommand(sqlStatement, mySqlDBConnection.MySqlConnection); - } - } - else if (Database.Equals(DB.Oracle)) - { - using (var oracleDBConnection = GetOracleConnection()) - { - var _systemAdapter = new Oracle.Adapter(); - return _systemAdapter.ExecuteCommand(sqlStatement, oracleDBConnection.OracleConnection); - } - } - else if (Database.Equals(DB.PostgreSQL)) - { - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) - { - var _systemAdapter = new PostgreSQL.Adapter(); - return _systemAdapter.ExecuteCommand(sqlStatement, postgreSqlDBConnection.PostgreSQLConnection); - } + switch (Database) + { + case DB.MSSQL: + using (var msSqlDBConnection = GetSqlServerConnection()) + { + var _systemAdapter = new MSSQL.Adapter(); + return _systemAdapter.ExecuteCommand(sqlStatement, msSqlDBConnection.SqlConnection); + } + case DB.MySQL: + using (var mySqlDBConnection = GetMySqlConnection()) + { + var _systemAdapter = new MySQL.Adapter(); + return _systemAdapter.ExecuteCommand(sqlStatement, mySqlDBConnection.MySqlConnection); + } + case DB.Oracle: + using (var oracleDBConnection = GetOracleConnection()) + { + var _systemAdapter = new Oracle.Adapter(); + return _systemAdapter.ExecuteCommand(sqlStatement, oracleDBConnection.OracleConnection); + } + case DB.PostgreSQL: + using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + { + var _systemAdapter = new PostgreSQL.Adapter(); + return _systemAdapter.ExecuteCommand(sqlStatement, postgreSqlDBConnection.PostgreSQLConnection); + } + default: + return -1; } - return -1; } /// @@ -505,41 +493,37 @@ public int ExecuteCommand(string sqlStatement) public async Task ExecuteCommandAsync(string sqlStatement) { if (Regex.IsMatch(sqlStatement, Utils.SelectQueryPattern, RegexOptions.IgnoreCase | RegexOptions.Singleline, TimeSpan.FromSeconds(5))) - throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedSelectExecuteCommand, + throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedSelectExecuteCommand, QueryDBExceptions.ErrorType.UnsupportedCommand, QueryDBExceptions.AdditionalInfo.UnsupportedSelectExecuteCommand); - if (Database.Equals(DB.MSSQL)) - { - using (var msSqlDBConnection = GetSqlServerConnection()) - { - var _systemAdapter = new MSSQL.Adapter(); - return await _systemAdapter.ExecuteCommandAsync(sqlStatement, msSqlDBConnection.SqlConnection); - } - } - else if (Database.Equals(DB.MySQL)) - { - using (var mySqlDBConnection = GetMySqlConnection()) - { - var _systemAdapter = new MySQL.Adapter(); - return await _systemAdapter.ExecuteCommandAsync(sqlStatement, mySqlDBConnection.MySqlConnection); - } - } - else if (Database.Equals(DB.Oracle)) - { - using (var oracleDBConnection = GetOracleConnection()) - { - var _systemAdapter = new Oracle.Adapter(); - return await _systemAdapter.ExecuteCommandAsync(sqlStatement, oracleDBConnection.OracleConnection); - } + switch (Database) + { + case DB.MSSQL: + using (var msSqlDBConnection = GetSqlServerConnection()) + { + var _systemAdapter = new MSSQL.Adapter(); + return await _systemAdapter.ExecuteCommandAsync(sqlStatement, msSqlDBConnection.SqlConnection); + } + case DB.MySQL: + using (var mySqlDBConnection = GetMySqlConnection()) + { + var _systemAdapter = new MySQL.Adapter(); + return await _systemAdapter.ExecuteCommandAsync(sqlStatement, mySqlDBConnection.MySqlConnection); + } + case DB.Oracle: + using (var oracleDBConnection = GetOracleConnection()) + { + var _systemAdapter = new Oracle.Adapter(); + return await _systemAdapter.ExecuteCommandAsync(sqlStatement, oracleDBConnection.OracleConnection); + } + case DB.PostgreSQL: + using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + { + var _systemAdapter = new PostgreSQL.Adapter(); + return await _systemAdapter.ExecuteCommandAsync(sqlStatement, postgreSqlDBConnection.PostgreSQLConnection); + } + default: + return -1; } - else if (Database.Equals(DB.PostgreSQL)) - { - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) - { - var _systemAdapter = new PostgreSQL.Adapter(); - return await _systemAdapter.ExecuteCommandAsync(sqlStatement, postgreSqlDBConnection.PostgreSQLConnection); - } - } - return -1; } /// @@ -557,35 +541,34 @@ public Result ExecuteTransaction(List sqlStatements) var result = new Result(); var selectExists = sqlStatements.Any(sqlStatement => Regex.IsMatch(sqlStatement, Utils.SelectQueryPattern, RegexOptions.IgnoreCase | RegexOptions.Singleline, TimeSpan.FromSeconds(5))); if (selectExists) - throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedSelectExecuteTransaction, + throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedSelectExecuteTransaction, QueryDBExceptions.ErrorType.UnsupportedCommand, QueryDBExceptions.AdditionalInfo.UnsupportedSelectExecuteTransaction); - if (Database.Equals(DB.MSSQL)) - { - using (var msSqlDBConnection = GetSqlServerConnection()) - { - result = MSSQL.Adapter.ExecuteTransaction(sqlStatements, msSqlDBConnection.SqlConnection); - } - } - else if (Database.Equals(DB.MySQL)) - { - using (var mySqlDBConnection = GetMySqlConnection()) - { - result = MySQL.Adapter.ExecuteTransaction(sqlStatements, mySqlDBConnection.MySqlConnection); - } - } - else if (Database.Equals(DB.Oracle)) - { - using (var oracleDBConnection = GetOracleConnection()) - { - result = Oracle.Adapter.ExecuteTransaction(sqlStatements, oracleDBConnection.OracleConnection); - } - } - else if (Database.Equals(DB.PostgreSQL)) - { - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) - { - result = PostgreSQL.Adapter.ExecuteTransaction(sqlStatements, postgreSqlDBConnection.PostgreSQLConnection); - } + switch (Database) + { + case DB.MSSQL: + using (var msSqlDBConnection = GetSqlServerConnection()) + { + result = MSSQL.Adapter.ExecuteTransaction(sqlStatements, msSqlDBConnection.SqlConnection); + } + break; + case DB.MySQL: + using (var mySqlDBConnection = GetMySqlConnection()) + { + result = MySQL.Adapter.ExecuteTransaction(sqlStatements, mySqlDBConnection.MySqlConnection); + } + break; + case DB.Oracle: + using (var oracleDBConnection = GetOracleConnection()) + { + result = Oracle.Adapter.ExecuteTransaction(sqlStatements, oracleDBConnection.OracleConnection); + } + break; + case DB.PostgreSQL: + using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + { + result = PostgreSQL.Adapter.ExecuteTransaction(sqlStatements, postgreSqlDBConnection.PostgreSQLConnection); + } + break; } return result; } @@ -605,35 +588,34 @@ public async Task ExecuteTransactionAsync(List sqlStatements) var result = new Result(); var selectExists = sqlStatements.Any(sqlStatement => Regex.IsMatch(sqlStatement, Utils.SelectQueryPattern, RegexOptions.IgnoreCase | RegexOptions.Singleline, TimeSpan.FromSeconds(5))); if (selectExists) - throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedSelectExecuteTransaction, + throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedSelectExecuteTransaction, QueryDBExceptions.ErrorType.UnsupportedCommand, QueryDBExceptions.AdditionalInfo.UnsupportedSelectExecuteTransaction); - if (Database.Equals(DB.MSSQL)) - { - using (var msSqlDBConnection = GetSqlServerConnection()) - { - result = await MSSQL.Adapter.ExecuteTransactionAsync(sqlStatements, msSqlDBConnection.SqlConnection); - } - } - else if (Database.Equals(DB.MySQL)) - { - using (var mySqlDBConnection = GetMySqlConnection()) - { - result = await MySQL.Adapter.ExecuteTransactionAsync(sqlStatements, mySqlDBConnection.MySqlConnection); - } - } - else if (Database.Equals(DB.Oracle)) - { - using (var oracleDBConnection = GetOracleConnection()) - { - result = await Oracle.Adapter.ExecuteTransactionAsync(sqlStatements, oracleDBConnection.OracleConnection); - } - } - else if (Database.Equals(DB.PostgreSQL)) - { - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) - { - result = await PostgreSQL.Adapter.ExecuteTransactionAsync(sqlStatements, postgreSqlDBConnection.PostgreSQLConnection); - } + switch (Database) + { + case DB.MSSQL: + using (var msSqlDBConnection = GetSqlServerConnection()) + { + result = await MSSQL.Adapter.ExecuteTransactionAsync(sqlStatements, msSqlDBConnection.SqlConnection); + } + break; + case DB.MySQL: + using (var mySqlDBConnection = GetMySqlConnection()) + { + result = await MySQL.Adapter.ExecuteTransactionAsync(sqlStatements, mySqlDBConnection.MySqlConnection); + } + break; + case DB.Oracle: + using (var oracleDBConnection = GetOracleConnection()) + { + result = await Oracle.Adapter.ExecuteTransactionAsync(sqlStatements, oracleDBConnection.OracleConnection); + } + break; + case DB.PostgreSQL: + using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + { + result = await PostgreSQL.Adapter.ExecuteTransactionAsync(sqlStatements, postgreSqlDBConnection.PostgreSQLConnection); + } + break; } return result; } From 9249c03f5c11d7480653dbd8cbbfb0b930e6c4a8 Mon Sep 17 00:00:00 2001 From: abhinavminhas Date: Sat, 26 Jul 2025 21:21:16 +1000 Subject: [PATCH 09/14] Refatoring --- QueryDB/DBContext.cs | 272 +++++++++++++++++++++---------------------- 1 file changed, 136 insertions(+), 136 deletions(-) diff --git a/QueryDB/DBContext.cs b/QueryDB/DBContext.cs index 1cb7ffe..6a8e6e9 100644 --- a/QueryDB/DBContext.cs +++ b/QueryDB/DBContext.cs @@ -73,31 +73,31 @@ public List FetchData(string selectSql, bool upperCaseKeys = fal switch (Database) { case DB.MSSQL: - using (var msSqlDBConnection = GetSqlServerConnection()) + using (var connection = GetSqlServerConnection()) { - var _systemAdapter = new MSSQL.Adapter(); - dataList = _systemAdapter.FetchData(selectSql, msSqlDBConnection.SqlConnection, upperCaseKeys); + var adapter = new MSSQL.Adapter(); + dataList = adapter.FetchData(selectSql, connection.SqlConnection, upperCaseKeys); } break; case DB.MySQL: - using (var mySqlDBConnection = GetMySqlConnection()) + using (var connection = GetMySqlConnection()) { - var _systemAdapter = new MySQL.Adapter(); - dataList = _systemAdapter.FetchData(selectSql, mySqlDBConnection.MySqlConnection, upperCaseKeys); + var adapter = new MySQL.Adapter(); + dataList = adapter.FetchData(selectSql, connection.MySqlConnection, upperCaseKeys); } break; case DB.Oracle: - using (var oracleDBConnection = GetOracleConnection()) + using (var connection = GetOracleConnection()) { - var _systemAdapter = new Oracle.Adapter(); - dataList = _systemAdapter.FetchData(selectSql, oracleDBConnection.OracleConnection, upperCaseKeys); + var adapter = new Oracle.Adapter(); + dataList = adapter.FetchData(selectSql, connection.OracleConnection, upperCaseKeys); } break; case DB.PostgreSQL: - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + using (var connection = GetPostgreSqlConnection()) { - var _systemAdapter = new PostgreSQL.Adapter(); - dataList = _systemAdapter.FetchData(selectSql, postgreSqlDBConnection.PostgreSQLConnection, upperCaseKeys); + var adapter = new PostgreSQL.Adapter(); + dataList = adapter.FetchData(selectSql, connection.PostgreSQLConnection, upperCaseKeys); } break; } @@ -120,31 +120,31 @@ public List FetchData(string selectSql, bool upperCaseKeys = fal switch (Database) { case DB.MSSQL: - using (var msSqlDBConnection = GetSqlServerConnection()) + using (var connection = GetSqlServerConnection()) { - var _systemAdapter = new MSSQL.Adapter(); - dataList = _systemAdapter.FetchData(selectSql, msSqlDBConnection.SqlConnection, strict); + var adapter = new MSSQL.Adapter(); + dataList = adapter.FetchData(selectSql, connection.SqlConnection, strict); } break; case DB.MySQL: - using (var mySqlDBConnection = GetMySqlConnection()) + using (var connection = GetMySqlConnection()) { - var _systemAdapter = new MySQL.Adapter(); - dataList = _systemAdapter.FetchData(selectSql, mySqlDBConnection.MySqlConnection, strict); + var adapter = new MySQL.Adapter(); + dataList = adapter.FetchData(selectSql, connection.MySqlConnection, strict); } break; case DB.Oracle: - using (var oracleDBConnection = GetOracleConnection()) + using (var connection = GetOracleConnection()) { - var _systemAdapter = new Oracle.Adapter(); - dataList = _systemAdapter.FetchData(selectSql, oracleDBConnection.OracleConnection, strict); + var adapter = new Oracle.Adapter(); + dataList = adapter.FetchData(selectSql, connection.OracleConnection, strict); } break; case DB.PostgreSQL: - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + using (var connection = GetPostgreSqlConnection()) { - var _systemAdapter = new PostgreSQL.Adapter(); - dataList = _systemAdapter.FetchData(selectSql, postgreSqlDBConnection.PostgreSQLConnection, strict); + var adapter = new PostgreSQL.Adapter(); + dataList = adapter.FetchData(selectSql, connection.PostgreSQLConnection, strict); } break; } @@ -168,31 +168,31 @@ public async Task> FetchDataAsync(string selectSql, bool up switch (Database) { case DB.MSSQL: - using (var msSqlDBConnection = GetSqlServerConnection()) + using (var connection = GetSqlServerConnection()) { - var _systemAdapter = new MSSQL.Adapter(); - dataList = await _systemAdapter.FetchDataAsync(selectSql, msSqlDBConnection.SqlConnection, upperCaseKeys); + var adapter = new MSSQL.Adapter(); + dataList = await adapter.FetchDataAsync(selectSql, connection.SqlConnection, upperCaseKeys); } break; case DB.MySQL: - using (var mySqlDBConnection = GetMySqlConnection()) + using (var connection = GetMySqlConnection()) { - var _systemAdapter = new MySQL.Adapter(); - dataList = await _systemAdapter.FetchDataAsync(selectSql, mySqlDBConnection.MySqlConnection, upperCaseKeys); + var adapter = new MySQL.Adapter(); + dataList = await adapter.FetchDataAsync(selectSql, connection.MySqlConnection, upperCaseKeys); } break; case DB.Oracle: - using (var oracleDBConnection = GetOracleConnection()) + using (var connection = GetOracleConnection()) { - var _systemAdapter = new Oracle.Adapter(); - dataList = await _systemAdapter.FetchDataAsync(selectSql, oracleDBConnection.OracleConnection, upperCaseKeys); + var adapter = new Oracle.Adapter(); + dataList = await adapter.FetchDataAsync(selectSql, connection.OracleConnection, upperCaseKeys); } break; case DB.PostgreSQL: - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + using (var connection = GetPostgreSqlConnection()) { - var _systemAdapter = new PostgreSQL.Adapter(); - dataList = await _systemAdapter.FetchDataAsync(selectSql, postgreSqlDBConnection.PostgreSQLConnection, upperCaseKeys); + var adapter = new PostgreSQL.Adapter(); + dataList = await adapter.FetchDataAsync(selectSql, connection.PostgreSQLConnection, upperCaseKeys); } break; } @@ -215,31 +215,31 @@ public async Task> FetchDataAsync(string selectSql, bool up switch (Database) { case DB.MSSQL: - using (var msSqlDBConnection = GetSqlServerConnection()) + using (var connection = GetSqlServerConnection()) { - var _systemAdapter = new MSSQL.Adapter(); - dataList = await _systemAdapter.FetchDataAsync(selectSql, msSqlDBConnection.SqlConnection, strict); + var adapter = new MSSQL.Adapter(); + dataList = await adapter.FetchDataAsync(selectSql, connection.SqlConnection, strict); } break; case DB.MySQL: - using (var mySqlDBConnection = GetMySqlConnection()) + using (var connection = GetMySqlConnection()) { - var _systemAdapter = new MySQL.Adapter(); - dataList = await _systemAdapter.FetchDataAsync(selectSql, mySqlDBConnection.MySqlConnection, strict); + var adapter = new MySQL.Adapter(); + dataList = await adapter.FetchDataAsync(selectSql, connection.MySqlConnection, strict); } break; case DB.Oracle: - using (var oracleDBConnection = GetOracleConnection()) + using (var connection = GetOracleConnection()) { - var _systemAdapter = new Oracle.Adapter(); - dataList = await _systemAdapter.FetchDataAsync(selectSql, oracleDBConnection.OracleConnection, strict); + var adapter = new Oracle.Adapter(); + dataList = await adapter.FetchDataAsync(selectSql, connection.OracleConnection, strict); } break; case DB.PostgreSQL: - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + using (var connection = GetPostgreSqlConnection()) { - var _systemAdapter = new PostgreSQL.Adapter(); - dataList = await _systemAdapter.FetchDataAsync(selectSql, postgreSqlDBConnection.PostgreSQLConnection, strict); + var adapter = new PostgreSQL.Adapter(); + dataList = await adapter.FetchDataAsync(selectSql, connection.PostgreSQLConnection, strict); } break; } @@ -264,31 +264,31 @@ public string ExecuteScalar(string sqlStatement) switch (Database) { case DB.MSSQL: - using (var msSqlDBConnection = GetSqlServerConnection()) + using (var connection = GetSqlServerConnection()) { - var _systemAdapter = new MSSQL.Adapter(); - value = _systemAdapter.ExecuteScalar(sqlStatement, msSqlDBConnection.SqlConnection); + var adapter = new MSSQL.Adapter(); + value = adapter.ExecuteScalar(sqlStatement, connection.SqlConnection); } break; case DB.MySQL: - using (var mySqlDBConnection = GetMySqlConnection()) + using (var connection = GetMySqlConnection()) { - var _systemAdapter = new MySQL.Adapter(); - value = _systemAdapter.ExecuteScalar(sqlStatement, mySqlDBConnection.MySqlConnection); + var adapter = new MySQL.Adapter(); + value = adapter.ExecuteScalar(sqlStatement, connection.MySqlConnection); } break; case DB.Oracle: - using (var oracleDBConnection = GetOracleConnection()) + using (var connection = GetOracleConnection()) { - var _systemAdapter = new Oracle.Adapter(); - value = _systemAdapter.ExecuteScalar(sqlStatement, oracleDBConnection.OracleConnection); + var adapter = new Oracle.Adapter(); + value = adapter.ExecuteScalar(sqlStatement, connection.OracleConnection); } break; case DB.PostgreSQL: - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + using (var connection = GetPostgreSqlConnection()) { - var _systemAdapter = new PostgreSQL.Adapter(); - value = _systemAdapter.ExecuteScalar(sqlStatement, postgreSqlDBConnection.PostgreSQLConnection); + var adapter = new PostgreSQL.Adapter(); + value = adapter.ExecuteScalar(sqlStatement, connection.PostgreSQLConnection); } break; } @@ -314,31 +314,31 @@ public T ExecuteScalar(string sqlStatement) switch (Database) { case DB.MSSQL: - using (var msSqlDBConnection = GetSqlServerConnection()) + using (var connection = GetSqlServerConnection()) { - var _systemAdapter = new MSSQL.Adapter(); - value = _systemAdapter.ExecuteScalar(sqlStatement, msSqlDBConnection.SqlConnection); + var adapter = new MSSQL.Adapter(); + value = adapter.ExecuteScalar(sqlStatement, connection.SqlConnection); } break; case DB.MySQL: - using (var mySqlDBConnection = GetMySqlConnection()) + using (var connection = GetMySqlConnection()) { - var _systemAdapter = new MySQL.Adapter(); - value = _systemAdapter.ExecuteScalar(sqlStatement, mySqlDBConnection.MySqlConnection); + var adapter = new MySQL.Adapter(); + value = adapter.ExecuteScalar(sqlStatement, connection.MySqlConnection); } break; case DB.Oracle: - using (var oracleDBConnection = GetOracleConnection()) + using (var connection = GetOracleConnection()) { - var _systemAdapter = new Oracle.Adapter(); - value = _systemAdapter.ExecuteScalar(sqlStatement, oracleDBConnection.OracleConnection); + var adapter = new Oracle.Adapter(); + value = adapter.ExecuteScalar(sqlStatement, connection.OracleConnection); } break; case DB.PostgreSQL: - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + using (var connection = GetPostgreSqlConnection()) { - var _systemAdapter = new PostgreSQL.Adapter(); - value = _systemAdapter.ExecuteScalar(sqlStatement, postgreSqlDBConnection.PostgreSQLConnection); + var adapter = new PostgreSQL.Adapter(); + value = adapter.ExecuteScalar(sqlStatement, connection.PostgreSQLConnection); } break; } @@ -363,31 +363,31 @@ public async Task ExecuteScalarAsync(string sqlStatement) switch (Database) { case DB.MSSQL: - using (var msSqlDBConnection = GetSqlServerConnection()) + using (var connection = GetSqlServerConnection()) { - var _systemAdapter = new MSSQL.Adapter(); - value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, msSqlDBConnection.SqlConnection); + var adapter = new MSSQL.Adapter(); + value = await adapter.ExecuteScalarAsync(sqlStatement, connection.SqlConnection); } break; case DB.MySQL: - using (var mySqlDBConnection = GetMySqlConnection()) + using (var connection = GetMySqlConnection()) { - var _systemAdapter = new MySQL.Adapter(); - value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, mySqlDBConnection.MySqlConnection); + var adapter = new MySQL.Adapter(); + value = await adapter.ExecuteScalarAsync(sqlStatement, connection.MySqlConnection); } break; case DB.Oracle: - using (var oracleDBConnection = GetOracleConnection()) + using (var connection = GetOracleConnection()) { - var _systemAdapter = new Oracle.Adapter(); - value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, oracleDBConnection.OracleConnection); + var adapter = new Oracle.Adapter(); + value = await adapter.ExecuteScalarAsync(sqlStatement, connection.OracleConnection); } break; case DB.PostgreSQL: - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + using (var connection = GetPostgreSqlConnection()) { - var _systemAdapter = new PostgreSQL.Adapter(); - value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, postgreSqlDBConnection.PostgreSQLConnection); + var adapter = new PostgreSQL.Adapter(); + value = await adapter.ExecuteScalarAsync(sqlStatement, connection.PostgreSQLConnection); } break; } @@ -413,31 +413,31 @@ public async Task ExecuteScalarAsync(string sqlStatement) switch (Database) { case DB.MSSQL: - using (var msSqlDBConnection = GetSqlServerConnection()) + using (var connection = GetSqlServerConnection()) { - var _systemAdapter = new MSSQL.Adapter(); - value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, msSqlDBConnection.SqlConnection); + var adapter = new MSSQL.Adapter(); + value = await adapter.ExecuteScalarAsync(sqlStatement, connection.SqlConnection); } break; case DB.MySQL: - using (var mySqlDBConnection = GetMySqlConnection()) + using (var connection = GetMySqlConnection()) { - var _systemAdapter = new MySQL.Adapter(); - value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, mySqlDBConnection.MySqlConnection); + var adapter = new MySQL.Adapter(); + value = await adapter.ExecuteScalarAsync(sqlStatement, connection.MySqlConnection); } break; case DB.Oracle: - using (var oracleDBConnection = GetOracleConnection()) + using (var connection = GetOracleConnection()) { - var _systemAdapter = new Oracle.Adapter(); - value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, oracleDBConnection.OracleConnection); + var adapter = new Oracle.Adapter(); + value = await adapter.ExecuteScalarAsync(sqlStatement, connection.OracleConnection); } break; case DB.PostgreSQL: - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + using (var connection = GetPostgreSqlConnection()) { - var _systemAdapter = new PostgreSQL.Adapter(); - value = await _systemAdapter.ExecuteScalarAsync(sqlStatement, postgreSqlDBConnection.PostgreSQLConnection); + var adapter = new PostgreSQL.Adapter(); + value = await adapter.ExecuteScalarAsync(sqlStatement, connection.PostgreSQLConnection); } break; } @@ -457,28 +457,28 @@ public int ExecuteCommand(string sqlStatement) switch (Database) { case DB.MSSQL: - using (var msSqlDBConnection = GetSqlServerConnection()) + using (var connection = GetSqlServerConnection()) { - var _systemAdapter = new MSSQL.Adapter(); - return _systemAdapter.ExecuteCommand(sqlStatement, msSqlDBConnection.SqlConnection); + var adapter = new MSSQL.Adapter(); + return adapter.ExecuteCommand(sqlStatement, connection.SqlConnection); } case DB.MySQL: - using (var mySqlDBConnection = GetMySqlConnection()) + using (var connection = GetMySqlConnection()) { - var _systemAdapter = new MySQL.Adapter(); - return _systemAdapter.ExecuteCommand(sqlStatement, mySqlDBConnection.MySqlConnection); + var adapter = new MySQL.Adapter(); + return adapter.ExecuteCommand(sqlStatement, connection.MySqlConnection); } case DB.Oracle: - using (var oracleDBConnection = GetOracleConnection()) + using (var connection = GetOracleConnection()) { - var _systemAdapter = new Oracle.Adapter(); - return _systemAdapter.ExecuteCommand(sqlStatement, oracleDBConnection.OracleConnection); + var adapter = new Oracle.Adapter(); + return adapter.ExecuteCommand(sqlStatement, connection.OracleConnection); } case DB.PostgreSQL: - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + using (var connection = GetPostgreSqlConnection()) { - var _systemAdapter = new PostgreSQL.Adapter(); - return _systemAdapter.ExecuteCommand(sqlStatement, postgreSqlDBConnection.PostgreSQLConnection); + var adapter = new PostgreSQL.Adapter(); + return adapter.ExecuteCommand(sqlStatement, connection.PostgreSQLConnection); } default: return -1; @@ -498,28 +498,28 @@ public async Task ExecuteCommandAsync(string sqlStatement) switch (Database) { case DB.MSSQL: - using (var msSqlDBConnection = GetSqlServerConnection()) + using (var connection = GetSqlServerConnection()) { - var _systemAdapter = new MSSQL.Adapter(); - return await _systemAdapter.ExecuteCommandAsync(sqlStatement, msSqlDBConnection.SqlConnection); + var adapter = new MSSQL.Adapter(); + return await adapter.ExecuteCommandAsync(sqlStatement, connection.SqlConnection); } case DB.MySQL: - using (var mySqlDBConnection = GetMySqlConnection()) + using (var connection = GetMySqlConnection()) { - var _systemAdapter = new MySQL.Adapter(); - return await _systemAdapter.ExecuteCommandAsync(sqlStatement, mySqlDBConnection.MySqlConnection); + var adapter = new MySQL.Adapter(); + return await adapter.ExecuteCommandAsync(sqlStatement, connection.MySqlConnection); } case DB.Oracle: - using (var oracleDBConnection = GetOracleConnection()) + using (var connection = GetOracleConnection()) { - var _systemAdapter = new Oracle.Adapter(); - return await _systemAdapter.ExecuteCommandAsync(sqlStatement, oracleDBConnection.OracleConnection); + var adapter = new Oracle.Adapter(); + return await adapter.ExecuteCommandAsync(sqlStatement, connection.OracleConnection); } case DB.PostgreSQL: - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + using (var connection = GetPostgreSqlConnection()) { - var _systemAdapter = new PostgreSQL.Adapter(); - return await _systemAdapter.ExecuteCommandAsync(sqlStatement, postgreSqlDBConnection.PostgreSQLConnection); + var adapter = new PostgreSQL.Adapter(); + return await adapter.ExecuteCommandAsync(sqlStatement, connection.PostgreSQLConnection); } default: return -1; @@ -546,27 +546,27 @@ public Result ExecuteTransaction(List sqlStatements) switch (Database) { case DB.MSSQL: - using (var msSqlDBConnection = GetSqlServerConnection()) + using (var connection = GetSqlServerConnection()) { - result = MSSQL.Adapter.ExecuteTransaction(sqlStatements, msSqlDBConnection.SqlConnection); + result = MSSQL.Adapter.ExecuteTransaction(sqlStatements, connection.SqlConnection); } break; case DB.MySQL: - using (var mySqlDBConnection = GetMySqlConnection()) + using (var connection = GetMySqlConnection()) { - result = MySQL.Adapter.ExecuteTransaction(sqlStatements, mySqlDBConnection.MySqlConnection); + result = MySQL.Adapter.ExecuteTransaction(sqlStatements, connection.MySqlConnection); } break; case DB.Oracle: - using (var oracleDBConnection = GetOracleConnection()) + using (var connection = GetOracleConnection()) { - result = Oracle.Adapter.ExecuteTransaction(sqlStatements, oracleDBConnection.OracleConnection); + result = Oracle.Adapter.ExecuteTransaction(sqlStatements, connection.OracleConnection); } break; case DB.PostgreSQL: - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + using (var connection = GetPostgreSqlConnection()) { - result = PostgreSQL.Adapter.ExecuteTransaction(sqlStatements, postgreSqlDBConnection.PostgreSQLConnection); + result = PostgreSQL.Adapter.ExecuteTransaction(sqlStatements, connection.PostgreSQLConnection); } break; } @@ -593,27 +593,27 @@ public async Task ExecuteTransactionAsync(List sqlStatements) switch (Database) { case DB.MSSQL: - using (var msSqlDBConnection = GetSqlServerConnection()) + using (var connection = GetSqlServerConnection()) { - result = await MSSQL.Adapter.ExecuteTransactionAsync(sqlStatements, msSqlDBConnection.SqlConnection); + result = await MSSQL.Adapter.ExecuteTransactionAsync(sqlStatements, connection.SqlConnection); } break; case DB.MySQL: - using (var mySqlDBConnection = GetMySqlConnection()) + using (var connection = GetMySqlConnection()) { - result = await MySQL.Adapter.ExecuteTransactionAsync(sqlStatements, mySqlDBConnection.MySqlConnection); + result = await MySQL.Adapter.ExecuteTransactionAsync(sqlStatements, connection.MySqlConnection); } break; case DB.Oracle: - using (var oracleDBConnection = GetOracleConnection()) + using (var connection = GetOracleConnection()) { - result = await Oracle.Adapter.ExecuteTransactionAsync(sqlStatements, oracleDBConnection.OracleConnection); + result = await Oracle.Adapter.ExecuteTransactionAsync(sqlStatements, connection.OracleConnection); } break; case DB.PostgreSQL: - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) + using (var connection = GetPostgreSqlConnection()) { - result = await PostgreSQL.Adapter.ExecuteTransactionAsync(sqlStatements, postgreSqlDBConnection.PostgreSQLConnection); + result = await PostgreSQL.Adapter.ExecuteTransactionAsync(sqlStatements, connection.PostgreSQLConnection); } break; } From 52e8df7c1fde0e0c7dc04627cc5dc7a5a280db00 Mon Sep 17 00:00:00 2001 From: abhinavminhas Date: Sat, 26 Jul 2025 21:45:50 +1000 Subject: [PATCH 10/14] Replace if with switch --- QueryDB/DBContext.cs | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/QueryDB/DBContext.cs b/QueryDB/DBContext.cs index 6a8e6e9..e6efafc 100644 --- a/QueryDB/DBContext.cs +++ b/QueryDB/DBContext.cs @@ -46,14 +46,21 @@ public sealed class DBContext : IDBContext public DBContext(DB database, string connectionString) { Database = database; - if (Database.Equals(DB.MSSQL)) - SqlConnectionString = connectionString; - else if (Database.Equals(DB.MySQL)) - MySqlConnectionString = connectionString; - else if(Database.Equals(DB.Oracle)) - OracleConnectionString = connectionString; - else if (Database.Equals(DB.PostgreSQL)) - PostgreSqlConnectionString = connectionString; + switch (Database) + { + case DB.MSSQL: + SqlConnectionString = connectionString; + break; + case DB.MySQL: + MySqlConnectionString = connectionString; + break; + case DB.Oracle: + OracleConnectionString = connectionString; + break; + case DB.PostgreSQL: + PostgreSqlConnectionString = connectionString; + break; + } } /// From d31ce345158b585323f919a65905a1c4b6548c5f Mon Sep 17 00:00:00 2001 From: abhinavminhas Date: Sat, 26 Jul 2025 22:50:30 +1000 Subject: [PATCH 11/14] Readme updates --- README.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index 6fb81c6..8ed1b52 100644 --- a/README.md +++ b/README.md @@ -13,28 +13,28 @@ QueryDB is a flexible database query framework designed to simplify querying and executing transactions across multiple database systems. -## Supported Databases +## 🌐 Supported Databases - [MSSQL](https://www.microsoft.com/en-us/sql-server) - [MySQL](https://www.mysql.com/) - [Oracle](https://www.oracle.com/) - [PostgreSQL](https://www.postgresql.org/) -## Download +## πŸ“₯ Download The package is available and can be downloaded using [nuget.org](https://www.nuget.org/) package manager. - Package Name - [QueryDB](https://www.nuget.org/packages/QueryDB). -## .NET Supported Versions +## 🎯 .NET Supported Versions Built on **.NET Standard 2.0** - ( [_Supported Versions_](https://learn.microsoft.com/en-us/dotnet/standard/net-standard?tabs=net-standard-2-0#tabpanel_1_net-standard-2-0:~:text=Select%20.NET%20Standard%20version) ) -## Features -- Retrieve data efficiently from the database. -- Execute scalar queries (returning a single value). -- Execute non-query commands (e.g. `INSERT`, `UPDATE`, `DELETE`). -- Execute transactions while maintaining atomicity. -- Support for both Synchronous and Asynchronous operations. +## ✨ Key Features +- πŸ” Efficient data retrieval using query and command execution. +- βž• Execute scalar queries for single-value results. +- ✏️ Execute non-query commands (e.g. `INSERT`, `UPDATE`, `DELETE`). +- πŸ”„ Perform multi-command transactions while maintaining atomicity. +- πŸ” Support for both Synchronous and Asynchronous operations. -## Getting Started +## πŸš€ Getting Started - _**Setup `DBContext` with the database of your choice :**_ From 4f9d9475ef3373651844b7ef7ef5d53cdf23e44c Mon Sep 17 00:00:00 2001 From: abhinavminhas Date: Sat, 26 Jul 2025 22:54:51 +1000 Subject: [PATCH 12/14] Nuget package creation - v1.3.0 --- .github/workflows/publish-nuget-Package.yml | 2 +- CHANGELOG.md | 8 +++++++- QueryDB/QueryDB.csproj | 17 ++++++++--------- 3 files changed, 16 insertions(+), 11 deletions(-) diff --git a/.github/workflows/publish-nuget-Package.yml b/.github/workflows/publish-nuget-Package.yml index fbf7cab..5d73aab 100644 --- a/.github/workflows/publish-nuget-Package.yml +++ b/.github/workflows/publish-nuget-Package.yml @@ -1,7 +1,7 @@ name: Publish Nuget Package env: - NUGET_PACKAGE_NAME_VERSION: "QueryDB.1.2.0.nupkg" + NUGET_PACKAGE_NAME_VERSION: "QueryDB.1.3.0.nupkg" on: workflow_dispatch: diff --git a/CHANGELOG.md b/CHANGELOG.md index 17bdde9..7c092ab 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,12 @@ All notable changes to this project documented here. ## [Released] +## [1.3.0](https://www.nuget.org/packages/QueryDB/1.3.0) - 2025-07-27 +### Changed +- Seal adapter classes for better encapsulation. +- Restrict fetch data to SELECT commands. +- Refactoring DBContext to use switch statement for improved clarity and structure. + ## [1.2.0](https://www.nuget.org/packages/QueryDB/1.2.0) - 2025-03-04 ### Added - Asynchronous operations @@ -11,7 +17,7 @@ All notable changes to this project documented here. - `ExecuteCommandAsync()` - `ExecuteTransactionAsync()` ### Changed -- Execute transaction to return transaction outcome and exception details in case of failure instead of logging into console. +- Execute transaction to return transaction outcome and exception details in case of failure instead of logging into console. ## [1.1.0](https://www.nuget.org/packages/QueryDB/1.1.0) - 2025-02-20 ### Added diff --git a/QueryDB/QueryDB.csproj b/QueryDB/QueryDB.csproj index e1f90ba..da725a6 100644 --- a/QueryDB/QueryDB.csproj +++ b/QueryDB/QueryDB.csproj @@ -11,20 +11,19 @@ Supported Databases: - Oracle - PostgreSQL -Features: -- Retrieve data from the database. -- Execute scalar queries (returning a single value). -- Execute non-query database commands. -- Execute transactions while maintaining atomicity. -- Support for Synchronous and Asynchronous operations. +Key Features: +- Efficient data retrieval using query and command execution. +- Execute scalar queries for single-value results. +- Execute non-query commands. +- Perform multi-command transactions while maintaining atomicity. +- Support for both Synchronous and Asynchronous operations. https://github.com/abhinavminhas/QueryDB.NET https://github.com/abhinavminhas/QueryDB.NET git LICENSE sql, query, rdbms, database, mssql, sqlserver, mysql, oracle, postgresql - 1. Asynchronous operations. -2. Execute transaction to return transaction outcome and exception details in case of failures. - 1.2.0 + 1. Restrict fetch data to SELECT commands. + 1.3.0 From 7a4ea1719d99233622df0730debad8257c28a728 Mon Sep 17 00:00:00 2001 From: abhinavminhas Date: Sat, 26 Jul 2025 22:58:41 +1000 Subject: [PATCH 13/14] Readme update --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 8ed1b52..d7ae5da 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# QueryDB +# ⚑QueryDB *QueryDB solution in .NET*.

[![Build / Test](https://github.com/abhinavminhas/QueryDB.NET/actions/workflows/build.yml/badge.svg)](https://github.com/abhinavminhas/QueryDB.NET/actions/workflows/build.yml) [![codecov](https://codecov.io/gh/abhinavminhas/QueryDB.NET/graph/badge.svg?token=L21DM7HZ46)](https://codecov.io/gh/abhinavminhas/QueryDB.NET) From 1a77fa671364fd6ebaa38c828c7e0fb2f41f4b24 Mon Sep 17 00:00:00 2001 From: abhinavminhas Date: Sat, 26 Jul 2025 23:00:41 +1000 Subject: [PATCH 14/14] Readme update --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index d7ae5da..2406f24 100644 --- a/README.md +++ b/README.md @@ -94,7 +94,7 @@ Built on **.NET Standard 2.0** - ( [_Supported Versions_](https://learn.microsof -## Examples +## 🧠 Examples > Data Retrieval ``` csharp