public StmtForgeMethodResult Make( string @namespace, string classPostfix, StatementCompileTimeServices services) { var statementSpec = @base.StatementSpec; var spec = statementSpec.Raw.CreateSchemaDesc; if (services.EventTypeCompileTimeResolver.GetTypeByName(spec.SchemaName) != null) { throw new ExprValidationException( "Event type named '" + spec.SchemaName + "' has already been declared"); } EPLValidationUtil.ValidateTableExists(services.TableCompileTimeResolver, spec.SchemaName); var eventType = HandleCreateSchema(spec, services); var statementFieldsClassName = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(StatementFields), classPostfix); var namespaceScope = new CodegenNamespaceScope( @namespace, statementFieldsClassName, services.IsInstrumented); var fieldsForgable = new StmtClassForgableStmtFields(statementFieldsClassName, namespaceScope, 0); var aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(StatementAIFactoryProvider), classPostfix); var forge = new StatementAgentInstanceFactoryCreateSchemaForge(eventType); var aiFactoryForgable = new StmtClassForgableAIFactoryProviderCreateSchema( aiFactoryProviderClassName, namespaceScope, forge); var selectSubscriberDescriptor = new SelectSubscriberDescriptor(); var informationals = StatementInformationalsUtil.GetInformationals( @base, new EmptyList<FilterSpecCompiled>(), new EmptyList<ScheduleHandleCallbackProvider>(), new EmptyList<NamedWindowConsumerStreamSpec>(), false, selectSubscriberDescriptor, namespaceScope, services); var statementProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix); var stmtProvider = new StmtClassForgableStmtProvider( aiFactoryProviderClassName, statementProviderClassName, informationals, namespaceScope); IList<StmtClassForgable> forgables = new List<StmtClassForgable>(); forgables.Add(fieldsForgable); forgables.Add(aiFactoryForgable); forgables.Add(stmtProvider); return new StmtForgeMethodResult( forgables, new EmptyList<FilterSpecCompiled>(), new EmptyList<ScheduleHandleCallbackProvider>(), new EmptyList<NamedWindowConsumerStreamSpec>(), new EmptyList<FilterSpecParamExprNodeForge>()); }
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 StmtForgeMethodResult Make( string @namespace, string classPostfix, StatementCompileTimeServices services) { var statementSpec = @base.StatementSpec; // determine context var contextName = @base.StatementSpec.Raw.OptionalContextName; if (contextName != null) { throw new ExprValidationException("Update IStream is not supported in conjunction with a context"); } var streamSpec = statementSpec.StreamSpecs[0]; var updateSpec = statementSpec.Raw.UpdateDesc; string triggereventTypeName; EventType streamEventType; if (streamSpec is FilterStreamSpecCompiled) { var filterStreamSpec = (FilterStreamSpecCompiled) streamSpec; triggereventTypeName = filterStreamSpec.FilterSpecCompiled.FilterForEventTypeName; streamEventType = filterStreamSpec.FilterSpecCompiled.FilterForEventType; } else if (streamSpec is NamedWindowConsumerStreamSpec) { var namedSpec = (NamedWindowConsumerStreamSpec) streamSpec; streamEventType = namedSpec.NamedWindow.EventType; triggereventTypeName = streamEventType.Name; } else if (streamSpec is TableQueryStreamSpec) { throw new ExprValidationException("Tables cannot be used in an update-istream statement"); } else { throw new ExprValidationException("Unknown stream specification streamEventType: " + streamSpec); } // determine a stream name var streamName = triggereventTypeName; if (updateSpec.OptionalStreamName != null) { streamName = updateSpec.OptionalStreamName; } StreamTypeService typeService = new StreamTypeServiceImpl( new[] {streamEventType}, new[] {streamName}, new[] {true}, false, false); // create subselect information IList<FilterSpecCompiled> filterSpecCompileds = new List<FilterSpecCompiled>(); IList<NamedWindowConsumerStreamSpec> namedWindowConsumers = new List<NamedWindowConsumerStreamSpec>(); var subselectActivation = SubSelectHelperActivations.CreateSubSelectActivation( filterSpecCompileds, namedWindowConsumers, @base, services); // handle subselects var subselectForges = SubSelectHelperForgePlanner.PlanSubSelect( @base, subselectActivation, typeService.StreamNames, typeService.EventTypes, new[] {triggereventTypeName}, services); var validationContext = new ExprValidationContextBuilder(typeService, @base.StatementRawInfo, services).Build(); foreach (var assignment in updateSpec.Assignments) { var validated = ExprNodeUtilityValidate.GetValidatedAssignment(assignment, validationContext); assignment.Expression = validated; EPStatementStartMethodHelperValidate.ValidateNoAggregations( validated, "Aggregation functions may not be used within an update-clause"); } if (updateSpec.OptionalWhereClause != null) { var validated = ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.WHERE, updateSpec.OptionalWhereClause, validationContext); updateSpec.OptionalWhereClause = validated; EPStatementStartMethodHelperValidate.ValidateNoAggregations( validated, "Aggregation functions may not be used within an update-clause"); } // build route information var routerDesc = InternalEventRouterDescFactory.GetValidatePreprocessing( streamEventType, updateSpec, @base.StatementRawInfo.Annotations); var statementFieldsClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix); var packageScope = new CodegenNamespaceScope( @namespace, statementFieldsClassName, services.IsInstrumented); var aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(StatementAIFactoryProvider), classPostfix); var forge = new StatementAgentInstanceFactoryUpdateForge(routerDesc, subselectForges); var aiFactoryForgable = new StmtClassForgableAIFactoryProviderUpdate( aiFactoryProviderClassName, packageScope, forge); var selectSubscriberDescriptor = new SelectSubscriberDescriptor( new[] {streamEventType.UnderlyingType}, new[] {"*"}, false, null); var informationals = StatementInformationalsUtil.GetInformationals( @base, filterSpecCompileds, Collections.GetEmptyList<ScheduleHandleCallbackProvider>(), Collections.GetEmptyList<NamedWindowConsumerStreamSpec>(), false, 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(aiFactoryForgable); forgables.Add(stmtProvider); forgables.Add(new StmtClassForgableStmtFields(statementFieldsClassName, packageScope, 0)); return new StmtForgeMethodResult( forgables, filterSpecCompileds, Collections.GetEmptyList<ScheduleHandleCallbackProvider>(), namedWindowConsumers, 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 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)); }
private StmtForgeMethodResult Build( string @namespace, string classPostfix, StatementCompileTimeServices services) { var createDesc = @base.StatementSpec.Raw.CreateTableDesc; var tableName = createDesc.TableName; var additionalForgeables = new List<StmtClassForgeableFactory>(); // determine whether already declared as table or variable EPLValidationUtil.ValidateAlreadyExistsTableOrVariable( tableName, services.VariableCompileTimeResolver, services.TableCompileTimeResolver, services.EventTypeCompileTimeResolver); // determine key types ValidateKeyTypes(createDesc.Columns, services.ImportServiceCompileTime); // check column naming, interpret annotations var columnsValidated = ValidateExpressions(createDesc.Columns, services); var columnDescs = columnsValidated.First; additionalForgeables.AddRange(columnsValidated.Second); // analyze and plan the state holders var plan = AnalyzePlanAggregations(createDesc.TableName, columnDescs, @base.StatementRawInfo, services); additionalForgeables.AddAll(plan.AdditionalForgeables); var visibility = plan.PublicEventType.Metadata.AccessModifier; // determine context information var contextName = @base.StatementRawInfo.ContextName; 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; } // add table var tableMetaData = new TableMetaData( tableName, @base.ModuleName, visibility, contextName, contextVisibility, contextModuleName, plan.InternalEventType, plan.PublicEventType, plan.PrimaryKeyColumns, plan.PrimaryKeyTypes, plan.PrimaryKeyColNums, plan.TableColumns, plan.ColsAggMethod.Length); services.TableCompileTimeRegistry.NewTable(tableMetaData); var aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(StatementAIFactoryProvider), classPostfix); var statementFieldsClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix); var statementProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix); var forge = new StatementAgentInstanceFactoryCreateTableForge( aiFactoryProviderClassName, tableMetaData.TableName, plan); // build forge list var namespaceScope = new CodegenNamespaceScope( @namespace, statementFieldsClassName, services.IsInstrumented); var forgeables = additionalForgeables .Select(additional => additional.Make(namespaceScope, classPostfix)) .ToList(); var aiFactoryForgeable = new StmtClassForgeableAIFactoryProviderCreateTable( aiFactoryProviderClassName, namespaceScope, forge, tableName); forgeables.Add(aiFactoryForgeable); var selectSubscriberDescriptor = new SelectSubscriberDescriptor(); var informationals = StatementInformationalsUtil.GetInformationals( @base, EmptyList<FilterSpecCompiled>.Instance, EmptyList<ScheduleHandleCallbackProvider>.Instance, EmptyList<NamedWindowConsumerStreamSpec>.Instance, true, selectSubscriberDescriptor, namespaceScope, services); informationals.Properties.Put(StatementProperty.CREATEOBJECTNAME, createDesc.TableName); forgeables.Add( new StmtClassForgeableStmtProvider( aiFactoryProviderClassName, statementProviderClassName, informationals, namespaceScope)); forgeables.Add( new StmtClassForgeableStmtFields( statementFieldsClassName, namespaceScope, 1)); return new StmtForgeMethodResult( forgeables, EmptyList<FilterSpecCompiled>.Instance, EmptyList<ScheduleHandleCallbackProvider>.Instance, EmptyList<NamedWindowConsumerStreamSpec>.Instance, EmptyList<FilterSpecParamExprNodeForge>.Instance); }
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 StmtForgeMethodResult Make( string @namespace, string classPostfix, StatementCompileTimeServices services) { var spec = @base.StatementSpec.Raw.CreateIndexDesc; var infraName = spec.WindowName; var namedWindow = services.NamedWindowCompileTimeResolver.Resolve(infraName); var table = services.TableCompileTimeResolver.Resolve(infraName); if (namedWindow == null && table == null) { throw new ExprValidationException("A named window or table by name '" + infraName + "' does not exist"); } if (namedWindow != null && table != null) { throw new ExprValidationException("A named window or table by name '" + infraName + "' are both found"); } string infraModuleName; NameAccessModifier infraVisibility; EventType indexedEventType; string infraContextName; if (namedWindow != null) { infraModuleName = namedWindow.NamedWindowModuleName; infraVisibility = namedWindow.EventType.Metadata.AccessModifier; indexedEventType = namedWindow.EventType; infraContextName = namedWindow.ContextName; } else { infraModuleName = table.TableModuleName; infraVisibility = table.TableVisibility; indexedEventType = table.InternalEventType; infraContextName = table.OptionalContextName; if (!table.IsKeyed) { throw new ExprValidationException( "Tables without primary key column(s) do not allow creating an index"); } } EPLValidationUtil.ValidateContextName( namedWindow == null, infraName, infraContextName, @base.StatementSpec.Raw.OptionalContextName, true); // validate index var explicitIndexDesc = EventTableIndexUtil.ValidateCompileExplicitIndex( spec.IndexName, spec.IsUnique, spec.Columns, indexedEventType, @base.StatementRawInfo, services); var advancedIndexDesc = explicitIndexDesc.AdvancedIndexProvisionDesc == null ? null : explicitIndexDesc.AdvancedIndexProvisionDesc.IndexDesc.AdvancedIndexDescRuntime; var imk = new IndexMultiKey( spec.IsUnique, explicitIndexDesc.HashPropsAsList, explicitIndexDesc.BtreePropsAsList, advancedIndexDesc); // add index as a new index to module-init var indexKey = new IndexCompileTimeKey( infraModuleName, infraName, infraVisibility, namedWindow != null, spec.IndexName, @base.ModuleName); services.IndexCompileTimeRegistry.NewIndex(indexKey, new IndexDetailForge(imk, explicitIndexDesc)); // add index current named window information if (namedWindow != null) { namedWindow.AddIndex(spec.IndexName, @base.ModuleName, imk, explicitIndexDesc.ToRuntime()); } else { table.AddIndex(spec.IndexName, @base.ModuleName, imk, explicitIndexDesc.ToRuntime()); } var statementFieldsClassName = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(StatementFields), classPostfix); var namespaceScope = new CodegenNamespaceScope( @namespace, statementFieldsClassName, services.IsInstrumented); var fieldsForgable = new StmtClassForgableStmtFields(statementFieldsClassName, namespaceScope, 0); var aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(StatementAIFactoryProvider), classPostfix); var forge = new StatementAgentInstanceFactoryCreateIndexForge( indexedEventType, spec.IndexName, @base.ModuleName, explicitIndexDesc, imk, namedWindow, table); var aiFactoryForgable = new StmtClassForgableAIFactoryProviderCreateIndex( aiFactoryProviderClassName, namespaceScope, forge); var selectSubscriberDescriptor = new SelectSubscriberDescriptor(); var informationals = StatementInformationalsUtil.GetInformationals( @base, new EmptyList<FilterSpecCompiled>(), new EmptyList<ScheduleHandleCallbackProvider>(), new EmptyList<NamedWindowConsumerStreamSpec>(), true, selectSubscriberDescriptor, namespaceScope, services); var statementProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix); var stmtProvider = new StmtClassForgableStmtProvider( aiFactoryProviderClassName, statementProviderClassName, informationals, namespaceScope); IList<StmtClassForgable> forgables = new List<StmtClassForgable>(); forgables.Add(fieldsForgable); forgables.Add(aiFactoryForgable); forgables.Add(stmtProvider); return new StmtForgeMethodResult( forgables, new EmptyList<FilterSpecCompiled>(), new EmptyList<ScheduleHandleCallbackProvider>(), new EmptyList<NamedWindowConsumerStreamSpec>(), new EmptyList<FilterSpecParamExprNodeForge>()); }
public StmtForgeMethodResult Make( string @namespace, string classPostfix, StatementCompileTimeServices services) { string objectName = Register(services); // define output event type string statementEventTypeName = services.EventTypeNameGeneratorStatement.AnonymousTypeName; EventTypeMetadata 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); string statementFieldsClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix); CodegenNamespaceScope namespaceScope = new CodegenNamespaceScope( @namespace, statementFieldsClassName, services.IsInstrumented); string aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementAIFactoryProvider), classPostfix); StmtClassForgeable aiFactoryForgeable = AiFactoryForgable(aiFactoryProviderClassName, namespaceScope, statementEventType, objectName); SelectSubscriberDescriptor selectSubscriberDescriptor = new SelectSubscriberDescriptor(); StatementInformationalsCompileTime informationals = StatementInformationalsUtil.GetInformationals( _base, EmptyList <FilterSpecCompiled> .Instance, EmptyList <ScheduleHandleCallbackProvider> .Instance, EmptyList <NamedWindowConsumerStreamSpec> .Instance, false, selectSubscriberDescriptor, namespaceScope, services); informationals.Properties.Put(StatementProperty.CREATEOBJECTNAME, objectName); string statementProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix); StmtClassForgeableStmtProvider stmtProvider = new StmtClassForgeableStmtProvider( aiFactoryProviderClassName, statementProviderClassName, informationals, namespaceScope); var stmtClassForgeableStmtFields = new StmtClassForgeableStmtFields( statementFieldsClassName, namespaceScope, 1); IList <StmtClassForgeable> forgeables = new List <StmtClassForgeable>(); forgeables.Add(aiFactoryForgeable); forgeables.Add(stmtProvider); forgeables.Add(stmtClassForgeableStmtFields); return(new StmtForgeMethodResult( forgeables, EmptyList <FilterSpecCompiled> .Instance, EmptyList <ScheduleHandleCallbackProvider> .Instance, EmptyList <NamedWindowConsumerStreamSpec> .Instance, EmptyList <FilterSpecParamExprNodeForge> .Instance)); }
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>()); }