Skip to content

Commit 30a2265

Browse files
abhinavminhasabhinavminhas
committed
Execute Scalar - Unsupported Commands
1 parent 52edf45 commit 30a2265

File tree

6 files changed

+312
-0
lines changed

6 files changed

+312
-0
lines changed

‎QueryDB.Core.Tests/MSSQLTests.cs‎

Lines changed: 74 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -357,6 +357,43 @@ public void Test_MSSQL_ExecuteScalar_As_StringReturn_DefaultValue()
357357
Assert.AreEqual(string.Empty, result);
358358
}
359359

360+
[TestMethod]
361+
[TestCategory(DB_TESTS), TestCategory(MSSQL_TESTS)]
362+
public void Test_MSSQL_ExecuteScalar_As_StringReturn_UnsupportedCommands()
363+
{
364+
var sqlStatements = new List<string>
365+
{
366+
Queries.MSSQLQueries.TestDB.DDL.Create_Table,
367+
Queries.MSSQLQueries.TestDB.DDL.Alter_Table,
368+
Queries.MSSQLQueries.TestDB.DDL.Comment_Table,
369+
Queries.MSSQLQueries.TestDB.DDL.Truncate_Table,
370+
Queries.MSSQLQueries.TestDB.DDL.Drop_Table,
371+
372+
Queries.MSSQLQueries.TestDB.DML.InsertSql,
373+
Queries.MSSQLQueries.TestDB.DML.UpdateSql,
374+
Queries.MSSQLQueries.TestDB.DML.DeleteSql,
375+
376+
Queries.MSSQLQueries.TestDB.DCL.GrantSql_Command_Table_User,
377+
Queries.MSSQLQueries.TestDB.DCL.RevokeSql_Command_Table_User
378+
};
379+
380+
foreach (var sqlStatement in sqlStatements)
381+
{
382+
try
383+
{
384+
var dbContext = new DBContext(DB.MSSQL, MSSQLConnectionString);
385+
dbContext.ExecuteScalar(sqlStatement);
386+
Assert.Fail("No Exception");
387+
}
388+
catch (QueryDBException ex)
389+
{
390+
Assert.AreEqual("Only SELECT queries are supported here.", ex.Message);
391+
Assert.AreEqual("UnsupportedCommand", ex.ErrorType);
392+
Assert.AreEqual("'ExecuteScalar' only supports SELECT queries that have a scalar (single value) return.", ex.AdditionalInfo);
393+
}
394+
}
395+
}
396+
360397
#endregion
361398

362399
#region Execute Scalar Tests - << T ExecuteScalar<T>(string sqlStatement); >>
@@ -485,6 +522,43 @@ public void Test_MSSQL_ExecuteScalar_As_TypedReturn_DefaultValue()
485522
Assert.AreEqual(default(DateTime?), result);
486523
}
487524

525+
[TestMethod]
526+
[TestCategory(DB_TESTS), TestCategory(MSSQL_TESTS)]
527+
public void Test_MSSQL_ExecuteScalar_As_TypedReturn_UnsupportedCommands()
528+
{
529+
var sqlStatements = new List<string>
530+
{
531+
Queries.MSSQLQueries.TestDB.DDL.Create_Table,
532+
Queries.MSSQLQueries.TestDB.DDL.Alter_Table,
533+
Queries.MSSQLQueries.TestDB.DDL.Comment_Table,
534+
Queries.MSSQLQueries.TestDB.DDL.Truncate_Table,
535+
Queries.MSSQLQueries.TestDB.DDL.Drop_Table,
536+
537+
Queries.MSSQLQueries.TestDB.DML.InsertSql,
538+
Queries.MSSQLQueries.TestDB.DML.UpdateSql,
539+
Queries.MSSQLQueries.TestDB.DML.DeleteSql,
540+
541+
Queries.MSSQLQueries.TestDB.DCL.GrantSql_Command_Table_User,
542+
Queries.MSSQLQueries.TestDB.DCL.RevokeSql_Command_Table_User
543+
};
544+
545+
foreach (var sqlStatement in sqlStatements)
546+
{
547+
try
548+
{
549+
var dbContext = new DBContext(DB.MSSQL, MSSQLConnectionString);
550+
dbContext.ExecuteScalar<string>(sqlStatement);
551+
Assert.Fail("No Exception");
552+
}
553+
catch (QueryDBException ex)
554+
{
555+
Assert.AreEqual("Only SELECT queries are supported here.", ex.Message);
556+
Assert.AreEqual("UnsupportedCommand", ex.ErrorType);
557+
Assert.AreEqual("'ExecuteScalar' only supports SELECT queries that have a scalar (single value) return.", ex.AdditionalInfo);
558+
}
559+
}
560+
}
561+
488562
#endregion
489563

