public StmtForgeMethodResult Make( string @namespace, string classPostfix, StatementCompileTimeServices services) { // determine context var contextName = @base.StatementSpec.Raw.OptionalContextName; IList<FilterSpecCompiled> filterSpecCompileds = new List<FilterSpecCompiled>(); IList<ScheduleHandleCallbackProvider> schedules = new List<ScheduleHandleCallbackProvider>(); IList<NamedWindowConsumerStreamSpec> namedWindowConsumers = new List<NamedWindowConsumerStreamSpec>(); IList<StmtClassForgeableFactory> additionalForgeables = new List<StmtClassForgeableFactory>(); // create subselect information var subSelectActivationDesc = SubSelectHelperActivations.CreateSubSelectActivation( filterSpecCompileds, namedWindowConsumers, @base, services); IDictionary<ExprSubselectNode, SubSelectActivationPlan> subselectActivation = subSelectActivationDesc.Subselects; additionalForgeables.AddAll(subSelectActivationDesc.AdditionalForgeables); // obtain activator var streamSpec = @base.StatementSpec.StreamSpecs[0]; StreamSelector? optionalStreamSelector = null; OnTriggerActivatorDesc activatorResult; if (streamSpec is FilterStreamSpecCompiled) { var filterStreamSpec = (FilterStreamSpecCompiled) streamSpec; activatorResult = ActivatorFilter(filterStreamSpec, services); filterSpecCompileds.Add(filterStreamSpec.FilterSpecCompiled); } else if (streamSpec is PatternStreamSpecCompiled) { var patternStreamSpec = (PatternStreamSpecCompiled) streamSpec; var forges = patternStreamSpec.Root.CollectFactories(); foreach (var forge in forges) { forge.CollectSelfFilterAndSchedule(filterSpecCompileds, schedules); } activatorResult = ActivatorPattern(patternStreamSpec, services); } else if (streamSpec is NamedWindowConsumerStreamSpec) { var namedSpec = (NamedWindowConsumerStreamSpec) streamSpec; activatorResult = ActivatorNamedWindow(namedSpec, services); namedWindowConsumers.Add(namedSpec); } else if (streamSpec is TableQueryStreamSpec) { throw new ExprValidationException("Tables cannot be used in an on-action statement triggering stream"); } else { throw new ExprValidationException("Unknown stream specification type: " + streamSpec); } var statementFieldsClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix); var namespaceScope = new CodegenNamespaceScope( @namespace, statementFieldsClassName, services.IsInstrumented); var aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(StatementAIFactoryProvider), classPostfix); // context-factory creation // // handle on-merge for table var onTriggerDesc = @base.StatementSpec.Raw.OnTriggerDesc; OnTriggerPlan onTriggerPlan; if (onTriggerDesc is OnTriggerWindowDesc) { var desc = (OnTriggerWindowDesc) onTriggerDesc; var namedWindow = services.NamedWindowCompileTimeResolver.Resolve(desc.WindowName); TableMetaData table = null; if (namedWindow == null) { table = services.TableCompileTimeResolver.Resolve(desc.WindowName); if (table == null) { throw new ExprValidationException( "A named window or table '" + desc.WindowName + "' has not been declared"); } } var planDesc = new OnTriggerWindowPlan( desc, contextName, activatorResult, optionalStreamSelector, subselectActivation, streamSpec); onTriggerPlan = OnTriggerWindowUtil.HandleContextFactoryOnTrigger( aiFactoryProviderClassName, namespaceScope, classPostfix, namedWindow, table, planDesc, @base, services); } else if (onTriggerDesc is OnTriggerSetDesc) { // variable assignments var desc = (OnTriggerSetDesc) onTriggerDesc; var plan = OnTriggerSetUtil.HandleSetVariable( aiFactoryProviderClassName, namespaceScope, classPostfix, activatorResult, streamSpec.OptionalStreamName, subselectActivation, desc, @base, services); onTriggerPlan = new OnTriggerPlan( plan.Forgeable, plan.Forgeables, plan.SelectSubscriberDescriptor, plan.AdditionalForgeables); } else { // split-stream use case var desc = (OnTriggerSplitStreamDesc) onTriggerDesc; onTriggerPlan = OnSplitStreamUtil.HandleSplitStream( aiFactoryProviderClassName, namespaceScope, classPostfix, desc, streamSpec, activatorResult, subselectActivation, @base, services); } additionalForgeables.AddAll(onTriggerPlan.AdditionalForgeables); // build forge list IList<StmtClassForgeable> forgeables = new List<StmtClassForgeable>(); foreach (StmtClassForgeableFactory additional in additionalForgeables) { forgeables.Add(additional.Make(namespaceScope, classPostfix)); } forgeables.AddAll(onTriggerPlan.Forgeables); forgeables.Add(onTriggerPlan.Factory); var statementProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix); var informationals = StatementInformationalsUtil.GetInformationals( @base, filterSpecCompileds, schedules, namedWindowConsumers, true, onTriggerPlan.SubscriberDescriptor, namespaceScope, services); forgeables.Add( new StmtClassForgeableStmtProvider( aiFactoryProviderClassName, statementProviderClassName, informationals, namespaceScope)); forgeables.Add( new StmtClassForgeableStmtFields( statementFieldsClassName, namespaceScope, 2)); return new StmtForgeMethodResult( forgeables, filterSpecCompileds, schedules, namedWindowConsumers, FilterSpecCompiled.MakeExprNodeList( filterSpecCompileds, EmptyList<FilterSpecParamExprNodeForge>.Instance)); }
public StmtForgeMethodResult Make( string @namespace, string classPostfix, StatementCompileTimeServices services) { var statementSpec = @base.StatementSpec; if (statementSpec.Raw.OptionalContextName != null) { throw new ExprValidationException( "A create-context statement cannot itself be associated to a context, please declare a nested context instead"); } IList<FilterSpecCompiled> filterSpecCompileds = new List<FilterSpecCompiled>(); IList<ScheduleHandleCallbackProvider> scheduleHandleCallbackProviders = new List<ScheduleHandleCallbackProvider>(); IList<FilterSpecParamExprNodeForge> filterBooleanExpressions = new List<FilterSpecParamExprNodeForge>(); var context = statementSpec.Raw.CreateContextDesc; if (services.ContextCompileTimeResolver.GetContextInfo(context.ContextName) != null) { throw new ExprValidationException("Context by name '" + context.ContextName + "' already exists"); } // compile filter specs, if any var validationEnv = new CreateContextValidationEnv( context.ContextName, @base.StatementRawInfo, services, filterSpecCompileds, scheduleHandleCallbackProviders, filterBooleanExpressions); var additionalForgeables = ValidateContextDetail( context.ContextDetail, 0, validationEnv); // get controller factory forges var controllerFactoryForges = GetForges( context.ContextName, context.ContextDetail); // build context properties type information var contextProps = MakeContextProperties( controllerFactoryForges, @base.StatementRawInfo, services); // allocate type for context properties var contextEventTypeName = services.EventTypeNameGeneratorStatement.GetContextPropertyTypeName(context.ContextName); var metadata = new EventTypeMetadata( contextEventTypeName, @base.ModuleName, EventTypeTypeClass.CONTEXTPROPDERIVED, EventTypeApplicationType.MAP, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var contextPropertiesType = BaseNestableEventUtil.MakeMapTypeCompileTime( metadata, contextProps, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(contextPropertiesType); // register context var visibilityContext = services.ModuleVisibilityRules.GetAccessModifierContext(@base, context.ContextName); var validationInfo = new ContextControllerPortableInfo[controllerFactoryForges.Length]; for (var i = 0; i < validationInfo.Length; i++) { validationInfo[i] = controllerFactoryForges[i].ValidationInfo; } var detail = new ContextMetaData( context.ContextName, @base.ModuleName, visibilityContext, contextPropertiesType, validationInfo); services.ContextCompileTimeRegistry.NewContext(detail); // define output event type var statementEventTypeName = services.EventTypeNameGeneratorStatement.GetContextStatementTypeName(context.ContextName); var statementTypeMetadata = new EventTypeMetadata( statementEventTypeName, @base.ModuleName, EventTypeTypeClass.STATEMENTOUT, EventTypeApplicationType.MAP, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); EventType statementEventType = BaseNestableEventUtil.MakeMapTypeCompileTime( statementTypeMetadata, EmptyDictionary<string, object>.Instance, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(statementEventType); var statementFieldsClassName = CodeGenerationIDGenerator .GenerateClassNameSimple(typeof(StatementFields), classPostfix); var namespaceScope = new CodegenNamespaceScope( @namespace, statementFieldsClassName, services.IsInstrumented); var forgeables = new List<StmtClassForgeable>(); foreach (var additional in additionalForgeables) { forgeables.Add(additional.Make(namespaceScope, classPostfix)); } var statementProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix); var statementAIFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementAIFactoryProvider), classPostfix); var forge = new StatementAgentInstanceFactoryCreateContextForge(context.ContextName, statementEventType); forgeables.Add( new StmtClassForgeableAIFactoryProviderCreateContext( statementAIFactoryProviderClassName, namespaceScope, context.ContextName, controllerFactoryForges, contextPropertiesType, forge)); var selectSubscriberDescriptor = new SelectSubscriberDescriptor(); var informationals = StatementInformationalsUtil.GetInformationals( @base, filterSpecCompileds, scheduleHandleCallbackProviders, EmptyList<NamedWindowConsumerStreamSpec>.Instance, false, selectSubscriberDescriptor, namespaceScope, services); informationals.Properties.Put(StatementProperty.CREATEOBJECTNAME, context.ContextName); forgeables.Add( new StmtClassForgeableStmtProvider( statementAIFactoryProviderClassName, statementProviderClassName, informationals, namespaceScope)); forgeables.Add( new StmtClassForgeableStmtFields( statementFieldsClassName, namespaceScope, 0)); return new StmtForgeMethodResult( forgeables, filterSpecCompileds, scheduleHandleCallbackProviders, EmptyList<NamedWindowConsumerStreamSpec>.Instance, FilterSpecCompiled.MakeExprNodeList(filterSpecCompileds, filterBooleanExpressions)); }
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); }