public static CreateIndexDesc Walk(EsperEPL2GrammarParser.CreateIndexExprContext ctx, IDictionary <ITree, ExprNode> astExprNodeMap)
{
var indexName = ctx.n.Text;
var windowName = ctx.w.Text;
var unique = false;
if (ctx.u != null)
{
string ident = ctx.u.Text;
if (ident.ToLowerInvariant().Trim() == "unique")
{
unique = true;
}
else
{
throw ASTWalkException.From("Invalid keyword '" + ident + "' in create-index encountered, expected 'unique'");
}
}
var columns = new List <CreateIndexItem>();
var cols = ctx.createIndexColumnList().createIndexColumn();
foreach (var col in cols)
{
CreateIndexItem item = Walk(col, astExprNodeMap);
columns.Add(item);
}
return(new CreateIndexDesc(unique, indexName, windowName, columns));
}
public static MatchRecognizeSkipEnum ParseSkip(CommonTokenStream tokenStream, EsperEPL2GrammarParser.MatchRecogMatchesAfterSkipContext ctx)
{
if ((!ctx.i1.GetText().ToUpper().Equals("MATCH")) ||
(!ctx.i2.GetText().ToUpper().Equals("SKIP")) ||
(!ctx.i5.GetText().ToUpper().Equals("ROW"))
)
{
throw ASTWalkException.From(Message, tokenStream, ctx);
}
if ((!ctx.i3.GetText().ToUpper().Equals("TO")) &&
(!ctx.i3.GetText().ToUpper().Equals("PAST"))
)
{
throw ASTWalkException.From(Message, tokenStream, ctx);
}
if (ctx.i4.GetText().ToUpper().Equals("LAST"))
{
return(MatchRecognizeSkipEnum.PAST_LAST_ROW);
}
else if (ctx.i4.GetText().ToUpper().Equals("NEXT"))
{
return(MatchRecognizeSkipEnum.TO_NEXT_ROW);
}
else if (ctx.i4.GetText().ToUpper().Equals("CURRENT"))
{
return(MatchRecognizeSkipEnum.TO_CURRENT_ROW);
}
throw ASTWalkException.From(Message);
}
private static Object ParseNumber(IRuleNode number, int factor)
{
var tokenType = GetSingleChildTokenType(number);
if (tokenType == EsperEPL2GrammarLexer.IntegerLiteral)
{
return(ParseIntLongByte(number.GetText(), factor));
}
else if (tokenType == EsperEPL2GrammarLexer.FloatingPointLiteral)
{
var numberText = number.GetText();
if (numberText.EndsWith("m"))
{
return(DecimalValue.ParseString(number.GetText()) * factor);
}
else if (numberText.EndsWith("f") || numberText.EndsWith("F"))
{
return(FloatValue.ParseString(number.GetText()) * factor);
}
else
{
return(DoubleValue.ParseString(number.GetText()) * factor);
}
}
throw ASTWalkException.From("Encountered unrecognized constant", number.GetText());
}
private static Object WalkClassIdent(
EsperEPL2GrammarParser.ClassIdentifierContext ctx,
EngineImportService engineImportService)
{
string enumValueText = ctx.GetText();
Object enumValue;
try
{
enumValue = TypeHelper.ResolveIdentAsEnumConst(enumValueText, engineImportService, true);
}
catch (ExprValidationException)
{
throw ASTWalkException.From(
"Annotation value '" + enumValueText +
"' is not recognized as an enumeration value, please check imports or use a primitive or string type");
}
if (enumValue != null)
{
return(enumValue);
}
throw ASTWalkException.From(
"Annotation enumeration value '" + enumValueText +
"' not recognized as an enumeration class, please check imports or type used");
}
private static ContextDetailCondition GetContextCondition(
EsperEPL2GrammarParser.CreateContextRangePointContext ctx,
IDictionary <ITree, ExprNode> astExprNodeMap,
IDictionary <ITree, EvalFactoryNode> astPatternNodeMap,
PropertyEvalSpec propertyEvalSpec,
bool immediate)
{
if (ctx == null)
{
return(ContextDetailConditionNever.INSTANCE);
}
if (ctx.crontabLimitParameterSet() != null)
{
var crontab = ASTExprHelper.ExprCollectSubNodes(
ctx.crontabLimitParameterSet(), 0, astExprNodeMap);
return(new ContextDetailConditionCrontab(crontab, immediate));
}
else if (ctx.patternInclusionExpression() != null)
{
var evalNode = ASTExprHelper.PatternGetRemoveTopNode(
ctx.patternInclusionExpression(), astPatternNodeMap);
var inclusive = false;
if (ctx.i != null)
{
var ident = ctx.i.Text;
if (ident != null && !ident.ToLowerInvariant().Equals("inclusive"))
{
throw ASTWalkException.From(
"Expected 'inclusive' keyword after '@', found '" + ident + "' instead");
}
inclusive = true;
}
return(new ContextDetailConditionPattern(evalNode, inclusive, immediate));
}
else if (ctx.createContextFilter() != null)
{
var filterSpecRaw =
ASTFilterSpecHelper.WalkFilterSpec(
ctx.createContextFilter().eventFilterExpression(), propertyEvalSpec, astExprNodeMap);
var asName = ctx.createContextFilter().i != null?ctx.createContextFilter().i.Text : null;
if (immediate)
{
throw ASTWalkException.From(
"Invalid use of 'now' with initiated-by stream, this combination is not supported");
}
return(new ContextDetailConditionFilter(filterSpecRaw, asName));
}
else if (ctx.AFTER() != null)
{
var timePeriod =
(ExprTimePeriod)ASTExprHelper.ExprCollectSubNodes(ctx.timePeriod(), 0, astExprNodeMap)[0];
return(new ContextDetailConditionTimePeriod(timePeriod, immediate));
}
else
{
throw new IllegalStateException("Unrecognized child type");
}
}
/// <summary>
/// Validate.
/// </summary>
/// <param name="lowerBounds">is the lower bounds, or null if none supplied</param>
/// <param name="upperBounds">is the upper bounds, or null if none supplied</param>
/// <param name="isAllowLowerZero">true to allow zero value for lower range</param>
/// <returns>
/// true if closed range of constants and the constants are the same value
/// </returns>
/// <throws>ASTWalkException if the AST is incorrect</throws>
public static bool Validate(ExprNode lowerBounds, ExprNode upperBounds, bool isAllowLowerZero)
{
var isConstants = true;
Object constantLower = null;
if (ExprNodeUtility.IsConstantValueExpr(lowerBounds))
{
constantLower = lowerBounds.ExprEvaluator.Evaluate(new EvaluateParams(null, true, null));
if (constantLower == null || !(constantLower.IsNumber()))
{
throw ASTWalkException.From(NumericMessage);
}
}
else
{
isConstants = lowerBounds == null;
}
Object constantUpper = null;
if (ExprNodeUtility.IsConstantValueExpr(upperBounds))
{
constantUpper = upperBounds.ExprEvaluator.Evaluate(new EvaluateParams(null, true, null));
if (constantUpper == null || !(constantUpper.IsNumber()))
{
throw ASTWalkException.From(NumericMessage);
}
}
else
{
isConstants = isConstants && upperBounds == null;
}
if (!isConstants)
{
return(true);
}
if (constantLower != null && constantUpper != null)
{
int lower = constantLower.AsInt();
int upper = constantUpper.AsInt();
if (lower > upper)
{
throw ASTWalkException.From(
"Incorrect range specification, lower bounds value '" + lower +
"' is higher then higher bounds '" + upper + "'");
}
}
VerifyConstant(constantLower, isAllowLowerZero);
VerifyConstant(constantUpper, false);
return(constantLower != null && constantUpper != null && constantLower.Equals(constantUpper));
}
public static int GetAssertTerminatedTokenType(IParseTree child)
{
if (!(child is ITerminalNode))
{
throw ASTWalkException.From("Unexpected exception walking AST, expected terminal node", child.GetText());
}
var term = (ITerminalNode)child;
return(term.Symbol.Type);
}
// Min/Max nodes can be either an aggregate or a per-row function depending on the number or arguments
private static void HandleMinMax(
string ident,
EsperEPL2GrammarParser.LibFunctionArgsContext ctxArgs,
IDictionary <ITree, ExprNode> astExprNodeMap)
{
// Determine min or max
var childNodeText = ident;
MinMaxTypeEnum minMaxTypeEnum;
var filtered = childNodeText.StartsWith("f");
if (childNodeText.ToLowerInvariant().Equals("min") || childNodeText.ToLowerInvariant().Equals("fmin"))
{
minMaxTypeEnum = MinMaxTypeEnum.MIN;
}
else if (childNodeText.ToLowerInvariant().Equals("max") || childNodeText.ToLowerInvariant().Equals("fmax"))
{
minMaxTypeEnum = MinMaxTypeEnum.MAX;
}
else
{
throw ASTWalkException.From("Uncountered unrecognized min or max node '" + ident + "'");
}
var args = Collections.GetEmptyList <ExprNode>();
if (ctxArgs != null && ctxArgs.libFunctionArgItem() != null)
{
args = ASTExprHelper.ExprCollectSubNodes(ctxArgs, 0, astExprNodeMap);
}
var numArgsPositional = ExprAggregateNodeUtil.CountPositionalArgs(args);
var isDistinct = ctxArgs != null && ctxArgs.DISTINCT() != null;
if (numArgsPositional > 1 && isDistinct && !filtered)
{
throw ASTWalkException.From(
"The distinct keyword is not valid in per-row min and max " +
"functions with multiple sub-expressions");
}
ExprNode minMaxNode;
if (!isDistinct && numArgsPositional > 1 && !filtered)
{
// use the row function
minMaxNode = new ExprMinMaxRowNode(minMaxTypeEnum);
}
else
{
// use the aggregation function
minMaxNode = new ExprMinMaxAggrNode(isDistinct, minMaxTypeEnum, filtered, false);
}
minMaxNode.AddChildNodes(args);
astExprNodeMap.Put(ctxArgs, minMaxNode);
}
public static bool ValidateIsPrimitiveArray(IToken p)
{
if (p != null)
{
if (!p.Text.ToLower().Equals("primitive"))
{
throw ASTWalkException.From("Column type keyword '" + p.Text + "' not recognized, expecting '[primitive]'");
}
return(true);
}
return(false);
}
/// <summary>
/// Parse the AST constant node and return Object value.
/// </summary>
/// <param name="node">parse node for which to parse the string value</param>
/// <returns>value matching AST node type</returns>
public static Object Parse(IParseTree node)
{
if (node is ITerminalNode)
{
var terminal = (ITerminalNode)node;
switch (terminal.Symbol.Type)
{
case EsperEPL2GrammarParser.BOOLEAN_TRUE: return(BoolValue.ParseString(terminal.GetText()));
case EsperEPL2GrammarParser.BOOLEAN_FALSE: return(BoolValue.ParseString(terminal.GetText()));
case EsperEPL2GrammarParser.VALUE_NULL: return(null);
default:
throw ASTWalkException.From("Encountered unexpected constant type " + terminal.Symbol.Type, terminal.Symbol);
}
}
else
{
var ruleNode = (IRuleNode)node;
var ruleIndex = ruleNode.RuleContext.RuleIndex;
if (ruleIndex == EsperEPL2GrammarParser.RULE_number)
{
return(ParseNumber(ruleNode, 1));
}
else if (ruleIndex == EsperEPL2GrammarParser.RULE_numberconstant)
{
var number = FindChildRuleByType(ruleNode, EsperEPL2GrammarParser.RULE_number);
if (ruleNode.ChildCount > 1)
{
if (ASTUtil.IsTerminatedOfType(ruleNode.GetChild(0), EsperEPL2GrammarLexer.MINUS))
{
return(ParseNumber(number, -1));
}
return(ParseNumber(number, 1));
}
else
{
return(ParseNumber(number, 1));
}
}
else if (ruleIndex == EsperEPL2GrammarParser.RULE_stringconstant)
{
bool requireUnescape = !IsRegexpNode(node);
return(StringValue.ParseString(node.GetText(), requireUnescape));
}
else if (ruleIndex == EsperEPL2GrammarParser.RULE_constant)
{
return(Parse(ruleNode.GetChild(0)));
}
throw ASTWalkException.From("Encountered unrecognized constant", node.GetText());
}
}
private static bool CheckNow(IToken i)
{
if (i == null)
{
return(false);
}
var ident = i.Text;
if (!ident.ToLowerInvariant().Equals("now"))
{
throw ASTWalkException.From("Expected 'now' keyword after '@', found '" + ident + "' instead");
}
return(true);
}
private static bool CheckNow(IToken i)
{
if (i == null)
{
return(false);
}
String ident = i.Text;
if (ident.ToLower() != "now")
{
throw ASTWalkException.From("Expected 'now' keyword after '@', found '" + ident + "' instead");
}
return(true);
}
public static void RegExCollectAddSubNodes(RowRegexExprNode regexNode, ITree node, IDictionary <ITree, RowRegexExprNode> astRegExNodeMap)
{
if (regexNode == null)
{
throw ASTWalkException.From("Invalid null expression node for '" + ASTUtil.PrintNode(node) + "'");
}
RegExAction action = (exprNode, astRegExNodeMapX, nodeX) => {
astRegExNodeMapX.Remove(nodeX);
regexNode.AddChildNode(exprNode);
};
for (var i = 0; i < node.ChildCount; i++)
{
var childNode = node.GetChild(i);
RegExApplyActionRecursive(childNode, astRegExNodeMap, action);
}
}
public static void ExprCollectAddSingle(ExprNode parentNode, ITree node, IDictionary <ITree, ExprNode> astExprNodeMap)
{
if (parentNode == null)
{
throw ASTWalkException.From("Invalid null expression node for '" + ASTUtil.PrintNode(node) + "'");
}
if (node == null)
{
return;
}
ExprAction action = (exprNodeX, astExprNodeMapX, nodeX) => {
astExprNodeMapX.Remove(nodeX);
parentNode.AddChildNode(exprNodeX);
};
RecursiveFindRemoveChildExprNode(node, astExprNodeMap, action);
}
public static void PatternCollectAddSubnodesAddParentNode(EvalFactoryNode evalNode, ITree node, IDictionary <ITree, EvalFactoryNode> astPatternNodeMap)
{
if (evalNode == null)
{
throw ASTWalkException.From("Invalid null expression node for '" + ASTUtil.PrintNode(node) + "'");
}
for (var i = 0; i < node.ChildCount; i++)
{
var childNode = node.GetChild(i);
var childEvalNode = PatternGetRemoveTopNode(childNode, astPatternNodeMap);
if (childEvalNode != null)
{
evalNode.AddChildNode(childEvalNode);
}
}
astPatternNodeMap.Put(node, evalNode);
}
public static Pair <ExprTableAccessNode, IList <ExprChainedSpec> > CheckTableNameGetLibFunc(
TableService tableService,
EngineImportService engineImportService,
LazyAllocatedMap <ConfigurationPlugInAggregationMultiFunction, PlugInAggregationMultiFunctionFactory> plugInAggregations,
string engineURI,
string classIdent,
IList <ExprChainedSpec> chain)
{
var index = ASTUtil.UnescapedIndexOfDot(classIdent);
// handle special case "table.Keys()" function
if (index == -1)
{
if (tableService.GetTableMetadata(classIdent) == null)
{
return(null); // not a table
}
var funcName = chain[1].Name;
if (funcName.ToLowerInvariant().Equals("keys"))
{
var subchain = chain.SubList(2, chain.Count);
var node = new ExprTableAccessNodeKeys(classIdent);
return(new Pair <ExprTableAccessNode, IList <ExprChainedSpec> >(node, subchain));
}
else
{
throw ASTWalkException.From(
"Invalid use of variable '" + classIdent + "', unrecognized use of function '" + funcName +
"', expected 'keys()'");
}
}
// Handle "table.property" (without the variable[...] syntax since this is ungrouped use)
var tableName = ASTUtil.UnescapeDot(classIdent.Substring(0, index));
if (tableService.GetTableMetadata(tableName) == null)
{
return(null);
}
// this is a table access expression
var sub = classIdent.Substring(index + 1);
return(HandleTable(engineImportService, plugInAggregations, engineURI, tableName, sub, chain));
}
public static string ExpectMayTypeAnno(
EsperEPL2GrammarParser.TypeExpressionAnnotationContext ctx,
CommonTokenStream tokenStream)
{
if (ctx == null)
{
return(null);
}
string annoName = ctx.n.Text;
if (!annoName.ToLowerInvariant().Equals("type"))
{
throw ASTWalkException.From(
"Invalid annotation for property selection, expected 'type' but found '" + annoName + "'",
tokenStream, ctx);
}
return(ctx.v.Text);
}
public static ExprNode ResolvePropertyOrVariableIdentifier(String identifier, VariableService variableService, StatementSpecRaw spec)
{
var metaData = variableService.GetVariableMetaData(identifier);
if (metaData != null)
{
var exprNode = new ExprVariableNodeImpl(metaData, null);
spec.HasVariables = true;
AddVariableReference(spec, metaData.VariableName);
var message = VariableServiceUtil.CheckVariableContextName(spec.OptionalContextName, metaData);
if (message != null)
{
throw ASTWalkException.From(message);
}
return(exprNode);
}
else
{
return(new ExprIdentNodeImpl(identifier));
}
}
public static void ExprCollectAddSubNodes(ExprNode parentNode, ITree node, IDictionary <ITree, ExprNode> astExprNodeMap)
{
if (parentNode == null)
{
throw ASTWalkException.From("Invalid null expression node for '" + ASTUtil.PrintNode(node) + "'");
}
if (node == null)
{
return;
}
ExprAction action = (exprNode, astExprNodeMapX, nodeX) => {
astExprNodeMapX.Remove(nodeX);
parentNode.AddChildNode(exprNode);
};
for (var i = 0; i < node.ChildCount; i++)
{
var childNode = node.GetChild(i);
RecursiveFindRemoveChildExprNode(childNode, astExprNodeMap, action);
}
}
private static void VerifyConstant(Object value, bool isAllowZero)
{
if (value != null)
{
int bound = value.AsInt();
if (isAllowZero)
{
if (bound < 0)
{
throw ASTWalkException.From("Incorrect range specification, a bounds value of negative value is not allowed");
}
}
else
{
if (bound <= 0)
{
throw ASTWalkException.From("Incorrect range specification, a bounds value of zero or negative value is not allowed");
}
}
}
}
public static RowRegexExprRepeatDesc walkOptionalRepeat(EsperEPL2GrammarParser.MatchRecogPatternRepeatContext ctx, IDictionary <ITree, ExprNode> astExprNodeMap)
{
if (ctx == null)
{
return(null);
}
ExprNode e1 = ctx.e1 == null ? null : ASTExprHelper.ExprCollectSubNodes(ctx.e1, 0, astExprNodeMap)[0];
ExprNode e2 = ctx.e2 == null ? null : ASTExprHelper.ExprCollectSubNodes(ctx.e2, 0, astExprNodeMap)[0];
if (ctx.comma == null && ctx.e1 != null)
{
return(new RowRegexExprRepeatDesc(null, null, e1));
}
if (e1 == null && e2 == null)
{
throw ASTWalkException.From("Invalid match-recognize quantifier '" + ctx.GetText() + "', expecting an expression");
}
return(new RowRegexExprRepeatDesc(e1, e2, null));
}
private static MathArithTypeEnum TokenToMathEnum(int token)
{
switch (token)
{
case EsperEPL2GrammarLexer.DIV:
return(MathArithTypeEnum.DIVIDE);
case EsperEPL2GrammarLexer.STAR:
return(MathArithTypeEnum.MULTIPLY);
case EsperEPL2GrammarLexer.PLUS:
return(MathArithTypeEnum.ADD);
case EsperEPL2GrammarLexer.MINUS:
return(MathArithTypeEnum.SUBTRACT);
case EsperEPL2GrammarLexer.MOD:
return(MathArithTypeEnum.MODULO);
default:
throw ASTWalkException.From("Encountered unrecognized math token type " + token);
}
}
/// <summary>
/// Walk an annotation root name or child node (nested annotations).
/// </summary>
/// <param name="node">annotation walk node</param>
/// <returns>annotation descriptor</returns>
/// <throws>com.espertech.esper.epl.parse.ASTWalkException if the walk failed</throws>
public static Object Walk(CommonTokenStream tokenStream, EsperEPL2GrammarParser.JsonvalueContext node)
{
if (node.constant() != null)
{
EsperEPL2GrammarParser.ConstantContext constCtx = node.constant();
if (constCtx.stringconstant() != null)
{
return(ExtractString(constCtx.stringconstant().GetText()));
}
else
{
return(ASTConstantHelper.Parse(constCtx.GetChild(0)));
}
}
else if (node.jsonobject() != null)
{
return(WalkObject(tokenStream, node.jsonobject()));
}
else if (node.jsonarray() != null)
{
return(WalkArray(tokenStream, node.jsonarray()));
}
throw ASTWalkException.From("Encountered unexpected node type in json tree", tokenStream, node);
}
/// <summary>
/// Build an output limit spec from the AST node supplied.
/// </summary>
/// <param name="astExprNodeMap">is the map of current AST tree nodes to their respective expression root node</param>
/// <param name="engineURI">the engine uri</param>
/// <param name="timeProvider">provides time</param>
/// <param name="variableService">provides variable resolution</param>
/// <param name="exprEvaluatorContext">context for expression evaluatiom</param>
/// <returns>output limit spec</returns>
public static OutputLimitSpec BuildOutputLimitSpec(
CommonTokenStream tokenStream,
EsperEPL2GrammarParser.OutputLimitContext ctx,
IDictionary <ITree, ExprNode> astExprNodeMap,
VariableService variableService,
String engineURI,
TimeProvider timeProvider,
ExprEvaluatorContext exprEvaluatorContext)
{
OutputLimitLimitType displayLimit = OutputLimitLimitType.DEFAULT;
if (ctx.k != null)
{
switch (ctx.k.Type)
{
case EsperEPL2GrammarParser.FIRST: displayLimit = OutputLimitLimitType.FIRST; break;
case EsperEPL2GrammarParser.LAST: displayLimit = OutputLimitLimitType.LAST; break;
case EsperEPL2GrammarParser.SNAPSHOT: displayLimit = OutputLimitLimitType.SNAPSHOT; break;
case EsperEPL2GrammarParser.ALL: displayLimit = OutputLimitLimitType.ALL; break;
default: throw ASTWalkException.From("Encountered unrecognized token " + ctx.k.Text, tokenStream, ctx);
}
}
// next is a variable, or time period, or number
String variableName = null;
double? rate = null;
ExprNode whenExpression = null;
IList <ExprNode> crontabScheduleSpec = null;
IList <OnTriggerSetAssignment> thenExpressions = null;
ExprTimePeriod timePeriodExpr = null;
OutputLimitRateType rateType;
ExprNode andAfterTerminateExpr = null;
IList <OnTriggerSetAssignment> andAfterTerminateSetExpressions = null;
if (ctx.t != null)
{
rateType = OutputLimitRateType.TERM;
if (ctx.expression() != null)
{
andAfterTerminateExpr = ASTExprHelper.ExprCollectSubNodes(ctx.expression(), 0, astExprNodeMap)[0];
}
if (ctx.onSetExpr() != null)
{
andAfterTerminateSetExpressions = ASTExprHelper.GetOnTriggerSetAssignments(ctx.onSetExpr().onSetAssignmentList(), astExprNodeMap);
}
}
else if (ctx.wh != null)
{
rateType = OutputLimitRateType.WHEN_EXPRESSION;
whenExpression = ASTExprHelper.ExprCollectSubNodes(ctx.expression(), 0, astExprNodeMap)[0];
if (ctx.onSetExpr() != null)
{
thenExpressions = ASTExprHelper.GetOnTriggerSetAssignments(ctx.onSetExpr().onSetAssignmentList(), astExprNodeMap);
}
}
else if (ctx.at != null)
{
rateType = OutputLimitRateType.CRONTAB;
crontabScheduleSpec = ASTExprHelper.ExprCollectSubNodes(ctx.crontabLimitParameterSet(), 0, astExprNodeMap);
}
else
{
if (ctx.ev != null)
{
rateType = ctx.e != null ? OutputLimitRateType.EVENTS : OutputLimitRateType.TIME_PERIOD;
if (ctx.i != null)
{
variableName = ctx.i.Text;
}
else if (ctx.timePeriod() != null)
{
timePeriodExpr = (ExprTimePeriod)ASTExprHelper.ExprCollectSubNodes(ctx.timePeriod(), 0, astExprNodeMap)[0];
}
else
{
ASTExprHelper.ExprCollectSubNodes(ctx.number(), 0, astExprNodeMap); // remove
rate = Double.Parse(ctx.number().GetText());
}
}
else
{
rateType = OutputLimitRateType.AFTER;
}
}
// get the AFTER time period
ExprTimePeriod afterTimePeriodExpr = null;
int? afterNumberOfEvents = null;
if (ctx.outputLimitAfter() != null)
{
if (ctx.outputLimitAfter().timePeriod() != null)
{
ExprNode expression = ASTExprHelper.ExprCollectSubNodes(ctx.outputLimitAfter(), 0, astExprNodeMap)[0];
afterTimePeriodExpr = (ExprTimePeriod)expression;
}
else
{
Object constant = ASTConstantHelper.Parse(ctx.outputLimitAfter().number());
afterNumberOfEvents = constant.AsInt();
}
}
bool andAfterTerminate = false;
if (ctx.outputLimitAndTerm() != null)
{
andAfterTerminate = true;
if (ctx.outputLimitAndTerm().expression() != null)
{
andAfterTerminateExpr = ASTExprHelper.ExprCollectSubNodes(ctx.outputLimitAndTerm().expression(), 0, astExprNodeMap)[0];
}
if (ctx.outputLimitAndTerm().onSetExpr() != null)
{
andAfterTerminateSetExpressions = ASTExprHelper.GetOnTriggerSetAssignments(ctx.outputLimitAndTerm().onSetExpr().onSetAssignmentList(), astExprNodeMap);
}
}
return(new OutputLimitSpec(rate, variableName, rateType, displayLimit, whenExpression, thenExpressions, crontabScheduleSpec, timePeriodExpr, afterTimePeriodExpr, afterNumberOfEvents, andAfterTerminate, andAfterTerminateExpr, andAfterTerminateSetExpressions));
}
private static ASTLibModel GetModel(EsperEPL2GrammarParser.LibFunctionContext ctx, CommonTokenStream tokenStream)
{
var root = ctx.libFunctionWithClass();
IList <EsperEPL2GrammarParser.LibFunctionNoClassContext> ctxElements = ctx.libFunctionNoClass();
// there are no additional methods
if (ctxElements == null || ctxElements.IsEmpty())
{
var classIdent = root.classIdentifier() == null ? null : ASTUtil.UnescapeClassIdent(root.classIdentifier());
var ele = FromRoot(root);
return(new ASTLibModel(classIdent, Collections.SingletonList(ele)));
}
// add root and chain to just a list of elements
IList <ASTLibModelChainElement> chainElements = new List <ASTLibModelChainElement>(ctxElements.Count + 1);
var rootElement = FromRoot(root);
chainElements.Add(rootElement);
foreach (var chainedCtx in ctxElements)
{
var chainedElement = new ASTLibModelChainElement(chainedCtx.funcIdentChained().GetText(), chainedCtx.libFunctionArgs(), chainedCtx.l != null);
chainElements.Add(chainedElement);
}
// determine/remove the list of chain elements, from the start and uninterrupted, that don't have parameters (no parenthesis 'l')
IList <ASTLibModelChainElement> chainElementsNoArgs = new List <ASTLibModelChainElement>(chainElements.Count);
for (int ii = 0; ii < chainElements.Count; ii++)
{
var element = chainElements[ii];
if (!element.HasLeftParen)
{
// has no parenthesis, therefore part of class identifier
chainElementsNoArgs.Add(element);
chainElements.RemoveAt(ii--);
}
else
{
// else stop here
break;
}
}
// write the class identifier including the no-arg chain elements
var classIdentBuf = new StringBuilder();
var delimiter = "";
if (root.classIdentifier() != null)
{
classIdentBuf.Append(ASTUtil.UnescapeClassIdent(root.classIdentifier()));
delimiter = ".";
}
foreach (var noarg in chainElementsNoArgs)
{
classIdentBuf.Append(delimiter);
classIdentBuf.Append(noarg.FuncName);
delimiter = ".";
}
if (chainElements.IsEmpty())
{
// would this be an event property, but then that is handled greedily by parser
throw ASTWalkException.From("Encountered unrecognized lib function call", tokenStream, ctx);
}
// class ident can be null if empty
var classIdentifierString = classIdentBuf.ToString();
var classIdentifier = classIdentifierString.Length > 0 ? classIdentifierString : null;
return(new ASTLibModel(classIdentifier, chainElements));
}
private static ASTWalkException GetException()
{
return(ASTWalkException.From("Inconsistent use of substitution parameters, expecting all substitutions to either all provide a name or provide no name"));
}
public static Pair <ExpressionDeclItem, ExpressionScriptProvided> WalkExpressionDecl(
EsperEPL2GrammarParser.ExpressionDeclContext ctx,
IList <String> scriptBodies,
IDictionary <ITree, ExprNode> astExprNodeMap,
CommonTokenStream tokenStream)
{
var name = ctx.name.Text;
if (ctx.alias != null)
{
if (ctx.alias.Text.ToLower().Trim() != "alias")
{
throw ASTWalkException.From("For expression alias '" + name + "' expecting 'alias' keyword but received '" + ctx.alias.Text + "'");
}
if (ctx.columnList() != null)
{
throw ASTWalkException.From("For expression alias '" + name + "' expecting no parameters but received '" + tokenStream.GetText(ctx.columnList()) + "'");
}
if (ctx.expressionDef() != null && ctx.expressionDef().expressionLambdaDecl() != null)
{
throw ASTWalkException.From("For expression alias '" + name + "' expecting an expression without parameters but received '" + tokenStream.GetText(ctx.expressionDef().expressionLambdaDecl()) + "'");
}
if (ctx.expressionDef().stringconstant() != null)
{
throw ASTWalkException.From("For expression alias '" + name + "' expecting an expression but received a script");
}
var exprNode = ASTExprHelper.ExprCollectSubNodes(ctx, 0, astExprNodeMap)[0];
var alias = ctx.name.Text;
var decl = new ExpressionDeclItem(alias, Collections.GetEmptyList <String>(), exprNode, true);
return(new Pair <ExpressionDeclItem, ExpressionScriptProvided>(decl, null));
}
if (ctx.expressionDef().stringconstant() != null)
{
var expressionText = scriptBodies[0];
scriptBodies.RemoveAt(0);
var parameters = ASTUtil.GetIdentList(ctx.columnList());
var optionalReturnType = ctx.classIdentifier() == null
? null
: ASTUtil.UnescapeClassIdent(ctx.classIdentifier());
var optionalReturnTypeArray = ctx.array != null;
var optionalDialect = ctx.expressionDialect() == null ? null : ctx.expressionDialect().d.Text;
var script = new ExpressionScriptProvided(
name, expressionText, parameters,
optionalReturnType, optionalReturnTypeArray, optionalDialect);
return(new Pair <ExpressionDeclItem, ExpressionScriptProvided>(null, script));
}
var ctxexpr = ctx.expressionDef();
var inner = ASTExprHelper.ExprCollectSubNodes(ctxexpr.expression(), 0, astExprNodeMap)[0];
var parametersNames = Collections.GetEmptyList <string>();
var lambdactx = ctxexpr.expressionLambdaDecl();
if (ctxexpr.expressionLambdaDecl() != null)
{
parametersNames = ASTLibFunctionHelper.GetLambdaGoesParams(lambdactx);
}
var expr = new ExpressionDeclItem(name, parametersNames, inner, false);
return(new Pair <ExpressionDeclItem, ExpressionScriptProvided>(expr, null));
}
private static CreateTableColumn GetColumn(EsperEPL2GrammarParser.CreateTableColumnContext ctx, IDictionary <ITree, ExprNode> astExprNodeMap, EngineImportService engineImportService)
{
string columnName = ctx.n.Text;
ExprNode optExpression = null;
if (ctx.builtinFunc() != null || ctx.libFunction() != null)
{
optExpression = ASTExprHelper.ExprCollectSubNodes(ctx, 0, astExprNodeMap)[0];
}
string optTypeName = null;
bool? optTypeIsArray = null;
bool? optTypeIsPrimitiveArray = null;
if (ctx.createTableColumnPlain() != null)
{
EsperEPL2GrammarParser.CreateTableColumnPlainContext sub = ctx.createTableColumnPlain();
optTypeName = ASTUtil.UnescapeClassIdent(sub.classIdentifier());
optTypeIsArray = sub.b != null;
optTypeIsPrimitiveArray = ASTCreateSchemaHelper.ValidateIsPrimitiveArray(sub.p);
}
bool primaryKey = false;
if (ctx.p != null)
{
if (ctx.p.Text.ToLower() != "primary")
{
throw ASTWalkException.From("Invalid keyword '" + ctx.p.Text + "' encountered, expected 'primary key'");
}
if (ctx.k.Text.ToLower() != "key")
{
throw ASTWalkException.From("Invalid keyword '" + ctx.k.Text + "' encountered, expected 'primary key'");
}
primaryKey = true;
}
IList <AnnotationDesc> annots = Collections.GetEmptyList <AnnotationDesc>();
if (ctx.annotationEnum() != null)
{
annots = new List <AnnotationDesc>(ctx.annotationEnum().Length);
foreach (EsperEPL2GrammarParser.AnnotationEnumContext anctx in ctx.annotationEnum())
{
annots.Add(ASTAnnotationHelper.Walk(anctx, engineImportService));
}
}
if (ctx.propertyExpressionAnnotation() != null)
{
if (annots.IsEmpty())
{
annots = new List <AnnotationDesc>();
}
foreach (EsperEPL2GrammarParser.PropertyExpressionAnnotationContext anno in ctx.propertyExpressionAnnotation())
{
annots.Add(new AnnotationDesc(anno.n.Text, anno.v.Text));
}
}
return(new CreateTableColumn(columnName, optExpression, optTypeName, optTypeIsArray, optTypeIsPrimitiveArray, annots, primaryKey));
}
private static ContextDetail WalkChoice(EsperEPL2GrammarParser.CreateContextChoiceContext ctx, IDictionary <ITree, ExprNode> astExprNodeMap, IDictionary <ITree, EvalFactoryNode> astPatternNodeMap, PropertyEvalSpec propertyEvalSpec, FilterSpecRaw filterSpec)
{
// temporal fixed (start+end) and overlapping (initiated/terminated)
if (ctx.START() != null || ctx.INITIATED() != null)
{
ExprNode[] distinctExpressions = null;
if (ctx.createContextDistinct() != null)
{
if (ctx.createContextDistinct().expressionList() == null)
{
distinctExpressions = new ExprNode[0];
}
else
{
distinctExpressions = ASTExprHelper.ExprCollectSubNodesPerNode(ctx.createContextDistinct().expressionList().expression(), astExprNodeMap);
}
}
ContextDetailCondition startEndpoint;
if (ctx.START() != null)
{
bool immediate = CheckNow(ctx.i);
if (immediate)
{
startEndpoint = new ContextDetailConditionImmediate();
}
else
{
startEndpoint = GetContextCondition(ctx.r1, astExprNodeMap, astPatternNodeMap, propertyEvalSpec, false);
}
}
else
{
bool immediate = CheckNow(ctx.i);
startEndpoint = GetContextCondition(ctx.r1, astExprNodeMap, astPatternNodeMap, propertyEvalSpec, immediate);
}
bool overlapping = ctx.INITIATED() != null;
ContextDetailCondition endEndpoint = GetContextCondition(ctx.r2, astExprNodeMap, astPatternNodeMap, propertyEvalSpec, false);
return(new ContextDetailInitiatedTerminated(startEndpoint, endEndpoint, overlapping, distinctExpressions));
}
// partitioned
if (ctx.PARTITION() != null)
{
IList <EsperEPL2GrammarParser.CreateContextPartitionItemContext> partitions = ctx.createContextPartitionItem();
IList <ContextDetailPartitionItem> rawSpecs = new List <ContextDetailPartitionItem>();
foreach (EsperEPL2GrammarParser.CreateContextPartitionItemContext partition in partitions)
{
filterSpec = ASTFilterSpecHelper.WalkFilterSpec(partition.eventFilterExpression(), propertyEvalSpec, astExprNodeMap);
propertyEvalSpec = null;
IList <String> propertyNames = new List <String>();
IList <EsperEPL2GrammarParser.EventPropertyContext> properties = partition.eventProperty();
foreach (EsperEPL2GrammarParser.EventPropertyContext property in properties)
{
String propertyName = ASTUtil.GetPropertyName(property, 0);
propertyNames.Add(propertyName);
}
ASTExprHelper.ExprCollectSubNodes(partition, 0, astExprNodeMap); // remove expressions
rawSpecs.Add(new ContextDetailPartitionItem(filterSpec, propertyNames));
}
return(new ContextDetailPartitioned(rawSpecs));
}
// hash
else if (ctx.COALESCE() != null)
{
IList <EsperEPL2GrammarParser.CreateContextCoalesceItemContext> coalesces = ctx.createContextCoalesceItem();
IList <ContextDetailHashItem> rawSpecs = new List <ContextDetailHashItem>(coalesces.Count);
foreach (EsperEPL2GrammarParser.CreateContextCoalesceItemContext coalesce in coalesces)
{
ExprChainedSpec func = ASTLibFunctionHelper.GetLibFunctionChainSpec(coalesce.libFunctionNoClass(), astExprNodeMap);
filterSpec = ASTFilterSpecHelper.WalkFilterSpec(coalesce.eventFilterExpression(), propertyEvalSpec, astExprNodeMap);
propertyEvalSpec = null;
rawSpecs.Add(new ContextDetailHashItem(func, filterSpec));
}
String granularity = ctx.g.Text;
if (!granularity.ToLower().Equals("granularity"))
{
throw ASTWalkException.From("Expected 'granularity' keyword after list of coalesce items, found '" + granularity + "' instead");
}
var num = ASTConstantHelper.Parse(ctx.number());
String preallocateStr = ctx.p != null ? ctx.p.Text : null;
if (preallocateStr != null && !preallocateStr.ToLower().Equals("preallocate"))
{
throw ASTWalkException.From("Expected 'preallocate' keyword after list of coalesce items, found '" + preallocateStr + "' instead");
}
if (!num.GetType().IsNumericNonFP() || num.GetType().GetBoxedType() == typeof(long?))
{
throw ASTWalkException.From("Granularity provided must be an int-type number, received " + num.GetType() + " instead");
}
return(new ContextDetailHash(rawSpecs, num.AsInt(), preallocateStr != null));
}
// categorized
if (ctx.createContextGroupItem() != null)
{
IList <EsperEPL2GrammarParser.CreateContextGroupItemContext> grps = ctx.createContextGroupItem();
IList <ContextDetailCategoryItem> items = new List <ContextDetailCategoryItem>();
foreach (EsperEPL2GrammarParser.CreateContextGroupItemContext grp in grps)
{
ExprNode exprNode = ASTExprHelper.ExprCollectSubNodes(grp, 0, astExprNodeMap)[0];
String name = grp.i.Text;
items.Add(new ContextDetailCategoryItem(exprNode, name));
}
filterSpec = ASTFilterSpecHelper.WalkFilterSpec(ctx.eventFilterExpression(), propertyEvalSpec, astExprNodeMap);
return(new ContextDetailCategory(items, filterSpec));
}
throw new IllegalStateException("Unrecognized context detail type");
}
