public void Open(DataFlowOpOpenContext openContext) { FilterValueSet valueSet; try { IList <ExprNode> filters = new ExprNode[0]; if (filter != null) { filters = new ExprNode[] { filter }; } var spec = FilterSpecCompiler.MakeFilterSpec( _eventType, _eventType.Name, filters, null, null, null, new StreamTypeServiceImpl( _eventType, _eventType.Name, true, _agentInstanceContext.EngineURI), null, _agentInstanceContext.StatementContext, new List <int>()); valueSet = spec.GetValueSet(null, _agentInstanceContext, null); } catch (ExprValidationException ex) { throw new EPException("Failed to open filter: " + ex.Message, ex); } var handle = new EPStatementAgentInstanceHandle(_agentInstanceContext.StatementContext.EpStatementHandle, _agentInstanceContext.AgentInstanceLock, 0, new StatementAgentInstanceFilterVersion()); _callbackHandle = new EPStatementHandleCallback(handle, this); _filterServiceEntry = _agentInstanceContext.StatementContext.FilterService.Add(valueSet, _callbackHandle); }
public DataFlowOpForgeInitializeResult InitializeForge(DataFlowOpForgeInitializeContext context) { if (context.OutputPorts.Count != 1) { throw new ArgumentException( "EventBusSource operator requires one output stream but produces " + context.OutputPorts.Count + " streams"); } var portZero = context.OutputPorts[0]; if (portZero.OptionalDeclaredType == null || portZero.OptionalDeclaredType.EventType == null) { throw new ArgumentException( "EventBusSource operator requires an event type declated for the output stream"); } var eventType = portZero.OptionalDeclaredType.EventType; if (!portZero.OptionalDeclaredType.IsUnderlying) { submitEventBean = true; } DataFlowParameterValidation.Validate("filter", filter, eventType, typeof(bool), context); try { IList<ExprNode> filters = EmptyList<ExprNode>.Instance; if (filter != null) { filters = Collections.SingletonList(filter); } var streamTypeService = new StreamTypeServiceImpl(eventType, eventType.Name, true); var compiledDesc = FilterSpecCompiler.MakeFilterSpec( eventType, eventType.Name, filters, null, null, null, null, streamTypeService, null, context.StatementRawInfo, context.Services); FilterSpecCompiled = compiledDesc.FilterSpecCompiled; } catch (ExprValidationException ex) { throw new ExprValidationException("Failed to obtain filter parameters: " + ex.Message, ex); } return null; }
private static void RecursiveCompile( EvalFactoryNode evalNode, StatementContext context, ExprEvaluatorContext evaluatorContext, ICollection <string> eventTypeReferences, bool isInsertInto, MatchEventSpec tags, Deque <int> subexpressionIdStack, Stack <EvalFactoryNode> parentNodeStack, ICollection <string> allTagNamesOrdered) { var counter = 0; parentNodeStack.Push(evalNode); foreach (var child in evalNode.ChildNodes) { subexpressionIdStack.AddLast(counter++); RecursiveCompile( child, context, evaluatorContext, eventTypeReferences, isInsertInto, tags, subexpressionIdStack, parentNodeStack, allTagNamesOrdered); subexpressionIdStack.RemoveLast(); } parentNodeStack.Pop(); LinkedHashMap <string, Pair <EventType, string> > newTaggedEventTypes = null; LinkedHashMap <string, Pair <EventType, string> > newArrayEventTypes = null; if (evalNode is EvalFilterFactoryNode) { var filterNode = (EvalFilterFactoryNode)evalNode; var eventName = filterNode.RawFilterSpec.EventTypeName; if (context.TableService.GetTableMetadata(eventName) != null) { throw new ExprValidationException("Tables cannot be used in pattern filter atoms"); } var resolvedEventType = FilterStreamSpecRaw.ResolveType( context.EngineURI, eventName, context.EventAdapterService, context.PlugInTypeResolutionURIs); var finalEventType = resolvedEventType; var optionalTag = filterNode.EventAsName; var isPropertyEvaluation = false; var isParentMatchUntil = IsParentMatchUntil(evalNode, parentNodeStack); // obtain property event type, if final event type is properties if (filterNode.RawFilterSpec.OptionalPropertyEvalSpec != null) { var optionalPropertyEvaluator = PropertyEvaluatorFactory.MakeEvaluator( context.Container, filterNode.RawFilterSpec.OptionalPropertyEvalSpec, resolvedEventType, filterNode.EventAsName, context.EventAdapterService, context.EngineImportService, context.SchedulingService, context.VariableService, context.ScriptingService, context.TableService, context.EngineURI, context.StatementId, context.StatementName, context.Annotations, subexpressionIdStack, context.ConfigSnapshot, context.NamedWindowMgmtService, context.StatementExtensionServicesContext); finalEventType = optionalPropertyEvaluator.FragmentEventType; isPropertyEvaluation = true; } if (finalEventType is EventTypeSPI) { eventTypeReferences.Add(((EventTypeSPI)finalEventType).Metadata.PrimaryName); } // If a tag was supplied for the type, the tags must stay with this type, i.e. a=BeanA -> b=BeanA -> a=BeanB is a no if (optionalTag != null) { var pair = tags.TaggedEventTypes.Get(optionalTag); EventType existingType = null; if (pair != null) { existingType = pair.First; } if (existingType == null) { pair = tags.ArrayEventTypes.Get(optionalTag); if (pair != null) { throw new ExprValidationException( "Tag '" + optionalTag + "' for event '" + eventName + "' used in the repeat-until operator cannot also appear in other filter expressions"); } } if ((existingType != null) && (existingType != finalEventType)) { throw new ExprValidationException( "Tag '" + optionalTag + "' for event '" + eventName + "' has already been declared for events of type " + existingType.UnderlyingType.FullName); } pair = new Pair <EventType, string>(finalEventType, eventName); // add tagged type if (isPropertyEvaluation || isParentMatchUntil) { newArrayEventTypes = new LinkedHashMap <string, Pair <EventType, string> >(); newArrayEventTypes.Put(optionalTag, pair); } else { newTaggedEventTypes = new LinkedHashMap <string, Pair <EventType, string> >(); newTaggedEventTypes.Put(optionalTag, pair); } } // For this filter, filter types are all known tags at this time, // and additionally stream 0 (self) is our event type. // Stream type service allows resolution by property name event if that name appears in other tags. // by defaulting to stream zero. // Stream zero is always the current event type, all others follow the order of the map (stream 1 to N). var selfStreamName = optionalTag; if (selfStreamName == null) { selfStreamName = "s_" + UuidGenerator.Generate(); } var filterTypes = new LinkedHashMap <string, Pair <EventType, string> >(); var typePair = new Pair <EventType, string>(finalEventType, eventName); filterTypes.Put(selfStreamName, typePair); filterTypes.PutAll(tags.TaggedEventTypes); // for the filter, specify all tags used var filterTaggedEventTypes = new LinkedHashMap <string, Pair <EventType, string> >(tags.TaggedEventTypes); filterTaggedEventTypes.Remove(optionalTag); // handle array tags (match-until clause) LinkedHashMap <string, Pair <EventType, string> > arrayCompositeEventTypes = null; if (tags.ArrayEventTypes != null && !tags.ArrayEventTypes.IsEmpty()) { arrayCompositeEventTypes = new LinkedHashMap <string, Pair <EventType, string> >(); var patternSubexEventType = GetPatternSubexEventType( context.StatementId, "pattern", subexpressionIdStack); foreach (var entry in tags.ArrayEventTypes) { var specificArrayType = new LinkedHashMap <string, Pair <EventType, string> >(); specificArrayType.Put(entry.Key, entry.Value); var arrayTagCompositeEventType = context.EventAdapterService.CreateSemiAnonymousMapType( patternSubexEventType, Collections.GetEmptyMap <string, Pair <EventType, string> >(), specificArrayType, isInsertInto); context.StatementSemiAnonymousTypeRegistry.Register(arrayTagCompositeEventType); var tag = entry.Key; if (!filterTypes.ContainsKey(tag)) { var pair = new Pair <EventType, string>(arrayTagCompositeEventType, tag); filterTypes.Put(tag, pair); arrayCompositeEventTypes.Put(tag, pair); } } } StreamTypeService streamTypeService = new StreamTypeServiceImpl( filterTypes, context.EngineURI, true, false); var exprNodes = filterNode.RawFilterSpec.FilterExpressions; var spec = FilterSpecCompiler.MakeFilterSpec( resolvedEventType, eventName, exprNodes, filterNode.RawFilterSpec.OptionalPropertyEvalSpec, filterTaggedEventTypes, arrayCompositeEventTypes, streamTypeService, null, context, subexpressionIdStack); filterNode.FilterSpec = spec; } else if (evalNode is EvalObserverFactoryNode) { var observerNode = (EvalObserverFactoryNode)evalNode; try { var observerFactory = context.PatternResolutionService.Create(observerNode.PatternObserverSpec); var streamTypeService = GetStreamTypeService( context.EngineURI, context.StatementId, context.EventAdapterService, tags.TaggedEventTypes, tags.ArrayEventTypes, subexpressionIdStack, "observer", context); var validationContext = new ExprValidationContext( context.Container, streamTypeService, context.EngineImportService, context.StatementExtensionServicesContext, null, context.SchedulingService, context.VariableService, context.TableService, evaluatorContext, context.EventAdapterService, context.StatementName, context.StatementId, context.Annotations, context.ContextDescriptor, context.ScriptingService, false, false, false, false, null, false); var validated = ValidateExpressions( ExprNodeOrigin.PATTERNOBSERVER, observerNode.PatternObserverSpec.ObjectParameters, validationContext); MatchedEventConvertor convertor = new MatchedEventConvertorImpl( tags.TaggedEventTypes, tags.ArrayEventTypes, allTagNamesOrdered, context.EventAdapterService); observerNode.ObserverFactory = observerFactory; observerFactory.SetObserverParameters(validated, convertor, validationContext); } catch (ObserverParameterException e) { throw new ExprValidationException( "Invalid parameter for pattern observer '" + observerNode.ToPrecedenceFreeEPL() + "': " + e.Message, e); } catch (PatternObjectException e) { throw new ExprValidationException( "Failed to resolve pattern observer '" + observerNode.ToPrecedenceFreeEPL() + "': " + e.Message, e); } } else if (evalNode is EvalGuardFactoryNode) { var guardNode = (EvalGuardFactoryNode)evalNode; try { var guardFactory = context.PatternResolutionService.Create(guardNode.PatternGuardSpec); var streamTypeService = GetStreamTypeService( context.EngineURI, context.StatementId, context.EventAdapterService, tags.TaggedEventTypes, tags.ArrayEventTypes, subexpressionIdStack, "guard", context); var validationContext = new ExprValidationContext( context.Container, streamTypeService, context.EngineImportService, context.StatementExtensionServicesContext, null, context.SchedulingService, context.VariableService, context.TableService, evaluatorContext, context.EventAdapterService, context.StatementName, context.StatementId, context.Annotations, context.ContextDescriptor, context.ScriptingService, false, false, false, false, null, false); var validated = ValidateExpressions( ExprNodeOrigin.PATTERNGUARD, guardNode.PatternGuardSpec.ObjectParameters, validationContext); MatchedEventConvertor convertor = new MatchedEventConvertorImpl( tags.TaggedEventTypes, tags.ArrayEventTypes, allTagNamesOrdered, context.EventAdapterService); guardNode.GuardFactory = guardFactory; guardFactory.SetGuardParameters(validated, convertor); } catch (GuardParameterException e) { throw new ExprValidationException( "Invalid parameter for pattern guard '" + guardNode.ToPrecedenceFreeEPL() + "': " + e.Message, e); } catch (PatternObjectException e) { throw new ExprValidationException( "Failed to resolve pattern guard '" + guardNode.ToPrecedenceFreeEPL() + "': " + e.Message, e); } } else if (evalNode is EvalEveryDistinctFactoryNode) { var distinctNode = (EvalEveryDistinctFactoryNode)evalNode; var matchEventFromChildNodes = AnalyzeMatchEvent(distinctNode); var streamTypeService = GetStreamTypeService( context.EngineURI, context.StatementId, context.EventAdapterService, matchEventFromChildNodes.TaggedEventTypes, matchEventFromChildNodes.ArrayEventTypes, subexpressionIdStack, "every-distinct", context); var validationContext = new ExprValidationContext( context.Container, streamTypeService, context.EngineImportService, context.StatementExtensionServicesContext, null, context.SchedulingService, context.VariableService, context.TableService, evaluatorContext, context.EventAdapterService, context.StatementName, context.StatementId, context.Annotations, context.ContextDescriptor, context.ScriptingService, false, false, false, false, null, false); IList <ExprNode> validated; try { validated = ValidateExpressions( ExprNodeOrigin.PATTERNEVERYDISTINCT, distinctNode.Expressions, validationContext); } catch (ExprValidationPropertyException ex) { throw new ExprValidationPropertyException( ex.Message + ", every-distinct requires that all properties resolve from sub-expressions to the every-distinct", ex.InnerException); } MatchedEventConvertor convertor = new MatchedEventConvertorImpl( matchEventFromChildNodes.TaggedEventTypes, matchEventFromChildNodes.ArrayEventTypes, allTagNamesOrdered, context.EventAdapterService); distinctNode.Convertor = convertor; // Determine whether some expressions are constants or time period IList <ExprNode> distinctExpressions = new List <ExprNode>(); ExprTimePeriodEvalDeltaConst timeDeltaComputation = null; ExprNode expiryTimeExp = null; var count = -1; var last = validated.Count - 1; foreach (var expr in validated) { count++; if (count == last && expr is ExprTimePeriod) { expiryTimeExp = expr; var timePeriodExpr = (ExprTimePeriod)expiryTimeExp; timeDeltaComputation = timePeriodExpr.ConstEvaluator(new ExprEvaluatorContextStatement(context, false)); } else if (expr.IsConstantResult) { if (count == last) { var evaluateParams = new EvaluateParams(null, true, evaluatorContext); var value = expr.ExprEvaluator.Evaluate(evaluateParams); if (!(value.IsNumber())) { throw new ExprValidationException( "Invalid parameter for every-distinct, expected number of seconds constant (constant not considered for distinct)"); } var secondsExpire = expr.ExprEvaluator.Evaluate(evaluateParams); long?timeExpire; if (secondsExpire == null) { timeExpire = null; } else { timeExpire = context.TimeAbacus.DeltaForSecondsNumber(secondsExpire); } if (timeExpire != null && timeExpire > 0) { timeDeltaComputation = new ExprTimePeriodEvalDeltaConstGivenDelta(timeExpire.Value); expiryTimeExp = expr; } else { Log.Warn("Invalid seconds-expire " + timeExpire + " for " + ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(expr)); } } else { Log.Warn( "Every-distinct node utilizes an expression returning a constant value, please check expression '{0}', not adding expression to distinct-value expression list", expr.ToExpressionStringMinPrecedenceSafe()); } } else { distinctExpressions.Add(expr); } } if (distinctExpressions.IsEmpty()) { throw new ExprValidationException( "Every-distinct node requires one or more distinct-value expressions that each return non-constant result values"); } distinctNode.SetDistinctExpressions(distinctExpressions, timeDeltaComputation, expiryTimeExp); } else if (evalNode is EvalMatchUntilFactoryNode) { var matchUntilNode = (EvalMatchUntilFactoryNode)evalNode; // compile bounds expressions, if any var untilMatchEventSpec = new MatchEventSpec(tags.TaggedEventTypes, tags.ArrayEventTypes); var streamTypeService = GetStreamTypeService( context.EngineURI, context.StatementId, context.EventAdapterService, untilMatchEventSpec.TaggedEventTypes, untilMatchEventSpec.ArrayEventTypes, subexpressionIdStack, "until", context); var validationContext = new ExprValidationContext( context.Container, streamTypeService, context.EngineImportService, context.StatementExtensionServicesContext, null, context.SchedulingService, context.VariableService, context.TableService, evaluatorContext, context.EventAdapterService, context.StatementName, context.StatementId, context.Annotations, context.ContextDescriptor, context.ScriptingService, false, false, false, false, null, false); var lower = ValidateBounds(matchUntilNode.LowerBounds, validationContext); matchUntilNode.LowerBounds = lower; var upper = ValidateBounds(matchUntilNode.UpperBounds, validationContext); matchUntilNode.UpperBounds = upper; var single = ValidateBounds(matchUntilNode.SingleBound, validationContext); matchUntilNode.SingleBound = single; var convertor = new MatchedEventConvertorImpl( untilMatchEventSpec.TaggedEventTypes, untilMatchEventSpec.ArrayEventTypes, allTagNamesOrdered, context.EventAdapterService); matchUntilNode.Convertor = convertor; // compile new tag lists ISet <string> arrayTags = null; var matchUntilAnalysisResult = EvalNodeUtil.RecursiveAnalyzeChildNodes(matchUntilNode.ChildNodes[0]); foreach (var filterNode in matchUntilAnalysisResult.FilterNodes) { var optionalTag = filterNode.EventAsName; if (optionalTag != null) { if (arrayTags == null) { arrayTags = new HashSet <string>(); } arrayTags.Add(optionalTag); } } if (arrayTags != null) { foreach (var arrayTag in arrayTags) { if (!tags.ArrayEventTypes.ContainsKey(arrayTag)) { tags.ArrayEventTypes.Put(arrayTag, tags.TaggedEventTypes.Get(arrayTag)); tags.TaggedEventTypes.Remove(arrayTag); } } } matchUntilNode.TagsArrayed = GetIndexesForTags(allTagNamesOrdered, arrayTags); } else if (evalNode is EvalFollowedByFactoryNode) { var followedByNode = (EvalFollowedByFactoryNode)evalNode; StreamTypeService streamTypeService = new StreamTypeServiceImpl(context.EngineURI, false); var validationContext = new ExprValidationContext( context.Container, streamTypeService, context.EngineImportService, context.StatementExtensionServicesContext, null, context.SchedulingService, context.VariableService, context.TableService, evaluatorContext, context.EventAdapterService, context.StatementName, context.StatementId, context.Annotations, context.ContextDescriptor, context.ScriptingService, false, false, false, false, null, false); if (followedByNode.OptionalMaxExpressions != null) { IList <ExprNode> validated = new List <ExprNode>(); foreach (var maxExpr in followedByNode.OptionalMaxExpressions) { if (maxExpr == null) { validated.Add(null); } else { var visitor = new ExprNodeSummaryVisitor(); maxExpr.Accept(visitor); if (!visitor.IsPlain) { var errorMessage = "Invalid maximum expression in followed-by, " + visitor.GetMessage() + " are not allowed within the expression"; Log.Error(errorMessage); throw new ExprValidationException(errorMessage); } var validatedExpr = ExprNodeUtility.GetValidatedSubtree( ExprNodeOrigin.FOLLOWEDBYMAX, maxExpr, validationContext); validated.Add(validatedExpr); if ((validatedExpr.ExprEvaluator.ReturnType == null) || (!validatedExpr.ExprEvaluator.ReturnType.IsNumeric())) { var message = "Invalid maximum expression in followed-by, the expression must return an integer value"; throw new ExprValidationException(message); } } } followedByNode.OptionalMaxExpressions = validated; } } if (newTaggedEventTypes != null) { tags.TaggedEventTypes.PutAll(newTaggedEventTypes); } if (newArrayEventTypes != null) { tags.ArrayEventTypes.PutAll(newArrayEventTypes); } }
/// <summary> /// Ctor. /// </summary> /// <param name="statementSpec">is a container for the definition of all statement constructs thatmay have been used in the statement, i.e. if defines the select clauses, insert into, outer joins etc. /// </param> /// <param name="services">is the service instances for dependency injection</param> /// <param name="statementContext">is statement-level information and statement services</param> /// <throws>ExprValidationException if the preparation failed</throws> public EPPreparedExecuteMethodQuery(StatementSpecCompiled statementSpec, EPServicesContext services, StatementContext statementContext) { var queryPlanLogging = services.ConfigSnapshot.EngineDefaults.LoggingConfig.IsEnableQueryPlan; if (queryPlanLogging) { QueryPlanLog.Info("Query plans for Fire-and-forget query '" + statementContext.Expression + "'"); } _hasTableAccess = (statementSpec.TableNodes != null && statementSpec.TableNodes.Length > 0); foreach (var streamSpec in statementSpec.StreamSpecs) { _hasTableAccess |= streamSpec is TableQueryStreamSpec; } _statementSpec = statementSpec; _services = services; EPPreparedExecuteMethodHelper.ValidateFAFQuery(statementSpec); var numStreams = statementSpec.StreamSpecs.Length; var typesPerStream = new EventType[numStreams]; var namesPerStream = new string[numStreams]; _processors = new FireAndForgetProcessor[numStreams]; _agentInstanceContext = new AgentInstanceContext(statementContext, null, -1, null, null, statementContext.DefaultAgentInstanceScriptContext); // resolve types and processors for (var i = 0; i < numStreams; i++) { var streamSpec = statementSpec.StreamSpecs[i]; _processors[i] = FireAndForgetProcessorFactory.ValidateResolveProcessor(streamSpec, services); string streamName = _processors[i].NamedWindowOrTableName; if (streamSpec.OptionalStreamName != null) { streamName = streamSpec.OptionalStreamName; } namesPerStream[i] = streamName; typesPerStream[i] = _processors[i].EventTypeResultSetProcessor; } // compile filter to optimize access to named window _filters = new FilterSpecCompiled[numStreams]; if (statementSpec.FilterRootNode != null) { var tagged = new LinkedHashMap <string, Pair <EventType, string> >(); for (var i = 0; i < numStreams; i++) { try { var types = new StreamTypeServiceImpl(typesPerStream, namesPerStream, new bool[numStreams], services.EngineURI, false); _filters[i] = FilterSpecCompiler.MakeFilterSpec(typesPerStream[i], namesPerStream[i], Collections.SingletonList(statementSpec.FilterRootNode), null, tagged, tagged, types, null, statementContext, Collections.SingletonList(i)); } catch (Exception ex) { Log.Warn("Unexpected exception analyzing filter paths: " + ex.Message, ex); } } } // obtain result set processor var isIStreamOnly = new bool[namesPerStream.Length]; CompatExtensions.Fill(isIStreamOnly, true); StreamTypeService typeService = new StreamTypeServiceImpl(typesPerStream, namesPerStream, isIStreamOnly, services.EngineURI, true); EPStatementStartMethodHelperValidate.ValidateNodes(statementSpec, statementContext, typeService, null); var resultSetProcessorPrototype = ResultSetProcessorFactoryFactory.GetProcessorPrototype(statementSpec, statementContext, typeService, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, _services.ConfigSnapshot); _resultSetProcessor = EPStatementStartMethodHelperAssignExpr.GetAssignResultSetProcessor(_agentInstanceContext, resultSetProcessorPrototype); if (statementSpec.SelectClauseSpec.IsDistinct) { if (_resultSetProcessor.ResultEventType is EventTypeSPI) { _eventBeanReader = ((EventTypeSPI)_resultSetProcessor.ResultEventType).GetReader(); } if (_eventBeanReader == null) { _eventBeanReader = new EventBeanReaderDefaultImpl(_resultSetProcessor.ResultEventType); } } // plan joins or simple queries if (numStreams > 1) { var streamJoinAnalysisResult = new StreamJoinAnalysisResult(numStreams); CompatExtensions.Fill(streamJoinAnalysisResult.NamedWindow, true); for (var i = 0; i < numStreams; i++) { var processorInstance = _processors[i].GetProcessorInstance(_agentInstanceContext); if (_processors[i].IsVirtualDataWindow) { streamJoinAnalysisResult.ViewExternal[i] = agentInstanceContext => processorInstance.VirtualDataWindow; } var uniqueIndexes = _processors[i].GetUniqueIndexes(processorInstance); streamJoinAnalysisResult.UniqueKeys[i] = uniqueIndexes; } var hasAggregations = !resultSetProcessorPrototype.AggregationServiceFactoryDesc.Expressions.IsEmpty(); _joinSetComposerPrototype = JoinSetComposerPrototypeFactory.MakeComposerPrototype( null, null, statementSpec.OuterJoinDescList, statementSpec.FilterRootNode, typesPerStream, namesPerStream, streamJoinAnalysisResult, queryPlanLogging, statementContext, new HistoricalViewableDesc(numStreams), _agentInstanceContext, false, hasAggregations, services.TableService, true); } // check context partition use if (statementSpec.OptionalContextName != null) { if (numStreams > 1) { throw new ExprValidationException("Joins in runtime queries for context partitions are not supported"); } } }
protected override StatementAgentInstanceFactoryResult NewContextInternal(AgentInstanceContext agentInstanceContext, bool isRecoveringResilient) { IList <StopCallback> stopCallbacks = new List <StopCallback>(2); Viewable finalView; var viewableActivationResult = new ViewableActivationResult[_eventStreamParentViewableActivators.Length]; IDictionary <ExprSubselectNode, SubSelectStrategyHolder> subselectStrategies; AggregationService aggregationService; Viewable[] streamViews; Viewable[] eventStreamParentViewable; Viewable[] topViews; IDictionary <ExprPriorNode, ExprPriorEvalStrategy> priorNodeStrategies; IDictionary <ExprPreviousNode, ExprPreviousEvalStrategy> previousNodeStrategies; IDictionary <ExprTableAccessNode, ExprTableAccessEvalStrategy> tableAccessStrategies; RegexExprPreviousEvalStrategy regexExprPreviousEvalStrategy = null; IList <StatementAgentInstancePreload> preloadList = new List <StatementAgentInstancePreload>(); EvalRootState[] patternRoots; StatementAgentInstancePostLoad postLoadJoin = null; var suppressSameEventMatches = false; var discardPartialsOnMatch = false; EvalRootMatchRemover evalRootMatchRemover = null; try { // create root viewables eventStreamParentViewable = new Viewable[_numStreams]; patternRoots = new EvalRootState[_numStreams]; for (var stream = 0; stream < _eventStreamParentViewableActivators.Length; stream++) { var activationResult = _eventStreamParentViewableActivators[stream].Activate(agentInstanceContext, false, isRecoveringResilient); viewableActivationResult[stream] = activationResult; stopCallbacks.Add(activationResult.StopCallback); suppressSameEventMatches = activationResult.IsSuppressSameEventMatches; discardPartialsOnMatch = activationResult.IsDiscardPartialsOnMatch; // add stop callback for any stream-level viewable when applicable if (activationResult.Viewable is StopCallback) { stopCallbacks.Add((StopCallback)activationResult.Viewable); } eventStreamParentViewable[stream] = activationResult.Viewable; patternRoots[stream] = activationResult.OptionalPatternRoot; if (stream == 0) { evalRootMatchRemover = activationResult.OptEvalRootMatchRemover; } if (activationResult.OptionalLock != null) { agentInstanceContext.EpStatementAgentInstanceHandle.StatementAgentInstanceLock = activationResult.OptionalLock; _statementContext.DefaultAgentInstanceLock = activationResult.OptionalLock; } } // compile view factories adding "prior" as necessary var viewFactoryChains = new IList <ViewFactory> [_numStreams]; for (var i = 0; i < _numStreams; i++) { var viewFactoryChain = _unmaterializedViewChain[i].FactoryChain; // add "prior" view factory var hasPrior = _viewResourceDelegate.PerStream[i].PriorRequests != null && !_viewResourceDelegate.PerStream[i].PriorRequests.IsEmpty(); if (hasPrior) { var priorEventViewFactory = EPStatementStartMethodHelperPrior.GetPriorEventViewFactory( agentInstanceContext.StatementContext, i, viewFactoryChain.IsEmpty(), false, -1); viewFactoryChain = new List <ViewFactory>(viewFactoryChain); viewFactoryChain.Add(priorEventViewFactory); } viewFactoryChains[i] = viewFactoryChain; } // create view factory chain context: holds stream-specific services var viewFactoryChainContexts = new AgentInstanceViewFactoryChainContext[_numStreams]; for (var i = 0; i < _numStreams; i++) { viewFactoryChainContexts[i] = AgentInstanceViewFactoryChainContext.Create(viewFactoryChains[i], agentInstanceContext, _viewResourceDelegate.PerStream[i]); } // handle "prior" nodes and their strategies priorNodeStrategies = EPStatementStartMethodHelperPrior.CompilePriorNodeStrategies(_viewResourceDelegate, viewFactoryChainContexts); // handle "previous" nodes and their strategies previousNodeStrategies = EPStatementStartMethodHelperPrevious.CompilePreviousNodeStrategies(_viewResourceDelegate, viewFactoryChainContexts); // materialize views streamViews = new Viewable[_numStreams]; topViews = new Viewable[_numStreams]; for (var i = 0; i < _numStreams; i++) { var hasPreviousNode = _viewResourceDelegate.PerStream[i].PreviousRequests != null && !_viewResourceDelegate.PerStream[i].PreviousRequests.IsEmpty(); var createResult = _services.ViewService.CreateViews(eventStreamParentViewable[i], viewFactoryChains[i], viewFactoryChainContexts[i], hasPreviousNode); topViews[i] = createResult.TopViewable; streamViews[i] = createResult.FinalViewable; var isReuseableView = _eventStreamParentViewableActivators[i] is ViewableActivatorStreamReuseView; if (isReuseableView) { var viewsCreated = createResult.NewViews; var stopCallback = new ProxyStopCallback(() => { ViewServiceHelper.RemoveFirstUnsharedView(viewsCreated); }); stopCallbacks.Add(stopCallback); } // add views to stop callback if applicable AddViewStopCallback(stopCallbacks, createResult.NewViews); } // determine match-recognize "previous"-node strategy (none if not present, or one handling and number of nodes) var matchRecognize = EventRowRegexHelper.RecursiveFindRegexService(topViews[0]); if (matchRecognize != null) { regexExprPreviousEvalStrategy = matchRecognize.PreviousEvaluationStrategy; stopCallbacks.Add(new ProxyStopCallback(matchRecognize.Stop)); } // start subselects subselectStrategies = EPStatementStartMethodHelperSubselect.StartSubselects(_services, _subSelectStrategyCollection, agentInstanceContext, stopCallbacks, isRecoveringResilient); // plan table access tableAccessStrategies = EPStatementStartMethodHelperTableAccess.AttachTableAccess(_services, agentInstanceContext, _statementSpec.TableNodes); // obtain result set processor and aggregation services var processorPair = EPStatementStartMethodHelperUtil.StartResultSetAndAggregation(_resultSetProcessorFactoryDesc, agentInstanceContext, false, null); var resultSetProcessor = processorPair.First; aggregationService = processorPair.Second; stopCallbacks.Add(aggregationService); stopCallbacks.Add(resultSetProcessor); // for just 1 event stream without joins, handle the one-table process separately. JoinPreloadMethod joinPreloadMethod; JoinSetComposerDesc joinSetComposer = null; if (streamViews.Length == 1) { finalView = HandleSimpleSelect(streamViews[0], resultSetProcessor, agentInstanceContext, evalRootMatchRemover, suppressSameEventMatches, discardPartialsOnMatch); joinPreloadMethod = null; } else { var joinPlanResult = HandleJoin(_typeService.StreamNames, streamViews, resultSetProcessor, agentInstanceContext, stopCallbacks, _joinAnalysisResult, isRecoveringResilient); finalView = joinPlanResult.Viewable; joinPreloadMethod = joinPlanResult.PreloadMethod; joinSetComposer = joinPlanResult.JoinSetComposerDesc; } // for stoppable final views, add callback if (finalView is StopCallback) { stopCallbacks.Add((StopCallback)finalView); } // Replay any named window data, for later consumers of named data windows if (_services.EventTableIndexService.AllowInitIndex(isRecoveringResilient)) { var hasNamedWindow = false; var namedWindowPostloadFilters = new FilterSpecCompiled[_statementSpec.StreamSpecs.Length]; var namedWindowTailViews = new NamedWindowTailViewInstance[_statementSpec.StreamSpecs.Length]; var namedWindowFilters = new IList <ExprNode> [_statementSpec.StreamSpecs.Length]; for (var i = 0; i < _statementSpec.StreamSpecs.Length; i++) { var streamNum = i; var streamSpec = _statementSpec.StreamSpecs[i]; if (streamSpec is NamedWindowConsumerStreamSpec) { hasNamedWindow = true; var namedSpec = (NamedWindowConsumerStreamSpec)streamSpec; NamedWindowProcessor processor = _services.NamedWindowMgmtService.GetProcessor(namedSpec.WindowName); var processorInstance = processor.GetProcessorInstance(agentInstanceContext); if (processorInstance != null) { var consumerView = processorInstance.TailViewInstance; namedWindowTailViews[i] = consumerView; var view = (NamedWindowConsumerView)viewableActivationResult[i].Viewable; // determine preload/postload filter for index access if (!namedSpec.FilterExpressions.IsEmpty()) { namedWindowFilters[streamNum] = namedSpec.FilterExpressions; try { var streamName = streamSpec.OptionalStreamName != null ? streamSpec.OptionalStreamName : consumerView.EventType.Name; var types = new StreamTypeServiceImpl(consumerView.EventType, streamName, false, _services.EngineURI); var tagged = new LinkedHashMap <string, Pair <EventType, string> >(); namedWindowPostloadFilters[i] = FilterSpecCompiler.MakeFilterSpec(types.EventTypes[0], types.StreamNames[0], namedSpec.FilterExpressions, null, tagged, tagged, types, null, _statementContext, Collections.SingletonSet(0)); } catch (Exception ex) { Log.Warn("Unexpected exception analyzing filter paths: " + ex.Message, ex); } } // preload view for stream unless the expiry policy is batch window var preload = !consumerView.TailView.IsParentBatchWindow && consumerView.HasFirst(); if (preload) { if (isRecoveringResilient && _numStreams < 2) { preload = false; } } if (preload) { var yesRecoveringResilient = isRecoveringResilient; var preloadFilterSpec = namedWindowPostloadFilters[i]; preloadList.Add(new ProxyStatementAgentInstancePreload() { ProcExecutePreload = () => { var snapshot = consumerView.Snapshot(preloadFilterSpec, _statementContext.Annotations); var eventsInWindow = new List <EventBean>(snapshot.Count); ExprNodeUtility.ApplyFilterExpressionsIterable(snapshot, namedSpec.FilterExpressions, agentInstanceContext, eventsInWindow); EventBean[] newEvents = eventsInWindow.ToArray(); view.Update(newEvents, null); if (!yesRecoveringResilient && joinPreloadMethod != null && !joinPreloadMethod.IsPreloading && agentInstanceContext.EpStatementAgentInstanceHandle.OptionalDispatchable != null) { agentInstanceContext.EpStatementAgentInstanceHandle.OptionalDispatchable.Execute(); } }, }); } } else { Log.Info("Named window access is out-of-context, the named window '" + namedSpec.WindowName + "' has been declared for a different context then the current statement, the aggregation and join state will not be initialized for statement expression [" + _statementContext.Expression + "]"); } preloadList.Add(new ProxyStatementAgentInstancePreload() { ProcExecutePreload = () => { // in a join, preload indexes, if any if (joinPreloadMethod != null) { joinPreloadMethod.PreloadFromBuffer(streamNum); } else { if (agentInstanceContext.EpStatementAgentInstanceHandle.OptionalDispatchable != null) { agentInstanceContext.EpStatementAgentInstanceHandle.OptionalDispatchable.Execute(); } } }, }); } } // last, for aggregation we need to send the current join results to the result set processor if ((hasNamedWindow) && (joinPreloadMethod != null) && (!isRecoveringResilient) && _resultSetProcessorFactoryDesc.ResultSetProcessorFactory.HasAggregation) { preloadList.Add(new ProxyStatementAgentInstancePreload() { ProcExecutePreload = () => { joinPreloadMethod.PreloadAggregation(resultSetProcessor); }, }); } if (isRecoveringResilient) { postLoadJoin = new StatementAgentInstancePostLoadSelect(streamViews, joinSetComposer, namedWindowTailViews, namedWindowPostloadFilters, namedWindowFilters, _statementContext.Annotations, agentInstanceContext); } else if (joinSetComposer != null) { postLoadJoin = new StatementAgentInstancePostLoadIndexVisiting(joinSetComposer.JoinSetComposer); } } } catch (Exception) { var stopCallback = StatementAgentInstanceUtil.GetStopCallback(stopCallbacks, agentInstanceContext); StatementAgentInstanceUtil.StopSafe(stopCallback, _statementContext); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().AContextPartitionAllocate(); } throw; } var selectResult = new StatementAgentInstanceFactorySelectResult(finalView, null, agentInstanceContext, aggregationService, subselectStrategies, priorNodeStrategies, previousNodeStrategies, regexExprPreviousEvalStrategy, tableAccessStrategies, preloadList, patternRoots, postLoadJoin, topViews, eventStreamParentViewable, viewableActivationResult); if (_statementContext.StatementExtensionServicesContext != null) { _statementContext.StatementExtensionServicesContext.ContributeStopCallback(selectResult, stopCallbacks); } var stopCallbackX = StatementAgentInstanceUtil.GetStopCallback(stopCallbacks, agentInstanceContext); selectResult.StopCallback = stopCallbackX; return(selectResult); }
private void Preload( EPServicesContext services, EventTable[] eventIndex, Viewable subselectView, AgentInstanceContext agentInstanceContext) { if (_subSelectHolder.StreamSpecCompiled is NamedWindowConsumerStreamSpec) { var namedSpec = (NamedWindowConsumerStreamSpec)_subSelectHolder.StreamSpecCompiled; NamedWindowProcessor processor = services.NamedWindowMgmtService.GetProcessor(namedSpec.WindowName); if (processor == null) { throw new EPRuntimeException("Failed to find named window by name '" + namedSpec.WindowName + "'"); } var processorInstance = processor.GetProcessorInstance(agentInstanceContext); if (processorInstance == null) { throw new EPException( "Named window '" + namedSpec.WindowName + "' is associated to context '" + processor.ContextName + "' that is not available for querying"); } var consumerView = processorInstance.TailViewInstance; // preload view for stream ICollection <EventBean> eventsInWindow; if (namedSpec.FilterExpressions != null && !namedSpec.FilterExpressions.IsEmpty()) { try { var types = new StreamTypeServiceImpl( consumerView.EventType, consumerView.EventType.Name, false, services.EngineURI); var tagged = new LinkedHashMap <string, Pair <EventType, string> >(); var filterSpecCompiled = FilterSpecCompiler.MakeFilterSpec( types.EventTypes[0], types.StreamNames[0], namedSpec.FilterExpressions, null, tagged, tagged, types, null, agentInstanceContext.StatementContext, Collections.SingletonSet(0)); var snapshot = consumerView.SnapshotNoLock( filterSpecCompiled, agentInstanceContext.StatementContext.Annotations); eventsInWindow = new List <EventBean>(snapshot.Count); ExprNodeUtility.ApplyFilterExpressions( snapshot, namedSpec.FilterExpressions, agentInstanceContext, eventsInWindow); } catch (Exception ex) { Log.Warn("Unexpected exception analyzing filter paths: " + ex.Message, ex); eventsInWindow = new List <EventBean>(); ExprNodeUtility.ApplyFilterExpressionsIterable( consumerView, namedSpec.FilterExpressions, agentInstanceContext, eventsInWindow); } } else { eventsInWindow = new List <EventBean>(); for (IEnumerator <EventBean> it = consumerView.GetEnumerator(); it.MoveNext();) { eventsInWindow.Add(it.Current); } } EventBean[] newEvents = eventsInWindow.ToArray(); if (subselectView != null) { ((View)subselectView).Update(newEvents, null); } if (eventIndex != null) { foreach (var table in eventIndex) { table.Add(newEvents); // fill index } } } else // preload from the data window that sit on top { // Start up event table from the iterator IEnumerator <EventBean> it = subselectView.GetEnumerator(); if (it.MoveNext()) { var preloadEvents = new List <EventBean>(); do { preloadEvents.Add(it.Current); } while (it.MoveNext()); if (eventIndex != null) { foreach (var table in eventIndex) { table.Add(preloadEvents.ToArray()); } } } } }
/// <summary> /// Ctor. /// </summary> /// <param name="statementSpec">is a container for the definition of all statement constructs thatmay have been used in the statement, i.e. if defines the select clauses, insert into, outer joins etc. /// </param> /// <param name="services">is the service instances for dependency injection</param> /// <param name="statementContext">is statement-level information and statement services</param> /// <throws>com.espertech.esper.epl.expression.core.ExprValidationException if the preparation failed</throws> public EPPreparedExecuteIUDSingleStream( StatementSpecCompiled statementSpec, EPServicesContext services, StatementContext statementContext) { var queryPlanLogging = services.ConfigSnapshot.EngineDefaults.LoggingConfig.IsEnableQueryPlan; if (queryPlanLogging) { QueryPlanLog.Info("Query plans for Fire-and-forget query '" + statementContext.Expression + "'"); } HasTableAccess = statementSpec.IntoTableSpec != null || (statementSpec.TableNodes != null && statementSpec.TableNodes.Length > 0); if (statementSpec.InsertIntoDesc != null && services.TableService.GetTableMetadata(statementSpec.InsertIntoDesc.EventTypeName) != null) { HasTableAccess = true; } if (statementSpec.FireAndForgetSpec is FireAndForgetSpecUpdate || statementSpec.FireAndForgetSpec is FireAndForgetSpecDelete) { HasTableAccess |= statementSpec.StreamSpecs[0] is TableQueryStreamSpec; } StatementSpec = statementSpec; Services = services; StatementContext = statementContext; // validate general FAF criteria EPPreparedExecuteMethodHelper.ValidateFAFQuery(statementSpec); // obtain processor var streamSpec = statementSpec.StreamSpecs[0]; Processor = FireAndForgetProcessorFactory.ValidateResolveProcessor(streamSpec, services); // obtain name and type var processorName = Processor.NamedWindowOrTableName; var eventType = Processor.EventTypeResultSetProcessor; // determine alias var aliasName = processorName; if (streamSpec.OptionalStreamName != null) { aliasName = streamSpec.OptionalStreamName; } // compile filter to optimize access to named window var typeService = new StreamTypeServiceImpl(new EventType[] { eventType }, new string[] { aliasName }, new bool[] { true }, services.EngineURI, true); FilterSpecCompiled filter; if (statementSpec.FilterRootNode != null) { var tagged = new LinkedHashMap <string, Pair <EventType, string> >(); FilterSpecCompiled filterCompiled; try { filterCompiled = FilterSpecCompiler.MakeFilterSpec(eventType, aliasName, Collections.SingletonList(statementSpec.FilterRootNode), null, tagged, tagged, typeService, null, statementContext, Collections.SingletonList(0)); } catch (Exception ex) { Log.Warn("Unexpected exception analyzing filter paths: " + ex.Message, ex); filterCompiled = null; } filter = filterCompiled; } else { filter = null; } // validate expressions EPStatementStartMethodHelperValidate.ValidateNodes(statementSpec, statementContext, typeService, null); // get executor Executor = GetExecutor(filter, aliasName); }
public StreamSpecCompiled Compile(StatementContext context, ICollection <String> eventTypeReferences, bool isInsertInto, ICollection <int> assignedTypeNumberStack, bool isJoin, bool isContextDeclaration, bool isOnTrigger, String optionalStreamName) { StreamTypeService streamTypeService; // Determine the event type var eventName = _rawFilterSpec.EventTypeName; if (context.TableService != null && context.TableService.GetTableMetadata(eventName) != null) { if (this.ViewSpecs != null && this.ViewSpecs.Length > 0) { throw new ExprValidationException("Views are not supported with tables"); } if (this.RawFilterSpec.OptionalPropertyEvalSpec != null) { throw new ExprValidationException("Contained-event expressions are not supported with tables"); } var tableMetadata = context.TableService.GetTableMetadata(eventName); var streamTypeServiceX = new StreamTypeServiceImpl(new EventType[] { tableMetadata.InternalEventType }, new String[] { optionalStreamName }, new bool[] { true }, context.EngineURI, false); var validatedNodes = FilterSpecCompiler.ValidateAllowSubquery(ExprNodeOrigin.FILTER, _rawFilterSpec.FilterExpressions, streamTypeServiceX, context, null, null); return(new TableQueryStreamSpec(this.OptionalStreamName, this.ViewSpecs, this.Options, eventName, validatedNodes)); } // Could be a named window if (context.NamedWindowMgmtService.IsNamedWindow(eventName)) { var namedWindowType = context.NamedWindowMgmtService.GetProcessor(eventName).TailView.EventType; streamTypeService = new StreamTypeServiceImpl(new EventType[] { namedWindowType }, new String[] { optionalStreamName }, new bool[] { true }, context.EngineURI, false); var validatedNodes = FilterSpecCompiler.ValidateAllowSubquery( ExprNodeOrigin.FILTER, _rawFilterSpec.FilterExpressions, streamTypeService, context, null, null); PropertyEvaluator optionalPropertyEvaluator = null; if (_rawFilterSpec.OptionalPropertyEvalSpec != null) { optionalPropertyEvaluator = PropertyEvaluatorFactory.MakeEvaluator( _rawFilterSpec.OptionalPropertyEvalSpec, namedWindowType, OptionalStreamName, context.EventAdapterService, context.MethodResolutionService, context.TimeProvider, context.VariableService, context.ScriptingService, context.TableService, context.EngineURI, context.StatementId, context.StatementName, context.Annotations, assignedTypeNumberStack, context.ConfigSnapshot, context.NamedWindowMgmtService); } eventTypeReferences.Add(((EventTypeSPI)namedWindowType).Metadata.PrimaryName); return(new NamedWindowConsumerStreamSpec(eventName, OptionalStreamName, ViewSpecs, validatedNodes, Options, optionalPropertyEvaluator)); } EventType eventType = null; if (context.ValueAddEventService.IsRevisionTypeName(eventName)) { eventType = context.ValueAddEventService.GetValueAddUnderlyingType(eventName); eventTypeReferences.Add(((EventTypeSPI)eventType).Metadata.PrimaryName); } if (eventType == null) { eventType = ResolveType(context.EngineURI, eventName, context.EventAdapterService, context.PlugInTypeResolutionURIs); if (eventType is EventTypeSPI) { eventTypeReferences.Add(((EventTypeSPI)eventType).Metadata.PrimaryName); } } // Validate all nodes, make sure each returns a bool and types are good; // Also decompose all AND super nodes into individual expressions streamTypeService = new StreamTypeServiceImpl(new EventType[] { eventType }, new String[] { base.OptionalStreamName }, new bool[] { true }, context.EngineURI, false); var spec = FilterSpecCompiler.MakeFilterSpec(eventType, eventName, _rawFilterSpec.FilterExpressions, _rawFilterSpec.OptionalPropertyEvalSpec, null, null, // no tags streamTypeService, OptionalStreamName, context, assignedTypeNumberStack); return(new FilterStreamSpecCompiled(spec, ViewSpecs, OptionalStreamName, Options)); }