public static void AddEndpointTypes( ContextSpecCondition endpoint, IDictionary<string, object> properties, ISet<string> allTags) { if (endpoint is ContextSpecConditionFilter) { var filter = (ContextSpecConditionFilter) endpoint; if (filter.OptionalFilterAsName != null) { allTags.Add(filter.OptionalFilterAsName); properties.Put(filter.OptionalFilterAsName, filter.FilterSpecCompiled.FilterForEventType); } } if (endpoint is ContextSpecConditionPattern) { var pattern = (ContextSpecConditionPattern) endpoint; foreach (var entry in pattern.PatternCompiled.TaggedEventTypes) { if (properties.ContainsKey(entry.Key) && !properties.Get(entry.Key).Equals(entry.Value.First)) { throw new ExprValidationException( "The stream or tag name '" + entry.Key + "' is already declared"); } allTags.Add(entry.Key); properties.Put(entry.Key, entry.Value.First); } } }
public ContextSpecKeyed( IList<ContextSpecKeyedItem> items, IList<ContextSpecConditionFilter> optionalInit, ContextSpecCondition optionalTermination) { Items = items; OptionalInit = optionalInit; OptionalTermination = optionalTermination; }
internal ContextDetailMatchPair( ContextSpecCondition condition, MatchEventSpec matches, ISet<string> allTags) { Condition = condition; Matches = matches; AllTags = allTags; }
private static void CollectExpressions( IList<ExprNode> expressions, ContextSpecCondition endpoint) { if (endpoint is ContextSpecConditionCrontab crontab) { foreach (var crontabItem in crontab.Crontabs) { expressions.AddAll(crontabItem); } } }
internal ContextDetailMatchPair( ContextSpecCondition condition, MatchEventSpec matches, ISet<string> allTags, IList<StmtClassForgeableFactory> additionalForgeables) { Condition = condition; Matches = matches; AllTags = allTags; AdditionalForgeables = additionalForgeables; }
public ContextSpecInitiatedTerminated( ContextSpecCondition startCondition, ContextSpecCondition endCondition, bool overlapping, ExprNode[] distinctExpressions) { StartCondition = startCondition; EndCondition = endCondition; IsOverlapping = overlapping; DistinctExpressions = distinctExpressions; }
private static ContextSpec WalkChoice( EsperEPL2GrammarParser.CreateContextChoiceContext ctx, IDictionary<ITree, ExprNode> astExprNodeMap, IDictionary<ITree, EvalForgeNode> astPatternNodeMap, PropertyEvalSpec propertyEvalSpec) { // 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 = ExprNodeUtilityQuery.EMPTY_EXPR_ARRAY; } else { distinctExpressions = ASTExprHelper.ExprCollectSubNodesPerNode( ctx.createContextDistinct().expressionList().expression(), astExprNodeMap); } } ContextSpecCondition startEndpoint; if (ctx.START() != null) { var immediate = CheckNow(ctx.i); if (immediate) { startEndpoint = ContextSpecConditionImmediate.INSTANCE; } else { startEndpoint = GetContextCondition(ctx.r1, astExprNodeMap, astPatternNodeMap, propertyEvalSpec, false); } } else { var immediate = CheckNow(ctx.i); startEndpoint = GetContextCondition(ctx.r1, astExprNodeMap, astPatternNodeMap, propertyEvalSpec, immediate); } var overlapping = ctx.INITIATED() != null; var endEndpoint = GetContextCondition(ctx.r2, astExprNodeMap, astPatternNodeMap, propertyEvalSpec, false); return new ContextSpecInitiatedTerminated(startEndpoint, endEndpoint, overlapping, distinctExpressions); } // partitioned if (ctx.PARTITION() != null) { IList<EsperEPL2GrammarParser.CreateContextPartitionItemContext> partitions = ctx.createContextPartitionItem(); IList<ContextSpecKeyedItem> rawSpecs = new List<ContextSpecKeyedItem>(); foreach (var partition in partitions) { var filterSpec = ASTFilterSpecHelper.WalkFilterSpec(partition.eventFilterExpression(), propertyEvalSpec, astExprNodeMap); propertyEvalSpec = null; IList<string> propertyNames = new List<string>(); IList<EsperEPL2GrammarParser.ChainableContext> properties = partition.chainable(); foreach (var property in properties) { var propertyName = ASTUtil.GetPropertyName(property, 0); propertyNames.Add(propertyName); } ASTExprHelper.ExprCollectSubNodes(partition, 0, astExprNodeMap); // remove expressions rawSpecs.Add( new ContextSpecKeyedItem( filterSpec, propertyNames, partition.keywordAllowedIdent() == null ? null : partition.keywordAllowedIdent().GetText())); } IList<ContextSpecConditionFilter> optionalInit = null; if (ctx.createContextPartitionInit() != null) { optionalInit = GetContextPartitionInit(ctx.createContextPartitionInit().createContextFilter(), astExprNodeMap); } ContextSpecCondition optionalTermination = null; if (ctx.createContextPartitionTerm() != null) { optionalTermination = GetContextCondition( ctx.createContextPartitionTerm().createContextRangePoint(), astExprNodeMap, astPatternNodeMap, propertyEvalSpec, false); } return new ContextSpecKeyed(rawSpecs, optionalInit, optionalTermination); } if (ctx.COALESCE() != null) { // hash IList<EsperEPL2GrammarParser.CreateContextCoalesceItemContext> coalesces = ctx.createContextCoalesceItem(); IList<ContextSpecHashItem> rawSpecs = new List<ContextSpecHashItem>(coalesces.Count); foreach (var coalesce in coalesces) { var chain = ASTChainSpecHelper.GetChainables(coalesce.chainable(), astExprNodeMap); var func = chain[0]; var filterSpec = ASTFilterSpecHelper.WalkFilterSpec(coalesce.eventFilterExpression(), propertyEvalSpec, astExprNodeMap); propertyEvalSpec = null; rawSpecs.Add(new ContextSpecHashItem(func, filterSpec)); } var granularity = ctx.g.Text; if (!granularity.ToLowerInvariant().Equals("granularity")) { throw ASTWalkException.From("Expected 'granularity' keyword after list of coalesce items, found '" + granularity + "' instead"); } var num = ASTConstantHelper.Parse(ctx.number()); var preallocateStr = ctx.p?.Text; if (preallocateStr != null && !preallocateStr.ToLowerInvariant().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 ContextSpecHash(rawSpecs, num.AsInt32(), preallocateStr != null); } // categorized if (ctx.createContextGroupItem() != null) { IList<EsperEPL2GrammarParser.CreateContextGroupItemContext> grps = ctx.createContextGroupItem(); IList<ContextSpecCategoryItem> items = new List<ContextSpecCategoryItem>(); foreach (var grp in grps) { var exprNode = ASTExprHelper.ExprCollectSubNodes(grp, 0, astExprNodeMap)[0]; var name = grp.i.Text; items.Add(new ContextSpecCategoryItem(exprNode, name)); } var filterSpec = ASTFilterSpecHelper.WalkFilterSpec(ctx.eventFilterExpression(), propertyEvalSpec, astExprNodeMap); return new ContextSpecCategory(items, filterSpec); } throw new IllegalStateException("Unrecognized context detail type"); }
private ContextDetailMatchPair ValidateRewriteContextCondition( bool isStartCondition, int nestingLevel, ContextSpecCondition endpoint, ISet<string> eventTypesReferenced, MatchEventSpec priorMatches, ISet<string> priorAllTags, CreateContextValidationEnv validationEnv) { if (endpoint is ContextSpecConditionCrontab) { var crontab = (ContextSpecConditionCrontab) endpoint; var forgesPerCrontab = new ExprForge[crontab.Crontabs.Count][]; for (int i = 0; i < crontab.Crontabs.Count; i++) { var item = crontab.Crontabs[i]; var forges = ScheduleExpressionUtil.CrontabScheduleValidate( ExprNodeOrigin.CONTEXTCONDITION, item, false, validationEnv.StatementRawInfo, validationEnv.Services); forgesPerCrontab[i] = forges; } crontab.ForgesPerCrontab = forgesPerCrontab; validationEnv.ScheduleHandleCallbackProviders.Add(crontab); return new ContextDetailMatchPair( crontab, new MatchEventSpec(), new LinkedHashSet<string>(), EmptyList<StmtClassForgeableFactory>.Instance); } if (endpoint is ContextSpecConditionTimePeriod) { var timePeriod = (ContextSpecConditionTimePeriod) endpoint; var validationContext = new ExprValidationContextBuilder( new StreamTypeServiceImpl(false), validationEnv.StatementRawInfo, validationEnv.Services).Build(); ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.CONTEXTCONDITION, timePeriod.TimePeriod, validationContext); if (timePeriod.TimePeriod.IsConstantResult) { if (timePeriod.TimePeriod.EvaluateAsSeconds(null, true, null) < 0) { throw new ExprValidationException( "Invalid negative time period expression '" + ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(timePeriod.TimePeriod) + "'"); } } validationEnv.ScheduleHandleCallbackProviders.Add(timePeriod); return new ContextDetailMatchPair( timePeriod, new MatchEventSpec(), new LinkedHashSet<string>(), EmptyList<StmtClassForgeableFactory>.Instance); } if (endpoint is ContextSpecConditionPattern) { var pattern = (ContextSpecConditionPattern) endpoint; var matches = ValidatePatternContextConditionPattern( isStartCondition, nestingLevel, pattern, eventTypesReferenced, priorMatches, priorAllTags, validationEnv); var validatedDesc = ValidatePatternContextConditionPattern( isStartCondition, nestingLevel, pattern, eventTypesReferenced, priorMatches, priorAllTags, validationEnv); return new ContextDetailMatchPair( pattern, validatedDesc.MatchEventSpec, validatedDesc.AllTags, validatedDesc.AdditionalForgeables); } if (endpoint is ContextSpecConditionFilter) { var filter = (ContextSpecConditionFilter) endpoint; ValidateNotTable(filter.FilterSpecRaw.EventTypeName, validationEnv.Services); // compile as filter if there are no prior match to consider if (priorMatches == null || priorMatches.ArrayEventTypes.IsEmpty() && priorMatches.TaggedEventTypes.IsEmpty()) { var rawExpr = new FilterStreamSpecRaw( filter.FilterSpecRaw, ViewSpec.EMPTY_VIEWSPEC_ARRAY, null, StreamSpecOptions.DEFAULT); var compiledDesc = StreamSpecCompiler.Compile( rawExpr, eventTypesReferenced, false, false, true, false, filter.OptionalFilterAsName, 0, validationEnv.StatementRawInfo, validationEnv.Services); var compiled = (FilterStreamSpecCompiled) compiledDesc.StreamSpecCompiled; filter.FilterSpecCompiled = compiled.FilterSpecCompiled; var matchEventSpec = new MatchEventSpec(); var filterForType = compiled.FilterSpecCompiled.FilterForEventType; var allTags = new LinkedHashSet<string>(); if (filter.OptionalFilterAsName != null) { matchEventSpec.TaggedEventTypes.Put( filter.OptionalFilterAsName, new Pair<EventType, string>(filterForType, rawExpr.RawFilterSpec.EventTypeName)); allTags.Add(filter.OptionalFilterAsName); } validationEnv.FilterSpecCompileds.Add(compiled.FilterSpecCompiled); var serdeForgeables = SerdeEventTypeUtility.Plan( filter.FilterSpecCompiled.FilterForEventType, validationEnv.StatementRawInfo, validationEnv.Services.SerdeEventTypeRegistry, validationEnv.Services.SerdeResolver); var allForgeables = compiledDesc.AdditionalForgeables .Concat(serdeForgeables) .ToList(); return new ContextDetailMatchPair(filter, matchEventSpec, allTags, allForgeables); } // compile as pattern if there are prior matches to consider, since this is a type of followed-by relationship EvalForgeNode forgeNode = new EvalFilterForgeNode(validationEnv.Services.IsAttachPatternText, filter.FilterSpecRaw, filter.OptionalFilterAsName, 0); var pattern = new ContextSpecConditionPattern(forgeNode, true, false); var validated = ValidatePatternContextConditionPattern( isStartCondition, nestingLevel, pattern, eventTypesReferenced, priorMatches, priorAllTags, validationEnv); return new ContextDetailMatchPair(pattern, validated.MatchEventSpec, validated.AllTags, validated.AdditionalForgeables); } if (endpoint is ContextSpecConditionImmediate || endpoint is ContextSpecConditionNever) { return new ContextDetailMatchPair( endpoint, new MatchEventSpec(), new LinkedHashSet<String>(), EmptyList<StmtClassForgeableFactory>.Instance); } throw new IllegalStateException("Unrecognized endpoint type " + endpoint); }