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.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: 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..075021e 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) >> @@ -1177,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); @@ -1193,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); @@ -1340,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); @@ -1356,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/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.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}'"; } } diff --git a/QueryDB/DBContext.cs b/QueryDB/DBContext.cs index cc879fd..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; + } } /// @@ -66,38 +73,40 @@ 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)) - { - 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 connection = GetSqlServerConnection()) + { + var adapter = new MSSQL.Adapter(); + dataList = adapter.FetchData(selectSql, connection.SqlConnection, upperCaseKeys); + } + break; + case DB.MySQL: + using (var connection = GetMySqlConnection()) + { + var adapter = new MySQL.Adapter(); + dataList = adapter.FetchData(selectSql, connection.MySqlConnection, upperCaseKeys); + } + break; + case DB.Oracle: + using (var connection = GetOracleConnection()) + { + var adapter = new Oracle.Adapter(); + dataList = adapter.FetchData(selectSql, connection.OracleConnection, upperCaseKeys); + } + break; + case DB.PostgreSQL: + using (var connection = GetPostgreSqlConnection()) + { + var adapter = new PostgreSQL.Adapter(); + dataList = adapter.FetchData(selectSql, connection.PostgreSQLConnection, upperCaseKeys); + } + break; } return dataList; } @@ -111,38 +120,40 @@ 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)) - { - 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 connection = GetSqlServerConnection()) + { + var adapter = new MSSQL.Adapter(); + dataList = adapter.FetchData(selectSql, connection.SqlConnection, strict); + } + break; + case DB.MySQL: + using (var connection = GetMySqlConnection()) + { + var adapter = new MySQL.Adapter(); + dataList = adapter.FetchData(selectSql, connection.MySqlConnection, strict); + } + break; + case DB.Oracle: + using (var connection = GetOracleConnection()) + { + var adapter = new Oracle.Adapter(); + dataList = adapter.FetchData(selectSql, connection.OracleConnection, strict); + } + break; + case DB.PostgreSQL: + using (var connection = GetPostgreSqlConnection()) + { + var adapter = new PostgreSQL.Adapter(); + dataList = adapter.FetchData(selectSql, connection.PostgreSQLConnection, strict); + } + break; } return dataList; } @@ -157,38 +168,40 @@ 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)) - { - 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 connection = GetSqlServerConnection()) + { + var adapter = new MSSQL.Adapter(); + dataList = await adapter.FetchDataAsync(selectSql, connection.SqlConnection, upperCaseKeys); + } + break; + case DB.MySQL: + using (var connection = GetMySqlConnection()) + { + var adapter = new MySQL.Adapter(); + dataList = await adapter.FetchDataAsync(selectSql, connection.MySqlConnection, upperCaseKeys); + } + break; + case DB.Oracle: + using (var connection = GetOracleConnection()) + { + var adapter = new Oracle.Adapter(); + dataList = await adapter.FetchDataAsync(selectSql, connection.OracleConnection, upperCaseKeys); + } + break; + case DB.PostgreSQL: + using (var connection = GetPostgreSqlConnection()) + { + var adapter = new PostgreSQL.Adapter(); + dataList = await adapter.FetchDataAsync(selectSql, connection.PostgreSQLConnection, upperCaseKeys); + } + break; } return dataList; } @@ -202,38 +215,40 @@ 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)) - { - 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 connection = GetSqlServerConnection()) + { + var adapter = new MSSQL.Adapter(); + dataList = await adapter.FetchDataAsync(selectSql, connection.SqlConnection, strict); + } + break; + case DB.MySQL: + using (var connection = GetMySqlConnection()) + { + var adapter = new MySQL.Adapter(); + dataList = await adapter.FetchDataAsync(selectSql, connection.MySqlConnection, strict); + } + break; + case DB.Oracle: + using (var connection = GetOracleConnection()) + { + var adapter = new Oracle.Adapter(); + dataList = await adapter.FetchDataAsync(selectSql, connection.OracleConnection, strict); + } + break; + case DB.PostgreSQL: + using (var connection = GetPostgreSqlConnection()) + { + var adapter = new PostgreSQL.Adapter(); + dataList = await adapter.FetchDataAsync(selectSql, connection.PostgreSQLConnection, strict); + } + break; } return dataList; } @@ -250,40 +265,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 connection = GetSqlServerConnection()) + { + var adapter = new MSSQL.Adapter(); + value = adapter.ExecuteScalar(sqlStatement, connection.SqlConnection); + } + break; + case DB.MySQL: + using (var connection = GetMySqlConnection()) + { + var adapter = new MySQL.Adapter(); + value = adapter.ExecuteScalar(sqlStatement, connection.MySqlConnection); + } + break; + case DB.Oracle: + using (var connection = GetOracleConnection()) + { + var adapter = new Oracle.Adapter(); + value = adapter.ExecuteScalar(sqlStatement, connection.OracleConnection); + } + break; + case DB.PostgreSQL: + using (var connection = GetPostgreSqlConnection()) + { + var adapter = new PostgreSQL.Adapter(); + value = adapter.ExecuteScalar(sqlStatement, connection.PostgreSQLConnection); + } + break; } return value; } @@ -301,40 +315,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 connection = GetSqlServerConnection()) + { + var adapter = new MSSQL.Adapter(); + value = adapter.ExecuteScalar(sqlStatement, connection.SqlConnection); + } + break; + case DB.MySQL: + using (var connection = GetMySqlConnection()) + { + var adapter = new MySQL.Adapter(); + value = adapter.ExecuteScalar(sqlStatement, connection.MySqlConnection); + } + break; + case DB.Oracle: + using (var connection = GetOracleConnection()) + { + var adapter = new Oracle.Adapter(); + value = adapter.ExecuteScalar(sqlStatement, connection.OracleConnection); + } + break; + case DB.PostgreSQL: + using (var connection = GetPostgreSqlConnection()) + { + var adapter = new PostgreSQL.Adapter(); + value = adapter.ExecuteScalar(sqlStatement, connection.PostgreSQLConnection); + } + break; } return value; } @@ -351,40 +364,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 connection = GetSqlServerConnection()) + { + var adapter = new MSSQL.Adapter(); + value = await adapter.ExecuteScalarAsync(sqlStatement, connection.SqlConnection); + } + break; + case DB.MySQL: + using (var connection = GetMySqlConnection()) + { + var adapter = new MySQL.Adapter(); + value = await adapter.ExecuteScalarAsync(sqlStatement, connection.MySqlConnection); + } + break; + case DB.Oracle: + using (var connection = GetOracleConnection()) + { + var adapter = new Oracle.Adapter(); + value = await adapter.ExecuteScalarAsync(sqlStatement, connection.OracleConnection); + } + break; + case DB.PostgreSQL: + using (var connection = GetPostgreSqlConnection()) + { + var adapter = new PostgreSQL.Adapter(); + value = await adapter.ExecuteScalarAsync(sqlStatement, connection.PostgreSQLConnection); + } + break; } return value; } @@ -402,40 +414,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 connection = GetSqlServerConnection()) + { + var adapter = new MSSQL.Adapter(); + value = await adapter.ExecuteScalarAsync(sqlStatement, connection.SqlConnection); + } + break; + case DB.MySQL: + using (var connection = GetMySqlConnection()) + { + var adapter = new MySQL.Adapter(); + value = await adapter.ExecuteScalarAsync(sqlStatement, connection.MySqlConnection); + } + break; + case DB.Oracle: + using (var connection = GetOracleConnection()) + { + var adapter = new Oracle.Adapter(); + value = await adapter.ExecuteScalarAsync(sqlStatement, connection.OracleConnection); + } + break; + case DB.PostgreSQL: + using (var connection = GetPostgreSqlConnection()) + { + var adapter = new PostgreSQL.Adapter(); + value = await adapter.ExecuteScalarAsync(sqlStatement, connection.PostgreSQLConnection); + } + break; } return value; } @@ -448,41 +459,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 connection = GetSqlServerConnection()) + { + var adapter = new MSSQL.Adapter(); + return adapter.ExecuteCommand(sqlStatement, connection.SqlConnection); + } + case DB.MySQL: + using (var connection = GetMySqlConnection()) + { + var adapter = new MySQL.Adapter(); + return adapter.ExecuteCommand(sqlStatement, connection.MySqlConnection); + } + case DB.Oracle: + using (var connection = GetOracleConnection()) + { + var adapter = new Oracle.Adapter(); + return adapter.ExecuteCommand(sqlStatement, connection.OracleConnection); + } + case DB.PostgreSQL: + using (var connection = GetPostgreSqlConnection()) + { + var adapter = new PostgreSQL.Adapter(); + return adapter.ExecuteCommand(sqlStatement, connection.PostgreSQLConnection); + } + default: + return -1; } - return -1; } /// @@ -493,41 +500,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); - } + switch (Database) + { + case DB.MSSQL: + using (var connection = GetSqlServerConnection()) + { + var adapter = new MSSQL.Adapter(); + return await adapter.ExecuteCommandAsync(sqlStatement, connection.SqlConnection); + } + case DB.MySQL: + using (var connection = GetMySqlConnection()) + { + var adapter = new MySQL.Adapter(); + return await adapter.ExecuteCommandAsync(sqlStatement, connection.MySqlConnection); + } + case DB.Oracle: + using (var connection = GetOracleConnection()) + { + var adapter = new Oracle.Adapter(); + return await adapter.ExecuteCommandAsync(sqlStatement, connection.OracleConnection); + } + case DB.PostgreSQL: + using (var connection = GetPostgreSqlConnection()) + { + var adapter = new PostgreSQL.Adapter(); + return await adapter.ExecuteCommandAsync(sqlStatement, connection.PostgreSQLConnection); + } + default: + return -1; } - else if (Database.Equals(DB.Oracle)) - { - using (var oracleDBConnection = GetOracleConnection()) - { - var _systemAdapter = new Oracle.Adapter(); - return await _systemAdapter.ExecuteCommandAsync(sqlStatement, oracleDBConnection.OracleConnection); - } - } - else if (Database.Equals(DB.PostgreSQL)) - { - using (var postgreSqlDBConnection = GetPostgreSqlConnection()) - { - var _systemAdapter = new PostgreSQL.Adapter(); - return await _systemAdapter.ExecuteCommandAsync(sqlStatement, postgreSqlDBConnection.PostgreSQLConnection); - } - } - return -1; } /// @@ -545,35 +548,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 connection = GetSqlServerConnection()) + { + result = MSSQL.Adapter.ExecuteTransaction(sqlStatements, connection.SqlConnection); + } + break; + case DB.MySQL: + using (var connection = GetMySqlConnection()) + { + result = MySQL.Adapter.ExecuteTransaction(sqlStatements, connection.MySqlConnection); + } + break; + case DB.Oracle: + using (var connection = GetOracleConnection()) + { + result = Oracle.Adapter.ExecuteTransaction(sqlStatements, connection.OracleConnection); + } + break; + case DB.PostgreSQL: + using (var connection = GetPostgreSqlConnection()) + { + result = PostgreSQL.Adapter.ExecuteTransaction(sqlStatements, connection.PostgreSQLConnection); + } + break; } return result; } @@ -593,35 +595,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 connection = GetSqlServerConnection()) + { + result = await MSSQL.Adapter.ExecuteTransactionAsync(sqlStatements, connection.SqlConnection); + } + break; + case DB.MySQL: + using (var connection = GetMySqlConnection()) + { + result = await MySQL.Adapter.ExecuteTransactionAsync(sqlStatements, connection.MySqlConnection); + } + break; + case DB.Oracle: + using (var connection = GetOracleConnection()) + { + result = await Oracle.Adapter.ExecuteTransactionAsync(sqlStatements, connection.OracleConnection); + } + break; + case DB.PostgreSQL: + using (var connection = GetPostgreSqlConnection()) + { + result = await PostgreSQL.Adapter.ExecuteTransactionAsync(sqlStatements, connection.PostgreSQLConnection); + } + break; } return result; } 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."; } } } 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 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 diff --git a/README.md b/README.md index 81892d3..2406f24 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) @@ -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 from the database. -- Execute scalar queries (returning a single value). -- Execute non-query database commands (e.g. `INSERT`, `UPDATE`, `DELETE`). -- 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 (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 :**_ @@ -94,7 +94,7 @@ Built on **.NET Standard 2.0** - ( [_Supported Versions_](https://learn.microsof -## Examples +## 🧠 Examples > Data Retrieval ``` csharp @@ -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