// method assumes that statement is trimmed
private bool IsSetTermStatement(string statement, out string newTerm)
{
bool result = false;
newTerm = "";
if (StringParser.StartsWith(statement, "SET TERM", true))
{
newTerm = statement.Substring(8).Trim();
result = true;
}
return(result);
}
/// <summary>
/// Determines the <see cref="SqlStatementType"/> of the provided SQL statement.
/// </summary>
/// <param name="sqlStatement">The string containing the SQL statement.</param>
/// <returns>The <see cref="SqlStatementType"/> of the <b>sqlStatement</b>.</returns>
/// <remarks>If the type of <b>sqlStatement</b> could not be determinated this
/// method will throw an exception.</remarks>
public static SqlStatementType GetStatementType(string sqlStatement)
{
char type = sqlStatement == null ? ' ' : sqlStatement.Trim().ToUpper(CultureInfo.CurrentCulture)[0];
switch (type)
{
case 'A':
if (StringParser.StartsWith(sqlStatement, "ALTER DATABASE", true))
{
return(SqlStatementType.AlterDatabase);
}
if (StringParser.StartsWith(sqlStatement, "ALTER DOMAIN", true))
{
return(SqlStatementType.AlterDomain);
}
if (StringParser.StartsWith(sqlStatement, "ALTER EXCEPTION", true))
{
return(SqlStatementType.AlterException);
}
if (StringParser.StartsWith(sqlStatement, "ALTER INDEX", true))
{
return(SqlStatementType.AlterIndex);
}
if (StringParser.StartsWith(sqlStatement, "ALTER PROCEDURE", true))
{
return(SqlStatementType.AlterProcedure);
}
if (StringParser.StartsWith(sqlStatement, "ALTER TABLE", true))
{
return(SqlStatementType.AlterTable);
}
if (StringParser.StartsWith(sqlStatement, "ALTER TRIGGER", true))
{
return(SqlStatementType.AlterTrigger);
}
throw new Exception("The type of the SQL statement could not be determinated.");
case 'C':
switch (char.ToUpper(sqlStatement[1], CultureInfo.CurrentCulture))
{
case 'L':
if (StringParser.StartsWith(sqlStatement, "CLOSE", true))
{
return(SqlStatementType.Close);
}
throw new Exception("The type of the SQL statement could not be determinated.");
case 'O':
if (StringParser.StartsWith(sqlStatement, "COMMIT", true))
{
return(SqlStatementType.Commit);
}
if (StringParser.StartsWith(sqlStatement, "CONNECT", true))
{
return(SqlStatementType.Connect);
}
throw new Exception("The type of the SQL statement could not be determinated.");
case 'R':
if (StringParser.StartsWith(sqlStatement, "CREATE DATABASE", true))
{
return(SqlStatementType.CreateDatabase);
}
if (StringParser.StartsWith(sqlStatement, "CREATE DOMAIN", true))
{
return(SqlStatementType.CreateDomain);
}
if (StringParser.StartsWith(sqlStatement, "CREATE EXCEPTION", true))
{
return(SqlStatementType.CreateException);
}
if (StringParser.StartsWith(sqlStatement, "CREATE GENERATOR", true))
{
return(SqlStatementType.CreateGenerator);
}
if (StringParser.StartsWith(sqlStatement, "CREATE INDEX", true))
{
return(SqlStatementType.CreateIndex);
}
if (StringParser.StartsWith(sqlStatement, "CREATE DESCENDING INDEX", true))
{
return(SqlStatementType.CreateIndex);
}
if (StringParser.StartsWith(sqlStatement, "CREATE PROCEDURE", true))
{
return(SqlStatementType.CreateProcedure);
}
if (StringParser.StartsWith(sqlStatement, "CREATE ROLE", true))
{
return(SqlStatementType.CreateRole);
}
if (StringParser.StartsWith(sqlStatement, "CREATE SHADOW", true))
{
return(SqlStatementType.CreateShadow);
}
if (StringParser.StartsWith(sqlStatement, "CREATE TABLE", true))
{
return(SqlStatementType.CreateTable);
}
if (StringParser.StartsWith(sqlStatement, "CREATE TRIGGER", true))
{
return(SqlStatementType.CreateTrigger);
}
if (StringParser.StartsWith(sqlStatement, "CREATE UNIQUE INDEX", true))
{
return(SqlStatementType.CreateIndex);
}
if (StringParser.StartsWith(sqlStatement, "CREATE VIEW", true))
{
return(SqlStatementType.CreateView);
}
throw new Exception("The type of the SQL statement could not be determinated.");
default:
throw new Exception("The type of the SQL statement could not be determinated.");
}
case 'D':
switch (char.ToUpper(sqlStatement[1], CultureInfo.CurrentCulture))
{
case 'E':
if (StringParser.StartsWith(sqlStatement, "DECLARE CURSOR", true))
{
return(SqlStatementType.DeclareCursor);
}
if (StringParser.StartsWith(sqlStatement, "DECLARE EXTERNAL FUNCTION", true))
{
return(SqlStatementType.DeclareExternalFunction);
}
if (StringParser.StartsWith(sqlStatement, "DECLARE FILTER", true))
{
return(SqlStatementType.DeclareFilter);
}
if (StringParser.StartsWith(sqlStatement, "DECLARE STATEMENT", true))
{
return(SqlStatementType.DeclareStatement);
}
if (StringParser.StartsWith(sqlStatement, "DECLARE TABLE", true))
{
return(SqlStatementType.DeclareTable);
}
if (StringParser.StartsWith(sqlStatement, "DELETE", true))
{
return(SqlStatementType.Delete);
}
if (StringParser.StartsWith(sqlStatement, "DESCRIBE", true))
{
return(SqlStatementType.Describe);
}
throw new Exception("The type of the SQL statement could not be determinated.");
case 'I':
if (StringParser.StartsWith(sqlStatement, "DISCONNECT", true))
{
return(SqlStatementType.Disconnect);
}
throw new Exception("The type of the SQL statement could not be determinated.");
case 'R':
if (StringParser.StartsWith(sqlStatement, "DROP DATABASE", true))
{
return(SqlStatementType.DropDatabase);
}
if (StringParser.StartsWith(sqlStatement, "DROP DOMAIN", true))
{
return(SqlStatementType.DropDomain);
}
if (StringParser.StartsWith(sqlStatement, "DROP EXCEPTION", true))
{
return(SqlStatementType.DropException);
}
if (StringParser.StartsWith(sqlStatement, "DROP EXTERNAL FUNCTION", true))
{
return(SqlStatementType.DropExternalFunction);
}
if (StringParser.StartsWith(sqlStatement, "DROP FILTER", true))
{
return(SqlStatementType.DropFilter);
}
if (StringParser.StartsWith(sqlStatement, "DROP GENERATOR", true))
{
return(SqlStatementType.DropGenerator);
}
if (StringParser.StartsWith(sqlStatement, "DROP INDEX", true))
{
return(SqlStatementType.DropIndex);
}
if (StringParser.StartsWith(sqlStatement, "DROP PROCEDURE", true))
{
return(SqlStatementType.DropProcedure);
}
if (StringParser.StartsWith(sqlStatement, "DROP ROLE", true))
{
return(SqlStatementType.DropRole);
}
if (StringParser.StartsWith(sqlStatement, "DROP SHADOW", true))
{
return(SqlStatementType.DropShadow);
}
if (StringParser.StartsWith(sqlStatement, "DROP TABLE", true))
{
return(SqlStatementType.DropTable);
}
if (StringParser.StartsWith(sqlStatement, "DROP TRIGGER", true))
{
return(SqlStatementType.DropTrigger);
}
if (StringParser.StartsWith(sqlStatement, "DROP VIEW", true))
{
return(SqlStatementType.DropView);
}
throw new Exception("The type of the SQL statement could not be determinated.");
default:
throw new Exception("The type of the SQL statement could not be determinated.");
}
case 'E':
if (StringParser.StartsWith(sqlStatement, "EXECUTE PROCEDURE", true))
{
return(SqlStatementType.ExecuteProcedure);
}
if (StringParser.StartsWith(sqlStatement, "EXECUTE IMMEDIATE", true))
{
return(SqlStatementType.ExecuteImmediate);
}
if (StringParser.StartsWith(sqlStatement, "EXECUTE", true))
{
return(SqlStatementType.Execute);
}
if (StringParser.StartsWith(sqlStatement, "EVENT WAIT", true))
{
return(SqlStatementType.EventWait);
}
if (StringParser.StartsWith(sqlStatement, "EVENT INIT", true))
{
return(SqlStatementType.EventInit);
}
if (StringParser.StartsWith(sqlStatement, "END DECLARE SECTION", true))
{
return(SqlStatementType.EndDeclareSection);
}
throw new Exception("The type of the SQL statement could not be determinated.");
case 'F':
if (StringParser.StartsWith(sqlStatement, "FETCH", true))
{
return(SqlStatementType.Fetch);
}
throw new Exception("The type of the SQL statement could not be determinated.");
case 'G':
if (StringParser.StartsWith(sqlStatement, "GRANT", true))
{
return(SqlStatementType.Grant);
}
throw new Exception("The type of the SQL statement could not be determinated.");
case 'I':
if (StringParser.StartsWith(sqlStatement, "INSERT CURSOR", true))
{
return(SqlStatementType.InsertCursor);
}
if (StringParser.StartsWith(sqlStatement, "INSERT", true))
{
return(SqlStatementType.Insert);
}
throw new Exception("The type of the SQL statement could not be determinated.");
case 'O':
if (StringParser.StartsWith(sqlStatement, "OPEN", true))
{
return(SqlStatementType.Open);
}
throw new Exception("The type of the SQL statement could not be determinated.");
case 'P':
if (StringParser.StartsWith(sqlStatement, "PREPARE", true))
{
return(SqlStatementType.Prepare);
}
throw new Exception("The type of the SQL statement could not be determinated.");
case 'R':
if (StringParser.StartsWith(sqlStatement, "REVOKE", true))
{
return(SqlStatementType.Revoke);
}
if (StringParser.StartsWith(sqlStatement, "ROLLBACK", true))
{
return(SqlStatementType.Rollback);
}
throw new Exception("The type of the SQL statement could not be determinated.");
case 'S':
if (StringParser.StartsWith(sqlStatement, "SELECT", true))
{
return(SqlStatementType.Select);
}
if (StringParser.StartsWith(sqlStatement, "SET DATABASE", true))
{
return(SqlStatementType.SetDatabase);
}
if (StringParser.StartsWith(sqlStatement, "SET GENERATOR", true))
{
return(SqlStatementType.SetGenerator);
}
if (StringParser.StartsWith(sqlStatement, "SET NAMES", true))
{
return(SqlStatementType.SetGenerator);
}
if (StringParser.StartsWith(sqlStatement, "SET SQL DIALECT", true))
{
return(SqlStatementType.SetSQLDialect);
}
if (StringParser.StartsWith(sqlStatement, "SET STATISTICS", true))
{
return(SqlStatementType.SetStatistics);
}
if (StringParser.StartsWith(sqlStatement, "SET TRANSACTION", true))
{
return(SqlStatementType.SetTransaction);
}
if (StringParser.StartsWith(sqlStatement, "SHOW SQL DIALECT", true))
{
return(SqlStatementType.ShowSQLDialect);
}
throw new Exception("The type of the SQL statement could not be determinated.");
case 'U':
if (StringParser.StartsWith(sqlStatement, "UPDATE", true))
{
return(SqlStatementType.Update);
}
throw new Exception("The type of the SQL statement could not be determinated.");
case 'W':
if (StringParser.StartsWith(sqlStatement, "WHENEVER", true))
{
return(SqlStatementType.Whenever);
}
throw new Exception("The type of the SQL statement could not be determinated.");
default:
throw new Exception("The type of the SQL statement could not be determinated.");
}
}