490564
#region Execute Command Tests - << int ExecuteCommand(string sqlStatement) >>

‎QueryDB.Core.Tests/MySQLTests.cs‎

Lines changed: 74 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -337,6 +337,43 @@ public void Test_MySQL_ExecuteScalar_As_StringReturn_DefaultValue()
337337
Assert.AreEqual(string.Empty, result);
338338
}
339339

340+
[TestMethod]
341+
[TestCategory(DB_TESTS), TestCategory(MYSQL_TESTS)]
342+
public void Test_MySQL_ExecuteScalar_As_StringReturn_UnsupportedCommands()
343+
{
344+
var sqlStatements = new List<string>
345+
{
346+
Queries.MySQLQueries.TestDB.DDL.Create_Table,
347+
Queries.MySQLQueries.TestDB.DDL.Alter_Table,
348+
Queries.MySQLQueries.TestDB.DDL.Comment_Table,
349+
Queries.MySQLQueries.TestDB.DDL.Truncate_Table,
350+
Queries.MySQLQueries.TestDB.DDL.Drop_Table,
351+
352+
Queries.MySQLQueries.TestDB.DML.InsertSql,
353+
Queries.MySQLQueries.TestDB.DML.UpdateSql,
354+
Queries.MySQLQueries.TestDB.DML.DeleteSql,
355+
356+
Queries.MySQLQueries.TestDB.DCL.GrantSql_Command_Table_User,
357+
Queries.MySQLQueries.TestDB.DCL.RevokeSql_Command_Table_User
358+
};
359+
360+
foreach (var sqlStatement in sqlStatements)
361+
{
362+
try
363+
{
364+
var dbContext = new DBContext(DB.MySQL, MySQLConnectionString);
365+
dbContext.ExecuteScalar(sqlStatement);
366+
Assert.Fail("No Exception");
367+
}
368+
catch (QueryDBException ex)
369+
{
370+
Assert.AreEqual("Only SELECT queries are supported here.", ex.Message);
371+
Assert.AreEqual("UnsupportedCommand", ex.ErrorType);
372+
Assert.AreEqual("'ExecuteScalar' only supports SELECT queries that have a scalar (single value) return.", ex.AdditionalInfo);
373+
}
374+
}
375+
}
376+
340377
#endregion
341378

342379
#region Execute Scalar Tests - << T ExecuteScalar<T>(string sqlStatement); >>
@@ -465,6 +502,43 @@ public void Test_MySQL_ExecuteScalar_As_TypedReturn_DefaultValue()
465502
Assert.AreEqual(default(DateTime?), result);
466503
}
467504

505+
[TestMethod]
506+
[TestCategory(DB_TESTS), TestCategory(MYSQL_TESTS)]
507+
public void Test_MySQL_ExecuteScalar_As_TypedReturn_UnsupportedCommands()
508+
{
509+
var sqlStatements = new List<string>
510+
{
511+
Queries.MySQLQueries.TestDB.DDL.Create_Table,
512+
Queries.MySQLQueries.TestDB.DDL.Alter_Table,
513+
Queries.MySQLQueries.TestDB.DDL.Comment_Table,
514+
Queries.MySQLQueries.TestDB.DDL.Truncate_Table,
515+
Queries.MySQLQueries.TestDB.DDL.Drop_Table,
516+
517+
Queries.MySQLQueries.TestDB.DML.InsertSql,
518+
Queries.MySQLQueries.TestDB.DML.UpdateSql,
519+
Queries.MySQLQueries.TestDB.DML.DeleteSql,
520+
521+
Queries.MySQLQueries.TestDB.DCL.GrantSql_Command_Table_User,
522+
Queries.MySQLQueries.TestDB.DCL.RevokeSql_Command_Table_User
523+
};
524+
525+
foreach (var sqlStatement in sqlStatements)
526+
{
527+
try
528+
{
529+
var dbContext = new DBContext(DB.MySQL, MySQLConnectionString);
530+
dbContext.ExecuteScalar<string>(sqlStatement);
531+
Assert.Fail("No Exception");
532+
}
533+
catch (QueryDBException ex)
534+
{
535+
Assert.AreEqual("Only SELECT queries are supported here.", ex.Message);
536+
Assert.AreEqual("UnsupportedCommand", ex.ErrorType);
537+
Assert.AreEqual("'ExecuteScalar' only supports SELECT queries that have a scalar (single value) return.", ex.AdditionalInfo);
538+
}
539+
}
540+
}
541+
468542
#endregion
469543

