private static bool IsPolling(StreamSpecCompiled streamSpec) { return streamSpec is MethodStreamSpec || streamSpec is DBStatementStreamSpec || streamSpec is TableQueryStreamSpec; }
public static FireAndForgetProcessor ValidateResolveProcessor(StreamSpecCompiled streamSpec, EPServicesContext services) { // resolve processor string processorName; if (streamSpec is NamedWindowConsumerStreamSpec) { NamedWindowConsumerStreamSpec namedSpec = (NamedWindowConsumerStreamSpec)streamSpec; processorName = namedSpec.WindowName; } else { TableQueryStreamSpec tableSpec = (TableQueryStreamSpec)streamSpec; processorName = tableSpec.TableName; } // get processor instance TableMetadata tableMetadata = services.TableService.GetTableMetadata(processorName); if (tableMetadata != null) { return(new FireAndForgetProcessorTable(services.TableService, tableMetadata)); } else { NamedWindowProcessor nwprocessor = services.NamedWindowService.GetProcessor(processorName); if (nwprocessor == null) { throw new ExprValidationException("A table or named window by name '" + processorName + "' does not exist"); } return(new FireAndForgetProcessorNamedWindow(nwprocessor)); } }
public StreamSpecCompiledDesc( StreamSpecCompiled streamSpecCompiled, IList<StmtClassForgeableFactory> additionalForgeables) { this.streamSpecCompiled = streamSpecCompiled; this.additionalForgeables = additionalForgeables; }
public SubSelectActivationHolder(int streamNumber, EventType viewableType, ViewFactoryChain viewFactoryChain, ViewableActivator activator, StreamSpecCompiled streamSpecCompiled) { StreamNumber = streamNumber; ViewableType = viewableType; ViewFactoryChain = viewFactoryChain; Activator = activator; StreamSpecCompiled = streamSpecCompiled; }
private static void ValidateNoViews(StreamSpecCompiled streamSpec, string conceptName) { if (streamSpec.ViewSpecs.Length > 0) { throw new ExprValidationException(conceptName + " joins do not allow views onto the data, view '" + streamSpec.ViewSpecs[0].ObjectNamespace + ':' + streamSpec.ViewSpecs[0].ObjectName + "' is not valid in this context"); } }
public static FireAndForgetProcessorForge ValidateResolveProcessor(StreamSpecCompiled streamSpec) { if (streamSpec is NamedWindowConsumerStreamSpec) { NamedWindowMetaData nwdetail = ((NamedWindowConsumerStreamSpec) streamSpec).NamedWindow; return new FireAndForgetProcessorNamedWindowForge(nwdetail); } TableQueryStreamSpec tableSpec = (TableQueryStreamSpec) streamSpec; return new FireAndForgetProcessorTableForge(tableSpec.Table); }
public SubSelectActivationPlan( EventType viewableType, IList<ViewFactoryForge> viewForges, ViewableActivatorForge activator, StreamSpecCompiled streamSpecCompiled) { ViewableType = viewableType; ViewForges = viewForges; Activator = activator; StreamSpecCompiled = streamSpecCompiled; }
public OnTriggerWindowPlan( OnTriggerWindowDesc onTriggerDesc, string contextName, OnTriggerActivatorDesc activatorResult, StreamSelector? optionalStreamSelector, IDictionary<ExprSubselectNode, SubSelectActivationPlan> subselectActivation, StreamSpecCompiled streamSpec) { OnTriggerDesc = onTriggerDesc; ContextName = contextName; ActivatorResult = activatorResult; OptionalStreamSelector = optionalStreamSelector; SubselectActivation = subselectActivation; StreamSpec = streamSpec; }
private static DataFlowActivationResult HandleDataflowActivation( ViewFactoryForgeArgs args, StreamSpecCompiled streamSpec) { if (!(streamSpec is FilterStreamSpecCompiled)) { throw new ExprValidationException( "Dataflow operator only allows filters for event types and does not allow tables, named windows or patterns"); } var filterStreamSpec = (FilterStreamSpecCompiled) streamSpec; var filterSpecCompiled = filterStreamSpec.FilterSpecCompiled; var eventType = filterSpecCompiled.ResultEventType; var typeName = filterStreamSpec.FilterSpecCompiled.FilterForEventTypeName; var views = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, eventType); var viewableActivator = new ViewableActivatorDataFlowForge(eventType); return new DataFlowActivationResult(eventType, typeName, viewableActivator, views); }
protected internal static void ValidateFAFQuery(StatementSpecCompiled statementSpec) { for (int i = 0; i < statementSpec.StreamSpecs.Length; i++) { StreamSpecCompiled streamSpec = statementSpec.StreamSpecs[i]; if (!(streamSpec is NamedWindowConsumerStreamSpec || streamSpec is TableQueryStreamSpec)) { throw new ExprValidationException( "On-demand queries require tables or named windows and do not allow event streams or patterns"); } if (streamSpec.ViewSpecs.Length != 0) { throw new ExprValidationException("Views are not a supported feature of on-demand queries"); } } if (statementSpec.Raw.OutputLimitSpec != null) { throw new ExprValidationException( "Output rate limiting is not a supported feature of on-demand queries"); } }
internal static bool DetermineSubquerySameStream(StatementSpecCompiled statementSpec, FilterStreamSpecCompiled filterStreamSpec) { foreach (ExprSubselectNode subselect in statementSpec.SubSelectExpressions) { StreamSpecCompiled streamSpec = subselect.StatementSpecCompiled.StreamSpecs[0]; if (!(streamSpec is FilterStreamSpecCompiled)) { continue; } FilterStreamSpecCompiled filterStream = (FilterStreamSpecCompiled)streamSpec; EventType typeSubselect = filterStream.FilterSpec.FilterForEventType; EventType typeFiltered = filterStreamSpec.FilterSpec.FilterForEventType; if (EventTypeUtility.IsTypeOrSubTypeOf(typeSubselect, typeFiltered) || EventTypeUtility.IsTypeOrSubTypeOf(typeFiltered, typeSubselect)) { return(true); } } return(false); }
public static OnTriggerPlan HandleSplitStream( string aiFactoryProviderClassName, CodegenNamespaceScope namespaceScope, string classPostfix, OnTriggerSplitStreamDesc desc, StreamSpecCompiled streamSpec, OnTriggerActivatorDesc activatorResult, IDictionary<ExprSubselectNode, SubSelectActivationPlan> subselectActivation, StatementBaseInfo @base, StatementCompileTimeServices services) { var raw = @base.StatementSpec.Raw; if (raw.InsertIntoDesc == null) { throw new ExprValidationException( "Required insert-into clause is not provided, the clause is required for split-stream syntax"); } if (raw.GroupByExpressions != null && raw.GroupByExpressions.Count > 0 || raw.HavingClause != null || raw.OrderByList.Count > 0) { throw new ExprValidationException( "A group-by clause, having-clause or order-by clause is not allowed for the split stream syntax"); } var streamName = streamSpec.OptionalStreamName; if (streamName == null) { streamName = "stream_0"; } StreamTypeService typeServiceTrigger = new StreamTypeServiceImpl( new[] {activatorResult.ActivatorResultEventType}, new[] {streamName}, new[] {true}, false, false); // materialize sub-select views var subselectForges = SubSelectHelperForgePlanner.PlanSubSelect( @base, subselectActivation, new[] {streamSpec.OptionalStreamName}, new[] {activatorResult.ActivatorResultEventType}, new[] {activatorResult.TriggerEventTypeName}, services); // compile top-level split var items = new OnSplitItemForge[desc.SplitStreams.Count + 1]; items[0] = OnSplitValidate( typeServiceTrigger, @base.StatementSpec, @base.ContextPropertyRegistry, null, @base.StatementRawInfo, services); // compile each additional split var index = 1; foreach (var splits in desc.SplitStreams) { var splitSpec = new StatementSpecCompiled(); splitSpec.Raw.InsertIntoDesc = splits.InsertInto; splitSpec.SelectClauseCompiled = CompileSelectAllowSubselect(splits.SelectClause); splitSpec.Raw.WhereClause = splits.WhereClause; PropertyEvaluatorForge optionalPropertyEvaluator = null; StreamTypeService typeServiceProperty; if (splits.FromClause != null) { optionalPropertyEvaluator = PropertyEvaluatorForgeFactory.MakeEvaluator( splits.FromClause.PropertyEvalSpec, activatorResult.ActivatorResultEventType, streamName, @base.StatementRawInfo, services); typeServiceProperty = new StreamTypeServiceImpl( new[] {optionalPropertyEvaluator.FragmentEventType}, new[] {splits.FromClause.OptionalStreamName}, new[] {true}, false, false); } else { typeServiceProperty = typeServiceTrigger; } items[index] = OnSplitValidate( typeServiceProperty, splitSpec, @base.ContextPropertyRegistry, optionalPropertyEvaluator, @base.StatementRawInfo, services); index++; } // handle result set processor classes IList<StmtClassForgable> forgables = new List<StmtClassForgable>(); for (var i = 0; i < items.Length; i++) { var classNameRSP = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(ResultSetProcessorFactoryProvider), classPostfix + "_" + i); forgables.Add( new StmtClassForgableRSPFactoryProvider( classNameRSP, items[i].ResultSetProcessorDesc, namespaceScope, @base.StatementRawInfo)); items[i].ResultSetProcessorClassName = classNameRSP; } // plan table access var tableAccessForges = ExprTableEvalHelperPlan.PlanTableAccess(@base.StatementSpec.TableAccessNodes); // build forge var splitStreamForge = new StatementAgentInstanceFactoryOnTriggerSplitStreamForge( activatorResult.Activator, activatorResult.ActivatorResultEventType, subselectForges, tableAccessForges, items, desc.IsFirst); var triggerForge = new StmtClassForgableAIFactoryProviderOnTrigger( aiFactoryProviderClassName, namespaceScope, splitStreamForge); return new OnTriggerPlan(triggerForge, forgables, new SelectSubscriberDescriptor()); }
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 FAFQueryMethodIUDBaseForge( StatementSpecCompiled spec, Compilable compilable, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { this.annotations = spec.Annotations; this.hasTableAccess = spec.Raw.IntoTableSpec != null || (spec.TableAccessNodes != null && spec.TableAccessNodes.Count > 0); if (spec.Raw.InsertIntoDesc != null && services.TableCompileTimeResolver.Resolve(spec.Raw.InsertIntoDesc.EventTypeName) != null) { hasTableAccess = true; } if (spec.Raw.FireAndForgetSpec is FireAndForgetSpecUpdate || spec.Raw.FireAndForgetSpec is FireAndForgetSpecDelete) { hasTableAccess |= spec.StreamSpecs[0] is TableQueryStreamSpec; } hasTableAccess |= StatementLifecycleSvcUtil.IsSubqueryWithTable( spec.SubselectNodes, services.TableCompileTimeResolver); // validate general FAF criteria FAFQueryMethodHelper.ValidateFAFQuery(spec); // obtain processor StreamSpecCompiled streamSpec = spec.StreamSpecs[0]; processor = FireAndForgetProcessorForgeFactory.ValidateResolveProcessor(streamSpec); // obtain name and type string processorName = processor.NamedWindowOrTableName; EventType eventType = processor.EventTypeRspInputEvents; // determine alias string aliasName = processorName; if (streamSpec.OptionalStreamName != null) { aliasName = streamSpec.OptionalStreamName; } // activate subselect activations var @base = new StatementBaseInfo(compilable, spec, null, statementRawInfo, null); var subqueryNamedWindowConsumers = new List<NamedWindowConsumerStreamSpec>(); var subSelectActivationDesc = SubSelectHelperActivations.CreateSubSelectActivation( EmptyList<FilterSpecCompiled>.Instance, subqueryNamedWindowConsumers, @base, services); var subselectActivation = subSelectActivationDesc.Subselects; _additionalForgeables.AddAll(subSelectActivationDesc.AdditionalForgeables); // plan subselects var namesPerStream = new[] {aliasName}; var typesPerStream = new[] { processor.EventTypePublic }; var eventTypeNames = new[] {typesPerStream[0].Name}; SubSelectHelperForgePlan subSelectForgePlan = SubSelectHelperForgePlanner.PlanSubSelect( @base, subselectActivation, namesPerStream, typesPerStream, eventTypeNames, services); _subselectForges = subSelectForgePlan.Subselects; _additionalForgeables.AddAll(subSelectForgePlan.AdditionalForgeables); // compile filter to optimize access to named window StreamTypeServiceImpl typeService = new StreamTypeServiceImpl( new[] {eventType}, new[] {aliasName}, new[] {true}, true, false); ExcludePlanHint excludePlanHint = ExcludePlanHint.GetHint( typeService.StreamNames, statementRawInfo, services); if (spec.Raw.WhereClause != null) { queryGraph = new QueryGraphForge(1, excludePlanHint, false); EPLValidationUtil.ValidateFilterWQueryGraphSafe( queryGraph, spec.Raw.WhereClause, typeService, statementRawInfo, services); } else { queryGraph = null; } // validate expressions whereClause = EPStatementStartMethodHelperValidate.ValidateNodes( spec.Raw, typeService, null, statementRawInfo, services); // get executor InitExec(aliasName, spec, statementRawInfo, services); // plan table access tableAccessForges = ExprTableEvalHelperPlan.PlanTableAccess(spec.Raw.TableExpressions); }
public static SubSelectActivationDesc CreateSubSelectActivation( IList <FilterSpecCompiled> filterSpecCompileds, IList <NamedWindowConsumerStreamSpec> namedWindowConsumers, StatementBaseInfo statement, StatementCompileTimeServices services) { IDictionary <ExprSubselectNode, SubSelectActivationPlan> result = new LinkedHashMap <ExprSubselectNode, SubSelectActivationPlan>(); IList <StmtClassForgeableFactory> additionalForgeables = new List <StmtClassForgeableFactory>(); // Process all subselect expression nodes foreach (ExprSubselectNode subselect in statement.StatementSpec.SubselectNodes) { StatementSpecCompiled statementSpec = subselect.StatementSpecCompiled; StreamSpecCompiled streamSpec = statementSpec.StreamSpecs[0]; int subqueryNumber = subselect.SubselectNumber; if (subqueryNumber == -1) { throw new IllegalStateException("Unexpected subquery"); } ViewFactoryForgeArgs args = new ViewFactoryForgeArgs(-1, true, subqueryNumber, streamSpec.Options, null, statement.StatementRawInfo, services); if (streamSpec is FilterStreamSpecCompiled) { if (services.IsFireAndForget) { throw new ExprValidationException("Fire-and-forget queries only allow subqueries against named windows and tables"); } FilterStreamSpecCompiled filterStreamSpec = (FilterStreamSpecCompiled)statementSpec.StreamSpecs[0]; // Register filter, create view factories ViewableActivatorForge activatorDeactivator = new ViewableActivatorFilterForge( filterStreamSpec.FilterSpecCompiled, false, null, true, subqueryNumber); ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges( streamSpec.ViewSpecs, args, filterStreamSpec.FilterSpecCompiled.ResultEventType); IList <ViewFactoryForge> forges = viewForgeDesc.Forges; additionalForgeables.AddAll(viewForgeDesc.MultikeyForges); EventType eventType = forges.IsEmpty() ? filterStreamSpec.FilterSpecCompiled.ResultEventType : forges[forges.Count - 1].EventType; subselect.RawEventType = eventType; filterSpecCompileds.Add(filterStreamSpec.FilterSpecCompiled); // Add lookup to list, for later starts result.Put( subselect, new SubSelectActivationPlan(filterStreamSpec.FilterSpecCompiled.ResultEventType, forges, activatorDeactivator, streamSpec)); } else if (streamSpec is TableQueryStreamSpec) { TableQueryStreamSpec table = (TableQueryStreamSpec)streamSpec; ExprNode filter = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(table.FilterExpressions); ViewableActivatorForge viewableActivator = new ViewableActivatorTableForge(table.Table, filter); result.Put( subselect, new SubSelectActivationPlan(table.Table.InternalEventType, EmptyList <ViewFactoryForge> .Instance, viewableActivator, streamSpec)); subselect.RawEventType = table.Table.InternalEventType; } else { NamedWindowConsumerStreamSpec namedSpec = (NamedWindowConsumerStreamSpec)statementSpec.StreamSpecs[0]; namedWindowConsumers.Add(namedSpec); NamedWindowMetaData nwinfo = namedSpec.NamedWindow; EventType namedWindowType = nwinfo.EventType; if (namedSpec.OptPropertyEvaluator != null) { namedWindowType = namedSpec.OptPropertyEvaluator.FragmentEventType; } // if named-window index sharing is disabled (the default) or filter expressions are provided then consume the insert-remove stream bool disableIndexShare = HintEnum.DISABLE_WINDOW_SUBQUERY_INDEXSHARE.GetHint(statement.StatementRawInfo.Annotations) != null; bool processorDisableIndexShare = !namedSpec.NamedWindow.IsEnableIndexShare; if (disableIndexShare && namedSpec.NamedWindow.IsVirtualDataWindow) { disableIndexShare = false; } if ((!namedSpec.FilterExpressions.IsEmpty() || processorDisableIndexShare || disableIndexShare) && (!services.IsFireAndForget)) { ExprNode filterEvaluator = null; if (!namedSpec.FilterExpressions.IsEmpty()) { filterEvaluator = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(namedSpec.FilterExpressions); } ViewableActivatorForge activatorNamedWindow = new ViewableActivatorNamedWindowForge( namedSpec, nwinfo, filterEvaluator, null, true, namedSpec.OptPropertyEvaluator); ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, namedWindowType); IList <ViewFactoryForge> forges = viewForgeDesc.Forges; additionalForgeables.AddAll(viewForgeDesc.MultikeyForges); subselect.RawEventType = forges.IsEmpty() ? namedWindowType : forges[forges.Count - 1].EventType; result.Put(subselect, new SubSelectActivationPlan(namedWindowType, forges, activatorNamedWindow, streamSpec)); } else { // else if there are no named window stream filter expressions and index sharing is enabled ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, namedWindowType); IList <ViewFactoryForge> forges = viewForgeDesc.Forges; additionalForgeables.AddAll(viewForgeDesc.MultikeyForges); subselect.RawEventType = namedWindowType; ViewableActivatorForge activatorNamedWindow = new ViewableActivatorSubselectNoneForge(namedWindowType); result.Put(subselect, new SubSelectActivationPlan(namedWindowType, forges, activatorNamedWindow, streamSpec)); } } } return(new SubSelectActivationDesc(result, additionalForgeables)); }
public FAFQueryMethodIUDBaseForge( StatementSpecCompiled spec, Compilable compilable, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { this.annotations = spec.Annotations; this.hasTableAccess = spec.Raw.IntoTableSpec != null || (spec.TableAccessNodes != null && spec.TableAccessNodes.Count > 0); if (spec.Raw.InsertIntoDesc != null && services.TableCompileTimeResolver.Resolve(spec.Raw.InsertIntoDesc.EventTypeName) != null) { hasTableAccess = true; } if (spec.Raw.FireAndForgetSpec is FireAndForgetSpecUpdate || spec.Raw.FireAndForgetSpec is FireAndForgetSpecDelete) { hasTableAccess |= spec.StreamSpecs[0] is TableQueryStreamSpec; } // validate general FAF criteria FAFQueryMethodHelper.ValidateFAFQuery(spec); // obtain processor StreamSpecCompiled streamSpec = spec.StreamSpecs[0]; processor = FireAndForgetProcessorForgeFactory.ValidateResolveProcessor(streamSpec); // obtain name and type string processorName = processor.NamedWindowOrTableName; EventType eventType = processor.EventTypeRspInputEvents; // determine alias string aliasName = processorName; if (streamSpec.OptionalStreamName != null) { aliasName = streamSpec.OptionalStreamName; } // compile filter to optimize access to named window StreamTypeServiceImpl typeService = new StreamTypeServiceImpl( new EventType[] {eventType}, new string[] {aliasName}, new bool[] {true}, true, false); ExcludePlanHint excludePlanHint = ExcludePlanHint.GetHint( typeService.StreamNames, statementRawInfo, services); if (spec.Raw.WhereClause != null) { queryGraph = new QueryGraphForge(1, excludePlanHint, false); EPLValidationUtil.ValidateFilterWQueryGraphSafe( queryGraph, spec.Raw.WhereClause, typeService, statementRawInfo, services); } else { queryGraph = null; } // validate expressions whereClause = EPStatementStartMethodHelperValidate.ValidateNodes( spec.Raw, typeService, null, statementRawInfo, services); // get executor InitExec(aliasName, spec, statementRawInfo, services); // plan table access tableAccessForges = ExprTableEvalHelperPlan.PlanTableAccess(spec.Raw.TableExpressions); }