/// <summary>
/// Returns array of matches for a statement (word(s) ended with ';'); Optionally every match can be processed with delegate ParseStatement.
/// </summary>
public static ArrayList GetStatements(string text, string patern, ParseStatement parser)
{
ArrayList retval = new ArrayList();
Regex regex = new Regex(patern, regexOptions);
Match m = regex.Match(text);
string retvalStr = "";
while (m.Success)
{
int startPos = m.Index;
int endPos = text.IndexOf(";", m.Index);
if (endPos != -1)
{
retvalStr = text.Substring(startPos, endPos - startPos);
if (parser != null)
{
retval.Add(parser(retvalStr));
}
else
{
retval.Add(retvalStr);
}
}
m = m.NextMatch();
}
return(retval);
}
public override bool Parse()
{
var result = base.Parse();
if (result)
{
var statement = new ParseStatement(Message);
result = statement.Parse(ParseStatement.Option.RECORDS_FETCHED);
if (result)
{
StatementId = statement.Id;
Text = statement.Text;
Plan = statement.Plan;
Params = statement.Params;
RecordsFetched = statement.RecordsFetched;
RemoveFirstCharactersOfMessage(statement.CharactersParsed);
}
}
if (result)
{
var parseCounters = new ParseCounters(Message);
result = parseCounters.Parse();
if (result)
{
ElapsedTime = parseCounters.ElapsedTime;
Reads = parseCounters.Reads;
Writes = parseCounters.Writes;
Fetches = parseCounters.Fetches;
Marks = parseCounters.Marks;
RemoveFirstCharactersOfMessage(parseCounters.CharactersParsed);
}
}
if (result && !string.IsNullOrWhiteSpace(Message))
{
var parseTableCounts = new ParseTableCounts(Message);
result = parseTableCounts.Parse();
if (result)
{
TableCounts = parseTableCounts.TableCounts;
}
}
return(result);
}
static SqlParser()
{
// as for example
// ... FROM Northwind.dbo.[Order Details] AS OrdDet ...
// This was first noticed for the SELECT ... FROM statements from the Northwind example DB.
// Order these statement parsers in descending order of frequency of use.
// We'll do a linear search through the table to find the appropriate matcher.
_statementParser = CreateCompoundStatementParser(
// selects are tricky with the set crap on the front of the statement.. /* fooo */set
// leave those out of the dictionary
new DefaultStatementParser("select", SelectRegex, string.Empty).ParseStatement,
new ShowStatementParser().ParseStatement,
new DefaultStatementParser("insert", InsertRegex, InsertPhraseShortcut).ParseStatement,
new DefaultStatementParser("update", UpdateRegex, UpdatePhraseShortcut).ParseStatement,
new DefaultStatementParser("delete", DeleteRegex, DeletePhraseShortcut).ParseStatement,
new DefaultStatementParser("ExecuteProcedure", ExecuteProcedureRegex1, ExecuteProcedure1Shortcut).ParseStatement,
new DefaultStatementParser("ExecuteProcedure", ExecuteProcedureRegex2, ExecuteProcedure2Shortcut).ParseStatement,
// Invocation of a conventionally named stored procedure.
new DefaultStatementParser("ExecuteProcedure", ExecuteProcedureRegex3, ExecuteProcedure3Shortcut).ParseStatement,
new DefaultStatementParser("create", CreateRegex, CreatePhraseShortcut).ParseStatement,
new DefaultStatementParser("drop", DropRegex, DropPhraseShortcut).ParseStatement,
new DefaultStatementParser("alter", AlterRegex, AlterPhraseShortcut).ParseStatement,
new DefaultStatementParser("call", CallRegex, CallPhraseShortcut).ParseStatement,
// See http://msdn.microsoft.com/en-us/library/ms189484.aspx
// The set statement targets a local identifier whose name may start with @. We just scan over the @.
new DefaultStatementParser("set", SetRegex, SetPhraseShortcut).ParseStatement,
// See http://msdn.microsoft.com/en-us/library/ms188927.aspx
// The declare statement targets a local identifier whose name may start with @. We just scan over the @.
new DefaultStatementParser("declare", DeclareRegex, DeclarePhraseShortcut).ParseStatement,
new SelectVariableStatementParser().ParseStatement,
// The Waitfor statement is [probably] only in Transact SQL. There are multiple variations of the statement.
// See http://msdn.microsoft.com/en-us/library/ms187331.aspx
new WaitforStatementParser().ParseStatement);
}
public override bool Parse()
{
var result = base.Parse();
if (result)
{
var statement = new ParseStatement(Message);
result = statement.Parse(ParseStatement.Option.NONE);
if (result)
{
StatementId = statement.Id;
Text = statement.Text;
Plan = statement.Plan;
RemoveFirstCharactersOfMessage(statement.CharactersParsed);
result = string.IsNullOrWhiteSpace(Message);
}
}
return(result);
}
public override bool Parse()
{
var result = base.Parse();
if (result)
{
var statement = new ParseStatement(Message);
result = statement.Parse(ParseStatement.Option.ELAPSED_TIME);
if (result)
{
StatementId = statement.Id;
Text = statement.Text;
Plan = statement.Plan;
ElapsedTime = statement.ElapsedTime ?? TimeSpan.MinValue;
RemoveFirstCharactersOfMessage(statement.CharactersParsed);
result = string.IsNullOrWhiteSpace(Message);
}
}
return(result);
}
/// <summary>
/// Returns array of matches; Optionally every match can be processed with delegate ParseStatement.
/// </summary>
public static ArrayList RegexGetMatches(string text, string patern, ParseStatement parser)
{
ArrayList retval = new ArrayList();
Regex regex = new Regex(patern, regexOptions);
Match m = regex.Match(text);
string retvalStr = "";
while (m.Success)
{
retvalStr = m.ToString();
if (parser != null)
{
retval.Add(parser(retvalStr));
}
else
{
retval.Add(retvalStr);
}
m = m.NextMatch();
}
return(retval);
}
/// <summary>
/// Returns array of matches; Optionally every match can be processed with delegate ParseStatement.
/// </summary>
public static ArrayList RegexGetMatches(string text, string patern, ParseStatement parser)
{
ArrayList retval = new ArrayList();
Regex regex = new Regex(patern, regexOptions);
Match m = regex.Match(text);
string retvalStr = "";
while (m.Success)
{
retvalStr = m.ToString();
if (parser != null)
retval.Add(parser(retvalStr));
else
retval.Add(retvalStr);
m = m.NextMatch();
}
return retval;
}
/// <summary>
/// Returns array of matches for a statement (word(s) ended with ';'); Optionally every match can be processed with delegate ParseStatement.
/// </summary>
public static ArrayList GetStatements(string text, string patern, ParseStatement parser)
{
ArrayList retval = new ArrayList();
Regex regex = new Regex(patern, regexOptions);
Match m = regex.Match(text);
string retvalStr = "";
while (m.Success)
{
int startPos = m.Index;
int endPos = text.IndexOf(";", m.Index);
if (endPos != -1)
{
retvalStr = text.Substring(startPos, endPos - startPos);
if (parser != null)
retval.Add(parser(retvalStr));
else
retval.Add(retvalStr);
}
m = m.NextMatch();
}
return retval;
}
/** Parses the many variants of \c let statements. */
private Statement ParseLetStatement()
{
Token start = _matcher.Match(TokenKind.Keyword_Let);
_matcher.Match(TokenKind.Space);
Expression first = ParseExpression();
_matcher.Match(TokenKind.Space);
Token assignment = _matcher.Read();
_matcher.Match(TokenKind.Space);
Expression other = ParseExpression();
_matcher.Match(TokenKind.EndOfLine);
switch (assignment.Kind)
{
case TokenKind.Assign_Add:
case TokenKind.Assign_Bitwise_And:
case TokenKind.Assign_Bitwise_Ior:
case TokenKind.Assign_Bitwise_Xor:
case TokenKind.Assign_Default:
case TokenKind.Assign_Divide:
case TokenKind.Assign_Identity:
case TokenKind.Assign_Modulus:
case TokenKind.Assign_Multiply:
case TokenKind.Assign_Subtract:
break;
#if false
case TokenKind.Parse:
result = new ParseStatement(assignment.Cursor, first, other);
break;
case TokenKind.Print:
result = new PrintStatement(assignment.Cursor, first, other);
break;
#endif
default:
throw new ParserError(assignment.Cursor, "Expected assignment operator");
}
return new LetStatement(assignment.Cursor, TokenKindToAssignmentKind(assignment.Kind), first, other);
}