470544
#region Execute Command Tests - << int ExecuteCommand(string sqlStatement) >>

‎QueryDB.Core.Tests/OracleTests.cs‎

Lines changed: 74 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -339,6 +339,43 @@ public void Test_Oracle_ExecuteScalar_As_StringReturn_DefaultValue()
339339
Assert.AreEqual(string.Empty, result);
340340
}
341341

342+
[TestMethod]
343+
[TestCategory(DB_TESTS), TestCategory(ORACLE_TESTS)]
344+
public void Test_Oracle_ExecuteScalar_As_StringReturn_UnsupportedCommands()
345+
{
346+
var sqlStatements = new List<string>
347+
{
348+
Queries.OracleQueries.TestDB.DDL.Create_Table,
349+
Queries.OracleQueries.TestDB.DDL.Alter_Table,
350+
Queries.OracleQueries.TestDB.DDL.Comment_Table,
351+
Queries.OracleQueries.TestDB.DDL.Truncate_Table,
352+
Queries.OracleQueries.TestDB.DDL.Drop_Table,
353+
354+
Queries.OracleQueries.TestDB.DML.InsertSql,
355+
Queries.OracleQueries.TestDB.DML.UpdateSql,
356+
Queries.OracleQueries.TestDB.DML.DeleteSql,
357+
358+
Queries.OracleQueries.TestDB.DCL.GrantSql_Command_Table_User,
359+
Queries.OracleQueries.TestDB.DCL.RevokeSql_Command_Table_User
360+
};
361+
362+
foreach (var sqlStatement in sqlStatements)
363+
{
364+
try
365+
{
366+
var dbContext = new DBContext(DB.Oracle, OracleConnectionString);
367+
dbContext.ExecuteScalar(sqlStatement);
368+
Assert.Fail("No Exception");
369+
}
370+
catch (QueryDBException ex)
371+
{
372+
Assert.AreEqual("Only SELECT queries are supported here.", ex.Message);
373+
Assert.AreEqual("UnsupportedCommand", ex.ErrorType);
374+
Assert.AreEqual("'ExecuteScalar' only supports SELECT queries that have a scalar (single value) return.", ex.AdditionalInfo);
375+
}
376+
}
377+
}
378+
342379
#endregion
343380

344381
#region Execute Scalar Tests - << T ExecuteScalar<T>(string sqlStatement); >>
@@ -467,6 +504,43 @@ public void Test_Oracle_ExecuteScalar_As_TypedReturn_DefaultValue()
467504
Assert.AreEqual(default(DateTime?), result);
468505
}
469506

507+
[TestMethod]
508+
[TestCategory(DB_TESTS), TestCategory(ORACLE_TESTS)]
509+
public void Test_Oracle_ExecuteScalar_As_TypedReturn_UnsupportedCommands()
510+
{
511+
var sqlStatements = new List<string>
512+
{
513+
Queries.OracleQueries.TestDB.DDL.Create_Table,
514+
Queries.OracleQueries.TestDB.DDL.Alter_Table,
515+
Queries.OracleQueries.TestDB.DDL.Comment_Table,
516+
Queries.OracleQueries.TestDB.DDL.Truncate_Table,
517+
Queries.OracleQueries.TestDB.DDL.Drop_Table,
518+
519+
Queries.OracleQueries.TestDB.DML.InsertSql,
520+
Queries.OracleQueries.TestDB.DML.UpdateSql,
521+
Queries.OracleQueries.TestDB.DML.DeleteSql,
522+
523+
Queries.OracleQueries.TestDB.DCL.GrantSql_Command_Table_User,
524+
Queries.OracleQueries.TestDB.DCL.RevokeSql_Command_Table_User
525+
};
526+
527+
foreach (var sqlStatement in sqlStatements)
528+
{
529+
try
530+
{
531+
var dbContext = new DBContext(DB.Oracle, OracleConnectionString);
532+
dbContext.ExecuteScalar<string>(sqlStatement);
533+
Assert.Fail("No Exception");
534+
}
535+
catch (QueryDBException ex)
536+
{
537+
Assert.AreEqual("Only SELECT queries are supported here.", ex.Message);
538+
Assert.AreEqual("UnsupportedCommand", ex.ErrorType);
539+
Assert.AreEqual("'ExecuteScalar' only supports SELECT queries that have a scalar (single value) return.", ex.AdditionalInfo);
540+
}
541+
}
542+
}
543+
470544
#endregion
471545

