private static CreateIndexItem Walk(EsperEPL2GrammarParser.CreateIndexColumnContext col, IDictionary <ITree, ExprNode> astExprNodeMap) { var expressions = Collections.GetEmptyList <ExprNode>(); if (col.i != null) { expressions = ASTExprHelper.ExprCollectSubNodes(col.i, 0, astExprNodeMap); } else if (col.expression() != null) { expressions = ASTExprHelper.ExprCollectSubNodes(col.expression(), 0, astExprNodeMap); } var type = CreateIndexType.HASH.GetNameInvariant(); if (col.t != null) { type = col.t.Text; } var parameters = Collections.GetEmptyList <ExprNode>(); if (col.p != null) { parameters = ASTExprHelper.ExprCollectSubNodes(col.p, 0, astExprNodeMap); } return(new CreateIndexItem(expressions, type, parameters)); }
/// <summary> /// Returns the list of set-variable assignments under the given node. /// </summary> /// <param name="astExprNodeMap">map of AST to expression</param> /// <returns>list of assignments</returns> internal static IList <OnTriggerSetAssignment> GetOnTriggerSetAssignments(EsperEPL2GrammarParser.OnSetAssignmentListContext ctx, IDictionary <ITree, ExprNode> astExprNodeMap) { if (ctx == null || ctx.onSetAssignment().IsEmpty()) { return(Collections.GetEmptyList <OnTriggerSetAssignment>()); } IList <EsperEPL2GrammarParser.OnSetAssignmentContext> ctxs = ctx.onSetAssignment(); IList <OnTriggerSetAssignment> assignments = new List <OnTriggerSetAssignment>(ctx.onSetAssignment().Length); foreach (var assign in ctxs) { ExprNode childEvalNode; if (assign.eventProperty() != null) { var prop = ASTExprHelper.ExprCollectSubNodes(assign.eventProperty(), 0, astExprNodeMap)[0]; var value = ASTExprHelper.ExprCollectSubNodes(assign.expression(), 0, astExprNodeMap)[0]; ExprEqualsNode equals = new ExprEqualsNodeImpl(false, false); equals.AddChildNode(prop); equals.AddChildNode(value); childEvalNode = equals; } else { childEvalNode = ASTExprHelper.ExprCollectSubNodes(assign, 0, astExprNodeMap)[0]; } assignments.Add(new OnTriggerSetAssignment(childEvalNode)); } return(assignments); }
public static ExprNode MathGetExpr(IParseTree ctx, IDictionary <ITree, ExprNode> astExprNodeMap, ConfigurationInformation configurationInformation) { var count = 1; var @base = ASTExprHelper.ExprCollectSubNodes(ctx.GetChild(0), 0, astExprNodeMap)[0]; while (true) { int token = ASTUtil.GetAssertTerminatedTokenType(ctx.GetChild(count)); var mathArithTypeEnum = TokenToMathEnum(token); var right = ASTExprHelper.ExprCollectSubNodes(ctx.GetChild(count + 1), 0, astExprNodeMap)[0]; var math = new ExprMathNode(mathArithTypeEnum, configurationInformation.EngineDefaults.ExpressionConfig.IsIntegerDivision, configurationInformation.EngineDefaults.ExpressionConfig.IsDivisionByZeroReturnsNull); math.AddChildNode(@base); math.AddChildNode(right); @base = math; count += 2; if (count >= ctx.ChildCount) { break; } } return(@base); }
public static IList <ExprNode> GetExprNodesLibFunc(EsperEPL2GrammarParser.LibFunctionArgsContext ctx, IDictionary <ITree, ExprNode> astExprNodeMap) { if (ctx == null) { return(Collections.GetEmptyList <ExprNode>()); } IList <EsperEPL2GrammarParser.LibFunctionArgItemContext> args = ctx.libFunctionArgItem(); if (args == null || args.IsEmpty()) { return(Collections.GetEmptyList <ExprNode>()); } IList <ExprNode> parameters = new List <ExprNode>(args.Count); foreach (var arg in args) { if (arg.expressionLambdaDecl() != null) { var lambdaparams = GetLambdaGoesParams(arg.expressionLambdaDecl()); var goes = new ExprLambdaGoesNode(lambdaparams); var lambdaExpr = ASTExprHelper.ExprCollectSubNodes(arg.expressionWithNamed(), 0, astExprNodeMap)[0]; goes.AddChildNode(lambdaExpr); parameters.Add(goes); } else { var parameter = ASTExprHelper.ExprCollectSubNodes(arg.expressionWithNamed(), 0, astExprNodeMap)[0]; parameters.Add(parameter); } } return(parameters); }
public static FilterSpecRaw WalkFilterSpec(EsperEPL2GrammarParser.EventFilterExpressionContext ctx, PropertyEvalSpec propertyEvalSpec, IDictionary <ITree, ExprNode> astExprNodeMap) { var eventName = ASTUtil.UnescapeClassIdent(ctx.classIdentifier()); var exprNodes = ctx.expressionList() != null?ASTExprHelper.ExprCollectSubNodes(ctx.expressionList(), 0, astExprNodeMap) : new List <ExprNode>(1); return(new FilterSpecRaw(eventName, exprNodes, propertyEvalSpec)); }
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"); } }
public static void AddOptionalSimpleProperty(ExprNode exprNode, IToken token, VariableService variableService, StatementSpecRaw spec) { if (token == null) { return; } var node = ASTExprHelper.ResolvePropertyOrVariableIdentifier(token.Text, variableService, spec); exprNode.AddChildNode(node); }
// 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); }
private static GroupByClauseElement WalkCombinable( EsperEPL2GrammarParser.GroupByCombinableExprContext ctx, IDictionary <ITree, ExprNode> astExprNodeMap) { if (ctx.e1 != null && ctx.LPAREN() == null) { ExprNode expr = ASTExprHelper.ExprCollectSubNodes(ctx.e1, 0, astExprNodeMap)[0]; return(new GroupByClauseElementExpr(expr)); } IList <ExprNode> combined = ASTExprHelper.ExprCollectSubNodes(ctx, 0, astExprNodeMap); return(new GroupByClauseElementCombinedExpr(combined)); }
private static GroupByClauseElement WalkChoice( EsperEPL2GrammarParser.GroupByListChoiceContext choice, IDictionary <ITree, ExprNode> astExprNodeMap) { if (choice.e1 != null) { ExprNode expr = ASTExprHelper.ExprCollectSubNodes(choice.e1, 0, astExprNodeMap)[0]; return(new GroupByClauseElementExpr(expr)); } if (choice.groupByCubeOrRollup() != null) { return(WalkCubeOrRollup(choice.groupByCubeOrRollup(), astExprNodeMap)); } return(WalkGroupingSets(choice.groupByGroupingSets().groupBySetsChoice(), astExprNodeMap)); }
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)); }
/// <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 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"); }
public static ExprTimePeriod TimePeriodGetExprAllParams(EsperEPL2GrammarParser.TimePeriodContext ctx, IDictionary <ITree, ExprNode> astExprNodeMap, VariableService variableService, StatementSpecRaw spec, ConfigurationInformation config) { var nodes = new ExprNode[8]; for (var i = 0; i < ctx.ChildCount; i++) { var unitRoot = ctx.GetChild(i); ExprNode valueExpr; if (ASTUtil.IsTerminatedOfType(unitRoot.GetChild(0), EsperEPL2GrammarLexer.IDENT)) { var ident = unitRoot.GetChild(0).GetText(); valueExpr = ASTExprHelper.ResolvePropertyOrVariableIdentifier(ident, variableService, spec); } else { var @ref = new Atomic <ExprNode>(); ExprAction action = (exprNode, astExprNodeMapX, nodeX) => { astExprNodeMapX.Remove(nodeX); @ref.Set(exprNode); }; ASTExprHelper.RecursiveFindRemoveChildExprNode(unitRoot.GetChild(0), astExprNodeMap, action); valueExpr = @ref.Get(); } if (ASTUtil.GetRuleIndexIfProvided(unitRoot) == EsperEPL2GrammarParser.RULE_millisecondPart) { nodes[7] = valueExpr; } if (ASTUtil.GetRuleIndexIfProvided(unitRoot) == EsperEPL2GrammarParser.RULE_secondPart) { nodes[6] = valueExpr; } if (ASTUtil.GetRuleIndexIfProvided(unitRoot) == EsperEPL2GrammarParser.RULE_minutePart) { nodes[5] = valueExpr; } if (ASTUtil.GetRuleIndexIfProvided(unitRoot) == EsperEPL2GrammarParser.RULE_hourPart) { nodes[4] = valueExpr; } if (ASTUtil.GetRuleIndexIfProvided(unitRoot) == EsperEPL2GrammarParser.RULE_dayPart) { nodes[3] = valueExpr; } if (ASTUtil.GetRuleIndexIfProvided(unitRoot) == EsperEPL2GrammarParser.RULE_weekPart) { nodes[2] = valueExpr; } if (ASTUtil.GetRuleIndexIfProvided(unitRoot) == EsperEPL2GrammarParser.RULE_monthPart) { nodes[1] = valueExpr; } if (ASTUtil.GetRuleIndexIfProvided(unitRoot) == EsperEPL2GrammarParser.RULE_yearPart) { nodes[0] = valueExpr; } } ExprTimePeriod timeNode = new ExprTimePeriodImpl(config.EngineDefaults.ExpressionConfig.TimeZone, nodes[0] != null, nodes[1] != null, nodes[2] != null, nodes[3] != null, nodes[4] != null, nodes[5] != null, nodes[6] != null, nodes[7] != null); if (nodes[0] != null) { timeNode.AddChildNode(nodes[0]); } if (nodes[1] != null) { timeNode.AddChildNode(nodes[1]); } if (nodes[2] != null) { timeNode.AddChildNode(nodes[2]); } if (nodes[3] != null) { timeNode.AddChildNode(nodes[3]); } if (nodes[4] != null) { timeNode.AddChildNode(nodes[4]); } if (nodes[5] != null) { timeNode.AddChildNode(nodes[5]); } if (nodes[6] != null) { timeNode.AddChildNode(nodes[6]); } if (nodes[7] != null) { timeNode.AddChildNode(nodes[7]); } return(timeNode); }
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)); }
public static void HandleLibFunc( CommonTokenStream tokenStream, EsperEPL2GrammarParser.LibFunctionContext ctx, ConfigurationInformation configurationInformation, EngineImportService engineImportService, IDictionary <ITree, ExprNode> astExprNodeMap, LazyAllocatedMap <ConfigurationPlugInAggregationMultiFunction, PlugInAggregationMultiFunctionFactory> plugInAggregations, string engineURI, ExpressionDeclDesc expressionDeclarations, ExprDeclaredService exprDeclaredService, IList <ExpressionScriptProvided> scriptExpressions, ContextDescriptor contextDescriptor, TableService tableService, StatementSpecRaw statementSpec, VariableService variableService) { var model = GetModel(ctx, tokenStream); var duckType = configurationInformation.EngineDefaults.ExpressionConfig.IsDuckTyping; var udfCache = configurationInformation.EngineDefaults.ExpressionConfig.IsUdfCache; // handle "some.xyz(...)" or "some.other.xyz(...)" if (model.ChainElements.Count == 1 && model.OptionalClassIdent != null && ASTTableExprHelper.CheckTableNameGetExprForProperty(tableService, model.OptionalClassIdent) == null) { var chainSpec = GetLibFunctionChainSpec(model.ChainElements[0], astExprNodeMap); var declaredNodeX = ExprDeclaredHelper.GetExistsDeclaredExpr(model.OptionalClassIdent, Collections.GetEmptyList <ExprNode>(), expressionDeclarations.Expressions, exprDeclaredService, contextDescriptor); if (declaredNodeX != null) { ExprNode exprNode = new ExprDotNode(Collections.SingletonList(chainSpec), duckType, udfCache); exprNode.AddChildNode(declaredNodeX); ASTExprHelper.ExprCollectAddSubNodesAddParentNode(exprNode, ctx, astExprNodeMap); return; } IList <ExprChainedSpec> chainX = new List <ExprChainedSpec>(2); chainX.Add(new ExprChainedSpec(model.OptionalClassIdent, Collections.GetEmptyList <ExprNode>(), true)); chainX.Add(chainSpec); var dotNodeX = new ExprDotNode(chainX, configurationInformation.EngineDefaults.ExpressionConfig.IsDuckTyping, configurationInformation.EngineDefaults.ExpressionConfig.IsUdfCache); if (dotNodeX.IsVariableOp(variableService)) { statementSpec.HasVariables = true; } ASTExprHelper.ExprCollectAddSubNodesAddParentNode(dotNodeX, ctx, astExprNodeMap); return; } // try additional built-in single-row function ExprNode singleRowExtNode = engineImportService.ResolveSingleRowExtendedBuiltin(model.ChainElements[0].FuncName); if (singleRowExtNode != null) { if (model.ChainElements.Count == 1) { ASTExprHelper.ExprCollectAddSubNodesAddParentNode(singleRowExtNode, ctx, astExprNodeMap); return; } var spec = new List <ExprChainedSpec>(); EsperEPL2GrammarParser.LibFunctionArgsContext firstArgs = model.ChainElements[0].Args; var childExpressions = ASTLibFunctionHelper.GetExprNodesLibFunc(firstArgs, astExprNodeMap); singleRowExtNode.AddChildNodes(childExpressions); AddChainRemainderFromOffset(model.ChainElements, 1, spec, astExprNodeMap); var dotNodeX = new ExprDotNode(spec, configurationInformation.EngineDefaults.ExpressionConfig.IsDuckTyping, configurationInformation.EngineDefaults.ExpressionConfig.IsUdfCache); dotNodeX.AddChildNode(singleRowExtNode); ASTExprHelper.ExprCollectAddSubNodesAddParentNode(dotNodeX, ctx, astExprNodeMap); return; } // try plug-in single-row function try { var firstFunctionX = model.ChainElements[0].FuncName; var firstFunctionIsProperty = !model.ChainElements[0].HasLeftParen; var classMethodPair = engineImportService.ResolveSingleRow(firstFunctionX); IList <ExprChainedSpec> spec = new List <ExprChainedSpec>(); var firstArgs = model.ChainElements[0].Args; var childExpressions = ASTLibFunctionHelper.GetExprNodesLibFunc(firstArgs, astExprNodeMap); spec.Add(new ExprChainedSpec(classMethodPair.Second.MethodName, childExpressions, firstFunctionIsProperty)); AddChainRemainderFromOffset(model.ChainElements, 1, spec, astExprNodeMap); var plugin = new ExprPlugInSingleRowNode(firstFunctionX, classMethodPair.First, spec, classMethodPair.Second); ASTExprHelper.ExprCollectAddSubNodesAddParentNode(plugin, ctx, astExprNodeMap); return; } catch (EngineImportUndefinedException e) { // Not an single-row function } catch (EngineImportException e) { throw new IllegalStateException("Error resolving single-row function: " + e.Message, e); } // special case for min,max var firstFunction = model.ChainElements[0].FuncName; if ((firstFunction.ToLower().Equals("max")) || (firstFunction.ToLower().Equals("min")) || (firstFunction.ToLower().Equals("fmax")) || (firstFunction.ToLower().Equals("fmin"))) { var firstArgs = model.ChainElements[0].Args; HandleMinMax(firstFunction, firstArgs, astExprNodeMap); return; } // obtain chain with actual expressions IList <ExprChainedSpec> chain = new List <ExprChainedSpec>(); AddChainRemainderFromOffset(model.ChainElements, 0, chain, astExprNodeMap); // add chain element for class info, if any var distinct = model.ChainElements[0].Args != null && model.ChainElements[0].Args.DISTINCT() != null; if (model.OptionalClassIdent != null) { chain.Insert(0, new ExprChainedSpec(model.OptionalClassIdent, Collections.GetEmptyList <ExprNode>(), true)); distinct = false; } firstFunction = chain[0].Name; // try plug-in aggregation function var aggregationNode = ASTAggregationHelper.TryResolveAsAggregation(engineImportService, distinct, firstFunction, plugInAggregations, engineURI); if (aggregationNode != null) { var firstSpec = chain.Pluck(0); aggregationNode.AddChildNodes(firstSpec.Parameters); ExprNode exprNode; if (chain.IsEmpty()) { exprNode = aggregationNode; } else { exprNode = new ExprDotNode(chain, duckType, udfCache); exprNode.AddChildNode(aggregationNode); } ASTExprHelper.ExprCollectAddSubNodesAddParentNode(exprNode, ctx, astExprNodeMap); return; } // try declared or alias expression var declaredNode = ExprDeclaredHelper.GetExistsDeclaredExpr(firstFunction, chain[0].Parameters, expressionDeclarations.Expressions, exprDeclaredService, contextDescriptor); if (declaredNode != null) { chain.RemoveAt(0); ExprNode exprNode; if (chain.IsEmpty()) { exprNode = declaredNode; } else { exprNode = new ExprDotNode(chain, duckType, udfCache); exprNode.AddChildNode(declaredNode); } ASTExprHelper.ExprCollectAddSubNodesAddParentNode(exprNode, ctx, astExprNodeMap); return; } // try script var scriptNode = ExprDeclaredHelper.GetExistsScript(configurationInformation.EngineDefaults.ScriptsConfig.DefaultDialect, chain[0].Name, chain[0].Parameters, scriptExpressions, exprDeclaredService); if (scriptNode != null) { chain.RemoveAt(0); ExprNode exprNode; if (chain.IsEmpty()) { exprNode = scriptNode; } else { exprNode = new ExprDotNode(chain, duckType, udfCache); exprNode.AddChildNode(scriptNode); } ASTExprHelper.ExprCollectAddSubNodesAddParentNode(exprNode, ctx, astExprNodeMap); return; } // try table var tableInfo = ASTTableExprHelper.CheckTableNameGetLibFunc(tableService, engineImportService, plugInAggregations, engineURI, firstFunction, chain); if (tableInfo != null) { ASTTableExprHelper.AddTableExpressionReference(statementSpec, tableInfo.First); chain = tableInfo.Second; ExprNode exprNode; if (chain.IsEmpty()) { exprNode = tableInfo.First; } else { exprNode = new ExprDotNode(chain, duckType, udfCache); exprNode.AddChildNode(tableInfo.First); } ASTExprHelper.ExprCollectAddSubNodesAddParentNode(exprNode, ctx, astExprNodeMap); return; } // Could be a mapped property with an expression-parameter "mapped(expr)" or array property with an expression-parameter "array(expr)". ExprDotNode dotNode; if (chain.Count == 1) { dotNode = new ExprDotNode(chain, false, false); } else { dotNode = new ExprDotNode(chain, duckType, udfCache); } ASTExprHelper.ExprCollectAddSubNodesAddParentNode(dotNode, ctx, astExprNodeMap); }
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)); }