public static FireAndForgetProcessor ValidateResolveProcessor(StreamSpecCompiled streamSpec, EPServicesContext services) { // resolve processor string processorName; if (streamSpec is NamedWindowConsumerStreamSpec) { NamedWindowConsumerStreamSpec namedSpec = (NamedWindowConsumerStreamSpec)streamSpec; processorName = namedSpec.WindowName; } else { TableQueryStreamSpec tableSpec = (TableQueryStreamSpec)streamSpec; processorName = tableSpec.TableName; } // get processor instance TableMetadata tableMetadata = services.TableService.GetTableMetadata(processorName); if (tableMetadata != null) { return(new FireAndForgetProcessorTable(services.TableService, tableMetadata)); } else { NamedWindowProcessor nwprocessor = services.NamedWindowService.GetProcessor(processorName); if (nwprocessor == null) { throw new ExprValidationException("A table or named window by name '" + processorName + "' does not exist"); } return(new FireAndForgetProcessorNamedWindow(nwprocessor)); } }
public static FireAndForgetProcessorForge ValidateResolveProcessor(StreamSpecCompiled streamSpec) { if (streamSpec is NamedWindowConsumerStreamSpec) { NamedWindowMetaData nwdetail = ((NamedWindowConsumerStreamSpec) streamSpec).NamedWindow; return new FireAndForgetProcessorNamedWindowForge(nwdetail); } TableQueryStreamSpec tableSpec = (TableQueryStreamSpec) streamSpec; return new FireAndForgetProcessorTableForge(tableSpec.Table); }
private static StatementSpecCompiled AssociatedFromClause( StatementSpecCompiled statementSpec, StatementCompileTimeServices services) { var raw = statementSpec.Raw; if (raw.WhereClause != null || statementSpec.StreamSpecs.Length > 0 || raw.HavingClause != null || raw.OutputLimitSpec != null || raw.ForClauseSpec != null || raw.MatchRecognizeSpec != null || raw.OrderByList != null && !raw.OrderByList.IsEmpty() || raw.RowLimitSpec != null) { throw new ExprValidationException( "Insert-into fire-and-forget query can only consist of an insert-into clause and a select-clause"); } var infraName = statementSpec.Raw.InsertIntoDesc.EventTypeName; var namedWindow = services.NamedWindowCompileTimeResolver.Resolve(infraName); var table = services.TableCompileTimeResolver.Resolve(infraName); if (namedWindow == null && table == null) { throw new ExprValidationException("Failed to find named window or table '" + infraName + "'"); } StreamSpecCompiled stream; if (namedWindow != null) { stream = new NamedWindowConsumerStreamSpec( namedWindow, null, new ViewSpec[0], Collections.GetEmptyList<ExprNode>(), StreamSpecOptions.DEFAULT, null); } else { stream = new TableQueryStreamSpec( null, new ViewSpec[0], StreamSpecOptions.DEFAULT, table, Collections.GetEmptyList<ExprNode>()); } return new StatementSpecCompiled(statementSpec, new[] {stream}); }
public static EPStatementStartMethodSelectDesc Prepare(StatementSpecCompiled statementSpec, EPServicesContext services, StatementContext statementContext, bool recoveringResilient, AgentInstanceContext defaultAgentInstanceContext, bool queryPlanLogging, ViewableActivatorFactory optionalViewableActivatorFactory, OutputProcessViewCallback optionalOutputProcessViewCallback, SelectExprProcessorDeliveryCallback selectExprProcessorDeliveryCallback) { // define stop and destroy List <StopCallback> stopCallbacks = new List <StopCallback>(); EPStatementDestroyCallbackList destroyCallbacks = new EPStatementDestroyCallbackList(); // determine context var contextName = statementSpec.OptionalContextName; var contextPropertyRegistry = (contextName != null) ? services.ContextManagementService.GetContextDescriptor(contextName).ContextPropertyRegistry : null; // Determine stream names for each stream - some streams may not have a name given var streamNames = EPStatementStartMethodHelperUtil.DetermineStreamNames(statementSpec.StreamSpecs); var numStreams = streamNames.Length; if (numStreams == 0) { throw new ExprValidationException("The from-clause is required but has not been specified"); } var isJoin = statementSpec.StreamSpecs.Length > 1; var hasContext = statementSpec.OptionalContextName != null; // First we create streams for subselects, if there are any var subSelectStreamDesc = EPStatementStartMethodHelperSubselect.CreateSubSelectActivation(services, statementSpec, statementContext, destroyCallbacks); // Create streams and views var eventStreamParentViewableActivators = new ViewableActivator[numStreams]; var unmaterializedViewChain = new ViewFactoryChain[numStreams]; var eventTypeNames = new String[numStreams]; var isNamedWindow = new bool[numStreams]; var historicalEventViewables = new HistoricalEventViewable[numStreams]; // verify for joins that required views are present var joinAnalysisResult = VerifyJoinViews(statementSpec, statementContext.NamedWindowService, defaultAgentInstanceContext); var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, false); for (var i = 0; i < statementSpec.StreamSpecs.Length; i++) { var streamSpec = statementSpec.StreamSpecs[i]; var isCanIterateUnbound = streamSpec.ViewSpecs.Length == 0 && (services.ConfigSnapshot.EngineDefaults.ViewResourcesConfig.IsIterableUnbound || AnnotationUtil.FindAttribute(statementSpec.Annotations, typeof(IterableUnboundAttribute)) != null); // Create view factories and parent view based on a filter specification if (streamSpec is FilterStreamSpecCompiled) { var filterStreamSpec = (FilterStreamSpecCompiled)streamSpec; eventTypeNames[i] = filterStreamSpec.FilterSpec.FilterForEventTypeName; // Since only for non-joins we get the existing stream's lock and try to reuse it's views var filterSubselectSameStream = EPStatementStartMethodHelperUtil.DetermineSubquerySameStream(statementSpec, filterStreamSpec); // create activator ViewableActivator activatorDeactivator; if (optionalViewableActivatorFactory != null) { activatorDeactivator = optionalViewableActivatorFactory.CreateActivatorSimple(filterStreamSpec); if (activatorDeactivator == null) { throw new IllegalStateException("Viewable activate is null for " + filterStreamSpec.FilterSpec.FilterForEventType.Name); } } else { if (!hasContext) { activatorDeactivator = services.ViewableActivatorFactory.CreateStreamReuseView( services, statementContext, statementSpec, filterStreamSpec, isJoin, evaluatorContextStmt, filterSubselectSameStream, i, isCanIterateUnbound); } else { InstrumentationAgent instrumentationAgentFilter = null; if (InstrumentationHelper.ENABLED) { var eventTypeName = filterStreamSpec.FilterSpec.FilterForEventType.Name; var streamNumber = i; instrumentationAgentFilter = new ProxyInstrumentationAgent() { ProcIndicateQ = () => InstrumentationHelper.Get().QFilterActivationStream(eventTypeName, streamNumber), ProcIndicateA = () => InstrumentationHelper.Get().AFilterActivationStream(), }; } activatorDeactivator = services.ViewableActivatorFactory.CreateFilterProxy( services, filterStreamSpec.FilterSpec, statementSpec.Annotations, false, instrumentationAgentFilter, isCanIterateUnbound); } } eventStreamParentViewableActivators[i] = activatorDeactivator; var resultEventType = filterStreamSpec.FilterSpec.ResultEventType; unmaterializedViewChain[i] = services.ViewService.CreateFactories(i, resultEventType, streamSpec.ViewSpecs, streamSpec.Options, statementContext); } // Create view factories and parent view based on a pattern expression else if (streamSpec is PatternStreamSpecCompiled) { var patternStreamSpec = (PatternStreamSpecCompiled)streamSpec; var usedByChildViews = streamSpec.ViewSpecs.Length > 0 || (statementSpec.InsertIntoDesc != null); var patternTypeName = statementContext.StatementId + "_pattern_" + i; var eventType = services.EventAdapterService.CreateSemiAnonymousMapType(patternTypeName, patternStreamSpec.TaggedEventTypes, patternStreamSpec.ArrayEventTypes, usedByChildViews); unmaterializedViewChain[i] = services.ViewService.CreateFactories(i, eventType, streamSpec.ViewSpecs, streamSpec.Options, statementContext); var rootFactoryNode = services.PatternNodeFactory.MakeRootNode(patternStreamSpec.EvalFactoryNode); var patternContext = statementContext.PatternContextFactory.CreateContext(statementContext, i, rootFactoryNode, patternStreamSpec.MatchedEventMapMeta, true); // create activator ViewableActivator patternActivator = services.ViewableActivatorFactory.CreatePattern( patternContext, rootFactoryNode, eventType, EPStatementStartMethodHelperUtil.IsConsumingFilters(patternStreamSpec.EvalFactoryNode), patternStreamSpec.IsSuppressSameEventMatches, patternStreamSpec.IsDiscardPartialsOnMatch, isCanIterateUnbound); eventStreamParentViewableActivators[i] = patternActivator; } // Create view factories and parent view based on a database SQL statement else if (streamSpec is DBStatementStreamSpec) { ValidateNoViews(streamSpec, "Historical data"); var sqlStreamSpec = (DBStatementStreamSpec)streamSpec; var typeConversionHook = (SQLColumnTypeConversion)TypeHelper.GetAnnotationHook(statementSpec.Annotations, HookType.SQLCOL, typeof(SQLColumnTypeConversion), statementContext.MethodResolutionService); var outputRowConversionHook = (SQLOutputRowConversion)TypeHelper.GetAnnotationHook(statementSpec.Annotations, HookType.SQLROW, typeof(SQLOutputRowConversion), statementContext.MethodResolutionService); var epStatementAgentInstanceHandle = defaultAgentInstanceContext.EpStatementAgentInstanceHandle; var historicalEventViewable = DatabasePollingViewableFactory.CreateDBStatementView( statementContext.StatementId, i, sqlStreamSpec, services.DatabaseRefService, services.EventAdapterService, epStatementAgentInstanceHandle, statementContext.Annotations, typeConversionHook, outputRowConversionHook, statementContext.ConfigSnapshot.EngineDefaults.LoggingConfig.IsEnableADO); historicalEventViewables[i] = historicalEventViewable; unmaterializedViewChain[i] = ViewFactoryChain.FromTypeNoViews(historicalEventViewable.EventType); eventStreamParentViewableActivators[i] = new ProxyViewableActivator( (agentInstanceContext, isSubselect, isRecoveringResilient) => new ViewableActivationResult(historicalEventViewable, CollectionUtil.STOP_CALLBACK_NONE, null, null, null, false, false, null)); stopCallbacks.Add(historicalEventViewable.Stop); } else if (streamSpec is MethodStreamSpec) { ValidateNoViews(streamSpec, "Method data"); var methodStreamSpec = (MethodStreamSpec)streamSpec; var epStatementAgentInstanceHandle = defaultAgentInstanceContext.EpStatementAgentInstanceHandle; var historicalEventViewable = MethodPollingViewableFactory.CreatePollMethodView(i, methodStreamSpec, services.EventAdapterService, epStatementAgentInstanceHandle, statementContext.MethodResolutionService, services.EngineImportService, statementContext.SchedulingService, statementContext.ScheduleBucket, evaluatorContextStmt, statementContext.VariableService, statementContext.ContextName); historicalEventViewables[i] = historicalEventViewable; unmaterializedViewChain[i] = ViewFactoryChain.FromTypeNoViews(historicalEventViewable.EventType); eventStreamParentViewableActivators[i] = new ProxyViewableActivator( (agentInstanceContext, isSubselect, isRecoveringResilient) => new ViewableActivationResult(historicalEventViewable, CollectionUtil.STOP_CALLBACK_NONE, null, null, null, false, false, null)); stopCallbacks.Add(historicalEventViewable.Stop); } else if (streamSpec is TableQueryStreamSpec) { ValidateNoViews(streamSpec, "Table data"); TableQueryStreamSpec tableStreamSpec = (TableQueryStreamSpec)streamSpec; if (isJoin && tableStreamSpec.FilterExpressions.Count > 0) { throw new ExprValidationException("Joins with tables do not allow table filter expressions, please add table filters to the where-clause instead"); } TableMetadata metadata = services.TableService.GetTableMetadata(tableStreamSpec.TableName); ExprEvaluator[] tableFilterEvals = null; if (tableStreamSpec.FilterExpressions.Count > 0) { tableFilterEvals = ExprNodeUtility.GetEvaluators(tableStreamSpec.FilterExpressions); } EPLValidationUtil.ValidateContextName(true, metadata.TableName, metadata.ContextName, statementSpec.OptionalContextName, false); eventStreamParentViewableActivators[i] = new ViewableActivatorTable(metadata, tableFilterEvals); unmaterializedViewChain[i] = ViewFactoryChain.FromTypeNoViews(metadata.InternalEventType); eventTypeNames[i] = tableStreamSpec.TableName; joinAnalysisResult.SetTablesForStream(i, metadata); if (tableStreamSpec.Options.IsUnidirectional) { throw new ExprValidationException("Tables cannot be marked as unidirectional"); } if (tableStreamSpec.Options.IsRetainIntersection || tableStreamSpec.Options.IsRetainUnion) { throw new ExprValidationException("Tables cannot be marked with retain"); } if (isJoin) { destroyCallbacks.AddCallback(EPStatementDestroyCallbackTableIdxRef.New(services.TableService, metadata, statementContext.StatementName)); } } else if (streamSpec is NamedWindowConsumerStreamSpec) { var namedSpec = (NamedWindowConsumerStreamSpec)streamSpec; var processor = services.NamedWindowService.GetProcessor(namedSpec.WindowName); var namedWindowType = processor.TailView.EventType; if (namedSpec.OptPropertyEvaluator != null) { namedWindowType = namedSpec.OptPropertyEvaluator.FragmentEventType; } eventStreamParentViewableActivators[i] = services.ViewableActivatorFactory.CreateNamedWindow(processor, namedSpec.FilterExpressions, namedSpec.OptPropertyEvaluator); unmaterializedViewChain[i] = services.ViewService.CreateFactories(i, namedWindowType, namedSpec.ViewSpecs, namedSpec.Options, statementContext); joinAnalysisResult.SetNamedWindow(i); eventTypeNames[i] = namedSpec.WindowName; isNamedWindow[i] = true; // Consumers to named windows cannot declare a data window view onto the named window to avoid duplicate remove streams EPStatementStartMethodHelperValidate.ValidateNoDataWindowOnNamedWindow(unmaterializedViewChain[i].FactoryChain); } else { throw new ExprValidationException("Unknown stream specification type: " + streamSpec); } } // handle match-recognize pattern if (statementSpec.MatchRecognizeSpec != null) { if (isJoin) { throw new ExprValidationException("Joins are not allowed when using match-recognize"); } if (joinAnalysisResult.TablesPerStream[0] != null) { throw new ExprValidationException("Tables cannot be used with match-recognize"); } var isUnbound = (unmaterializedViewChain[0].FactoryChain.IsEmpty()) && (!(statementSpec.StreamSpecs[0] is NamedWindowConsumerStreamSpec)); var factory = services.RegexHandlerFactory.MakeViewFactory(unmaterializedViewChain[0], statementSpec.MatchRecognizeSpec, defaultAgentInstanceContext, isUnbound, statementSpec.Annotations, services.ConfigSnapshot.EngineDefaults.MatchRecognizeConfig); unmaterializedViewChain[0].FactoryChain.Add(factory); EPStatementStartMethodHelperAssignExpr.AssignAggregations(factory.AggregationService, factory.AggregationExpressions); } // Obtain event types from view factory chains var streamEventTypes = new EventType[statementSpec.StreamSpecs.Length]; for (var i = 0; i < unmaterializedViewChain.Length; i++) { streamEventTypes[i] = unmaterializedViewChain[i].EventType; } // Add uniqueness information useful for joins joinAnalysisResult.AddUniquenessInfo(unmaterializedViewChain, statementSpec.Annotations); // Validate sub-select views var subSelectStrategyCollection = EPStatementStartMethodHelperSubselect.PlanSubSelect(services, statementContext, queryPlanLogging, subSelectStreamDesc, streamNames, streamEventTypes, eventTypeNames, statementSpec.DeclaredExpressions, contextPropertyRegistry); // Construct type information per stream StreamTypeService typeService = new StreamTypeServiceImpl(streamEventTypes, streamNames, EPStatementStartMethodHelperUtil.GetHasIStreamOnly(isNamedWindow, unmaterializedViewChain), services.EngineURI, false); var viewResourceDelegateUnverified = new ViewResourceDelegateUnverified(); // Validate views that require validation, specifically streams that don't have // sub-views such as DB SQL joins var historicalViewableDesc = new HistoricalViewableDesc(numStreams); for (var stream = 0; stream < historicalEventViewables.Length; stream++) { var historicalEventViewable = historicalEventViewables[stream]; if (historicalEventViewable == null) { continue; } historicalEventViewable.Validate( services.EngineImportService, typeService, statementContext.MethodResolutionService, statementContext.TimeProvider, statementContext.VariableService, statementContext.TableService, statementContext.ScriptingService, evaluatorContextStmt, services.ConfigSnapshot, services.SchedulingService, services.EngineURI, statementSpec.SqlParameters, statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations); historicalViewableDesc.SetHistorical(stream, historicalEventViewable.RequiredStreams); if (historicalEventViewable.RequiredStreams.Contains(stream)) { throw new ExprValidationException("Parameters for historical stream " + stream + " indicate that the stream is subordinate to itself as stream parameters originate in the same stream"); } } // unidirectional is not supported with into-table if (joinAnalysisResult.IsUnidirectional && statementSpec.IntoTableSpec != null) { throw new ExprValidationException("Into-table does not allow unidirectional joins"); } // Construct a processor for results posted by views and joins, which takes care of aggregation if required. // May return null if we don't need to post-process results posted by views or joins. var resultSetProcessorPrototypeDesc = ResultSetProcessorFactoryFactory.GetProcessorPrototype( statementSpec, statementContext, typeService, viewResourceDelegateUnverified, joinAnalysisResult.UnidirectionalInd, true, contextPropertyRegistry, selectExprProcessorDeliveryCallback, services.ConfigSnapshot); // Validate where-clause filter tree, outer join clause and output limit expression EPStatementStartMethodHelperValidate.ValidateNodes(statementSpec, statementContext, typeService, viewResourceDelegateUnverified); // Handle 'prior' function nodes in terms of view requirements var viewResourceDelegateVerified = EPStatementStartMethodHelperViewResources.VerifyPreviousAndPriorRequirements(unmaterializedViewChain, viewResourceDelegateUnverified); // handle join JoinSetComposerPrototype joinSetComposerPrototype = null; if (numStreams > 1) { var selectsRemoveStream = statementSpec.SelectStreamSelectorEnum.IsSelectsRStream() || statementSpec.OutputLimitSpec != null; var hasAggregations = !resultSetProcessorPrototypeDesc.AggregationServiceFactoryDesc.Expressions.IsEmpty(); joinSetComposerPrototype = JoinSetComposerPrototypeFactory.MakeComposerPrototype( statementContext.StatementName, statementContext.StatementId, statementSpec.OuterJoinDescList, statementSpec.FilterRootNode, typeService.EventTypes, streamNames, joinAnalysisResult, queryPlanLogging, statementContext, historicalViewableDesc, defaultAgentInstanceContext, selectsRemoveStream, hasAggregations, services.TableService, false); } // obtain factory for output limiting var outputViewFactory = OutputProcessViewFactoryFactory.Make( statementSpec, services.InternalEventRouter, statementContext, resultSetProcessorPrototypeDesc.ResultSetProcessorFactory.ResultEventType, optionalOutputProcessViewCallback, services.TableService, resultSetProcessorPrototypeDesc.ResultSetProcessorFactory.ResultSetProcessorType); // Factory for statement-context instances var factoryX = new StatementAgentInstanceFactorySelect( numStreams, eventStreamParentViewableActivators, statementContext, statementSpec, services, typeService, unmaterializedViewChain, resultSetProcessorPrototypeDesc, joinAnalysisResult, recoveringResilient, joinSetComposerPrototype, subSelectStrategyCollection, viewResourceDelegateVerified, outputViewFactory); EPStatementStopMethod stopMethod = new EPStatementStopMethodImpl(statementContext, stopCallbacks).Stop; return(new EPStatementStartMethodSelectDesc(factoryX, subSelectStrategyCollection, viewResourceDelegateUnverified, resultSetProcessorPrototypeDesc, stopMethod, destroyCallbacks)); }
public static SubSelectActivationDesc CreateSubSelectActivation( IList <FilterSpecCompiled> filterSpecCompileds, IList <NamedWindowConsumerStreamSpec> namedWindowConsumers, StatementBaseInfo statement, StatementCompileTimeServices services) { IDictionary <ExprSubselectNode, SubSelectActivationPlan> result = new LinkedHashMap <ExprSubselectNode, SubSelectActivationPlan>(); IList <StmtClassForgeableFactory> additionalForgeables = new List <StmtClassForgeableFactory>(); // Process all subselect expression nodes foreach (ExprSubselectNode subselect in statement.StatementSpec.SubselectNodes) { StatementSpecCompiled statementSpec = subselect.StatementSpecCompiled; StreamSpecCompiled streamSpec = statementSpec.StreamSpecs[0]; int subqueryNumber = subselect.SubselectNumber; if (subqueryNumber == -1) { throw new IllegalStateException("Unexpected subquery"); } ViewFactoryForgeArgs args = new ViewFactoryForgeArgs(-1, true, subqueryNumber, streamSpec.Options, null, statement.StatementRawInfo, services); if (streamSpec is FilterStreamSpecCompiled) { if (services.IsFireAndForget) { throw new ExprValidationException("Fire-and-forget queries only allow subqueries against named windows and tables"); } FilterStreamSpecCompiled filterStreamSpec = (FilterStreamSpecCompiled)statementSpec.StreamSpecs[0]; // Register filter, create view factories ViewableActivatorForge activatorDeactivator = new ViewableActivatorFilterForge( filterStreamSpec.FilterSpecCompiled, false, null, true, subqueryNumber); ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges( streamSpec.ViewSpecs, args, filterStreamSpec.FilterSpecCompiled.ResultEventType); IList <ViewFactoryForge> forges = viewForgeDesc.Forges; additionalForgeables.AddAll(viewForgeDesc.MultikeyForges); EventType eventType = forges.IsEmpty() ? filterStreamSpec.FilterSpecCompiled.ResultEventType : forges[forges.Count - 1].EventType; subselect.RawEventType = eventType; filterSpecCompileds.Add(filterStreamSpec.FilterSpecCompiled); // Add lookup to list, for later starts result.Put( subselect, new SubSelectActivationPlan(filterStreamSpec.FilterSpecCompiled.ResultEventType, forges, activatorDeactivator, streamSpec)); } else if (streamSpec is TableQueryStreamSpec) { TableQueryStreamSpec table = (TableQueryStreamSpec)streamSpec; ExprNode filter = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(table.FilterExpressions); ViewableActivatorForge viewableActivator = new ViewableActivatorTableForge(table.Table, filter); result.Put( subselect, new SubSelectActivationPlan(table.Table.InternalEventType, EmptyList <ViewFactoryForge> .Instance, viewableActivator, streamSpec)); subselect.RawEventType = table.Table.InternalEventType; } else { NamedWindowConsumerStreamSpec namedSpec = (NamedWindowConsumerStreamSpec)statementSpec.StreamSpecs[0]; namedWindowConsumers.Add(namedSpec); NamedWindowMetaData nwinfo = namedSpec.NamedWindow; EventType namedWindowType = nwinfo.EventType; if (namedSpec.OptPropertyEvaluator != null) { namedWindowType = namedSpec.OptPropertyEvaluator.FragmentEventType; } // if named-window index sharing is disabled (the default) or filter expressions are provided then consume the insert-remove stream bool disableIndexShare = HintEnum.DISABLE_WINDOW_SUBQUERY_INDEXSHARE.GetHint(statement.StatementRawInfo.Annotations) != null; bool processorDisableIndexShare = !namedSpec.NamedWindow.IsEnableIndexShare; if (disableIndexShare && namedSpec.NamedWindow.IsVirtualDataWindow) { disableIndexShare = false; } if ((!namedSpec.FilterExpressions.IsEmpty() || processorDisableIndexShare || disableIndexShare) && (!services.IsFireAndForget)) { ExprNode filterEvaluator = null; if (!namedSpec.FilterExpressions.IsEmpty()) { filterEvaluator = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(namedSpec.FilterExpressions); } ViewableActivatorForge activatorNamedWindow = new ViewableActivatorNamedWindowForge( namedSpec, nwinfo, filterEvaluator, null, true, namedSpec.OptPropertyEvaluator); ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, namedWindowType); IList <ViewFactoryForge> forges = viewForgeDesc.Forges; additionalForgeables.AddAll(viewForgeDesc.MultikeyForges); subselect.RawEventType = forges.IsEmpty() ? namedWindowType : forges[forges.Count - 1].EventType; result.Put(subselect, new SubSelectActivationPlan(namedWindowType, forges, activatorNamedWindow, streamSpec)); } else { // else if there are no named window stream filter expressions and index sharing is enabled ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, namedWindowType); IList <ViewFactoryForge> forges = viewForgeDesc.Forges; additionalForgeables.AddAll(viewForgeDesc.MultikeyForges); subselect.RawEventType = namedWindowType; ViewableActivatorForge activatorNamedWindow = new ViewableActivatorSubselectNoneForge(namedWindowType); result.Put(subselect, new SubSelectActivationPlan(namedWindowType, forges, activatorNamedWindow, streamSpec)); } } } return(new SubSelectActivationDesc(result, additionalForgeables)); }
public static StreamSpecCompiledDesc CompileFilter( FilterStreamSpecRaw streamSpec, bool isInsertInto, bool isJoin, bool isContextDeclaration, bool isOnTrigger, string optionalStreamName, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { // Determine the event type var rawFilterSpec = streamSpec.RawFilterSpec; var eventTypeName = rawFilterSpec.EventTypeName; var table = services.TableCompileTimeResolver.Resolve(eventTypeName); if (table != null) { if (streamSpec.ViewSpecs != null && streamSpec.ViewSpecs.Length > 0) { throw new ExprValidationException("Views are not supported with tables"); } if (streamSpec.RawFilterSpec.OptionalPropertyEvalSpec != null) { throw new ExprValidationException("Contained-event expressions are not supported with tables"); } StreamTypeService streamTypeService = new StreamTypeServiceImpl( new[] {table.InternalEventType}, new[] {optionalStreamName}, new[] {true}, false, false); FilterSpecValidatedDesc descX = FilterSpecCompiler.ValidateAllowSubquery( ExprNodeOrigin.FILTER, rawFilterSpec.FilterExpressions, streamTypeService, null, null, statementRawInfo, services); TableQueryStreamSpec tableStreamSpec = new TableQueryStreamSpec( streamSpec.OptionalStreamName, streamSpec.ViewSpecs, streamSpec.Options, table, descX.Expressions); return new StreamSpecCompiledDesc( tableStreamSpec, descX.AdditionalForgeables); } // Could be a named window var namedWindowInfo = services.NamedWindowCompileTimeResolver.Resolve(eventTypeName); if (namedWindowInfo != null) { StreamTypeService streamTypeService = new StreamTypeServiceImpl( new[] {namedWindowInfo.EventType}, new[] {optionalStreamName}, new[] {true}, false, false); FilterSpecValidatedDesc validated = FilterSpecCompiler.ValidateAllowSubquery( ExprNodeOrigin.FILTER, rawFilterSpec.FilterExpressions, streamTypeService, null, null, statementRawInfo, services); PropertyEvaluatorForge optionalPropertyEvaluator = null; if (rawFilterSpec.OptionalPropertyEvalSpec != null) { optionalPropertyEvaluator = PropertyEvaluatorForgeFactory.MakeEvaluator( rawFilterSpec.OptionalPropertyEvalSpec, namedWindowInfo.EventType, streamSpec.OptionalStreamName, statementRawInfo, services); } NamedWindowConsumerStreamSpec consumer = new NamedWindowConsumerStreamSpec( namedWindowInfo, streamSpec.OptionalStreamName, streamSpec.ViewSpecs, validated.Expressions, streamSpec.Options, optionalPropertyEvaluator); return new StreamSpecCompiledDesc(consumer, validated.AdditionalForgeables); } var eventType = ResolveTypeName(eventTypeName, services.EventTypeCompileTimeResolver); // Validate all nodes, make sure each returns a boolean and types are good; // Also decompose all AND super nodes into individual expressions StreamTypeService streamTypeServiceX = new StreamTypeServiceImpl( new[] {eventType}, new[] {streamSpec.OptionalStreamName}, new[] {true}, false, false); FilterSpecCompiledDesc desc = FilterSpecCompiler.MakeFilterSpec( eventType, eventTypeName, rawFilterSpec.FilterExpressions, rawFilterSpec.OptionalPropertyEvalSpec, null, null, null, // no tags streamTypeServiceX, streamSpec.OptionalStreamName, statementRawInfo, services); FilterStreamSpecCompiled compiled = new FilterStreamSpecCompiled( desc.FilterSpecCompiled, streamSpec.ViewSpecs, streamSpec.OptionalStreamName, streamSpec.Options); return new StreamSpecCompiledDesc(compiled, desc.AdditionalForgeables); }