private ContextControllerFactoryForge Make( ContextControllerFactoryEnv factoryContext, ContextSpec detail) { ContextControllerFactoryForge forge; if (detail is ContextSpecInitiatedTerminated) { forge = new ContextControllerInitTermFactoryForge( factoryContext, (ContextSpecInitiatedTerminated) detail); } else if (detail is ContextSpecKeyed) { forge = new ContextControllerKeyedFactoryForge(factoryContext, (ContextSpecKeyed) detail); } else if (detail is ContextSpecCategory) { forge = new ContextControllerCategoryFactoryForge(factoryContext, (ContextSpecCategory) detail); } else if (detail is ContextSpecHash) { forge = new ContextControllerHashFactoryForge(factoryContext, (ContextSpecHash) detail); } else { throw new UnsupportedOperationException( "Context detail " + detail + " is not yet supported in a nested context"); } return forge; }
private ContextControllerFactoryForge[] GetForges( string contextName, ContextSpec contextDetail) { if (!(contextDetail is ContextNested)) { var factoryEnv = new ContextControllerFactoryEnv( contextName, contextName, 1, 1); return new[] {Make(factoryEnv, contextDetail)}; } var nested = (ContextNested) contextDetail; var forges = new ContextControllerFactoryForge[nested.Contexts.Count]; var nestingLevel = 1; foreach (var desc in nested.Contexts) { var factoryEnv = new ContextControllerFactoryEnv( contextName, desc.ContextName, nestingLevel, nested.Contexts.Count); forges[nestingLevel - 1] = Make(factoryEnv, desc.ContextDetail); nestingLevel++; } return forges; }
public CreateContextDesc( string contextName, ContextSpec contextDetail) { ContextName = contextName; ContextDetail = contextDetail; }
private IList<StmtClassForgeableFactory> ValidateContextDetail( ContextSpec contextSpec, int nestingLevel, CreateContextValidationEnv validationEnv) { ISet<string> eventTypesReferenced = new HashSet<string>(); IList<StmtClassForgeableFactory> additionalForgeables = new List<StmtClassForgeableFactory>(); if (contextSpec is ContextSpecKeyed) { var segmented = (ContextSpecKeyed) contextSpec; IDictionary<string, EventType> asNames = new Dictionary<string, EventType>(); var partitionHasNameAssignment = false; Type[] getterTypes = null; foreach (var partition in segmented.Items) { Pair<FilterSpecCompiled, IList<StmtClassForgeableFactory>> pair = CompilePartitionedFilterSpec( partition.FilterSpecRaw, eventTypesReferenced, validationEnv); FilterSpecCompiled filterSpecCompiled = pair.First; additionalForgeables.AddAll(pair.Second); partition.FilterSpecCompiled = filterSpecCompiled; var getters = new EventPropertyGetterSPI[partition.PropertyNames.Count]; var serdes = new DataInputOutputSerdeForge[partition.PropertyNames.Count]; var eventType = (EventTypeSPI) filterSpecCompiled.FilterForEventType; getterTypes = new Type[partition.PropertyNames.Count]; for (var i = 0; i < partition.PropertyNames.Count; i++) { var propertyName = partition.PropertyNames[i]; var getter = eventType.GetGetterSPI(propertyName); if (getter == null) { throw new ExprValidationException( "For context '" + validationEnv.ContextName + "' property name '" + propertyName + "' not found on type " + eventType.Name); } getters[i] = getter; getterTypes[i] = eventType.GetPropertyType(propertyName); serdes[i] = validationEnv.Services.SerdeResolver.SerdeForFilter( getterTypes[i], validationEnv.StatementRawInfo); } partition.Getters = getters; partition.LookupableSerdes = serdes; if (partition.AliasName != null) { partitionHasNameAssignment = true; ValidateAsName(asNames, partition.AliasName, filterSpecCompiled.FilterForEventType); } } // plan multi-key, make sure we use the same multikey for all items MultiKeyPlan multiKeyPlan = MultiKeyPlanner.PlanMultiKey( getterTypes, false, @base.StatementRawInfo, validationEnv.Services.SerdeResolver); additionalForgeables.AddAll(multiKeyPlan.MultiKeyForgeables); foreach (ContextSpecKeyedItem partition in segmented.Items) { partition.KeyMultiKey = multiKeyPlan.ClassRef; } segmented.MultiKeyClassRef = multiKeyPlan.ClassRef; if (segmented.OptionalInit != null) { asNames.Clear(); foreach (var initCondition in segmented.OptionalInit) { ContextDetailMatchPair pair = ValidateRewriteContextCondition( true, nestingLevel, initCondition, eventTypesReferenced, new MatchEventSpec(), new EmptySet<string>(), validationEnv); additionalForgeables.AddAll(pair.AdditionalForgeables); var filterForType = initCondition.FilterSpecCompiled.FilterForEventType; var found = false; foreach (var partition in segmented.Items) { if (partition.FilterSpecCompiled.FilterForEventType == filterForType) { found = true; break; } } if (!found) { throw new ExprValidationException( "Segmented context '" + validationEnv.ContextName + "' requires that all of the event types that are listed in the initialized-by also appear in the partition-by, type '" + filterForType.Name + "' is not one of the types listed in partition-by"); } if (initCondition.OptionalFilterAsName != null) { if (partitionHasNameAssignment) { throw new ExprValidationException( "Segmented context '" + validationEnv.ContextName + "' requires that either partition-by or initialized-by assign stream names, but not both"); } ValidateAsName(asNames, initCondition.OptionalFilterAsName, filterForType); } } } if (segmented.OptionalTermination != null) { var matchEventSpec = new MatchEventSpec(); var allTags = new LinkedHashSet<string>(); foreach (var partition in segmented.Items) { if (partition.AliasName != null) { allTags.Add(partition.AliasName); var eventType = partition.FilterSpecCompiled.FilterForEventType; matchEventSpec.TaggedEventTypes[partition.AliasName] = new Pair<EventType,string>( eventType, partition.FilterSpecRaw.EventTypeName); var serdeForgeables = SerdeEventTypeUtility.Plan( eventType, validationEnv.StatementRawInfo, validationEnv.Services.SerdeEventTypeRegistry, validationEnv.Services.SerdeResolver); additionalForgeables.AddAll(serdeForgeables); } } if (segmented.OptionalInit != null) { foreach (var initCondition in segmented.OptionalInit) { if (initCondition.OptionalFilterAsName != null) { allTags.Add(initCondition.OptionalFilterAsName); matchEventSpec.TaggedEventTypes.Put( initCondition.OptionalFilterAsName, new Pair<EventType, string>( initCondition.FilterSpecCompiled.FilterForEventType, initCondition.FilterSpecRaw.EventTypeName)); } } } var endCondition = ValidateRewriteContextCondition( false, nestingLevel, segmented.OptionalTermination, eventTypesReferenced, matchEventSpec, allTags, validationEnv); additionalForgeables.AddAll(endCondition.AdditionalForgeables); segmented.OptionalTermination = endCondition.Condition; } } else if (contextSpec is ContextSpecCategory) { // compile filter var category = (ContextSpecCategory) contextSpec; ValidateNotTable(category.FilterSpecRaw.EventTypeName, validationEnv.Services); var raw = new FilterStreamSpecRaw( category.FilterSpecRaw, ViewSpec.EMPTY_VIEWSPEC_ARRAY, null, StreamSpecOptions.DEFAULT); var compiledDesc = StreamSpecCompiler.CompileFilter( raw, false, false, true, false, null, validationEnv.StatementRawInfo, validationEnv.Services); var result = (FilterStreamSpecCompiled) compiledDesc.StreamSpecCompiled; additionalForgeables.AddAll(compiledDesc.AdditionalForgeables); category.FilterSpecCompiled = result.FilterSpecCompiled; validationEnv.FilterSpecCompileds.Add(result.FilterSpecCompiled); // compile expressions foreach (var item in category.Items) { ValidateNotTable(category.FilterSpecRaw.EventTypeName, validationEnv.Services); var filterSpecRaw = new FilterSpecRaw( category.FilterSpecRaw.EventTypeName, Collections.SingletonList(item.Expression), null); var rawExpr = new FilterStreamSpecRaw( filterSpecRaw, ViewSpec.EMPTY_VIEWSPEC_ARRAY, null, StreamSpecOptions.DEFAULT); var compiledDescItems = StreamSpecCompiler.CompileFilter( rawExpr, false, false, true, false, null, validationEnv.StatementRawInfo, validationEnv.Services); var compiled = (FilterStreamSpecCompiled) compiledDescItems.StreamSpecCompiled; additionalForgeables.AddAll(compiledDescItems.AdditionalForgeables); compiled.FilterSpecCompiled.TraverseFilterBooleanExpr( node => validationEnv.FilterBooleanExpressions.Add(node)); item.FilterPlan = compiled.FilterSpecCompiled.Parameters; } } else if (contextSpec is ContextSpecHash) { var hashed = (ContextSpecHash) contextSpec; foreach (var hashItem in hashed.Items) { var raw = new FilterStreamSpecRaw( hashItem.FilterSpecRaw, ViewSpec.EMPTY_VIEWSPEC_ARRAY, null, StreamSpecOptions.DEFAULT); ValidateNotTable(hashItem.FilterSpecRaw.EventTypeName, validationEnv.Services); var compiledDesc = StreamSpecCompiler.Compile( raw, eventTypesReferenced, false, false, true, false, null, 0, validationEnv.StatementRawInfo, validationEnv.Services); additionalForgeables.AddAll(compiledDesc.AdditionalForgeables); var result = (FilterStreamSpecCompiled) compiledDesc.StreamSpecCompiled; validationEnv.FilterSpecCompileds.Add(result.FilterSpecCompiled); hashItem.FilterSpecCompiled = result.FilterSpecCompiled; // validate parameters var streamTypes = new StreamTypeServiceImpl( result.FilterSpecCompiled.FilterForEventType, null, true); var validationContext = new ExprValidationContextBuilder( streamTypes, validationEnv.StatementRawInfo, validationEnv.Services) .WithIsFilterExpression(true) .Build(); ExprNodeUtilityValidate.Validate( ExprNodeOrigin.CONTEXT, Collections.SingletonList(hashItem.Function), validationContext); } } else if (contextSpec is ContextSpecInitiatedTerminated) { var def = (ContextSpecInitiatedTerminated) contextSpec; var startCondition = ValidateRewriteContextCondition( true, nestingLevel, def.StartCondition, eventTypesReferenced, new MatchEventSpec(), new LinkedHashSet<string>(), validationEnv); additionalForgeables.AddAll(startCondition.AdditionalForgeables); var endCondition = ValidateRewriteContextCondition( false, nestingLevel, def.EndCondition, eventTypesReferenced, startCondition.Matches, startCondition.AllTags, validationEnv); additionalForgeables.AddAll(endCondition.AdditionalForgeables); def.StartCondition = startCondition.Condition; def.EndCondition = endCondition.Condition; if (def.DistinctExpressions != null) { if (!(startCondition.Condition is ContextSpecConditionFilter)) { throw new ExprValidationException( "Distinct-expressions require a stream as the initiated-by condition"); } var distinctExpressions = def.DistinctExpressions; if (distinctExpressions.Length == 0) { throw new ExprValidationException("Distinct-expressions have not been provided"); } var filter = (ContextSpecConditionFilter) startCondition.Condition; if (filter.OptionalFilterAsName == null) { throw new ExprValidationException( "Distinct-expressions require that a stream name is assigned to the stream using 'as'"); } var types = new StreamTypeServiceImpl( filter.FilterSpecCompiled.FilterForEventType, filter.OptionalFilterAsName, true); var validationContext = new ExprValidationContextBuilder(types, validationEnv.StatementRawInfo, validationEnv.Services) .WithAllowBindingConsumption(true) .Build(); for (var i = 0; i < distinctExpressions.Length; i++) { ExprNodeUtilityValidate.ValidatePlainExpression( ExprNodeOrigin.CONTEXTDISTINCT, distinctExpressions[i]); distinctExpressions[i] = ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.CONTEXTDISTINCT, distinctExpressions[i], validationContext); } var multiKeyPlan = MultiKeyPlanner.PlanMultiKey( distinctExpressions, false, @base.StatementRawInfo, validationEnv.Services.SerdeResolver); def.DistinctMultiKey = multiKeyPlan.ClassRef; additionalForgeables.AddAll(multiKeyPlan.MultiKeyForgeables); } } else if (contextSpec is ContextNested) { var nested = (ContextNested) contextSpec; var level = 0; ISet<string> namesUsed = new HashSet<string>(); namesUsed.Add(validationEnv.ContextName); foreach (var nestedContext in nested.Contexts) { if (namesUsed.Contains(nestedContext.ContextName)) { throw new ExprValidationException( "Context by name '" + nestedContext.ContextName + "' has already been declared within nested context '" + validationEnv.ContextName + "'"); } namesUsed.Add(nestedContext.ContextName); var forgeables = ValidateContextDetail(nestedContext.ContextDetail, level, validationEnv); additionalForgeables.AddAll(forgeables); level++; } } else { throw new IllegalStateException("Unrecognized context detail " + contextSpec); } return additionalForgeables; }
public TimeBoundaryQueryDescriptor() { ContextValue = new ContextSpec(); }
public static IList<ExprNode> CollectExpressionsShallow(StatementSpecRaw raw) { IList<ExprNode> expressions = new List<ExprNode>(); if (raw.CreateContextDesc != null) { ContextSpec detail = raw.CreateContextDesc.ContextDetail; if (detail is ContextSpecKeyed) { var ks = (ContextSpecKeyed) detail; foreach (ContextSpecKeyedItem item in ks.Items) { if (item.FilterSpecRaw.FilterExpressions != null) { expressions.AddAll(item.FilterSpecRaw.FilterExpressions); } } if (ks.OptionalInit != null) { foreach (ContextSpecConditionFilter filter in ks.OptionalInit) { CollectExpressions(expressions, filter); } } if (ks.OptionalTermination != null) { CollectExpressions(expressions, ks.OptionalTermination); } } else if (detail is ContextSpecCategory) { var cat = (ContextSpecCategory) detail; foreach (var item in cat.Items) { if (item.Expression != null) { expressions.Add(item.Expression); } } if (cat.FilterSpecRaw.FilterExpressions != null) { expressions.AddAll(cat.FilterSpecRaw.FilterExpressions); } } else if (detail is ContextSpecInitiatedTerminated) { var ts = (ContextSpecInitiatedTerminated) detail; CollectExpressions(expressions, ts.StartCondition); CollectExpressions(expressions, ts.EndCondition); } else { throw new EPException("Failed to obtain expressions from context detail " + detail); } } if (raw.CreateVariableDesc != null) { var expr = raw.CreateVariableDesc.Assignment; if (expr != null) { expressions.Add(expr); } } if (raw.CreateWindowDesc != null) { var expr = raw.CreateWindowDesc.InsertFilter; if (expr != null) { expressions.Add(expr); } foreach (var view in raw.CreateWindowDesc.ViewSpecs) { expressions.AddAll(view.ObjectParameters); } } if (raw.UpdateDesc != null) { if (raw.UpdateDesc.OptionalWhereClause != null) { expressions.Add(raw.UpdateDesc.OptionalWhereClause); } if (raw.UpdateDesc.Assignments != null) { foreach (var pair in raw.UpdateDesc.Assignments) { expressions.Add(pair.Expression); } } } // on-expr if (raw.OnTriggerDesc != null) { if (raw.OnTriggerDesc is OnTriggerSplitStreamDesc) { var onSplit = (OnTriggerSplitStreamDesc) raw.OnTriggerDesc; foreach (var item in onSplit.SplitStreams) { if (item.SelectClause != null) { AddSelectClause(expressions, item.SelectClause.SelectExprList); } if (item.WhereClause != null) { expressions.Add(item.WhereClause); } } } var onSet = raw.OnTriggerDesc as OnTriggerSetDesc; if (onSet?.Assignments != null) { foreach (var aitem in onSet.Assignments) { expressions.Add(aitem.Expression); } } var onUpdate = raw.OnTriggerDesc as OnTriggerWindowUpdateDesc; if (onUpdate?.Assignments != null) { foreach (var bitem in onUpdate.Assignments) { expressions.Add(bitem.Expression); } } if (raw.OnTriggerDesc is OnTriggerMergeDesc) { var onMerge = (OnTriggerMergeDesc) raw.OnTriggerDesc; foreach (var item in onMerge.Items) { if (item.OptionalMatchCond != null) { expressions.Add(item.OptionalMatchCond); } foreach (var action in item.Actions) { if (action.OptionalWhereClause != null) { expressions.Add(action.OptionalWhereClause); } if (action is OnTriggerMergeActionUpdate) { var update = (OnTriggerMergeActionUpdate) action; foreach (var assignment in update.Assignments) { expressions.Add(assignment.Expression); } } else if (action is OnTriggerMergeActionInsert) { var insert = (OnTriggerMergeActionInsert) action; AddSelectClause(expressions, insert.SelectClause); } } } if (onMerge.OptionalInsertNoMatch != null) { AddSelectClause(expressions, onMerge.OptionalInsertNoMatch.SelectClause); } } } // select clause if (raw.SelectClauseSpec != null) { AddSelectClause(expressions, raw.SelectClauseSpec.SelectExprList); } // from clause if (raw.StreamSpecs != null) { foreach (var stream in raw.StreamSpecs) { // filter stream if (stream is FilterStreamSpecRaw) { var filterStream = (FilterStreamSpecRaw) stream; var filter = filterStream.RawFilterSpec; if (filter != null && filter.FilterExpressions != null) { expressions.AddAll(filter.FilterExpressions); } if (filter != null && filter.OptionalPropertyEvalSpec != null) { foreach (var contained in filter.OptionalPropertyEvalSpec.Atoms) { AddSelectClause( expressions, contained.OptionalSelectClause == null ? null : contained.OptionalSelectClause.SelectExprList); if (contained.OptionalWhereClause != null) { expressions.Add(contained.OptionalWhereClause); } } } } // pattern stream if (stream is PatternStreamSpecRaw) { var patternStream = (PatternStreamSpecRaw) stream; CollectPatternExpressions(expressions, patternStream.EvalForgeNode); } // method stream var methodStream = stream as MethodStreamSpec; if (methodStream?.Expressions != null) { expressions.AddAll(methodStream.Expressions); } if (stream.ViewSpecs != null) { foreach (var view in stream.ViewSpecs) { expressions.AddAll(view.ObjectParameters); } } } if (raw.OuterJoinDescList != null) { foreach (var q in raw.OuterJoinDescList) { if (q.OptLeftNode != null) { expressions.Add(q.OptLeftNode); expressions.Add(q.OptRightNode); foreach (ExprIdentNode ident in q.AdditionalLeftNodes) { expressions.Add(ident); } foreach (ExprIdentNode ident in q.AdditionalRightNodes) { expressions.Add(ident); } } } } } if (raw.WhereClause != null) { expressions.Add(raw.WhereClause); } if (raw.GroupByExpressions != null) { foreach (var element in raw.GroupByExpressions) { if (element is GroupByClauseElementExpr) { expressions.Add(((GroupByClauseElementExpr) element).Expr); } else if (element is GroupByClauseElementRollupOrCube) { var rollup = (GroupByClauseElementRollupOrCube) element; AnalyzeRollup(rollup, expressions); } else { var set = (GroupByClauseElementGroupingSet) element; foreach (var inner in set.Elements) { if (inner is GroupByClauseElementExpr) { expressions.Add(((GroupByClauseElementExpr) inner).Expr); } else if (inner is GroupByClauseElementCombinedExpr) { expressions.AddAll(((GroupByClauseElementCombinedExpr) inner).Expressions); } else { AnalyzeRollup((GroupByClauseElementRollupOrCube) inner, expressions); } } } } } if (raw.HavingClause != null) { expressions.Add(raw.HavingClause); } if (raw.OutputLimitSpec != null) { if (raw.OutputLimitSpec.WhenExpressionNode != null) { expressions.Add(raw.OutputLimitSpec.WhenExpressionNode); } if (raw.OutputLimitSpec.ThenExpressions != null) { foreach (var thenAssign in raw.OutputLimitSpec.ThenExpressions) { expressions.Add(thenAssign.Expression); } } if (raw.OutputLimitSpec.CrontabAtSchedule != null) { expressions.AddAll(raw.OutputLimitSpec.CrontabAtSchedule); } if (raw.OutputLimitSpec.TimePeriodExpr != null) { expressions.Add(raw.OutputLimitSpec.TimePeriodExpr); } if (raw.OutputLimitSpec.AfterTimePeriodExpr != null) { expressions.Add(raw.OutputLimitSpec.AfterTimePeriodExpr); } } if (raw.OrderByList != null) { foreach (var orderByElement in raw.OrderByList) { expressions.Add(orderByElement.ExprNode); } } if (raw.MatchRecognizeSpec != null) { if (raw.MatchRecognizeSpec.PartitionByExpressions != null) { expressions.AddAll(raw.MatchRecognizeSpec.PartitionByExpressions); } foreach (var selectItemMR in raw.MatchRecognizeSpec.Measures) { expressions.Add(selectItemMR.Expr); } foreach (var define in raw.MatchRecognizeSpec.Defines) { expressions.Add(define.Expression); } if (raw.MatchRecognizeSpec.Interval?.TimePeriodExpr != null) { expressions.Add(raw.MatchRecognizeSpec.Interval.TimePeriodExpr); } } if (raw.ForClauseSpec != null) { foreach (var item in raw.ForClauseSpec.Clauses) { if (item.Expressions != null) { expressions.AddAll(item.Expressions); } } } return expressions; }