public static StatementSpecRaw CompileEPL(
string eplStatement,
string eplStatementForErrorMsg,
bool addPleaseCheck,
string statementName,
SelectClauseStreamSelectorEnum defaultStreamSelector,
EngineImportService engineImportService,
VariableService variableService,
SchedulingService schedulingService,
string engineURI,
ConfigurationInformation configSnapshot,
PatternNodeFactory patternNodeFactory,
ContextManagementService contextManagementService,
ExprDeclaredService exprDeclaredService,
TableService tableService)
{
if (Log.IsDebugEnabled)
{
Log.Debug(".createEPLStmt statementName=" + statementName + " eplStatement=" + eplStatement);
}
ParseResult parseResult = ParseHelper.Parse(
eplStatement, eplStatementForErrorMsg, addPleaseCheck, EPLParseRule, true);
ITree ast = parseResult.Tree;
var walker = new EPLTreeWalkerListener(
parseResult.TokenStream, engineImportService, variableService, schedulingService, defaultStreamSelector,
engineURI, configSnapshot, patternNodeFactory, contextManagementService, parseResult.Scripts,
exprDeclaredService, tableService);
try
{
ParseHelper.Walk(ast, walker, eplStatement, eplStatementForErrorMsg);
}
catch (ASTWalkException ex)
{
Log.Error(".createEPL Error validating expression", ex);
throw new EPStatementException(ex.Message, ex, eplStatementForErrorMsg);
}
catch (EPStatementSyntaxException ex)
{
throw;
}
catch (Exception ex)
{
string message = "Error in expression";
Log.Debug(message, ex);
throw new EPStatementException(GetNullableErrortext(message, ex.Message), ex, eplStatementForErrorMsg);
}
if (Log.IsDebugEnabled)
{
ASTUtil.DumpAST(ast);
}
StatementSpecRaw raw = walker.StatementSpec;
raw.ExpressionNoAnnotations = parseResult.ExpressionWithoutAnnotations;
return(raw);
}
public static void DisplayAST(ITree ast)
{
Log.Debug(".displayAST...");
if (Log.IsDebugEnabled)
{
ASTUtil.DumpAST(ast);
}
}
private static StatementSpecRaw Walk(
ParseResult parseResult,
string epl,
StatementSpecMapEnv mapEnv)
{
var ast = parseResult.Tree;
var defaultStreamSelector =
StatementSpecMapper.MapFromSODA(mapEnv.Configuration.Compiler.StreamSelection.DefaultStreamSelector);
var walker = new EPLTreeWalkerListener(
parseResult.TokenStream,
defaultStreamSelector,
parseResult.Scripts,
parseResult.Classes,
mapEnv);
try {
ParseHelper.Walk(ast, walker, epl, epl);
}
catch (ASTWalkException ex) {
throw new StatementSpecCompileException(ex.Message, ex, epl);
}
catch (ValidationException ex) {
throw new StatementSpecCompileException(ex.Message, ex, epl);
}
catch (Exception ex) {
var message = "Invalid expression encountered";
throw new StatementSpecCompileException(GetNullableErrortext(message, ex.Message), ex, epl);
}
if (Log.IsDebugEnabled)
{
ASTUtil.DumpAST(ast);
}
return(walker.StatementSpec);
}
public static StatementSpecRaw CompilePattern(String expression, String expressionForErrorMessage, bool addPleaseCheck, EPServicesContext services, SelectClauseStreamSelectorEnum defaultStreamSelector)
{
// Parse
ParseResult parseResult = ParseHelper.Parse(expression, expressionForErrorMessage, addPleaseCheck, PatternParseRule, true);
var ast = parseResult.Tree;
if (Log.IsDebugEnabled)
{
ASTUtil.DumpAST(ast);
}
// Walk
EPLTreeWalkerListener walker = new EPLTreeWalkerListener(
parseResult.TokenStream,
services.EngineImportService,
services.VariableService,
services.SchedulingService,
defaultStreamSelector,
services.EngineURI,
services.ConfigSnapshot,
services.PatternNodeFactory,
services.ContextManagementService,
parseResult.Scripts,
services.ExprDeclaredService,
services.TableService);
try
{
ParseHelper.Walk(ast, walker, expression, expressionForErrorMessage);
}
catch (ASTWalkException ex)
{
Log.Debug(".createPattern Error validating expression", ex);
throw new EPStatementException(ex.Message, expression);
}
catch (EPStatementSyntaxException ex)
{
throw;
}
catch (Exception ex)
{
String message = "Error in expression";
Log.Debug(message, ex);
throw new EPStatementException(GetNullableErrortext(message, ex.Message), expression);
}
var walkerStatementSpec = walker.GetStatementSpec();
if (walkerStatementSpec.StreamSpecs.Count > 1)
{
throw new IllegalStateException("Unexpected multiple stream specifications encountered");
}
// Get pattern specification
var patternStreamSpec = (PatternStreamSpecRaw)walkerStatementSpec.StreamSpecs[0];
// Create statement spec, set pattern stream, set wildcard select
var statementSpec = new StatementSpecRaw(SelectClauseStreamSelectorEnum.ISTREAM_ONLY);
statementSpec.StreamSpecs.Add(patternStreamSpec);
statementSpec.SelectClauseSpec.SelectExprList.Clear();
statementSpec.SelectClauseSpec.SelectExprList.Add(new SelectClauseElementWildcard());
statementSpec.Annotations = walkerStatementSpec.Annotations;
statementSpec.ExpressionNoAnnotations = parseResult.ExpressionWithoutAnnotations;
return(statementSpec);
}