472546
#region Execute Command Tests - << int ExecuteCommand(string sqlStatement) >>

‎QueryDB.Core.Tests/PostgreSQLTests.cs‎

Lines changed: 74 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -331,6 +331,43 @@ public void Test_PostgreSQL_ExecuteScalar_As_StringReturn_DefaultValue()
331331
Assert.AreEqual(string.Empty, result);
332332
}
333333

334+
[TestMethod]
335+
[TestCategory(DB_TESTS), TestCategory(POSTGRESQL_TESTS)]
336+
public void Test_PostgreSQL_ExecuteScalar_As_StringReturn_UnsupportedCommands()
337+
{
338+
var sqlStatements = new List<string>
339+
{
340+
Queries.PostgreSQLQueries.TestDB.DDL.Create_Table,
341+
Queries.PostgreSQLQueries.TestDB.DDL.Alter_Table,
342+
Queries.PostgreSQLQueries.TestDB.DDL.Comment_Table,
343+
Queries.PostgreSQLQueries.TestDB.DDL.Truncate_Table,
344+
Queries.PostgreSQLQueries.TestDB.DDL.Drop_Table,
345+
346+
Queries.PostgreSQLQueries.TestDB.DML.InsertSql,
347+
Queries.PostgreSQLQueries.TestDB.DML.UpdateSql,
348+
Queries.PostgreSQLQueries.TestDB.DML.DeleteSql,
349+
350+
Queries.PostgreSQLQueries.TestDB.DCL.GrantSql_Command_Table_User,
351+
Queries.PostgreSQLQueries.TestDB.DCL.RevokeSql_Command_Table_User
352+
};
353+
354+
foreach (var sqlStatement in sqlStatements)
355+
{
356+
try
357+
{
358+
var dbContext = new DBContext(DB.PostgreSQL, PostgreSQLConnectionString);
359+
dbContext.ExecuteScalar(sqlStatement);
360+
Assert.Fail("No Exception");
361+
}
362+
catch (QueryDBException ex)
363+
{
364+
Assert.AreEqual("Only SELECT queries are supported here.", ex.Message);
365+
Assert.AreEqual("UnsupportedCommand", ex.ErrorType);
366+
Assert.AreEqual("'ExecuteScalar' only supports SELECT queries that have a scalar (single value) return.", ex.AdditionalInfo);
367+
}
368+
}
369+
}
370+
334371
#endregion
335372

336373
#region Execute Scalar Tests - << T ExecuteScalar<T>(string sqlStatement); >>
@@ -459,6 +496,43 @@ public void Test_PostgreSQL_ExecuteScalar_As_TypedReturn_DefaultValue()
459496
Assert.AreEqual(default(DateTime?), result);
460497
}
461498

