private static EsperEPL2GrammarParser.StartEventPropertyRuleContext HandleRecognitionEx(RecognitionException e, CommonTokenStream tokens, string propertyName, EsperEPL2GrammarParser g)
{
// Check for keywords and escape each, parse again
var escapedPropertyName = EscapeKeywords(tokens);
ICharStream inputEscaped;
try
{
inputEscaped = new NoCaseSensitiveStream(escapedPropertyName);
}
catch (IOException ex)
{
throw new PropertyAccessException("IOException parsing property name '" + propertyName + '\'', ex);
}
var lexEscaped = ParseHelper.NewLexer(inputEscaped);
var tokensEscaped = new CommonTokenStream(lexEscaped);
var gEscaped = ParseHelper.NewParser(tokensEscaped);
try
{
return(gEscaped.startEventPropertyRule());
}
catch
{
}
throw ExceptionConvertor.ConvertProperty(e, propertyName, true, g);
}
/// <summary>
/// Parses a given property name returning an AST.
/// </summary>
/// <param name="propertyName">to parse</param>
/// <returns>AST syntax tree</returns>
public static EsperEPL2GrammarParser.StartEventPropertyRuleContext Parse(string propertyName)
{
ICharStream input;
try
{
input = new NoCaseSensitiveStream(propertyName);
}
catch (IOException ex)
{
throw new PropertyAccessException("IOException parsing property name '" + propertyName + '\'', ex);
}
var lex = ParseHelper.NewLexer(input);
var tokens = new CommonTokenStream(lex);
try
{
tokens.Fill();
}
catch (Exception e)
{
if (ParseHelper.HasControlCharacters(propertyName))
{
throw new PropertyAccessException("Unrecognized control characters found in text");
}
throw new PropertyAccessException("Failed to parse text: " + e.Message);
}
var g = ParseHelper.NewParser(tokens);
EsperEPL2GrammarParser.StartEventPropertyRuleContext r;
try
{
r = g.startEventPropertyRule();
}
catch (RecognitionException e)
{
return(HandleRecognitionEx(e, tokens, propertyName, g));
}
catch (Exception e)
{
if (Log.IsDebugEnabled)
{
Log.Debug("Error parsing property expression [" + propertyName + "]", e);
}
if (e.InnerException is RecognitionException)
{
return(HandleRecognitionEx((RecognitionException)e.InnerException, tokens, propertyName, g));
}
else
{
throw;
}
}
return(r);
}
public static Pair <ITree, CommonTokenStream> Parse(ParseRuleSelector parseRuleSelector, String text)
{
NoCaseSensitiveStream input;
try
{
input = new NoCaseSensitiveStream(text);
}
catch (IOException ex)
{
throw new IOException("IOException parsing text '" + text + '\'', ex);
}
var lex = ParseHelper.NewLexer(input);
var tokens = new CommonTokenStream(lex);
var g = ParseHelper.NewParser(tokens);
var ctx = parseRuleSelector.Invoke(g);
return(new Pair <ITree, CommonTokenStream>(ctx, tokens));
}
/// <summary>
/// Lexes the sample SQL and inserts a "where 1=0" where-clause.
/// </summary>
/// <param name="querySQL">to inspect using lexer</param>
/// <returns>sample SQL with where-clause inserted</returns>
/// <exception cref="ExprValidationException">indicates a lexer problem</exception>
public static String LexSampleSQL(String querySQL)
{
querySQL = Regex.Replace(querySQL, "\\s\\s+|\\n|\\r", m => " ");
ICharStream input;
try
{
input = new NoCaseSensitiveStream(querySQL);
}
catch (IOException ex)
{
throw new ExprValidationException("IOException lexing query SQL '" + querySQL + '\'', ex);
}
var whereIndex = -1;
var groupbyIndex = -1;
var havingIndex = -1;
var orderByIndex = -1;
var unionIndexes = new List <int>();
var lex = ParseHelper.NewLexer(input);
var tokens = new CommonTokenStream(lex);
tokens.Fill();
IList <IToken> tokenList = tokens.GetTokens();
for (var i = 0; i < tokenList.Count; i++)
{
var token = (IToken)tokenList[i];
if ((token == null) || token.Text == null)
{
break;
}
var text = token.Text.ToLower().Trim();
if (text == "")
{
continue;
}
switch (text)
{
case "where":
whereIndex = token.Column + 1;
break;
case "group":
groupbyIndex = token.Column + 1;
break;
case "having":
havingIndex = token.Column + 1;
break;
case "order":
orderByIndex = token.Column + 1;
break;
case "union":
unionIndexes.Add(token.Column + 1);
break;
}
}
// If we have a union, break string into subselects and process each
if (unionIndexes.Count != 0)
{
String fragment;
String lexedFragment;
var changedSQL = new StringBuilder();
var lastIndex = 0;
for (var i = 0; i < unionIndexes.Count; i++)
{
var index = unionIndexes[i];
if (i > 0)
{
fragment = querySQL.Substring(lastIndex + 5, index - 6 - lastIndex);
}
else
{
fragment = querySQL.Substring(lastIndex, index - 1 - lastIndex);
}
lexedFragment = LexSampleSQL(fragment);
if (i > 0)
{
changedSQL.Append("union ");
}
changedSQL.Append(lexedFragment);
lastIndex = index - 1;
}
// last part after last union
fragment = querySQL.Substring(lastIndex + 5);
lexedFragment = LexSampleSQL(fragment);
changedSQL.Append("union ");
changedSQL.Append(lexedFragment);
return(changedSQL.ToString());
}
// Found a where clause, simplest cases
if (whereIndex != -1)
{
var changedSQL = new StringBuilder();
var prefix = querySQL.Substring(0, whereIndex + 5);
var suffix = querySQL.Substring(whereIndex + 5);
changedSQL.Append(prefix);
changedSQL.Append("1=0 and ");
changedSQL.Append(suffix);
return(changedSQL.ToString());
}
// No where clause, find group-by
int insertIndex;
if (groupbyIndex != -1)
{
insertIndex = groupbyIndex;
}
else if (havingIndex != -1)
{
insertIndex = havingIndex;
}
else if (orderByIndex != -1)
{
insertIndex = orderByIndex;
}
else
{
var changedSQL = new StringBuilder();
changedSQL.Append(querySQL);
changedSQL.Append(" where 1=0 ");
return(changedSQL.ToString());
}
try
{
var changedSQL = new StringBuilder();
var prefix = querySQL.Substring(0, insertIndex - 1);
changedSQL.Append(prefix);
changedSQL.Append("where 1=0 ");
var suffix = querySQL.Substring(insertIndex - 1);
changedSQL.Append(suffix);
return(changedSQL.ToString());
}
catch (Exception ex)
{
const string text =
"Error constructing sample SQL to retrieve metadata for JDBC-drivers that don't support metadata, consider using the " +
SAMPLE_WHERECLAUSE_PLACEHOLDER + " placeholder or providing a sample SQL";
Log.Error(text, ex);
throw new ExprValidationException(text, ex);
}
}
public static IList <EPLModuleParseItem> Parse(String module)
{
ICharStream input;
try
{
input = new NoCaseSensitiveStream(module);
}
catch (IOException ex)
{
Log.Error("Exception reading module expression: " + ex.Message, ex);
return(null);
}
var lex = ParseHelper.NewLexer(input);
var tokens = new CommonTokenStream(lex);
try
{
tokens.Fill();
}
catch (Exception ex)
{
String message = "Unexpected exception recognizing module text";
if (ex is LexerNoViableAltException)
{
if (ParseHelper.HasControlCharacters(module))
{
message = "Unrecognized control characters found in text, failed to parse text";
}
else
{
message += ", recognition failed for " + ex;
}
}
else if (ex is RecognitionException)
{
var recog = (RecognitionException)ex;
message += ", recognition failed for " + recog;
}
else if (!string.IsNullOrWhiteSpace(ex.Message))
{
message += ": " + ex.Message;
}
message += " [" + module + "]";
Log.Error(message, ex);
throw new ParseException(message);
}
var statements = new List <EPLModuleParseItem>();
var current = new StringWriter();
int?lineNum = null;
int charPosStart = 0;
int charPos = 0;
var tokenList = tokens.GetTokens();
var skippedSemicolonIndexes = GetSkippedSemicolons(tokenList);
int index = -1;
foreach (var token in tokenList.TakeWhile(t => t.Type != EsperEPL2GrammarParser.Eof))
{
index++;
var t = token;
bool semi = t.Type == EsperEPL2GrammarParser.SEMI && !skippedSemicolonIndexes.Contains(index);
if (semi)
{
if (current.ToString().Trim().Length > 0)
{
statements.Add(
new EPLModuleParseItem(
current.ToString().Trim(), lineNum ?? 0, charPosStart, charPos));
lineNum = null;
}
current = new StringWriter();
}
else
{
if ((lineNum == null) && (t.Type != EsperEPL2GrammarParser.WS))
{
lineNum = t.Line;
charPosStart = charPos;
}
if (t.Type != EsperEPL2GrammarLexer.Eof)
{
current.Write(t.Text);
charPos += t.Text.Length;
}
}
}
if (!string.IsNullOrWhiteSpace(current.ToString()))
{
statements.Add(new EPLModuleParseItem(current.ToString().Trim(), lineNum ?? 0, 0, 0));
}
return(statements);
}
public static ParseNode GetModule(EPLModuleParseItem item, String resourceName)
{
var input = new NoCaseSensitiveStream(item.Expression);
var lex = ParseHelper.NewLexer(input);
var tokenStream = new CommonTokenStream(lex);
tokenStream.Fill();
var tokens = tokenStream.GetTokens();
var beginIndex = 0;
var isMeta = false;
var isModule = false;
var isUses = false;
var isExpression = false;
while (beginIndex < tokens.Count)
{
var t = tokens[beginIndex];
if (t.Type == EsperEPL2GrammarParser.Eof)
{
break;
}
if ((t.Type == EsperEPL2GrammarParser.WS) ||
(t.Type == EsperEPL2GrammarParser.SL_COMMENT) ||
(t.Type == EsperEPL2GrammarParser.ML_COMMENT))
{
beginIndex++;
continue;
}
var tokenText = t.Text.Trim().ToLower();
switch (tokenText)
{
case "module":
isModule = true;
isMeta = true;
break;
case "uses":
isUses = true;
isMeta = true;
break;
case "import":
isMeta = true;
break;
default:
isExpression = true;
break;
}
beginIndex++;
beginIndex++; // skip space
break;
}
if (isExpression)
{
return(new ParseNodeExpression(item));
}
if (!isMeta)
{
return(new ParseNodeComment(item));
}
// check meta tag (module, uses, import)
var buffer = new StringWriter();
for (int i = beginIndex; i < tokens.Count; i++)
{
var t = tokens[i];
if (t.Type == EsperEPL2GrammarParser.Eof)
{
break;
}
if ((t.Type != EsperEPL2GrammarParser.IDENT) &&
(t.Type != EsperEPL2GrammarParser.DOT) &&
(t.Type != EsperEPL2GrammarParser.STAR) &&
(!t.Text.Matches("[a-zA-Z]*")))
{
throw GetMessage(isModule, isUses, resourceName, t.Type);
}
buffer.Write(t.Text.Trim());
}
String result = buffer.ToString().Trim();
if (result.Length == 0)
{
throw GetMessage(isModule, isUses, resourceName, -1);
}
if (isModule)
{
return(new ParseNodeModule(item, result));
}
else if (isUses)
{
return(new ParseNodeUses(item, result));
}
return(new ParseNodeImport(item, result));
}
