// settable for view-sharing /// <summary> /// Constructor. /// </summary> /// <param name="stmtEngineServices">is the engine services for the statement</param> /// <param name="schedulingService">implementation for schedule registration</param> /// <param name="scheduleBucket">is for ordering scheduled callbacks within the view statements</param> /// <param name="epStatementHandle">is the statements-own handle for use in registering callbacks with services</param> /// <param name="viewResultionService">is a service for resolving view namespace and name to a view factory</param> /// <param name="patternResolutionService">is the service that resolves pattern objects for the statement</param> /// <param name="statementExtensionSvcContext">provide extension points for custom statement resources</param> /// <param name="statementStopService">for registering a callback invoked when a statement is stopped</param> /// <param name="methodResolutionService">is a service for resolving static methods and aggregation functions</param> /// <param name="patternContextFactory">is the pattern-level services and context information factory</param> /// <param name="filterService">is the filtering service</param> /// <param name="statementResultService">handles awareness of listeners/subscriptions for a statement customizing output produced</param> /// <param name="internalEventEngineRouteDest">routing destination</param> /// <param name="annotations">The annotations.</param> /// <param name="statementAgentInstanceRegistry">The statement agent instance registry.</param> /// <param name="defaultAgentInstanceLock">The default agent instance lock.</param> /// <param name="contextDescriptor">The context descriptor.</param> /// <param name="patternSubexpressionPoolSvc">The pattern subexpression pool SVC.</param> /// <param name="matchRecognizeStatePoolStmtSvc">The match recognize state pool statement SVC.</param> /// <param name="statelessSelect">if set to <c>true</c> [stateless select].</param> /// <param name="contextControllerFactoryService">The context controller factory service.</param> /// <param name="defaultAgentInstanceScriptContext">The default agent instance script context.</param> /// <param name="aggregationServiceFactoryService">The aggregation service factory service.</param> /// <param name="scriptingService">The scripting service.</param> /// <param name="writesToTables">if set to <c>true</c> [writes to tables].</param> /// <param name="statementUserObject">The statement user object.</param> /// <param name="statementSemiAnonymousTypeRegistry">The statement semi anonymous type registry.</param> /// <param name="priority">The priority.</param> public StatementContext( StatementContextEngineServices stmtEngineServices, SchedulingService schedulingService, ScheduleBucket scheduleBucket, EPStatementHandle epStatementHandle, ViewResolutionService viewResultionService, PatternObjectResolutionService patternResolutionService, StatementExtensionSvcContext statementExtensionSvcContext, StatementStopService statementStopService, MethodResolutionService methodResolutionService, PatternContextFactory patternContextFactory, FilterService filterService, StatementResultService statementResultService, InternalEventRouteDest internalEventEngineRouteDest, Attribute[] annotations, StatementAIResourceRegistry statementAgentInstanceRegistry, IReaderWriterLock defaultAgentInstanceLock, ContextDescriptor contextDescriptor, PatternSubexpressionPoolStmtSvc patternSubexpressionPoolSvc, MatchRecognizeStatePoolStmtSvc matchRecognizeStatePoolStmtSvc, bool statelessSelect, ContextControllerFactoryService contextControllerFactoryService, AgentInstanceScriptContext defaultAgentInstanceScriptContext, AggregationServiceFactoryService aggregationServiceFactoryService, ScriptingService scriptingService, bool writesToTables, object statementUserObject, StatementSemiAnonymousTypeRegistry statementSemiAnonymousTypeRegistry, int priority) { _stmtEngineServices = stmtEngineServices; SchedulingService = schedulingService; ScheduleBucket = scheduleBucket; EpStatementHandle = epStatementHandle; ViewResolutionService = viewResultionService; PatternResolutionService = patternResolutionService; StatementExtensionServicesContext = statementExtensionSvcContext; StatementStopService = statementStopService; MethodResolutionService = methodResolutionService; PatternContextFactory = patternContextFactory; FilterService = filterService; _statementResultService = statementResultService; InternalEventEngineRouteDest = internalEventEngineRouteDest; ScheduleAdjustmentService = stmtEngineServices.ConfigSnapshot.EngineDefaults.ExecutionConfig.IsAllowIsolatedService ? new ScheduleAdjustmentService() : null; Annotations = annotations; StatementAgentInstanceRegistry = statementAgentInstanceRegistry; DefaultAgentInstanceLock = defaultAgentInstanceLock; ContextDescriptor = contextDescriptor; PatternSubexpressionPoolSvc = patternSubexpressionPoolSvc; MatchRecognizeStatePoolStmtSvc = matchRecognizeStatePoolStmtSvc; IsStatelessSelect = statelessSelect; ContextControllerFactoryService = contextControllerFactoryService; DefaultAgentInstanceScriptContext = defaultAgentInstanceScriptContext; AggregationServiceFactoryService = aggregationServiceFactoryService; ScriptingService = scriptingService; IsWritesToTables = writesToTables; StatementUserObject = statementUserObject; StatementSemiAnonymousTypeRegistry = statementSemiAnonymousTypeRegistry; Priority = priority; }
public void EvaluateFalse(EvalStateNode fromNode, bool restartable) { int index; fromNode.Quit(); var hasIndex = Nodes.TryGetValue(fromNode, out index); Nodes.Remove(fromNode); if (hasIndex && index > 0) { if (EvalFollowedByNode.IsTrackWithMax) { CountActivePerChild[index - 1]--; } if (EvalFollowedByNode.IsTrackWithPool) { PatternSubexpressionPoolStmtSvc poolSvc = EvalFollowedByNode.Context.StatementContext.PatternSubexpressionPoolSvc; poolSvc.EngineSvc.DecreaseCount(EvalFollowedByNode, EvalFollowedByNode.Context.AgentInstanceContext); poolSvc.StmtHandler.DecreaseCount(); } } if (Nodes.IsEmpty()) { ParentEvaluator.EvaluateFalse(this, true); Quit(); } }
public override void Quit() { AgentInstanceContext agentInstanceContext = evalFollowedByNode.Context.AgentInstanceContext; agentInstanceContext.InstrumentationProvider.QPatternFollowedByQuit(evalFollowedByNode.factoryNode); agentInstanceContext.AuditProvider.PatternInstance( false, evalFollowedByNode.factoryNode, agentInstanceContext); foreach (var entry in nodes) { entry.Key.Quit(); if (evalFollowedByNode.IsTrackWithPool) { if (entry.Value > 0) { PatternSubexpressionPoolStmtSvc poolSvc = evalFollowedByNode.Context.StatementContext.PatternSubexpressionPoolSvc; poolSvc.RuntimeSvc.DecreaseCount( evalFollowedByNode, evalFollowedByNode.Context.AgentInstanceContext); poolSvc.StmtHandler.DecreaseCount(); } } } agentInstanceContext.InstrumentationProvider.APatternFollowedByQuit(); }
public StatementContext( IContainer container, ContextRuntimeDescriptor contextRuntimeDescriptor, string deploymentId, int statementId, string statementName, string moduleName, StatementInformationalsRuntime statementInformationals, object userObjectRuntime, StatementContextRuntimeServices statementContextRuntimeServices, EPStatementHandle epStatementHandle, IDictionary<int, FilterSpecActivatable> filterSpecActivatables, PatternSubexpressionPoolStmtSvc patternSubexpressionPoolSvc, RowRecogStatePoolStmtSvc rowRecogStatePoolStmtSvc, ScheduleBucket scheduleBucket, StatementAIResourceRegistry statementAIResourceRegistry, StatementCPCacheService statementCPCacheService, StatementAIFactoryProvider statementAIFactoryProvider, StatementResultService statementResultService, UpdateDispatchView updateDispatchView, FilterService filterService, SchedulingService schedulingService, InternalEventRouteDest internalEventRouteDest) { Container = container; ContextRuntimeDescriptor = contextRuntimeDescriptor; DeploymentId = deploymentId; StatementId = statementId; StatementName = statementName; ModuleName = moduleName; StatementInformationals = statementInformationals; UserObjectRuntime = userObjectRuntime; StatementContextRuntimeServices = statementContextRuntimeServices; EpStatementHandle = epStatementHandle; FilterSpecActivatables = filterSpecActivatables; PatternSubexpressionPoolSvc = patternSubexpressionPoolSvc; RowRecogStatePoolStmtSvc = rowRecogStatePoolStmtSvc; ScheduleBucket = scheduleBucket; StatementAIResourceRegistry = statementAIResourceRegistry; StatementCPCacheService = statementCPCacheService; StatementAIFactoryProvider = statementAIFactoryProvider; StatementResultService = statementResultService; UpdateDispatchView = updateDispatchView; StatementContextFilterEvalEnv = new StatementContextFilterEvalEnv( statementContextRuntimeServices.ImportServiceRuntime, statementInformationals.Annotations, statementContextRuntimeServices.VariableManagementService, statementContextRuntimeServices.TableExprEvaluatorContext); this.FilterService = filterService; this.SchedulingService = schedulingService; this.InternalEventRouteDest = internalEventRouteDest; }
public override void Quit() { foreach (var entry in Nodes) { entry.Key.Quit(); if (EvalFollowedByNode.IsTrackWithPool) { if (entry.Value > 0) { PatternSubexpressionPoolStmtSvc poolSvc = EvalFollowedByNode.Context.StatementContext.PatternSubexpressionPoolSvc; poolSvc.EngineSvc.DecreaseCount(EvalFollowedByNode, EvalFollowedByNode.Context.AgentInstanceContext); poolSvc.StmtHandler.DecreaseCount(); } } } }
public void EvaluateFalse( EvalStateNode fromNode, bool restartable) { AgentInstanceContext agentInstanceContext = evalFollowedByNode.Context.AgentInstanceContext; agentInstanceContext.InstrumentationProvider.QPatternFollowedByEvalFalse(evalFollowedByNode.factoryNode); fromNode.Quit(); bool hasIndex = nodes.TryGetValue(fromNode, out var index); if (hasIndex) { nodes.Remove(fromNode); } if (hasIndex && index > 0) { if (evalFollowedByNode.IsTrackWithMax) { countActivePerChild[index - 1]--; } if (evalFollowedByNode.IsTrackWithPool) { PatternSubexpressionPoolStmtSvc poolSvc = evalFollowedByNode.Context.StatementContext.PatternSubexpressionPoolSvc; poolSvc.RuntimeSvc.DecreaseCount( evalFollowedByNode, evalFollowedByNode.Context.AgentInstanceContext); poolSvc.StmtHandler.DecreaseCount(); } } if (nodes.IsEmpty()) { agentInstanceContext.AuditProvider.PatternFalse( evalFollowedByNode.FactoryNode, this, agentInstanceContext); this.ParentEvaluator.EvaluateFalse(this, true); Quit(); } agentInstanceContext.InstrumentationProvider.APatternFollowedByEvalFalse(); }
public StatementContext MakeContext( int statementId, string statementName, string expression, StatementType statementType, EPServicesContext engineServices, IDictionary <string, object> optAdditionalContext, bool isFireAndForget, Attribute[] annotations, EPIsolationUnitServices isolationUnitServices, bool stateless, StatementSpecRaw statementSpecRaw, IList <ExprSubselectNode> subselectNodes, bool writesToTables, object statementUserObject) { // Allocate the statement's schedule bucket which stays constant over it's lifetime. // The bucket allows callbacks for the same time to be ordered (within and across statements) and thus deterministic. var scheduleBucket = engineServices.SchedulingMgmtService.AllocateBucket(); // Create a lock for the statement IReaderWriterLock defaultStatementAgentInstanceLock; // For on-delete statements, use the create-named-window statement lock var optCreateWindowDesc = statementSpecRaw.CreateWindowDesc; var optOnTriggerDesc = statementSpecRaw.OnTriggerDesc; if ((optOnTriggerDesc != null) && (optOnTriggerDesc is OnTriggerWindowDesc)) { var windowName = ((OnTriggerWindowDesc)optOnTriggerDesc).WindowName; if (engineServices.TableService.GetTableMetadata(windowName) == null) { defaultStatementAgentInstanceLock = engineServices.NamedWindowMgmtService.GetNamedWindowLock(windowName); if (defaultStatementAgentInstanceLock == null) { throw new EPStatementException("Named window or table '" + windowName + "' has not been declared", expression); } } else { defaultStatementAgentInstanceLock = engineServices.StatementLockFactory.GetStatementLock(statementName, annotations, stateless); } } // For creating a named window, save the lock for use with on-delete/on-merge/on-Update etc. statements else if (optCreateWindowDesc != null) { defaultStatementAgentInstanceLock = engineServices.NamedWindowMgmtService.GetNamedWindowLock(optCreateWindowDesc.WindowName); if (defaultStatementAgentInstanceLock == null) { defaultStatementAgentInstanceLock = engineServices.StatementLockFactory.GetStatementLock( statementName, annotations, false); engineServices.NamedWindowMgmtService.AddNamedWindowLock( optCreateWindowDesc.WindowName, defaultStatementAgentInstanceLock, statementName); } } else { defaultStatementAgentInstanceLock = engineServices.StatementLockFactory.GetStatementLock( statementName, annotations, stateless); } StatementMetricHandle stmtMetric = null; if (!isFireAndForget) { stmtMetric = engineServices.MetricsReportingService.GetStatementHandle(statementId, statementName); } var annotationData = AnnotationAnalysisResult.AnalyzeAnnotations(annotations); var hasVariables = statementSpecRaw.HasVariables || (statementSpecRaw.CreateContextDesc != null); var hasTableAccess = StatementContextFactoryUtil.DetermineHasTableAccess(subselectNodes, statementSpecRaw, engineServices); var epStatementHandle = new EPStatementHandle( statementId, statementName, expression, statementType, expression, hasVariables, stmtMetric, annotationData.Priority, annotationData.IsPremptive, hasTableAccess, engineServices.MultiMatchHandlerFactory.GetDefaultHandler()); var patternContextFactory = new PatternContextFactoryDefault(); var optionalCreateNamedWindowName = statementSpecRaw.CreateWindowDesc != null ? statementSpecRaw.CreateWindowDesc.WindowName : null; var viewResolutionService = new ViewResolutionServiceImpl( _viewRegistry, optionalCreateNamedWindowName, _systemVirtualDwViewFactory); var patternResolutionService = new PatternObjectResolutionServiceImpl(_patternObjectClasses); var schedulingService = engineServices.SchedulingService; var filterService = engineServices.FilterService; if (isolationUnitServices != null) { filterService = isolationUnitServices.FilterService; schedulingService = isolationUnitServices.SchedulingService; } var scheduleAudit = AuditEnum.SCHEDULE.GetAudit(annotations); if (scheduleAudit != null) { schedulingService = new SchedulingServiceAudit( engineServices.EngineURI, statementName, schedulingService); } StatementAIResourceRegistry statementAgentInstanceRegistry = null; ContextDescriptor contextDescriptor = null; var optionalContextName = statementSpecRaw.OptionalContextName; if (optionalContextName != null) { contextDescriptor = engineServices.ContextManagementService.GetContextDescriptor(optionalContextName); // allocate a per-instance registry of aggregations and prev/prior/subselect if (contextDescriptor != null) { statementAgentInstanceRegistry = contextDescriptor.AiResourceRegistryFactory.Invoke(); } } var countSubexpressions = engineServices.ConfigSnapshot.EngineDefaults.PatternsConfig.MaxSubexpressions != null; PatternSubexpressionPoolStmtSvc patternSubexpressionPoolStmtSvc = null; if (countSubexpressions) { var stmtCounter = new PatternSubexpressionPoolStmtHandler(); patternSubexpressionPoolStmtSvc = new PatternSubexpressionPoolStmtSvc(engineServices.PatternSubexpressionPoolSvc, stmtCounter); engineServices.PatternSubexpressionPoolSvc.AddPatternContext(statementName, stmtCounter); } var countMatchRecogStates = engineServices.ConfigSnapshot.EngineDefaults.MatchRecognizeConfig.MaxStates != null; MatchRecognizeStatePoolStmtSvc matchRecognizeStatePoolStmtSvc = null; if (countMatchRecogStates && statementSpecRaw.MatchRecognizeSpec != null) { var stmtCounter = new MatchRecognizeStatePoolStmtHandler(); matchRecognizeStatePoolStmtSvc = new MatchRecognizeStatePoolStmtSvc(engineServices.MatchRecognizeStatePoolEngineSvc, stmtCounter); engineServices.MatchRecognizeStatePoolEngineSvc.AddPatternContext(statementName, stmtCounter); } AgentInstanceScriptContext defaultAgentInstanceScriptContext = null; if (statementSpecRaw.ScriptExpressions != null && !statementSpecRaw.ScriptExpressions.IsEmpty()) { defaultAgentInstanceScriptContext = new AgentInstanceScriptContext(); } // allow a special context controller factory for testing var contextControllerFactoryService = GetContextControllerFactoryService(annotations); // may use resource tracking var statementResourceService = new StatementResourceService(optionalContextName != null); StatementExtensionSvcContext extensionSvcContext = new ProxyStatementExtensionSvcContext { ProcStmtResources = () => statementResourceService, ProcExtractStatementResourceHolder = resultOfStart => StatementResourceHolderUtil.PopulateHolder(resultOfStart) }; // Create statement context return(new StatementContext( _stmtEngineServices, schedulingService, scheduleBucket, epStatementHandle, viewResolutionService, patternResolutionService, extensionSvcContext, new StatementStopServiceImpl(), patternContextFactory, filterService, new StatementResultServiceImpl( statementName, engineServices.StatementLifecycleSvc, engineServices.MetricsReportingService, engineServices.ThreadingService), engineServices.InternalEventEngineRouteDest, annotations, statementAgentInstanceRegistry, defaultStatementAgentInstanceLock, contextDescriptor, patternSubexpressionPoolStmtSvc, matchRecognizeStatePoolStmtSvc, stateless, contextControllerFactoryService, defaultAgentInstanceScriptContext, AggregationServiceFactoryServiceImpl.DEFAULT_FACTORY, engineServices.ScriptingService, writesToTables, statementUserObject, StatementSemiAnonymousTypeRegistryImpl.INSTANCE, annotationData.Priority)); }
private static StatementLightweight InitStatement( bool recovery, string moduleName, StatementProvider statementProvider, string deploymentId, int statementId, EventTypeResolver eventTypeResolver, ModuleIncidentals moduleIncidentals, StatementNameRuntimeOption statementNameResolverRuntime, StatementUserObjectRuntimeOption userObjectResolverRuntime, ClassLoader moduleClassLoader, EPServicesContext services) { var informationals = statementProvider.Informationals; // set instrumentation unless already provided if (informationals.InstrumentationProvider == null) { informationals.InstrumentationProvider = InstrumentationDefault.INSTANCE; } var statementResultService = new StatementResultServiceImpl(informationals, services); FilterSharedLookupableRegistery filterSharedLookupableRegistery = new ProxyFilterSharedLookupableRegistery() { ProcRegisterLookupable = ( eventTypeX, lookupable) => { services.FilterSharedLookupableRepository.RegisterLookupable(statementId, eventTypeX, lookupable); }, }; FilterSharedBoolExprRegistery filterSharedBoolExprRegistery = new ProxyFilterSharedBoolExprRegistery() { ProcRegisterBoolExpr = (node) => { services.FilterSharedBoolExprRepository.RegisterBoolExpr(statementId, node); }, }; IDictionary <int, FilterSpecActivatable> filterSpecActivatables = new Dictionary <int, FilterSpecActivatable>(); FilterSpecActivatableRegistry filterSpecActivatableRegistry = new ProxyFilterSpecActivatableRegistry() { ProcRegister = (filterSpecActivatable) => { filterSpecActivatables.Put(filterSpecActivatable.FilterCallbackId, filterSpecActivatable); }, }; var contextPartitioned = informationals.OptionalContextName != null; var statementResourceService = new StatementResourceService(contextPartitioned); // determine statement name var statementName = informationals.StatementNameCompileTime; if (statementNameResolverRuntime != null) { string statementNameAssigned = statementNameResolverRuntime.Invoke( new StatementNameRuntimeContext( deploymentId, statementName, statementId, (string)informationals.Properties.Get(StatementProperty.EPL), informationals.Annotations)); if (statementNameAssigned != null) { statementName = statementNameAssigned; } } statementName = statementName.Trim(); var epInitServices = new EPStatementInitServicesImpl( statementName, informationals.Properties, informationals.Annotations, deploymentId, eventTypeResolver, filterSpecActivatableRegistry, filterSharedBoolExprRegistery, filterSharedLookupableRegistery, moduleIncidentals, recovery, statementResourceService, statementResultService, services); if (!services.EpServicesHA.RuntimeExtensionServices.IsHAEnabled) { statementProvider.Initialize(epInitServices); } else { // for HA we set the context classloader as state may be loaded considering the module provider's classloader // - NEsper doesn't support HA like this, and we wouldn't want to deliver this information in // - this manner. An alternative delivery mechanism must be established to carry the information // - without relying on the "current" thread to carry that detail. // ClassLoader originalClassLoader = Thread.CurrentThread().ContextClassLoader; // try { // Thread.CurrentThread().ContextClassLoader = moduleClassLoader; // statementProvider.Initialize(epInitServices); // } // finally { // Thread.CurrentThread().ContextClassLoader = originalClassLoader; // } } var multiMatchHandler = services.MultiMatchHandlerFactory.Make(informationals.HasSubquery, informationals.IsNeedDedup); var stmtMetric = services.MetricReportingService.GetStatementHandle(statementId, deploymentId, statementName); var optionalEPL = (string)informationals.Properties.Get(StatementProperty.EPL); InsertIntoLatchFactory insertIntoFrontLatchFactory = null; InsertIntoLatchFactory insertIntoBackLatchFactory = null; if (informationals.InsertIntoLatchName != null) { var latchFactoryNameBack = "insert_stream_B_" + informationals.InsertIntoLatchName + "_" + statementName; var latchFactoryNameFront = "insert_stream_F_" + informationals.InsertIntoLatchName + "_" + statementName; var msecTimeout = services.RuntimeSettingsService.ConfigurationRuntime.Threading.InsertIntoDispatchTimeout; var locking = services.RuntimeSettingsService.ConfigurationRuntime.Threading.InsertIntoDispatchLocking; var latchFactoryFront = new InsertIntoLatchFactory( latchFactoryNameFront, informationals.IsStateless, msecTimeout, locking, services.TimeSourceService); var latchFactoryBack = new InsertIntoLatchFactory( latchFactoryNameBack, informationals.IsStateless, msecTimeout, locking, services.TimeSourceService); insertIntoFrontLatchFactory = latchFactoryFront; insertIntoBackLatchFactory = latchFactoryBack; } var statementHandle = new EPStatementHandle( statementName, deploymentId, statementId, optionalEPL, informationals.Priority, informationals.IsPreemptive, informationals.IsCanSelfJoin, multiMatchHandler, informationals.HasVariables, informationals.HasTableAccess, stmtMetric, insertIntoFrontLatchFactory, insertIntoBackLatchFactory); // determine context StatementAIResourceRegistry statementAgentInstanceRegistry = null; ContextRuntimeDescriptor contextRuntimeDescriptor = null; var optionalContextName = informationals.OptionalContextName; if (optionalContextName != null) { var contextDeploymentId = ContextDeployTimeResolver.ResolveContextDeploymentId( informationals.OptionalContextModuleName, informationals.OptionalContextVisibility, optionalContextName, deploymentId, services.ContextPathRegistry); var contextManager = services.ContextManagementService.GetContextManager(contextDeploymentId, optionalContextName); contextRuntimeDescriptor = contextManager.ContextRuntimeDescriptor; var registryRequirements = statementProvider.StatementAIFactoryProvider.Factory.RegistryRequirements; statementAgentInstanceRegistry = contextManager.AllocateAgentInstanceResourceRegistry(registryRequirements); } var statementCPCacheService = new StatementCPCacheService( contextPartitioned, statementResourceService, statementAgentInstanceRegistry); var eventType = statementProvider.StatementAIFactoryProvider.Factory.StatementEventType; var configurationThreading = services.RuntimeSettingsService.ConfigurationRuntime.Threading; var preserveDispatchOrder = configurationThreading.IsListenerDispatchPreserveOrder && !informationals.IsStateless; var isSpinLocks = configurationThreading.ListenerDispatchLocking == Locking.SPIN; var msecBlockingTimeout = configurationThreading.ListenerDispatchTimeout; UpdateDispatchViewBase dispatchChildView; if (preserveDispatchOrder) { if (isSpinLocks) { dispatchChildView = new UpdateDispatchViewBlockingSpin( eventType, statementResultService, services.DispatchService, msecBlockingTimeout, services.TimeSourceService); } else { dispatchChildView = new UpdateDispatchViewBlockingWait(eventType, statementResultService, services.DispatchService, msecBlockingTimeout); } } else { dispatchChildView = new UpdateDispatchViewNonBlocking(eventType, statementResultService, services.DispatchService); } var countSubexpressions = services.ConfigSnapshot.Runtime.Patterns.MaxSubexpressions != null; PatternSubexpressionPoolStmtSvc patternSubexpressionPoolStmtSvc = null; if (countSubexpressions) { var stmtCounter = new PatternSubexpressionPoolStmtHandler(); patternSubexpressionPoolStmtSvc = new PatternSubexpressionPoolStmtSvc(services.PatternSubexpressionPoolRuntimeSvc, stmtCounter); services.PatternSubexpressionPoolRuntimeSvc.AddPatternContext(statementId, statementName, stmtCounter); } var countMatchRecogStates = services.ConfigSnapshot.Runtime.MatchRecognize.MaxStates != null; RowRecogStatePoolStmtSvc rowRecogStatePoolStmtSvc = null; if (countMatchRecogStates && informationals.HasMatchRecognize) { var stmtCounter = new RowRecogStatePoolStmtHandler(); rowRecogStatePoolStmtSvc = new RowRecogStatePoolStmtSvc(services.RowRecogStatePoolEngineSvc, stmtCounter); services.RowRecogStatePoolEngineSvc.AddPatternContext(new DeploymentIdNamePair(deploymentId, statementName), stmtCounter); } // get user object for runtime object userObjectRuntime = null; if (userObjectResolverRuntime != null) { userObjectRuntime = userObjectResolverRuntime.GetUserObject( new StatementUserObjectRuntimeContext( deploymentId, statementName, statementId, (string)informationals.Properties.Get(StatementProperty.EPL), informationals.Annotations)); } var statementContext = new StatementContext( services.Container, contextRuntimeDescriptor, deploymentId, statementId, statementName, moduleName, informationals, userObjectRuntime, services.StatementContextRuntimeServices, statementHandle, filterSpecActivatables, patternSubexpressionPoolStmtSvc, rowRecogStatePoolStmtSvc, new ScheduleBucket(statementId), statementAgentInstanceRegistry, statementCPCacheService, statementProvider.StatementAIFactoryProvider, statementResultService, dispatchChildView, services.FilterService, services.SchedulingService, services.InternalEventRouteDest ); foreach (var readyCallback in epInitServices.ReadyCallbacks) { readyCallback.Ready(statementContext, moduleIncidentals, recovery); } return(new StatementLightweight(statementProvider, informationals, statementResultService, statementContext)); }
public void EvaluateTrue(MatchedEventMap matchEvent, EvalStateNode fromNode, bool isQuitted) { int index; var hasIndex = Nodes.TryGetValue(fromNode, out index); if (isQuitted) { Nodes.Remove(fromNode); if (hasIndex && index > 0) { if (EvalFollowedByNode.IsTrackWithMax) { CountActivePerChild[index - 1]--; } if (EvalFollowedByNode.IsTrackWithPool) { PatternSubexpressionPoolStmtSvc poolSvc = EvalFollowedByNode.Context.StatementContext.PatternSubexpressionPoolSvc; poolSvc.EngineSvc.DecreaseCount(EvalFollowedByNode, EvalFollowedByNode.Context.AgentInstanceContext); poolSvc.StmtHandler.DecreaseCount(); } } } // the node may already have quit as a result of an outer state quitting this state, // however the callback may still be received; It is fine to ignore this callback. if (!hasIndex) { return; } // If the match came from the very last filter, need to escalate int numChildNodes = EvalFollowedByNode.ChildNodes.Length; if (index == (numChildNodes - 1)) { bool isFollowedByQuitted = Nodes.IsEmpty(); ParentEvaluator.EvaluateTrue(matchEvent, this, isFollowedByQuitted); } // Else start a new sub-expression for the next-in-line filter else { if (EvalFollowedByNode.IsTrackWithMax) { int max = EvalFollowedByNode.FactoryNode.GetMax(index); if ((max != -1) && (max >= 0)) { if (CountActivePerChild[index] >= max) { EvalFollowedByNode.Context.AgentInstanceContext.StatementContext.ExceptionHandlingService.HandleCondition(new ConditionPatternSubexpressionMax(max), EvalFollowedByNode.Context.AgentInstanceContext.StatementContext.EpStatementHandle); return; } } } if (EvalFollowedByNode.IsTrackWithPool) { PatternSubexpressionPoolStmtSvc poolSvc = EvalFollowedByNode.Context.StatementContext.PatternSubexpressionPoolSvc; bool allow = poolSvc.EngineSvc.TryIncreaseCount(EvalFollowedByNode, EvalFollowedByNode.Context.AgentInstanceContext); if (!allow) { return; } poolSvc.StmtHandler.IncreaseCount(); } if (EvalFollowedByNode.IsTrackWithMax) { CountActivePerChild[index]++; } EvalNode child = EvalFollowedByNode.ChildNodes[index + 1]; EvalStateNode childState = child.NewState(this, null, 0L); Nodes.Put(childState, index + 1); childState.Start(matchEvent); } }
public void EvaluateTrue( MatchedEventMap matchEvent, EvalStateNode fromNode, bool isQuitted, EventBean optionalTriggeringEvent) { bool hasIndex = nodes.TryGetValue(fromNode, out var index); AgentInstanceContext agentInstanceContext = evalFollowedByNode.Context.AgentInstanceContext; agentInstanceContext.InstrumentationProvider.QPatternFollowedByEvaluateTrue( evalFollowedByNode.factoryNode, matchEvent, index); if (isQuitted) { nodes.Remove(fromNode); if (hasIndex && index > 0) { if (evalFollowedByNode.IsTrackWithMax) { countActivePerChild[index - 1]--; } if (evalFollowedByNode.IsTrackWithPool) { PatternSubexpressionPoolStmtSvc poolSvc = evalFollowedByNode.Context.StatementContext.PatternSubexpressionPoolSvc; poolSvc.RuntimeSvc.DecreaseCount( evalFollowedByNode, evalFollowedByNode.Context.AgentInstanceContext); poolSvc.StmtHandler.DecreaseCount(); } } } // the node may already have quit as a result of an outer state quitting this state, // however the callback may still be received; It is fine to ignore this callback. if (!hasIndex) { agentInstanceContext.InstrumentationProvider.APatternFollowedByEvaluateTrue(false); return; } // If the match came from the very last filter, need to escalate var numChildNodes = evalFollowedByNode.ChildNodes.Length; var isFollowedByQuitted = false; if (index == numChildNodes - 1) { if (nodes.IsEmpty()) { isFollowedByQuitted = true; agentInstanceContext.AuditProvider.PatternInstance( false, evalFollowedByNode.factoryNode, agentInstanceContext); } agentInstanceContext.AuditProvider.PatternTrue( evalFollowedByNode.FactoryNode, this, matchEvent, isFollowedByQuitted, agentInstanceContext); this.ParentEvaluator.EvaluateTrue(matchEvent, this, isFollowedByQuitted, optionalTriggeringEvent); } else { // Else start a new sub-expression for the next-in-line filter if (evalFollowedByNode.IsTrackWithMax) { var max = evalFollowedByNode.FactoryNode.GetMax(index); if (max != -1 && max >= 0) { if (countActivePerChild[index] >= max) { evalFollowedByNode.Context.AgentInstanceContext.StatementContext.ExceptionHandlingService .HandleCondition( new ConditionPatternSubexpressionMax(max), evalFollowedByNode.Context.AgentInstanceContext.StatementContext); return; } } } if (evalFollowedByNode.IsTrackWithPool) { PatternSubexpressionPoolStmtSvc poolSvc = evalFollowedByNode.Context.StatementContext.PatternSubexpressionPoolSvc; bool allow = poolSvc.RuntimeSvc.TryIncreaseCount( evalFollowedByNode, evalFollowedByNode.Context.AgentInstanceContext); if (!allow) { return; } poolSvc.StmtHandler.IncreaseCount(); } if (evalFollowedByNode.IsTrackWithMax) { countActivePerChild[index]++; } var child = evalFollowedByNode.ChildNodes[index + 1]; var childState = child.NewState(this); nodes.Put(childState, index + 1); childState.Start(matchEvent); } agentInstanceContext.InstrumentationProvider.APatternFollowedByEvaluateTrue(isFollowedByQuitted); }