public void TestGetProcessorSimpleSelect() { // empty group-by and no event properties aggregated in select clause (wildcard), no having clause var wildcardSelect = new SelectClauseElementCompiled[] { new SelectClauseElementWildcard() }; var spec = MakeSpec(new SelectClauseSpecCompiled(wildcardSelect, false), null, _groupByList, null, null, _orderByList); var processor = ResultSetProcessorFactoryFactory.GetProcessorPrototype( spec, _stmtContext, _typeService3Stream, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, new Configuration(_container), null, false, false); Assert.IsTrue(processor.ResultSetProcessorFactory is ResultSetProcessorHandThroughFactory); // empty group-by with select clause elements var selectList = SupportSelectExprFactory.MakeNoAggregateSelectListUnnamed(); spec = MakeSpec(new SelectClauseSpecCompiled(selectList, false), null, _groupByList, null, null, _orderByList); processor = ResultSetProcessorFactoryFactory.GetProcessorPrototype( spec, _stmtContext, _typeService1Stream, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, new Configuration(_container), null, false, false); Assert.IsTrue(processor.ResultSetProcessorFactory is ResultSetProcessorHandThroughFactory); // non-empty group-by and wildcard select, group by ignored _groupByList.Add(SupportExprNodeFactory.MakeIdentNode("DoubleBoxed", "s0")); spec = MakeSpec(new SelectClauseSpecCompiled(wildcardSelect, false), null, _groupByList, null, null, _orderByList); processor = ResultSetProcessorFactoryFactory.GetProcessorPrototype( spec, _stmtContext, _typeService1Stream, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, new Configuration(_container), null, false, false); Assert.IsTrue(processor.ResultSetProcessorFactory is ResultSetProcessorSimpleFactory); }
public void TestGetProcessorNoProcessorRequired() { // single stream, empty group-by and wildcard select, no having clause, no need for any output processing var wildcardSelect = new SelectClauseElementCompiled[] { new SelectClauseElementWildcard() }; var spec = MakeSpec(new SelectClauseSpecCompiled(wildcardSelect, false), null, _groupByList, null, null, _orderByList); var processor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(spec, _stmtContext, _typeService1Stream, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, new Configuration()); Assert.IsTrue(processor.ResultSetProcessorFactory is ResultSetProcessorHandThroughFactory); }
public void TestGetProcessorInvalid() { var spec = MakeSpec(new SelectClauseSpecCompiled(SupportSelectExprFactory.MakeInvalidSelectList(), false), null, _groupByList, null, null, _orderByList); // invalid select clause try { ResultSetProcessorFactoryFactory.GetProcessorPrototype( spec, _stmtContext, _typeService3Stream, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, new Configuration(_container), null, false, false); Assert.Fail(); } catch (ExprValidationException) { // expected } // invalid group-by _groupByList.Add(new ExprIdentNodeImpl("xxxx", "s0")); try { spec = MakeSpec(new SelectClauseSpecCompiled(SupportSelectExprFactory.MakeNoAggregateSelectListUnnamed(), false), null, _groupByList, null, null, _orderByList); ResultSetProcessorFactoryFactory.GetProcessorPrototype( spec, _stmtContext, _typeService3Stream, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, new Configuration(_container), null, false, false); Assert.Fail(); } catch (ExprValidationException) { // expected } // Test group by having properties that are aggregated in select clause, should fail _groupByList.Clear(); _groupByList.Add(SupportExprNodeFactory.MakeSumAggregateNode()); var selectList = new SelectClauseElementCompiled[] { new SelectClauseExprCompiledSpec(SupportExprNodeFactory.MakeSumAggregateNode(), null, null, false) }; try { spec = MakeSpec(new SelectClauseSpecCompiled(selectList, false), null, _groupByList, null, null, _orderByList); ResultSetProcessorFactoryFactory.GetProcessorPrototype( spec, _stmtContext, _typeService3Stream, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, new Configuration(_container), null, false, false); Assert.Fail(); } catch (ExprValidationException) { // expected } }
public void TestGetProcessorRowForAll() { // empty group-by but aggragating event properties in select clause (output per event), no having clause // and all properties in the select clause are aggregated var selectList = SupportSelectExprFactory.MakeAggregateSelectListWithProps(); var spec = MakeSpec(new SelectClauseSpecCompiled(selectList, false), null, _groupByList, null, null, _orderByList); var processor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(spec, _stmtContext, _typeService1Stream, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, new Configuration()); Assert.IsTrue(processor.ResultSetProcessorFactory is ResultSetProcessorRowForAllFactory); }
public void TestGetProcessorRowPerGroup() { // with group-by and the non-aggregated event properties are all listed in the group by (output per group) // no having clause var selectList = SupportSelectExprFactory.MakeAggregateMixed(); _groupByList.Add(SupportExprNodeFactory.MakeIdentNode("DoubleBoxed", "s0")); var spec = MakeSpec(new SelectClauseSpecCompiled(selectList, false), null, _groupByList, null, null, _orderByList); var processor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(spec, _stmtContext, _typeService1Stream, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, new Configuration()); Assert.IsTrue(processor.ResultSetProcessorFactory is ResultSetProcessorRowPerGroupFactory); }
protected override StatementAgentInstanceFactoryResult NewContextInternal(AgentInstanceContext agentInstanceContext, bool isRecoveringResilient) { StopCallback stopCallback = new ProxyStopCallback(() => _services.VariableService.DeallocateVariableState(_variableMetaData.VariableName, agentInstanceContext.AgentInstanceId)); _services.VariableService.AllocateVariableState( _variableMetaData.VariableName, agentInstanceContext.AgentInstanceId, _statementContext.StatementExtensionServicesContext, isRecoveringResilient); CreateVariableView createView = new CreateVariableView( _statementContext.StatementId, _services.EventAdapterService, _services.VariableService, _createDesc.VariableName, _statementContext.StatementResultService, agentInstanceContext.AgentInstanceId); _services.VariableService.RegisterCallback(_createDesc.VariableName, agentInstanceContext.AgentInstanceId, createView.Update); _statementContext.StatementStopService.StatementStopped += () => _services.VariableService.UnregisterCallback(_createDesc.VariableName, 0, createView.Update); // Create result set processor, use wildcard selection _statementSpec.SelectClauseSpec.SetSelectExprList(new SelectClauseElementWildcard()); _statementSpec.SelectStreamDirEnum = SelectClauseStreamSelectorEnum.RSTREAM_ISTREAM_BOTH; var typeService = new StreamTypeServiceImpl(new EventType[] { createView.EventType }, new string[] { "create_variable" }, new bool[] { true }, _services.EngineURI, false); OutputProcessViewBase outputViewBase; try { ResultSetProcessorFactoryDesc resultSetProcessorPrototype = ResultSetProcessorFactoryFactory.GetProcessorPrototype( _statementSpec, _statementContext, typeService, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, _services.ConfigSnapshot, _services.ResultSetProcessorHelperFactory, false, false); ResultSetProcessor resultSetProcessor = EPStatementStartMethodHelperAssignExpr.GetAssignResultSetProcessor(agentInstanceContext, resultSetProcessorPrototype, false, null, false); // Attach output view OutputProcessViewFactory outputViewFactory = OutputProcessViewFactoryFactory.Make( _statementSpec, _services.InternalEventRouter, agentInstanceContext.StatementContext, resultSetProcessor.ResultEventType, null, _services.TableService, resultSetProcessorPrototype.ResultSetProcessorFactory.ResultSetProcessorType, _services.ResultSetProcessorHelperFactory, _services.StatementVariableRefService); outputViewBase = outputViewFactory.MakeView(resultSetProcessor, agentInstanceContext); createView.AddView(outputViewBase); } catch (ExprValidationException ex) { throw new EPException("Unexpected exception in create-variable context allocation: " + ex.Message, ex); } return(new StatementAgentInstanceFactoryCreateVariableResult(outputViewBase, stopCallback, agentInstanceContext)); }
public void TestGetProcessorAggregatingAll() { // empty group-by but aggragating event properties in select clause (output per event), no having clause // and one or more properties in the select clause is not aggregated var selectList = SupportSelectExprFactory.MakeAggregateMixed(); var spec = MakeSpec(new SelectClauseSpecCompiled(selectList, false), null, _groupByList, null, null, _orderByList); var processor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(spec, _stmtContext, _typeService1Stream, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, new Configuration()); Assert.IsTrue(processor.ResultSetProcessorFactory is ResultSetProcessorAggregateAllFactory); // test a case where a property is both aggregated and non-aggregated: select volume, Sum(volume) selectList = SupportSelectExprFactory.MakeAggregatePlusNoAggregate(); spec = MakeSpec(new SelectClauseSpecCompiled(selectList, false), null, _groupByList, null, null, _orderByList); processor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(spec, _stmtContext, _typeService1Stream, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, new Configuration()); Assert.IsTrue(processor.ResultSetProcessorFactory is ResultSetProcessorAggregateAllFactory); }
public void TestGetProcessorAggregatingGrouped() { // with group-by but either // wildcard // or one or more non-aggregated event properties are not in the group by (output per event) var selectList = SupportSelectExprFactory.MakeAggregateMixed(); var identNode = SupportExprNodeFactory.MakeIdentNode("TheString", "s0"); selectList = (SelectClauseElementCompiled[])CollectionUtil.ArrayExpandAddSingle(selectList, new SelectClauseExprCompiledSpec(identNode, null, null, false)); _groupByList.Add(SupportExprNodeFactory.MakeIdentNode("DoubleBoxed", "s0")); var spec = MakeSpec(new SelectClauseSpecCompiled(selectList, false), null, _groupByList, null, null, _orderByList); var processor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(spec, _stmtContext, _typeService1Stream, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, new Configuration()); Assert.IsTrue(processor.ResultSetProcessorFactory is ResultSetProcessorAggregateGroupedFactory); }
private static OnSplitItemForge OnSplitValidate( StreamTypeService typeServiceTrigger, StatementSpecCompiled statementSpecCompiled, ContextPropertyRegistry contextPropertyRegistry, PropertyEvaluatorForge optionalPropertyEval, StatementRawInfo rawInfo, StatementCompileTimeServices services) { var insertIntoName = statementSpecCompiled.Raw.InsertIntoDesc.EventTypeName; var isNamedWindowInsert = services.NamedWindowCompileTimeResolver.Resolve(insertIntoName) != null; var table = services.TableCompileTimeResolver.Resolve(insertIntoName); EPStatementStartMethodHelperValidate.ValidateNodes( statementSpecCompiled.Raw, typeServiceTrigger, null, rawInfo, services); var spec = new ResultSetSpec(statementSpecCompiled); var factoryDescs = ResultSetProcessorFactoryFactory.GetProcessorPrototype( spec, typeServiceTrigger, null, new bool[0], false, contextPropertyRegistry, false, true, rawInfo, services); return new OnSplitItemForge( statementSpecCompiled.Raw.WhereClause, isNamedWindowInsert, table, factoryDescs, optionalPropertyEval); }
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 var stopCallbacks = new List <StopCallback>(); var 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.NamedWindowMgmtService, 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, i); } } eventStreamParentViewableActivators[i] = activatorDeactivator; var resultEventType = filterStreamSpec.FilterSpec.ResultEventType; unmaterializedViewChain[i] = services.ViewService.CreateFactories(i, resultEventType, streamSpec.ViewSpecs, streamSpec.Options, statementContext, false, -1); } // 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, false, -1); var rootFactoryNode = services.PatternNodeFactory.MakeRootNode(patternStreamSpec.EvalFactoryNode); var patternContext = statementContext.PatternContextFactory.CreateContext(statementContext, i, rootFactoryNode, patternStreamSpec.MatchedEventMapMeta, true); // create activator var 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, services.DataCacheFactory, statementContext); historicalEventViewables[i] = historicalEventViewable; unmaterializedViewChain[i] = ViewFactoryChain.FromTypeNoViews(historicalEventViewable.EventType); eventStreamParentViewableActivators[i] = services.ViewableActivatorFactory.MakeHistorical(historicalEventViewable); stopCallbacks.Add(historicalEventViewable); } 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, services.DataCacheFactory, statementContext); historicalEventViewables[i] = historicalEventViewable; unmaterializedViewChain[i] = ViewFactoryChain.FromTypeNoViews(historicalEventViewable.EventType); eventStreamParentViewableActivators[i] = services.ViewableActivatorFactory.MakeHistorical(historicalEventViewable); stopCallbacks.Add(historicalEventViewable); } else if (streamSpec is TableQueryStreamSpec) { ValidateNoViews(streamSpec, "Table data"); var 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"); } var 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] = services.ViewableActivatorFactory.CreateTable(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(new EPStatementDestroyCallbackTableIdxRef(services.TableService, metadata, statementContext.StatementName)); } services.StatementVariableRefService.AddReferences(statementContext.StatementName, metadata.TableName); } else if (streamSpec is NamedWindowConsumerStreamSpec) { var namedSpec = (NamedWindowConsumerStreamSpec)streamSpec; var processor = services.NamedWindowMgmtService.GetProcessor(namedSpec.WindowName); var namedWindowType = processor.TailView.EventType; if (namedSpec.OptPropertyEvaluator != null) { namedWindowType = namedSpec.OptPropertyEvaluator.FragmentEventType; } eventStreamParentViewableActivators[i] = services.ViewableActivatorFactory.CreateNamedWindow(processor, namedSpec, statementContext); services.NamedWindowConsumerMgmtService.AddConsumer(statementContext, namedSpec); unmaterializedViewChain[i] = services.ViewService.CreateFactories(i, namedWindowType, namedSpec.ViewSpecs, namedSpec.Options, statementContext, false, -1); 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 factoryX = services.RegexHandlerFactory.MakeViewFactory(unmaterializedViewChain[0], statementSpec.MatchRecognizeSpec, defaultAgentInstanceContext, isUnbound, statementSpec.Annotations, services.ConfigSnapshot.EngineDefaults.MatchRecognizeConfig); unmaterializedViewChain[0].FactoryChain.Add(factoryX); EPStatementStartMethodHelperAssignExpr.AssignAggregations(factoryX.AggregationService, factoryX.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); 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, services.ResultSetProcessorHelperFactory, false, false); // 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, services.EventTableIndexService.AllowInitIndex(recoveringResilient)); } // obtain factory for output limiting var outputViewFactory = OutputProcessViewFactoryFactory.Make(statementSpec, services.InternalEventRouter, statementContext, resultSetProcessorPrototypeDesc.ResultSetProcessorFactory.ResultEventType, optionalOutputProcessViewCallback, services.TableService, resultSetProcessorPrototypeDesc.ResultSetProcessorFactory.ResultSetProcessorType, services.ResultSetProcessorHelperFactory, services.StatementVariableRefService); // Factory for statement-context instances var factory = new StatementAgentInstanceFactorySelect( numStreams, eventStreamParentViewableActivators, statementContext, statementSpec, services, typeService, unmaterializedViewChain, resultSetProcessorPrototypeDesc, joinAnalysisResult, recoveringResilient, joinSetComposerPrototype, subSelectStrategyCollection, viewResourceDelegateVerified, outputViewFactory); EPStatementStopMethod stopMethod = new EPStatementStopMethodImpl(statementContext, stopCallbacks); return(new EPStatementStartMethodSelectDesc(factory, subSelectStrategyCollection, viewResourceDelegateUnverified, resultSetProcessorPrototypeDesc, stopMethod, destroyCallbacks)); }
public override EPStatementStartResult StartInternal( EPServicesContext services, StatementContext statementContext, bool isNewStatement, bool isRecoveringStatement, bool isRecoveringResilient) { // define stop var stopCallbacks = new List <StopCallback>(); // determine context var contextName = _statementSpec.OptionalContextName; // Create view factories and parent view based on a filter specification // Since only for non-joins we get the existing stream's lock and try to reuse it's views var filterStreamSpec = (FilterStreamSpecCompiled)_statementSpec.StreamSpecs[0]; InstrumentationAgent instrumentationAgentCreateWindowInsert = null; if (InstrumentationHelper.ENABLED) { var eventTypeName = filterStreamSpec.FilterSpec.FilterForEventType.Name; instrumentationAgentCreateWindowInsert = new ProxyInstrumentationAgent() { ProcIndicateQ = () => InstrumentationHelper.Get().QFilterActivationNamedWindowInsert(eventTypeName), ProcIndicateA = () => InstrumentationHelper.Get().AFilterActivationNamedWindowInsert(), }; } var activator = services.ViewableActivatorFactory.CreateFilterProxy(services, filterStreamSpec.FilterSpec, statementContext.Annotations, false, instrumentationAgentCreateWindowInsert, false, 0); // create data window view factories var unmaterializedViewChain = services.ViewService.CreateFactories(0, filterStreamSpec.FilterSpec.ResultEventType, filterStreamSpec.ViewSpecs, filterStreamSpec.Options, statementContext, false, -1); // verify data window VerifyDataWindowViewFactoryChain(unmaterializedViewChain.FactoryChain); // get processor for variant-streams and versioned typed var windowName = _statementSpec.CreateWindowDesc.WindowName; var optionalRevisionProcessor = statementContext.ValueAddEventService.GetValueAddProcessor(windowName); // add named window processor (one per named window for all agent instances) var isPrioritized = services.EngineSettingsService.EngineSettings.ExecutionConfig.IsPrioritized; var isEnableSubqueryIndexShare = HintEnum.ENABLE_WINDOW_SUBQUERY_INDEXSHARE.GetHint(_statementSpec.Annotations) != null; if (!isEnableSubqueryIndexShare && unmaterializedViewChain.FactoryChain[0] is VirtualDWViewFactory) { isEnableSubqueryIndexShare = true; // index share is always enabled for virtual data window (otherwise it wouldn't make sense) } var isBatchingDataWindow = DetermineBatchingDataWindow(unmaterializedViewChain.FactoryChain); var virtualDataWindowFactory = DetermineVirtualDataWindow(unmaterializedViewChain.FactoryChain); var optionalUniqueKeyProps = ViewServiceHelper.GetUniqueCandidateProperties(unmaterializedViewChain.FactoryChain, _statementSpec.Annotations); var processor = services.NamedWindowMgmtService.AddProcessor( windowName, contextName, filterStreamSpec.FilterSpec.ResultEventType, statementContext.StatementResultService, optionalRevisionProcessor, statementContext.Expression, statementContext.StatementName, isPrioritized, isEnableSubqueryIndexShare, isBatchingDataWindow, virtualDataWindowFactory != null, optionalUniqueKeyProps, _statementSpec.CreateWindowDesc.AsEventTypeName, statementContext, services.NamedWindowDispatchService); Viewable finalViewable; EPStatementStopMethod stopStatementMethod; EPStatementDestroyMethod destroyStatementMethod; try { // add stop callback stopCallbacks.Add(new ProxyStopCallback(() => { services.NamedWindowMgmtService.RemoveProcessor(windowName); if (virtualDataWindowFactory != null) { virtualDataWindowFactory.DestroyNamedWindow(); } })); // Add a wildcard to the select clause as subscribers received the window contents _statementSpec.SelectClauseSpec.SetSelectExprList(new SelectClauseElementWildcard()); _statementSpec.SelectStreamDirEnum = SelectClauseStreamSelectorEnum.RSTREAM_ISTREAM_BOTH; // obtain result set processor factory StreamTypeService typeService = new StreamTypeServiceImpl(new EventType[] { processor.NamedWindowType }, new string[] { windowName }, new bool[] { true }, services.EngineURI, false); var resultSetProcessorPrototype = ResultSetProcessorFactoryFactory.GetProcessorPrototype( _statementSpec, statementContext, typeService, null, new bool[0], true, null, null, services.ConfigSnapshot, services.ResultSetProcessorHelperFactory, false, false); // obtain factory for output limiting var outputViewFactory = OutputProcessViewFactoryFactory.Make( _statementSpec, services.InternalEventRouter, statementContext, resultSetProcessorPrototype.ResultSetProcessorFactory.ResultEventType, null, services.TableService, resultSetProcessorPrototype.ResultSetProcessorFactory.ResultSetProcessorType, services.ResultSetProcessorHelperFactory, services.StatementVariableRefService); // create context factory // Factory for statement-context instances var contextFactory = new StatementAgentInstanceFactoryCreateWindow(statementContext, _statementSpec, services, activator, unmaterializedViewChain, resultSetProcessorPrototype, outputViewFactory, isRecoveringStatement); statementContext.StatementAgentInstanceFactory = contextFactory; // With context - delegate instantiation to context EPStatementStopMethod stopMethod = new EPStatementStopMethodImpl(statementContext, stopCallbacks); if (_statementSpec.OptionalContextName != null) { var mergeView = new ContextMergeView(processor.NamedWindowType); finalViewable = mergeView; var statement = new ContextManagedStatementCreateWindowDesc(_statementSpec, statementContext, mergeView, contextFactory); services.ContextManagementService.AddStatement(contextName, statement, isRecoveringResilient); stopStatementMethod = new ProxyEPStatementStopMethod(() => { services.ContextManagementService.StoppedStatement(contextName, statementContext.StatementName, statementContext.StatementId, statementContext.Expression, statementContext.ExceptionHandlingService); stopMethod.Stop(); }); destroyStatementMethod = new ProxyEPStatementDestroyMethod(() => services.ContextManagementService.DestroyedStatement(contextName, statementContext.StatementName, statementContext.StatementId)); } // Without context - start here else { var agentInstanceContext = GetDefaultAgentInstanceContext(statementContext); StatementAgentInstanceFactoryCreateWindowResult resultOfStart; try { resultOfStart = (StatementAgentInstanceFactoryCreateWindowResult)contextFactory.NewContext(agentInstanceContext, isRecoveringResilient); } catch (Exception) { services.NamedWindowMgmtService.RemoveProcessor(windowName); throw; } finalViewable = resultOfStart.FinalView; var stopCallback = services.EpStatementFactory.MakeStopMethod(resultOfStart); stopStatementMethod = new ProxyEPStatementStopMethod(() => { stopCallback.Stop(); stopMethod.Stop(); }); destroyStatementMethod = null; if (statementContext.StatementExtensionServicesContext != null && statementContext.StatementExtensionServicesContext.StmtResources != null) { var holder = statementContext.StatementExtensionServicesContext.ExtractStatementResourceHolder(resultOfStart); statementContext.StatementExtensionServicesContext.StmtResources.Unpartitioned = holder; statementContext.StatementExtensionServicesContext.PostProcessStart(resultOfStart, isRecoveringResilient); } } } catch (ExprValidationException) { services.NamedWindowMgmtService.RemoveProcessor(windowName); throw; } catch (Exception) { services.NamedWindowMgmtService.RemoveProcessor(windowName); throw; } services.StatementVariableRefService.AddReferences(statementContext.StatementName, windowName); return(new EPStatementStartResult(finalViewable, stopStatementMethod, destroyStatementMethod)); }
public static OnTriggerPlanValidationResult ValidateOnTriggerPlan( EventType namedWindowOrTableType, OnTriggerWindowDesc onTriggerDesc, StreamSpecCompiled streamSpec, OnTriggerActivatorDesc activatorResult, IDictionary<ExprSubselectNode, SubSelectActivationPlan> subselectActivation, StatementBaseInfo @base, StatementCompileTimeServices services) { var zeroStreamAliasName = onTriggerDesc.OptionalAsName; if (zeroStreamAliasName == null) { zeroStreamAliasName = "stream_0"; } var streamName = streamSpec.OptionalStreamName; if (streamName == null) { streamName = "stream_1"; } var namedWindowTypeName = onTriggerDesc.WindowName; // Materialize sub-select views // 0 - named window stream // 1 - arriving stream // 2 - initial value before update string[] subselectStreamNames = {zeroStreamAliasName, streamSpec.OptionalStreamName}; EventType[] subselectEventTypes = {namedWindowOrTableType, activatorResult.ActivatorResultEventType}; string[] subselectEventTypeNames = {namedWindowTypeName, activatorResult.TriggerEventTypeName}; var subselectForges = SubSelectHelperForgePlanner.PlanSubSelect( @base, subselectActivation, subselectStreamNames, subselectEventTypes, subselectEventTypeNames, services); var typeService = new StreamTypeServiceImpl( new[] {namedWindowOrTableType, activatorResult.ActivatorResultEventType}, new[] {zeroStreamAliasName, streamName}, new[] {false, true}, true, false); // allow "initial" as a prefix to properties StreamTypeServiceImpl assignmentTypeService; if (zeroStreamAliasName.Equals(INITIAL_VALUE_STREAM_NAME) || streamName.Equals(INITIAL_VALUE_STREAM_NAME)) { assignmentTypeService = typeService; } else { assignmentTypeService = new StreamTypeServiceImpl( new[] {namedWindowOrTableType, activatorResult.ActivatorResultEventType, namedWindowOrTableType}, new[] {zeroStreamAliasName, streamName, INITIAL_VALUE_STREAM_NAME}, new[] {false, true, true}, false, false); assignmentTypeService.IsStreamZeroUnambigous = true; } if (onTriggerDesc is OnTriggerWindowUpdateDesc) { var updateDesc = (OnTriggerWindowUpdateDesc) onTriggerDesc; var validationContext = new ExprValidationContextBuilder( assignmentTypeService, @base.StatementRawInfo, services) .WithAllowBindingConsumption(true) .Build(); foreach (var assignment in updateDesc.Assignments) { var validated = ExprNodeUtilityValidate.GetValidatedAssignment(assignment, validationContext); assignment.Expression = validated; EPStatementStartMethodHelperValidate.ValidateNoAggregations( validated, "Aggregation functions may not be used within an on-update-clause"); } } if (onTriggerDesc is OnTriggerMergeDesc) { var mergeDesc = (OnTriggerMergeDesc) onTriggerDesc; ValidateMergeDesc( mergeDesc, namedWindowOrTableType, zeroStreamAliasName, activatorResult.ActivatorResultEventType, streamName, @base.StatementRawInfo, services); } // validate join expression var validatedJoin = ValidateJoinNamedWindow( ExprNodeOrigin.WHERE, @base.StatementSpec.Raw.WhereClause, namedWindowOrTableType, zeroStreamAliasName, namedWindowTypeName, activatorResult.ActivatorResultEventType, streamName, activatorResult.TriggerEventTypeName, null, @base.StatementRawInfo, services); // validate filter, output rate limiting EPStatementStartMethodHelperValidate.ValidateNodes( @base.StatementSpec.Raw, typeService, null, @base.StatementRawInfo, services); // Construct a processor for results; for use in on-select to process selection results // Use a wildcard select if the select-clause is empty, such as for on-delete. // For on-select the select clause is not empty. if (@base.StatementSpec.SelectClauseCompiled.SelectExprList.Length == 0) { @base.StatementSpec.SelectClauseCompiled.WithSelectExprList(new SelectClauseElementWildcard()); } var resultSetProcessorPrototype = ResultSetProcessorFactoryFactory.GetProcessorPrototype( new ResultSetSpec(@base.StatementSpec), typeService, null, new bool[0], true, @base.ContextPropertyRegistry, false, true, @base.StatementRawInfo, services); // plan table access var tableAccessForges = ExprTableEvalHelperPlan.PlanTableAccess(@base.StatementSpec.TableAccessNodes); return new OnTriggerPlanValidationResult( subselectForges, tableAccessForges, resultSetProcessorPrototype, validatedJoin, zeroStreamAliasName); }
public override EPStatementStartResult StartInternal(EPServicesContext services, StatementContext statementContext, bool isNewStatement, bool isRecoveringStatement, bool isRecoveringResilient) { var createDesc = StatementSpec.CreateVariableDesc; VariableServiceUtil.CheckAlreadyDeclaredTable(createDesc.VariableName, services.TableService); // Get assignment value Object value = null; if (createDesc.Assignment != null) { // Evaluate assignment expression var typeService = new StreamTypeServiceImpl(new EventType[0], new String[0], new bool[0], services.EngineURI, false); var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, false); var validationContext = new ExprValidationContext( typeService, statementContext.MethodResolutionService, null, statementContext.SchedulingService, statementContext.VariableService, statementContext.TableService, evaluatorContextStmt, statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, false, false, false, false, null, false); var validated = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.VARIABLEASSIGN, createDesc.Assignment, validationContext); value = validated.ExprEvaluator.Evaluate(new EvaluateParams(null, true, evaluatorContextStmt)); } // Create variable try { services.VariableService.CreateNewVariable( StatementSpec.OptionalContextName, createDesc.VariableName, createDesc.VariableType, createDesc.IsConstant, createDesc.IsArray, createDesc.IsArrayOfPrimitive, value, services.EngineImportService); } catch (VariableExistsException ex) { // for new statement we don't allow creating the same variable if (isNewStatement) { throw new ExprValidationException("Cannot create variable: " + ex.Message, ex); } } catch (VariableDeclarationException ex) { throw new ExprValidationException("Cannot create variable: " + ex.Message, ex); } var destroyMethod = new EPStatementDestroyCallbackList(); destroyMethod.AddCallback( () => { try { services.StatementVariableRefService.RemoveReferencesStatement(statementContext.StatementName); } catch (Exception ex) { Log.Error("Error removing variable '" + createDesc.VariableName + "': " + ex.Message); } }); var stopMethod = new EPStatementStopMethod(() => { }); VariableMetaData variableMetaData = services.VariableService.GetVariableMetaData(createDesc.VariableName); Viewable outputView; if (StatementSpec.OptionalContextName != null) { EventType eventType = CreateVariableView.GetEventType(statementContext.StatementId, services.EventAdapterService, variableMetaData); var contextFactory = new StatementAgentInstanceFactoryCreateVariable(statementContext, services, variableMetaData, eventType); var mergeView = new ContextMergeView(eventType); outputView = mergeView; var statement = new ContextManagedStatementCreateVariableDesc(StatementSpec, statementContext, mergeView, contextFactory); services.ContextManagementService.AddStatement(StatementSpec.OptionalContextName, statement, isRecoveringResilient); ContextManagementService contextManagementService = services.ContextManagementService; destroyMethod.AddCallback(() => contextManagementService.DestroyedStatement(StatementSpec.OptionalContextName, statementContext.StatementName, statementContext.StatementId)); } else { // allocate services.VariableService.AllocateVariableState(createDesc.VariableName, VariableServiceConstants.NOCONTEXT_AGENTINSTANCEID, statementContext.StatementExtensionServicesContext); var createView = new CreateVariableView(statementContext.StatementId, services.EventAdapterService, services.VariableService, createDesc.VariableName, statementContext.StatementResultService); services.VariableService.RegisterCallback(createDesc.VariableName, 0, createView.Update); statementContext.StatementStopService.StatementStopped += () => services.VariableService.UnregisterCallback(createDesc.VariableName, 0, createView.Update); // Create result set processor, use wildcard selection StatementSpec.SelectClauseSpec.SetSelectExprList(new SelectClauseElementWildcard()); StatementSpec.SelectStreamDirEnum = SelectClauseStreamSelectorEnum.RSTREAM_ISTREAM_BOTH; StreamTypeService typeService = new StreamTypeServiceImpl(new EventType[] { createView.EventType }, new String[] { "create_variable" }, new bool[] { true }, services.EngineURI, false); var agentInstanceContext = GetDefaultAgentInstanceContext(statementContext); var resultSetProcessorPrototype = ResultSetProcessorFactoryFactory.GetProcessorPrototype( StatementSpec, statementContext, typeService, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, services.ConfigSnapshot); var resultSetProcessor = EPStatementStartMethodHelperAssignExpr.GetAssignResultSetProcessor(agentInstanceContext, resultSetProcessorPrototype); // Attach output view var outputViewFactory = OutputProcessViewFactoryFactory.Make(StatementSpec, services.InternalEventRouter, agentInstanceContext.StatementContext, resultSetProcessor.ResultEventType, null, services.TableService, resultSetProcessorPrototype.ResultSetProcessorFactory.ResultSetProcessorType); var outputViewBase = outputViewFactory.MakeView(resultSetProcessor, agentInstanceContext); createView.AddView(outputViewBase); outputView = outputViewBase; } services.StatementVariableRefService.AddReferences(statementContext.StatementName, Collections.SingletonList(createDesc.VariableName), null); return(new EPStatementStartResult(outputView, stopMethod, destroyMethod.Destroy)); }
public StmtForgeMethodResult Make( string @namespace, string classPostfix, StatementCompileTimeServices services) { var statementSpec = _base.StatementSpec; var createDesc = statementSpec.Raw.CreateVariableDesc; // Check if the variable is already declared EPLValidationUtil.ValidateAlreadyExistsTableOrVariable( createDesc.VariableName, services.VariableCompileTimeResolver, services.TableCompileTimeResolver, services.EventTypeCompileTimeResolver); // Get assignment value when compile-time-constant object initialValue = null; ExprForge initialValueExpr = null; if (createDesc.Assignment != null) { // Evaluate assignment expression StreamTypeService typeService = new StreamTypeServiceImpl( new EventType[0], new string[0], new bool[0], false, false); var validationContext = new ExprValidationContextBuilder(typeService, _base.StatementRawInfo, services).Build(); var validated = ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.VARIABLEASSIGN, createDesc.Assignment, validationContext); if (validated.Forge.ForgeConstantType == ExprForgeConstantType.COMPILETIMECONST) { initialValue = validated.Forge.ExprEvaluator.Evaluate(null, true, null); } createDesc.Assignment = validated; initialValueExpr = validated.Forge; } var contextName = statementSpec.Raw.OptionalContextName; NameAccessModifier? contextVisibility = null; string contextModuleName = null; if (contextName != null) { var contextDetail = services.ContextCompileTimeResolver.GetContextInfo(contextName); if (contextDetail == null) { throw new ExprValidationException("Failed to find context '" + contextName + "'"); } contextVisibility = contextDetail.ContextVisibility; contextModuleName = contextDetail.ContextModuleName; } // get visibility var visibility = services.ModuleVisibilityRules.GetAccessModifierVariable(_base, createDesc.VariableName); // Compile metadata var compileTimeConstant = createDesc.IsConstant && initialValueExpr != null && initialValueExpr.ForgeConstantType.IsCompileTimeConstant; var metaData = VariableUtil.CompileVariable( createDesc.VariableName, _base.ModuleName, visibility, contextName, contextVisibility, contextModuleName, createDesc.VariableType, createDesc.IsConstant, compileTimeConstant, initialValue, services.ImportServiceCompileTime, EventBeanTypedEventFactoryCompileTime.INSTANCE, services.EventTypeRepositoryPreconfigured, services.BeanEventTypeFactoryPrivate); // Register variable services.VariableCompileTimeRegistry.NewVariable(metaData); // Statement event type var eventTypePropertyTypes = Collections.SingletonDataMap( metaData.VariableName, metaData.Type); var eventTypeName = services.EventTypeNameGeneratorStatement.AnonymousTypeName; var eventTypeMetadata = new EventTypeMetadata( eventTypeName, _base.ModuleName, EventTypeTypeClass.STATEMENTOUT, EventTypeApplicationType.MAP, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var outputEventType = BaseNestableEventUtil.MakeMapTypeCompileTime( eventTypeMetadata, eventTypePropertyTypes, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(outputEventType); // Handle output format var defaultSelectAllSpec = new StatementSpecCompiled(); defaultSelectAllSpec.SelectClauseCompiled.WithSelectExprList(new SelectClauseElementWildcard()); defaultSelectAllSpec.Raw.SelectStreamDirEnum = SelectClauseStreamSelectorEnum.RSTREAM_ISTREAM_BOTH; StreamTypeService streamTypeService = new StreamTypeServiceImpl( new EventType[] {outputEventType}, new string[] {"trigger_stream"}, new bool[] {true}, false, false); var resultSetProcessor = ResultSetProcessorFactoryFactory.GetProcessorPrototype( new ResultSetSpec(defaultSelectAllSpec), streamTypeService, null, new bool[1], false, _base.ContextPropertyRegistry, false, false, _base.StatementRawInfo, services); // Code generation var statementFieldsClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix); var aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(StatementAIFactoryProvider), classPostfix); var classNameRSP = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(ResultSetProcessorFactoryProvider), classPostfix); var packageScope = new CodegenNamespaceScope( @namespace, statementFieldsClassName, services.IsInstrumented); var forge = new StatementAgentInstanceFactoryCreateVariableForge( createDesc.VariableName, initialValueExpr, classNameRSP); var aiFactoryForgable = new StmtClassForgableAIFactoryProviderCreateVariable( aiFactoryProviderClassName, packageScope, forge, createDesc.VariableName); var informationals = StatementInformationalsUtil.GetInformationals( _base, Collections.GetEmptyList<FilterSpecCompiled>(), Collections.GetEmptyList<ScheduleHandleCallbackProvider>(), Collections.GetEmptyList<NamedWindowConsumerStreamSpec>(), true, resultSetProcessor.SelectSubscriberDescriptor, packageScope, services); var statementProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix); var stmtProvider = new StmtClassForgableStmtProvider( aiFactoryProviderClassName, statementProviderClassName, informationals, packageScope); IList<StmtClassForgable> forgables = new List<StmtClassForgable>(); forgables.Add( new StmtClassForgableRSPFactoryProvider( classNameRSP, resultSetProcessor, packageScope, _base.StatementRawInfo)); forgables.Add(aiFactoryForgable); forgables.Add(stmtProvider); forgables.Add(new StmtClassForgableStmtFields(statementFieldsClassName, packageScope, 0)); return new StmtForgeMethodResult( forgables, Collections.GetEmptyList<FilterSpecCompiled>(), Collections.GetEmptyList<ScheduleHandleCallbackProvider>(), Collections.GetEmptyList<NamedWindowConsumerStreamSpec>(), Collections.GetEmptyList<FilterSpecParamExprNodeForge>()); }
public static StmtForgeMethodSelectResult Make( IContainer container, bool dataflowOperator, string @namespace, string classPostfix, StatementBaseInfo @base, StatementCompileTimeServices services) { var filterSpecCompileds = new List<FilterSpecCompiled>(); var scheduleHandleCallbackProviders = new List<ScheduleHandleCallbackProvider>(); var namedWindowConsumers = new List<NamedWindowConsumerStreamSpec>(); var statementSpec = @base.StatementSpec; var additionalForgeables = new List<StmtClassForgeableFactory>(); var streamNames = StatementForgeMethodSelectUtil.DetermineStreamNames(statementSpec.StreamSpecs); var numStreams = streamNames.Length; if (numStreams == 0) { throw new ExprValidationException("The from-clause is required but has not been specified"); } // first we create streams for subselects, if there are any SubSelectActivationDesc subSelectActivationDesc = SubSelectHelperActivations.CreateSubSelectActivation( filterSpecCompileds, namedWindowConsumers, @base, services); IDictionary<ExprSubselectNode, SubSelectActivationPlan> subselectActivation = subSelectActivationDesc.Subselects; additionalForgeables.AddAll(subSelectActivationDesc.AdditionalForgeables); // verify for joins that required views are present StreamJoinAnalysisResultCompileTime joinAnalysisResult = StatementForgeMethodSelectUtil.VerifyJoinViews(statementSpec); var streamEventTypes = new EventType[statementSpec.StreamSpecs.Length]; var eventTypeNames = new string[numStreams]; var isNamedWindow = new bool[numStreams]; var viewableActivatorForges = new ViewableActivatorForge[numStreams]; var viewForges = new IList<ViewFactoryForge>[numStreams]; var historicalEventViewables = new HistoricalEventViewableForge[numStreams]; for (var stream = 0; stream < numStreams; stream++) { var streamSpec = statementSpec.StreamSpecs[stream]; var isCanIterateUnbound = streamSpec.ViewSpecs.Length == 0 && (services.Configuration.Compiler.ViewResources.IsIterableUnbound || AnnotationUtil.HasAnnotation(statementSpec.Annotations, typeof(IterableUnboundAttribute))); var args = new ViewFactoryForgeArgs( stream, false, -1, streamSpec.Options, null, @base.StatementRawInfo, services); if (dataflowOperator) { var dfResult = HandleDataflowActivation(args, streamSpec); streamEventTypes[stream] = dfResult.StreamEventType; eventTypeNames[stream] = dfResult.EventTypeName; viewableActivatorForges[stream] = dfResult.ViewableActivatorForge; viewForges[stream] = dfResult.ViewForges; additionalForgeables.AddAll(dfResult.AdditionalForgeables); } else if (streamSpec is FilterStreamSpecCompiled) { var filterStreamSpec = (FilterStreamSpecCompiled) statementSpec.StreamSpecs[stream]; var filterSpecCompiled = filterStreamSpec.FilterSpecCompiled; streamEventTypes[stream] = filterSpecCompiled.ResultEventType; eventTypeNames[stream] = filterStreamSpec.FilterSpecCompiled.FilterForEventTypeName; viewableActivatorForges[stream] = new ViewableActivatorFilterForge( filterSpecCompiled, isCanIterateUnbound, stream, false, -1); ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, streamEventTypes[stream]); viewForges[stream] = viewForgeDesc.Forges; additionalForgeables.AddAll(viewForgeDesc.MultikeyForges); filterSpecCompileds.Add(filterSpecCompiled); } else if (streamSpec is PatternStreamSpecCompiled) { var patternStreamSpec = (PatternStreamSpecCompiled) streamSpec; var forges = patternStreamSpec.Root.CollectFactories(); foreach (var forgeNode in forges) { forgeNode.CollectSelfFilterAndSchedule(filterSpecCompileds, scheduleHandleCallbackProviders); } var patternType = ViewableActivatorPatternForge.MakeRegisterPatternType( @base, stream, patternStreamSpec, services); var patternContext = new PatternContext(0, patternStreamSpec.MatchedEventMapMeta, false, -1, false); viewableActivatorForges[stream] = new ViewableActivatorPatternForge( patternType, patternStreamSpec, patternContext, isCanIterateUnbound); streamEventTypes[stream] = patternType; ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, patternType); viewForges[stream] = viewForgeDesc.Forges; additionalForgeables.AddAll(viewForgeDesc.MultikeyForges); } else if (streamSpec is NamedWindowConsumerStreamSpec) { var namedSpec = (NamedWindowConsumerStreamSpec) streamSpec; var namedWindow = services.NamedWindowCompileTimeResolver.Resolve(namedSpec.NamedWindow.EventType.Name); var namedWindowType = namedWindow.EventType; if (namedSpec.OptPropertyEvaluator != null) { namedWindowType = namedSpec.OptPropertyEvaluator.FragmentEventType; } var typesFilterValidation = new StreamTypeServiceImpl( namedWindowType, namedSpec.OptionalStreamName, false); var filterSingle = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(namedSpec.FilterExpressions); var filterQueryGraph = EPLValidationUtil.ValidateFilterGetQueryGraphSafe( filterSingle, typesFilterValidation, @base.StatementRawInfo, services); namedWindowConsumers.Add(namedSpec); viewableActivatorForges[stream] = new ViewableActivatorNamedWindowForge( namedSpec, namedWindow, filterSingle, filterQueryGraph, true, namedSpec.OptPropertyEvaluator); streamEventTypes[stream] = namedWindowType; viewForges[stream] = Collections.GetEmptyList<ViewFactoryForge>(); joinAnalysisResult.SetNamedWindowsPerStream(stream, namedWindow); eventTypeNames[stream] = namedSpec.NamedWindow.EventType.Name; isNamedWindow[stream] = true; // Consumers to named windows cannot declare a data window view onto the named window to avoid duplicate remove streams ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, namedWindowType); viewForges[stream] = viewForgeDesc.Forges; additionalForgeables.AddAll(viewForgeDesc.MultikeyForges); EPStatementStartMethodHelperValidate.ValidateNoDataWindowOnNamedWindow(viewForges[stream]); } else if (streamSpec is TableQueryStreamSpec) { ValidateNoViews(streamSpec, "Table data"); var tableStreamSpec = (TableQueryStreamSpec) streamSpec; if (numStreams > 1 && 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"); } var table = tableStreamSpec.Table; EPLValidationUtil.ValidateContextName( true, table.TableName, table.OptionalContextName, statementSpec.Raw.OptionalContextName, false); var filter = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(tableStreamSpec.FilterExpressions); viewableActivatorForges[stream] = new ViewableActivatorTableForge(table, filter); viewForges[stream] = Collections.GetEmptyList<ViewFactoryForge>(); eventTypeNames[stream] = tableStreamSpec.Table.TableName; streamEventTypes[stream] = tableStreamSpec.Table.InternalEventType; joinAnalysisResult.SetTablesForStream(stream, table); 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"); } } else if (streamSpec is DBStatementStreamSpec) { ValidateNoViews(streamSpec, "Historical data"); var sqlStreamSpec = (DBStatementStreamSpec) streamSpec; var typeConversionHook = (SQLColumnTypeConversion) ImportUtil.GetAnnotationHook( statementSpec.Annotations, HookType.SQLCOL, typeof(SQLColumnTypeConversion), services.ImportServiceCompileTime); var outputRowConversionHook = (SQLOutputRowConversion) ImportUtil.GetAnnotationHook( statementSpec.Annotations, HookType.SQLROW, typeof(SQLOutputRowConversion), services.ImportServiceCompileTime); var viewable = HistoricalEventViewableDatabaseForgeFactory.CreateDBStatementView( stream, sqlStreamSpec, typeConversionHook, outputRowConversionHook, @base, services, statementSpec.Annotations); streamEventTypes[stream] = viewable.EventType; viewForges[stream] = Collections.GetEmptyList<ViewFactoryForge>(); viewableActivatorForges[stream] = new ViewableActivatorHistoricalForge(viewable); historicalEventViewables[stream] = viewable; } else if (streamSpec is MethodStreamSpec) { ValidateNoViews(streamSpec, "Method data"); var methodStreamSpec = (MethodStreamSpec) streamSpec; var viewable = HistoricalEventViewableMethodForgeFactory.CreateMethodStatementView( stream, methodStreamSpec, @base, services); historicalEventViewables[stream] = viewable; streamEventTypes[stream] = viewable.EventType; viewForges[stream] = Collections.GetEmptyList<ViewFactoryForge>(); viewableActivatorForges[stream] = new ViewableActivatorHistoricalForge(viewable); historicalEventViewables[stream] = viewable; } else { throw new IllegalStateException("Unrecognized stream " + streamSpec); } // plan serde for iterate-unbound if (isCanIterateUnbound) { var serdeForgeables = SerdeEventTypeUtility.Plan( streamEventTypes[stream], @base.StatementRawInfo, services.SerdeEventTypeRegistry, services.SerdeResolver); additionalForgeables.AddAll(serdeForgeables); } } // handle match-recognize pattern if (statementSpec.Raw.MatchRecognizeSpec != null) { if (numStreams > 1) { 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 = viewForges[0].IsEmpty() && !(statementSpec.StreamSpecs[0] is NamedWindowConsumerStreamSpec); var eventType = viewForges[0].IsEmpty() ? streamEventTypes[0] : viewForges[0][(viewForges[0].Count - 1)].EventType; var plan = RowRecogNFAViewPlanUtil.ValidateAndPlan(services.Container, eventType, isUnbound, @base, services); var forge = new RowRecogNFAViewFactoryForge(plan.Forge); additionalForgeables.AddAll(plan.AdditionalForgeables); scheduleHandleCallbackProviders.Add(forge); viewForges[0].Add(forge); var serdeForgeables = SerdeEventTypeUtility.Plan( eventType, @base.StatementRawInfo, services.SerdeEventTypeRegistry, services.SerdeResolver); additionalForgeables.AddAll(serdeForgeables); } // Obtain event types from view factory chains for (var i = 0; i < viewForges.Length; i++) { streamEventTypes[i] = viewForges[i].IsEmpty() ? streamEventTypes[i] : viewForges[i][(viewForges[i].Count - 1)].EventType; } // add unique-information to join analysis joinAnalysisResult.AddUniquenessInfo(viewForges, statementSpec.Annotations); // plan sub-selects SubSelectHelperForgePlan subselectForgePlan = SubSelectHelperForgePlanner.PlanSubSelect( @base, subselectActivation, streamNames, streamEventTypes, eventTypeNames, services); var subselectForges = subselectForgePlan.Subselects; additionalForgeables.AddAll(subselectForgePlan.AdditionalForgeables); DetermineViewSchedules(subselectForges, scheduleHandleCallbackProviders); // determine view schedules var viewResourceDelegateExpr = new ViewResourceDelegateExpr(); ViewFactoryForgeUtil.DetermineViewSchedules(viewForges, scheduleHandleCallbackProviders); var hasIStreamOnly = StatementForgeMethodSelectUtil.GetHasIStreamOnly(isNamedWindow, viewForges); var optionalStreamsIfAny = OuterJoinAnalyzer.OptionalStreamsIfAny(statementSpec.Raw.OuterJoinDescList); StreamTypeService typeService = new StreamTypeServiceImpl( streamEventTypes, streamNames, hasIStreamOnly, false, optionalStreamsIfAny); // 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; } scheduleHandleCallbackProviders.Add(historicalEventViewable); IList<StmtClassForgeableFactory> forgeables = historicalEventViewable.Validate(typeService, @base, services); additionalForgeables.AddAll(forgeables); 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"); } } // Validate where-clause filter tree, outer join clause and output limit expression var whereClauseValidated = EPStatementStartMethodHelperValidate.ValidateNodes( statementSpec.Raw, typeService, viewResourceDelegateExpr, @base.StatementRawInfo, services); var whereClauseForge = whereClauseValidated?.Forge; // Obtain result set processor var resultSetProcessorDesc = ResultSetProcessorFactoryFactory.GetProcessorPrototype( new ResultSetSpec(statementSpec), typeService, viewResourceDelegateExpr, joinAnalysisResult.UnidirectionalInd, true, @base.ContextPropertyRegistry, false, false, @base.StatementRawInfo, services); additionalForgeables.AddAll(resultSetProcessorDesc.AdditionalForgeables); // Handle 'prior' function nodes in terms of view requirements var viewResourceDelegateDesc = ViewResourceVerifyHelper.VerifyPreviousAndPriorRequirements(viewForges, viewResourceDelegateExpr); var hasPrior = ViewResourceDelegateDesc.HasPrior(viewResourceDelegateDesc); if (hasPrior) { for (var stream = 0; stream < numStreams; stream++) { if (!viewResourceDelegateDesc[stream].PriorRequests.IsEmpty()) { viewForges[stream].Add(new PriorEventViewForge(viewForges[stream].IsEmpty(), streamEventTypes[stream])); var serdeForgeables = SerdeEventTypeUtility.Plan( streamEventTypes[stream], @base.StatementRawInfo, services.SerdeEventTypeRegistry, services.SerdeResolver); additionalForgeables.AddAll(serdeForgeables); } } } var outputProcessDesc = OutputProcessViewForgeFactory.Make( typeService.EventTypes, resultSetProcessorDesc.ResultEventType, resultSetProcessorDesc.ResultSetProcessorType, statementSpec, @base.StatementRawInfo, services); var outputProcessViewFactoryForge = outputProcessDesc.Forge; additionalForgeables.AddAll(outputProcessDesc.AdditionalForgeables); outputProcessViewFactoryForge.CollectSchedules(scheduleHandleCallbackProviders); JoinSetComposerPrototypeForge joinForge = null; if (numStreams > 1) { var hasAggregations = !resultSetProcessorDesc.AggregationServiceForgeDesc.Expressions.IsEmpty(); var desc = JoinSetComposerPrototypeForgeFactory.MakeComposerPrototype( statementSpec, joinAnalysisResult, typeService, historicalViewableDesc, false, hasAggregations, @base.StatementRawInfo, services); joinForge = desc.Forge; additionalForgeables.AddAll(desc.AdditionalForgeables); HandleIndexDependencies(joinForge.OptionalQueryPlan, services); } // plan table access var tableAccessForges = ExprTableEvalHelperPlan.PlanTableAccess(@base.StatementSpec.TableAccessNodes); ValidateTableAccessUse(statementSpec.Raw.IntoTableSpec, statementSpec.Raw.TableExpressions); if (joinAnalysisResult.IsUnidirectional && statementSpec.Raw.IntoTableSpec != null) { throw new ExprValidationException("Into-table does not allow unidirectional joins"); } var orderByWithoutOutputLimit = statementSpec.Raw.OrderByList != null && !statementSpec.Raw.OrderByList.IsEmpty() && statementSpec.Raw.OutputLimitSpec == null; var statementAIFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(StatementAIFactoryProvider), classPostfix); var resultSetProcessorProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(ResultSetProcessorFactoryProvider), classPostfix); var outputProcessViewProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(OutputProcessViewFactoryProvider), classPostfix); var statementProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix); var statementFieldsClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix); //var statementFieldsClassName = namespaceScope.FieldsClassNameOptional; var forgeX = new StatementAgentInstanceFactorySelectForge( typeService.StreamNames, viewableActivatorForges, resultSetProcessorProviderClassName, viewForges, viewResourceDelegateDesc, whereClauseForge, joinForge, outputProcessViewProviderClassName, subselectForges, tableAccessForges, orderByWithoutOutputLimit, joinAnalysisResult.IsUnidirectional); var namespaceScope = new CodegenNamespaceScope( @namespace, statementFieldsClassName, services.IsInstrumented); var forgeablesX = additionalForgeables .Select(additional => additional.Make(namespaceScope, classPostfix)) .ToList(); forgeablesX.Add( new StmtClassForgeableRSPFactoryProvider( resultSetProcessorProviderClassName, resultSetProcessorDesc, namespaceScope, @base.StatementRawInfo)); forgeablesX.Add( new StmtClassForgeableOPVFactoryProvider( outputProcessViewProviderClassName, outputProcessViewFactoryForge, namespaceScope, numStreams, @base.StatementRawInfo)); forgeablesX.Add( new StmtClassForgeableAIFactoryProviderSelect(statementAIFactoryProviderClassName, namespaceScope, forgeX)); forgeablesX.Add( new StmtClassForgeableStmtFields(statementFieldsClassName, namespaceScope, numStreams)); if (!dataflowOperator) { var informationals = StatementInformationalsUtil.GetInformationals( @base, filterSpecCompileds, scheduleHandleCallbackProviders, namedWindowConsumers, true, resultSetProcessorDesc.SelectSubscriberDescriptor, namespaceScope, services); forgeablesX.Add( new StmtClassForgeableStmtProvider(statementAIFactoryProviderClassName, statementProviderClassName, informationals, namespaceScope)); } var forgeableResult = new StmtForgeMethodResult( forgeablesX, filterSpecCompileds, scheduleHandleCallbackProviders, namedWindowConsumers, FilterSpecCompiled.MakeExprNodeList(filterSpecCompileds, EmptyList<FilterSpecParamExprNodeForge>.Instance)); return new StmtForgeMethodSelectResult(forgeableResult, resultSetProcessorDesc.ResultEventType, numStreams); }
public static OnTriggerSetPlan HandleSetVariable( string className, CodegenNamespaceScope namespaceScope, string classPostfix, OnTriggerActivatorDesc activatorResult, string optionalStreamName, IDictionary<ExprSubselectNode, SubSelectActivationPlan> subselectActivation, OnTriggerSetDesc desc, StatementBaseInfo @base, StatementCompileTimeServices services) { StreamTypeService typeService = new StreamTypeServiceImpl( new[] {activatorResult.ActivatorResultEventType}, new[] {optionalStreamName}, new[] {true}, false, false); var validationContext = new ExprValidationContextBuilder(typeService, @base.StatementRawInfo, services) .WithAllowBindingConsumption(true) .Build(); // handle subselects var subselectForges = SubSelectHelperForgePlanner.PlanSubSelect( @base, subselectActivation, new[] {optionalStreamName}, new[] {activatorResult.ActivatorResultEventType}, new[] {activatorResult.TriggerEventTypeName}, services); // validate assignments foreach (var assignment in desc.Assignments) { var validated = ExprNodeUtilityValidate.GetValidatedAssignment(assignment, validationContext); assignment.Expression = validated; } // create read-write logic var variableReadWritePackageForge = new VariableReadWritePackageForge(desc.Assignments, services); // plan table access var tableAccessForges = ExprTableEvalHelperPlan.PlanTableAccess(@base.StatementSpec.TableAccessNodes); // create output event type var eventTypeName = services.EventTypeNameGeneratorStatement.AnonymousTypeName; var eventTypeMetadata = new EventTypeMetadata( eventTypeName, @base.ModuleName, EventTypeTypeClass.STATEMENTOUT, EventTypeApplicationType.MAP, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var eventType = BaseNestableEventUtil.MakeMapTypeCompileTime( eventTypeMetadata, variableReadWritePackageForge.VariableTypes, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(eventType); // Handle output format var defaultSelectAllSpec = new StatementSpecCompiled(); defaultSelectAllSpec.SelectClauseCompiled.WithSelectExprList(new SelectClauseElementWildcard()); defaultSelectAllSpec.Raw.SelectStreamDirEnum = SelectClauseStreamSelectorEnum.RSTREAM_ISTREAM_BOTH; StreamTypeService streamTypeService = new StreamTypeServiceImpl( new EventType[] {eventType}, new[] {"trigger_stream"}, new[] {true}, false, false); var resultSetProcessor = ResultSetProcessorFactoryFactory.GetProcessorPrototype( new ResultSetSpec(defaultSelectAllSpec), streamTypeService, null, new bool[1], false, @base.ContextPropertyRegistry, false, false, @base.StatementRawInfo, services); var classNameRSP = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(ResultSetProcessorFactoryProvider), classPostfix); var forge = new StatementAgentInstanceFactoryOnTriggerSetForge( activatorResult.Activator, eventType, subselectForges, tableAccessForges, variableReadWritePackageForge, classNameRSP); IList<StmtClassForgable> forgables = new List<StmtClassForgable>(); forgables.Add( new StmtClassForgableRSPFactoryProvider( classNameRSP, resultSetProcessor, namespaceScope, @base.StatementRawInfo)); var onTrigger = new StmtClassForgableAIFactoryProviderOnTrigger(className, namespaceScope, forge); return new OnTriggerSetPlan(onTrigger, forgables, resultSetProcessor.SelectSubscriberDescriptor); }
private StmtForgeMethodResult Build( string @namespace, string classPostfix, StatementCompileTimeServices services) { var compileResult = CreateWindowUtil.HandleCreateWindow(@base, services); var namedWindowType = compileResult.FilterSpecCompiled.FilterForEventType; // view must be non-empty list var createWindowDesc = @base.StatementSpec.Raw.CreateWindowDesc; if (createWindowDesc.ViewSpecs.IsEmpty()) { throw new ExprValidationException(NamedWindowManagementServiceConstants.ERROR_MSG_DATAWINDOWS); } if (services.NamedWindowCompileTimeResolver.Resolve(createWindowDesc.WindowName) != null) { throw new ExprValidationException( "Named window named '" + createWindowDesc.WindowName + "' has already been declared"); } // build forge var activator = new ViewableActivatorFilterForge(compileResult.FilterSpecCompiled, false, 0, false, -1); var viewSpecs = createWindowDesc.ViewSpecs; var viewArgs = new ViewFactoryForgeArgs( 0, false, -1, createWindowDesc.StreamSpecOptions, createWindowDesc.WindowName, @base.StatementRawInfo, services); var viewForges = ViewFactoryForgeUtil.CreateForges(viewSpecs.ToArray(), viewArgs, namedWindowType); IList<ScheduleHandleCallbackProvider> schedules = new List<ScheduleHandleCallbackProvider>(); ViewFactoryForgeUtil.DetermineViewSchedules(viewForges, schedules); VerifyDataWindowViewFactoryChain(viewForges); var optionalUniqueKeyProps = StreamJoinAnalysisResultCompileTime.GetUniqueCandidateProperties( viewForges, @base.StatementSpec.Annotations); var uniqueKeyProArray = optionalUniqueKeyProps == null ? null : optionalUniqueKeyProps.ToArray(); NamedWindowMetaData insertFromNamedWindow = null; ExprNode insertFromFilter = null; if (createWindowDesc.IsInsert || createWindowDesc.InsertFilter != null) { var name = createWindowDesc.AsEventTypeName; insertFromNamedWindow = services.NamedWindowCompileTimeResolver.Resolve(name); if (insertFromNamedWindow == null) { throw new ExprValidationException( "A named window by name '" + name + "' could not be located, the insert-keyword requires an existing named window"); } insertFromFilter = createWindowDesc.InsertFilter; if (insertFromFilter != null) { var checkMinimal = ExprNodeUtilityValidate.IsMinimalExpression(insertFromFilter); if (checkMinimal != null) { throw new ExprValidationException("Create window where-clause may not have " + checkMinimal); } StreamTypeService streamTypeService = new StreamTypeServiceImpl( insertFromNamedWindow.EventType, name, true); var validationContext = new ExprValidationContextBuilder( streamTypeService, @base.StatementRawInfo, services).Build(); insertFromFilter = ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.CREATEWINDOWFILTER, insertFromFilter, validationContext); } } // handle output format var defaultSelectAllSpec = new StatementSpecCompiled(); defaultSelectAllSpec.SelectClauseCompiled.WithSelectExprList(new SelectClauseElementWildcard()); defaultSelectAllSpec.Raw.SelectStreamDirEnum = SelectClauseStreamSelectorEnum.RSTREAM_ISTREAM_BOTH; StreamTypeService typeService = new StreamTypeServiceImpl( new[] {namedWindowType}, new[] {createWindowDesc.WindowName}, new[] {true}, false, false); var resultSetProcessor = ResultSetProcessorFactoryFactory.GetProcessorPrototype( new ResultSetSpec(defaultSelectAllSpec), typeService, null, new bool[1], false, @base.ContextPropertyRegistry, false, false, @base.StatementRawInfo, services); var classNameRSP = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(ResultSetProcessorFactoryProvider), classPostfix); var selectSubscriberDescriptor = resultSetProcessor.SelectSubscriberDescriptor; var forge = new StatementAgentInstanceFactoryCreateNWForge( activator, createWindowDesc.WindowName, viewForges, insertFromNamedWindow, insertFromFilter, compileResult.AsEventType, classNameRSP); // add named window var isBatchingDataWindow = DetermineBatchingDataWindow(viewForges); var virtualDataWindow = viewForges[0] is VirtualDWViewFactoryForge; var isEnableIndexShare = virtualDataWindow || HintEnum.ENABLE_WINDOW_SUBQUERY_INDEXSHARE.GetHint( @base.StatementSpec.Annotations) != null; var metaData = new NamedWindowMetaData( namedWindowType, @base.ModuleName, @base.ContextName, uniqueKeyProArray, isBatchingDataWindow, isEnableIndexShare, compileResult.AsEventType, virtualDataWindow); services.NamedWindowCompileTimeRegistry.NewNamedWindow(metaData); // build forge list IList<StmtClassForgable> forgables = new List<StmtClassForgable>(2); var statementFieldsClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix); var packageScope = new CodegenNamespaceScope( @namespace, statementFieldsClassName, services.IsInstrumented); forgables.Add( new StmtClassForgableRSPFactoryProvider( classNameRSP, resultSetProcessor, packageScope, @base.StatementRawInfo)); var aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(StatementAIFactoryProvider), classPostfix); var aiFactoryForgable = new StmtClassForgableAIFactoryProviderCreateNW( aiFactoryProviderClassName, packageScope, forge, createWindowDesc.WindowName); forgables.Add(aiFactoryForgable); var statementProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix); var informationals = StatementInformationalsUtil.GetInformationals( @base, Collections.SingletonList(compileResult.FilterSpecCompiled), schedules, new EmptyList<NamedWindowConsumerStreamSpec>(), true, selectSubscriberDescriptor, packageScope, services); forgables.Add( new StmtClassForgableStmtProvider( aiFactoryProviderClassName, statementProviderClassName, informationals, packageScope)); forgables.Add(new StmtClassForgableStmtFields(statementFieldsClassName, packageScope, 1)); return new StmtForgeMethodResult( forgables, Collections.SingletonList(compileResult.FilterSpecCompiled), schedules, new EmptyList<NamedWindowConsumerStreamSpec>(), new EmptyList<FilterSpecParamExprNodeForge>()); }
public static OnTriggerPlan HandleContextFactoryOnTrigger( string className, CodegenNamespaceScope namespaceScope, string classPostfix, NamedWindowMetaData namedWindow, TableMetaData table, OnTriggerWindowPlan planDesc, StatementBaseInfo @base, StatementCompileTimeServices services) { // validate context var infraName = planDesc.OnTriggerDesc.WindowName; var infraTitle = (namedWindow != null ? "Named window" : "Table") + " '" + infraName + "'"; var infraContextName = namedWindow != null ? namedWindow.ContextName : table.OptionalContextName; var infraModuleName = namedWindow != null ? namedWindow.NamedWindowModuleName : table.TableModuleName; var infraEventType = namedWindow != null ? namedWindow.EventType : table.InternalEventType; var resultEventType = namedWindow != null ? namedWindow.EventType : table.PublicEventType; var infraVisibility = namedWindow != null ? namedWindow.EventType.Metadata.AccessModifier : table.TableVisibility; ValidateOnExpressionContext(planDesc.ContextName, infraContextName, infraTitle); List<StmtClassForgeableFactory> additionalForgeables = new List<StmtClassForgeableFactory>(); // validate expressions and plan subselects var validationResult = OnTriggerPlanValidator.ValidateOnTriggerPlan( infraEventType, planDesc.OnTriggerDesc, planDesc.StreamSpec, planDesc.ActivatorResult, planDesc.SubselectActivation, @base, services); additionalForgeables.AddAll(validationResult.AdditionalForgeables); var validatedJoin = validationResult.ValidatedJoin; var activatorResultEventType = planDesc.ActivatorResult.ActivatorResultEventType; var pair = IndexHintPair.GetIndexHintPair( planDesc.OnTriggerDesc, @base.StatementSpec.StreamSpecs[0].OptionalStreamName, @base.StatementRawInfo, services); var indexHint = pair.IndexHint; var excludePlanHint = pair.ExcludePlanHint; var enabledSubqueryIndexShare = namedWindow != null && namedWindow.IsEnableIndexShare; var isVirtualWindow = namedWindow != null && namedWindow.IsVirtualDataWindow; var indexMetadata = namedWindow != null ? namedWindow.IndexMetadata : table.IndexMetadata; var optionalUniqueKeySet = namedWindow != null ? namedWindow.UniquenessAsSet : table.UniquenessAsSet; // query plan var onlyUseExistingIndexes = table != null; SubordinateWMatchExprQueryPlanResult planResult = SubordinateQueryPlanner.PlanOnExpression( validatedJoin, activatorResultEventType, indexHint, enabledSubqueryIndexShare, -1, excludePlanHint, isVirtualWindow, indexMetadata, infraEventType, optionalUniqueKeySet, onlyUseExistingIndexes, @base.StatementRawInfo, services); SubordinateWMatchExprQueryPlanForge queryPlan = planResult.Forge; additionalForgeables.AddAll(planResult.AdditionalForgeables); // indicate index dependencies if (queryPlan.Indexes != null && infraVisibility == NameAccessModifier.PUBLIC) { foreach (var index in queryPlan.Indexes) { services.ModuleDependenciesCompileTime.AddPathIndex( namedWindow != null, infraName, infraModuleName, index.IndexName, index.IndexModuleName, services.NamedWindowCompileTimeRegistry, services.TableCompileTimeRegistry); } } var onTriggerType = planDesc.OnTriggerDesc.OnTriggerType; var activator = planDesc.ActivatorResult.Activator; var subselectForges = validationResult.SubselectForges; var tableAccessForges = validationResult.TableAccessForges; IList<StmtClassForgeable> forgeables = new List<StmtClassForgeable>(2); StatementAgentInstanceFactoryOnTriggerInfraBaseForge forge; var classNameRSP = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(ResultSetProcessorFactoryProvider), classPostfix); ResultSetProcessorDesc resultSetProcessor; if (onTriggerType == OnTriggerType.ON_SELECT) { resultSetProcessor = validationResult.ResultSetProcessorPrototype; var outputEventType = resultSetProcessor.ResultEventType; var insertInto = false; TableMetaData optionalInsertIntoTable = null; var insertIntoDesc = @base.StatementSpec.Raw.InsertIntoDesc; var addToFront = false; if (insertIntoDesc != null) { insertInto = true; optionalInsertIntoTable = services.TableCompileTimeResolver.Resolve(insertIntoDesc.EventTypeName); var optionalInsertIntoNamedWindow = services.NamedWindowCompileTimeResolver.Resolve(insertIntoDesc.EventTypeName); addToFront = optionalInsertIntoNamedWindow != null || optionalInsertIntoTable != null; } var selectAndDelete = planDesc.OnTriggerDesc.IsDeleteAndSelect; var distinct = @base.StatementSpec.SelectClauseCompiled.IsDistinct; MultiKeyPlan distinctMultiKeyPlan = MultiKeyPlanner.PlanMultiKeyDistinct( distinct, outputEventType, @base.StatementRawInfo, services.SerdeResolver); additionalForgeables.AddAll(distinctMultiKeyPlan.MultiKeyForgeables); forge = new StatementAgentInstanceFactoryOnTriggerInfraSelectForge( activator, outputEventType, subselectForges, tableAccessForges, namedWindow, table, queryPlan, classNameRSP, insertInto, addToFront, optionalInsertIntoTable, selectAndDelete, distinct, distinctMultiKeyPlan.ClassRef); } else { var defaultSelectAllSpec = new StatementSpecCompiled(); defaultSelectAllSpec.SelectClauseCompiled.WithSelectExprList(new SelectClauseElementWildcard()); defaultSelectAllSpec.Raw.SelectStreamDirEnum = SelectClauseStreamSelectorEnum.RSTREAM_ISTREAM_BOTH; StreamTypeService typeService = new StreamTypeServiceImpl( new[] {resultEventType}, new[] {infraName}, new[] {false}, false, false); resultSetProcessor = ResultSetProcessorFactoryFactory.GetProcessorPrototype( new ResultSetSpec(defaultSelectAllSpec), typeService, null, new bool[1], false, @base.ContextPropertyRegistry, false, false, @base.StatementRawInfo, services); if (onTriggerType == OnTriggerType.ON_DELETE) { forge = new StatementAgentInstanceFactoryOnTriggerInfraDeleteForge( activator, resultEventType, subselectForges, tableAccessForges, classNameRSP, namedWindow, table, queryPlan); } else if (onTriggerType == OnTriggerType.ON_UPDATE) { var updateDesc = (OnTriggerWindowUpdateDesc) planDesc.OnTriggerDesc; EventBeanUpdateHelperForge updateHelper = EventBeanUpdateHelperForgeFactory.Make( infraName, (EventTypeSPI) infraEventType, updateDesc.Assignments, validationResult.ZeroStreamAliasName, activatorResultEventType, namedWindow != null, @base.StatementName, services.EventTypeAvroHandler); forge = new StatementAgentInstanceFactoryOnTriggerInfraUpdateForge( activator, resultEventType, subselectForges, tableAccessForges, classNameRSP, namedWindow, table, queryPlan, updateHelper); } else if (onTriggerType == OnTriggerType.ON_MERGE) { var onMergeTriggerDesc = (OnTriggerMergeDesc) planDesc.OnTriggerDesc; var onMergeHelper = new InfraOnMergeHelperForge( onMergeTriggerDesc, activatorResultEventType, planDesc.StreamSpec.OptionalStreamName, infraName, (EventTypeSPI) infraEventType, @base.StatementRawInfo, services, table); forge = new StatementAgentInstanceFactoryOnTriggerInfraMergeForge( activator, resultEventType, subselectForges, tableAccessForges, classNameRSP, namedWindow, table, queryPlan, onMergeHelper); } else { throw new IllegalStateException("Unrecognized trigger type " + onTriggerType); } } forgeables.Add( new StmtClassForgeableRSPFactoryProvider( classNameRSP, resultSetProcessor, namespaceScope, @base.StatementRawInfo)); var queryPlanLogging = services.Configuration.Common.Logging.IsEnableQueryPlan; SubordinateQueryPlannerUtil.QueryPlanLogOnExpr( queryPlanLogging, QUERY_PLAN_LOG, queryPlan, @base.StatementSpec.Annotations, services.ImportServiceCompileTime); StmtClassForgeableAIFactoryProviderOnTrigger onTrigger = new StmtClassForgeableAIFactoryProviderOnTrigger(className, namespaceScope, forge); return new OnTriggerPlan(onTrigger, forgeables, resultSetProcessor.SelectSubscriberDescriptor, additionalForgeables); }
/// <summary> /// Ctor. /// </summary> /// <param name="statementSpec">is a container for the definition of all statement constructs thatmay have been used in the statement, i.e. if defines the select clauses, insert into, outer joins etc. /// </param> /// <param name="services">is the service instances for dependency injection</param> /// <param name="statementContext">is statement-level information and statement services</param> /// <throws>ExprValidationException if the preparation failed</throws> public EPPreparedExecuteMethodQuery(StatementSpecCompiled statementSpec, EPServicesContext services, StatementContext statementContext) { var queryPlanLogging = services.ConfigSnapshot.EngineDefaults.LoggingConfig.IsEnableQueryPlan; if (queryPlanLogging) { QueryPlanLog.Info("Query plans for Fire-and-forget query '" + statementContext.Expression + "'"); } _hasTableAccess = (statementSpec.TableNodes != null && statementSpec.TableNodes.Length > 0); foreach (var streamSpec in statementSpec.StreamSpecs) { _hasTableAccess |= streamSpec is TableQueryStreamSpec; } _statementSpec = statementSpec; _services = services; EPPreparedExecuteMethodHelper.ValidateFAFQuery(statementSpec); var numStreams = statementSpec.StreamSpecs.Length; var typesPerStream = new EventType[numStreams]; var namesPerStream = new string[numStreams]; _processors = new FireAndForgetProcessor[numStreams]; _agentInstanceContext = new AgentInstanceContext(statementContext, null, -1, null, null, statementContext.DefaultAgentInstanceScriptContext); // resolve types and processors for (var i = 0; i < numStreams; i++) { var streamSpec = statementSpec.StreamSpecs[i]; _processors[i] = FireAndForgetProcessorFactory.ValidateResolveProcessor(streamSpec, services); string streamName = _processors[i].NamedWindowOrTableName; if (streamSpec.OptionalStreamName != null) { streamName = streamSpec.OptionalStreamName; } namesPerStream[i] = streamName; typesPerStream[i] = _processors[i].EventTypeResultSetProcessor; } // compile filter to optimize access to named window _filters = new FilterSpecCompiled[numStreams]; if (statementSpec.FilterRootNode != null) { var tagged = new LinkedHashMap <string, Pair <EventType, string> >(); for (var i = 0; i < numStreams; i++) { try { var types = new StreamTypeServiceImpl(typesPerStream, namesPerStream, new bool[numStreams], services.EngineURI, false); _filters[i] = FilterSpecCompiler.MakeFilterSpec(typesPerStream[i], namesPerStream[i], Collections.SingletonList(statementSpec.FilterRootNode), null, tagged, tagged, types, null, statementContext, Collections.SingletonList(i)); } catch (Exception ex) { Log.Warn("Unexpected exception analyzing filter paths: " + ex.Message, ex); } } } // obtain result set processor var isIStreamOnly = new bool[namesPerStream.Length]; CompatExtensions.Fill(isIStreamOnly, true); StreamTypeService typeService = new StreamTypeServiceImpl(typesPerStream, namesPerStream, isIStreamOnly, services.EngineURI, true); EPStatementStartMethodHelperValidate.ValidateNodes(statementSpec, statementContext, typeService, null); var resultSetProcessorPrototype = ResultSetProcessorFactoryFactory.GetProcessorPrototype(statementSpec, statementContext, typeService, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, _services.ConfigSnapshot); _resultSetProcessor = EPStatementStartMethodHelperAssignExpr.GetAssignResultSetProcessor(_agentInstanceContext, resultSetProcessorPrototype); if (statementSpec.SelectClauseSpec.IsDistinct) { if (_resultSetProcessor.ResultEventType is EventTypeSPI) { _eventBeanReader = ((EventTypeSPI)_resultSetProcessor.ResultEventType).GetReader(); } if (_eventBeanReader == null) { _eventBeanReader = new EventBeanReaderDefaultImpl(_resultSetProcessor.ResultEventType); } } // plan joins or simple queries if (numStreams > 1) { var streamJoinAnalysisResult = new StreamJoinAnalysisResult(numStreams); CompatExtensions.Fill(streamJoinAnalysisResult.NamedWindow, true); for (var i = 0; i < numStreams; i++) { var processorInstance = _processors[i].GetProcessorInstance(_agentInstanceContext); if (_processors[i].IsVirtualDataWindow) { streamJoinAnalysisResult.ViewExternal[i] = agentInstanceContext => processorInstance.VirtualDataWindow; } var uniqueIndexes = _processors[i].GetUniqueIndexes(processorInstance); streamJoinAnalysisResult.UniqueKeys[i] = uniqueIndexes; } var hasAggregations = !resultSetProcessorPrototype.AggregationServiceFactoryDesc.Expressions.IsEmpty(); _joinSetComposerPrototype = JoinSetComposerPrototypeFactory.MakeComposerPrototype( null, null, statementSpec.OuterJoinDescList, statementSpec.FilterRootNode, typesPerStream, namesPerStream, streamJoinAnalysisResult, queryPlanLogging, statementContext, new HistoricalViewableDesc(numStreams), _agentInstanceContext, false, hasAggregations, services.TableService, true); } // check context partition use if (statementSpec.OptionalContextName != null) { if (numStreams > 1) { throw new ExprValidationException("Joins in runtime queries for context partitions are not supported"); } } }
public FAFQueryMethodSelectDesc( StatementSpecCompiled statementSpec, Compilable compilable, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { Annotations = statementSpec.Annotations; ContextName = statementSpec.Raw.OptionalContextName; var queryPlanLogging = services.Configuration.Common.Logging.IsEnableQueryPlan; if (queryPlanLogging) { QUERY_PLAN_LOG.Info("Query plans for Fire-and-forget query '" + compilable.ToEPL() + "'"); } HasTableAccess = statementSpec.TableAccessNodes != null && statementSpec.TableAccessNodes.Count > 0; foreach (var streamSpec in statementSpec.StreamSpecs) { HasTableAccess |= streamSpec is TableQueryStreamSpec; } HasTableAccess |= StatementLifecycleSvcUtil.IsSubqueryWithTable( statementSpec.SubselectNodes, services.TableCompileTimeResolver); IsDistinct = statementSpec.SelectClauseCompiled.IsDistinct; FAFQueryMethodHelper.ValidateFAFQuery(statementSpec); var numStreams = statementSpec.StreamSpecs.Length; var typesPerStream = new EventType[numStreams]; var namesPerStream = new string[numStreams]; var eventTypeNames = new string[numStreams]; Processors = new FireAndForgetProcessorForge[numStreams]; ConsumerFilters = new ExprNode[numStreams]; // check context partition use if (statementSpec.Raw.OptionalContextName != null) { if (numStreams > 1) { throw new ExprValidationException( "Joins in runtime queries for context partitions are not supported"); } } // resolve types and processors for (var i = 0; i < numStreams; i++) { var streamSpec = statementSpec.StreamSpecs[i]; Processors[i] = FireAndForgetProcessorForgeFactory.ValidateResolveProcessor(streamSpec); if (numStreams > 1 && Processors[i].ContextName != null) { throw new ExprValidationException( "Joins against named windows that are under context are not supported"); } var streamName = Processors[i].NamedWindowOrTableName; if (streamSpec.OptionalStreamName != null) { streamName = streamSpec.OptionalStreamName; } namesPerStream[i] = streamName; typesPerStream[i] = Processors[i].EventTypeRspInputEvents; eventTypeNames[i] = typesPerStream[i].Name; IList<ExprNode> consumerFilterExprs; if (streamSpec is NamedWindowConsumerStreamSpec) { var namedSpec = (NamedWindowConsumerStreamSpec) streamSpec; consumerFilterExprs = namedSpec.FilterExpressions; } else { var tableSpec = (TableQueryStreamSpec) streamSpec; consumerFilterExprs = tableSpec.FilterExpressions; } ConsumerFilters[i] = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(consumerFilterExprs); } // compile filter to optimize access to named window var optionalStreamsIfAny = OuterJoinAnalyzer.OptionalStreamsIfAny(statementSpec.Raw.OuterJoinDescList); var types = new StreamTypeServiceImpl( typesPerStream, namesPerStream, new bool[numStreams], false, optionalStreamsIfAny); var excludePlanHint = ExcludePlanHint.GetHint(types.StreamNames, statementRawInfo, services); QueryGraph = new QueryGraphForge(numStreams, excludePlanHint, false); if (statementSpec.Raw.WhereClause != null) { for (var i = 0; i < numStreams; i++) { try { var validationContext = new ExprValidationContextBuilder(types, statementRawInfo, services) .WithAllowBindingConsumption(true) .WithIsFilterExpression(true) .Build(); var validated = ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.FILTER, statementSpec.Raw.WhereClause, validationContext); FilterExprAnalyzer.Analyze(validated, QueryGraph, false); } catch (Exception ex) { Log.Warn("Unexpected exception analyzing filter paths: " + ex.Message, ex); } } } // handle subselects // first we create streams for subselects, if there are any var @base = new StatementBaseInfo(compilable, statementSpec, null, statementRawInfo, null); var subqueryNamedWindowConsumers = new List<NamedWindowConsumerStreamSpec>(); SubSelectActivationDesc subSelectActivationDesc = SubSelectHelperActivations.CreateSubSelectActivation( EmptyList<FilterSpecCompiled>.Instance, subqueryNamedWindowConsumers, @base, services); IDictionary<ExprSubselectNode, SubSelectActivationPlan> subselectActivation = subSelectActivationDesc.Subselects; AdditionalForgeables.AddAll(subSelectActivationDesc.AdditionalForgeables); SubSelectHelperForgePlan subSelectForgePlan = SubSelectHelperForgePlanner.PlanSubSelect( @base, subselectActivation, namesPerStream, typesPerStream, eventTypeNames, services); SubselectForges = subSelectForgePlan.Subselects; AdditionalForgeables.AddAll(subSelectForgePlan.AdditionalForgeables); // obtain result set processor var isIStreamOnly = new bool[namesPerStream.Length]; isIStreamOnly.Fill(true); StreamTypeService typeService = new StreamTypeServiceImpl( typesPerStream, namesPerStream, isIStreamOnly, true, optionalStreamsIfAny); WhereClause = EPStatementStartMethodHelperValidate.ValidateNodes( statementSpec.Raw, typeService, null, statementRawInfo, services); var resultSetSpec = new ResultSetSpec(statementSpec); ResultSetProcessor = ResultSetProcessorFactoryFactory.GetProcessorPrototype( resultSetSpec, typeService, null, new bool[0], true, null, true, false, statementRawInfo, services); AdditionalForgeables.AddAll(ResultSetProcessor.AdditionalForgeables); // plan table access TableAccessForges = ExprTableEvalHelperPlan.PlanTableAccess(statementSpec.Raw.TableExpressions); // plan joins or simple queries if (numStreams > 1) { var streamJoinAnalysisResult = new StreamJoinAnalysisResultCompileTime(numStreams); CompatExtensions.Fill(streamJoinAnalysisResult.NamedWindowsPerStream, (NamedWindowMetaData) null); for (var i = 0; i < numStreams; i++) { var uniqueIndexes = Processors[i].UniqueIndexes; streamJoinAnalysisResult.UniqueKeys[i] = uniqueIndexes; } var hasAggregations = ResultSetProcessor.ResultSetProcessorType.IsAggregated(); var desc = JoinSetComposerPrototypeForgeFactory.MakeComposerPrototype( statementSpec, streamJoinAnalysisResult, types, new HistoricalViewableDesc(numStreams), true, hasAggregations, statementRawInfo, services); AdditionalForgeables.AddAll(desc.AdditionalForgeables); Joins = desc.Forge; } else { Joins = null; } var multiKeyPlan = MultiKeyPlanner.PlanMultiKeyDistinct( IsDistinct, ResultSetProcessor.ResultEventType, statementRawInfo, SerdeCompileTimeResolverNonHA.INSTANCE); AdditionalForgeables.AddAll(multiKeyPlan.MultiKeyForgeables); DistinctMultiKey = multiKeyPlan.ClassRef; }