499+
[TestMethod]
500+
[TestCategory(DB_TESTS), TestCategory(POSTGRESQL_TESTS)]
501+
public void Test_PostgreSQL_ExecuteScalar_As_TypedReturn_UnsupportedCommands()
502+
{
503+
var sqlStatements = new List<string>
504+
{
505+
Queries.PostgreSQLQueries.TestDB.DDL.Create_Table,
506+
Queries.PostgreSQLQueries.TestDB.DDL.Alter_Table,
507+
Queries.PostgreSQLQueries.TestDB.DDL.Comment_Table,
508+
Queries.PostgreSQLQueries.TestDB.DDL.Truncate_Table,
509+
Queries.PostgreSQLQueries.TestDB.DDL.Drop_Table,
510+
511+
Queries.PostgreSQLQueries.TestDB.DML.InsertSql,
512+
Queries.PostgreSQLQueries.TestDB.DML.UpdateSql,
513+
Queries.PostgreSQLQueries.TestDB.DML.DeleteSql,
514+
515+
Queries.PostgreSQLQueries.TestDB.DCL.GrantSql_Command_Table_User,
516+
Queries.PostgreSQLQueries.TestDB.DCL.RevokeSql_Command_Table_User
517+
};
518+
519+
foreach (var sqlStatement in sqlStatements)
520+
{
521+
try
522+
{
523+
var dbContext = new DBContext(DB.PostgreSQL, PostgreSQLConnectionString);
524+
dbContext.ExecuteScalar<string>(sqlStatement);
525+
Assert.Fail("No Exception");
526+
}
527+
catch (QueryDBException ex)
528+
{
529+
Assert.AreEqual("Only SELECT queries are supported here.", ex.Message);
530+
Assert.AreEqual("UnsupportedCommand", ex.ErrorType);
531+
Assert.AreEqual("'ExecuteScalar' only supports SELECT queries that have a scalar (single value) return.", ex.AdditionalInfo);
532+
}
533+
}
534+
}
535+
462536
#endregion
463537

464538
#region Execute Command Tests - << int ExecuteCommand(string sqlStatement) >>

‎QueryDB/DBContext.cs‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -153,6 +153,9 @@ public List<DataDictionary> FetchData(string selectSql, bool upperCaseKeys = fal
153153
/// <returns>A string representing the result of the query. If the result is DBNull, an empty string is returned.</returns>
154154
public string ExecuteScalar(string sqlStatement)
155155
{
156+
if (!Regex.IsMatch(sqlStatement, @"^\s*SELECT\s+.*", RegexOptions.IgnoreCase | RegexOptions.Singleline, TimeSpan.FromSeconds(5)))
157+
throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedExecuteScalarCommand,
158+
QueryDBExceptions.ErrorType.UnsupportedCommand, QueryDBExceptions.AdditionalInfo.UnsupportedExecuteScalarCommand);
156159
var value = string.Empty;
157160
if (Database.Equals(DB.MSSQL))
158161
{
@@ -197,6 +200,9 @@ public string ExecuteScalar(string sqlStatement)
197200
/// <returns>The result of the query, converted to the specified type. If the result is DBNull, the default value for the type is returned.</returns>
198201
public T ExecuteScalar<T>(string sqlStatement)
199202
{
203+
if (!Regex.IsMatch(sqlStatement, @"^\s*SELECT\s+.*", RegexOptions.IgnoreCase | RegexOptions.Singleline, TimeSpan.FromSeconds(5)))
204+
throw new QueryDBException(QueryDBExceptions.ErrorMessage.UnsupportedExecuteScalarCommand,
205+
QueryDBExceptions.ErrorType.UnsupportedCommand, QueryDBExceptions.AdditionalInfo.UnsupportedExecuteScalarCommand);
200206
var value = default(T);
201207
if (Database.Equals(DB.MSSQL))
202208
{

‎QueryDB/Exceptions/QueryDBException.cs‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -70,6 +70,11 @@ internal static class ErrorMessage
7070
/// Error message indicating that SELECT queries are not supported in 'ExecuteTransaction'.
7171
/// </summary>
7272
internal static readonly string UnsupportedSelectExecuteTransaction = "SELECT queries are not supported here.";
73+
74+
/// <summary>
75+
/// Error message indicating that SELECT queries are only supported in 'ExecuteScalar'.
76+
/// </summary>
77+
internal static readonly string UnsupportedExecuteScalarCommand = "Only SELECT queries are supported here.";
7378
}
7479

7580
/// <summary>
@@ -86,6 +91,11 @@ internal static class AdditionalInfo
8691
/// Additional information about unsupported SELECT queries in 'ExecuteTransaction'.
8792
/// </summary>
8893
internal static readonly string UnsupportedSelectExecuteTransaction = "'ExecuteTransaction' doesn't support SELECT queries.";
94+
95+
/// <summary>
96+
/// Error message indicating that SELECT queries are only supported in 'ExecuteScalar'.
97+
/// </summary>
98+
internal static readonly string UnsupportedExecuteScalarCommand = "'ExecuteScalar' only supports SELECT queries that have a scalar (single value) return.";
8999
}
90100
}
91101
}

0 commit comments

Comments
 (0)