public EvalInsertWildcardJoin(SelectExprContext selectExprContext, EventType resultEventType, SelectExprProcessor joinWildcardProcessor) : base(selectExprContext, resultEventType) { _joinWildcardProcessor = joinWildcardProcessor; }
/// <summary> /// Ctor. /// </summary> /// <param name="selectExprProcessor">for processing the select expression and generting the readonly output rows</param> /// <param name="groupKeyNodeExpressions">The group key node expressions.</param> /// <param name="groupKeyNodes">list of group-by expression nodes needed for building the group-by keys</param> /// <param name="optionalHavingNode">expression node representing validated HAVING clause, or null if none given.Aggregation functions in the having node must have been pointed to the AggregationService for evaluation.</param> /// <param name="isSelectRStream">true if remove stream events should be generated</param> /// <param name="isUnidirectional">true if unidirectional join</param> /// <param name="outputLimitSpec">The output limit spec.</param> /// <param name="isSorting">if set to <c>true</c> [is sorting].</param> /// <param name="isHistoricalOnly">if set to <c>true</c> [is historical only].</param> /// <param name="resultSetProcessorHelperFactory">The result set processor helper factory.</param> /// <param name="optionalOutputFirstConditionFactory">The optional output first condition factory.</param> /// <param name="enableOutputLimitOpt">if set to <c>true</c> [enable output limit opt].</param> /// <param name="numStreams">The number streams.</param> public ResultSetProcessorAggregateGroupedFactory( SelectExprProcessor selectExprProcessor, ExprNode[] groupKeyNodeExpressions, ExprEvaluator[] groupKeyNodes, ExprEvaluator optionalHavingNode, bool isSelectRStream, bool isUnidirectional, OutputLimitSpec outputLimitSpec, bool isSorting, bool isHistoricalOnly, ResultSetProcessorHelperFactory resultSetProcessorHelperFactory, OutputConditionPolledFactory optionalOutputFirstConditionFactory, bool enableOutputLimitOpt, int numStreams) { _selectExprProcessor = selectExprProcessor; GroupKeyNodeExpressions = groupKeyNodeExpressions; GroupKeyNode = groupKeyNodes.Length == 1 ? groupKeyNodes[0] : null; GroupKeyNodes = groupKeyNodes; OptionalHavingNode = optionalHavingNode; IsSorting = isSorting; IsSelectRStream = isSelectRStream; IsUnidirectional = isUnidirectional; IsHistoricalOnly = isHistoricalOnly; OutputLimitSpec = outputLimitSpec; ResultSetProcessorHelperFactory = resultSetProcessorHelperFactory; OptionalOutputFirstConditionFactory = optionalOutputFirstConditionFactory; IsEnableOutputLimitOpt = enableOutputLimitOpt; NumStreams = numStreams; }
/// <summary> /// Ctor. /// </summary> /// <param name="selectExprProcessor">for processing the select expression and generting the final output rows</param> /// <param name="groupKeyNodeExpressions">The group key node expressions.</param> /// <param name="groupKeyNodes">list of group-by expression nodes needed for building the group-by keys</param> /// <param name="optionalHavingNode">expression node representing validated HAVING clause, or null if none given.Aggregation functions in the having node must have been pointed to the AggregationService for evaluation.</param> /// <param name="isSelectRStream">true if remove stream events should be generated</param> /// <param name="isUnidirectional">true if unidirectional join</param> /// <param name="outputLimitSpec">The output limit spec.</param> /// <param name="isSorting">if set to <c>true</c> [is sorting].</param> /// <param name="noDataWindowSingleStream">if set to <c>true</c> [no data window single stream].</param> /// <param name="isHistoricalOnly">if set to <c>true</c> [is historical only].</param> /// <param name="iterateUnbounded">if set to <c>true</c> [iterate unbounded].</param> /// <param name="resultSetProcessorHelperFactory">The result set processor helper factory.</param> /// <param name="enableOutputLimitOpt">if set to <c>true</c> [enable output limit opt].</param> /// <param name="numStreams">The number streams.</param> /// <param name="optionalOutputFirstConditionFactory">The optional output first condition factory.</param> public ResultSetProcessorRowPerGroupFactory( SelectExprProcessor selectExprProcessor, ExprNode[] groupKeyNodeExpressions, ExprEvaluator[] groupKeyNodes, ExprEvaluator optionalHavingNode, bool isSelectRStream, bool isUnidirectional, OutputLimitSpec outputLimitSpec, bool isSorting, bool noDataWindowSingleStream, bool isHistoricalOnly, bool iterateUnbounded, ResultSetProcessorHelperFactory resultSetProcessorHelperFactory, bool enableOutputLimitOpt, int numStreams, OutputConditionPolledFactory optionalOutputFirstConditionFactory) { _groupKeyNodeExpressions = groupKeyNodeExpressions; _selectExprProcessor = selectExprProcessor; _groupKeyNodes = groupKeyNodes; _groupKeyNode = groupKeyNodes.Length == 1 ? groupKeyNodes[0] : null; _optionalHavingNode = optionalHavingNode; _isSorting = isSorting; _isSelectRStream = isSelectRStream; _isUnidirectional = isUnidirectional; _outputLimitSpec = outputLimitSpec; _noDataWindowSingleSnapshot = iterateUnbounded || (outputLimitSpec != null && outputLimitSpec.DisplayLimit == OutputLimitLimitType.SNAPSHOT && noDataWindowSingleStream); _isHistoricalOnly = isHistoricalOnly; ResultSetProcessorHelperFactory = resultSetProcessorHelperFactory; IsEnableOutputLimitOpt = enableOutputLimitOpt; NumStreams = numStreams; OptionalOutputFirstConditionFactory = optionalOutputFirstConditionFactory; }
/// <summary> /// Ctor. /// </summary> /// <param name="selectExprProcessor">for processing the select expression and generting the final output rows</param> /// <param name="groupKeyNodeExpressions">The group key node expressions.</param> /// <param name="groupKeyNodes">list of group-by expression nodes needed for building the group-by keys</param> /// <param name="optionalHavingNode">expression node representing validated HAVING clause, or null if none given.Aggregation functions in the having node must have been pointed to the AggregationService for evaluation.</param> /// <param name="isSelectRStream">true if remove stream events should be generated</param> /// <param name="isUnidirectional">true if unidirectional join</param> /// <param name="outputLimitSpec">The output limit spec.</param> /// <param name="isSorting">if set to <c>true</c> [is sorting].</param> /// <param name="noDataWindowSingleStream">if set to <c>true</c> [no data window single stream].</param> /// <param name="isHistoricalOnly">if set to <c>true</c> [is historical only].</param> public ResultSetProcessorRowPerGroupFactory( SelectExprProcessor selectExprProcessor, ExprNode[] groupKeyNodeExpressions, ExprEvaluator[] groupKeyNodes, ExprEvaluator optionalHavingNode, bool isSelectRStream, bool isUnidirectional, OutputLimitSpec outputLimitSpec, bool isSorting, bool noDataWindowSingleStream, bool isHistoricalOnly, bool iterateUnbounded) { _groupKeyNodeExpressions = groupKeyNodeExpressions; _selectExprProcessor = selectExprProcessor; _groupKeyNodes = groupKeyNodes; _groupKeyNode = groupKeyNodes.Length == 1 ? groupKeyNodes[0] : null; _optionalHavingNode = optionalHavingNode; _isSorting = isSorting; _isSelectRStream = isSelectRStream; _isUnidirectional = isUnidirectional; _outputLimitSpec = outputLimitSpec; _noDataWindowSingleSnapshot = iterateUnbounded || (outputLimitSpec != null && outputLimitSpec.DisplayLimit == OutputLimitLimitType.SNAPSHOT && noDataWindowSingleStream); _isHistoricalOnly = isHistoricalOnly; }
public EPPreparedExecuteIUDSingleStreamExecInsert(ExprEvaluatorContext exprEvaluatorContext, SelectExprProcessor insertHelper, ExprTableAccessNode[] optionalTableNodes, EPServicesContext services) { _exprEvaluatorContext = exprEvaluatorContext; _insertHelper = insertHelper; _optionalTableNodes = optionalTableNodes; _services = services; }
internal static void PopulateSelectJoinEventsHavingWithOrderBy(SelectExprProcessor exprProcessor, OrderByProcessor orderByProcessor, ICollection <MultiKey <EventBean> > events, ExprEvaluator havingNode, bool isNewData, bool isSynthesize, ICollection <EventBean> result, ICollection <Object> sortKeys, ExprEvaluatorContext exprEvaluatorContext) { if (events == null) { return; } foreach (var key in events) { var eventsPerStream = key.Array; var evaluateParams = new EvaluateParams(eventsPerStream, isNewData, exprEvaluatorContext); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().QHavingClauseJoin(eventsPerStream); } var passesHaving = havingNode.Evaluate(evaluateParams); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().AHavingClauseJoin(passesHaving.AsBoxedBoolean()); } if ((passesHaving == null) || (false.Equals(passesHaving))) { continue; } var resultEvent = exprProcessor.Process(eventsPerStream, isNewData, isSynthesize, exprEvaluatorContext); if (resultEvent != null) { result.Add(resultEvent); sortKeys.Add(orderByProcessor.GetSortKey(eventsPerStream, isNewData, exprEvaluatorContext)); } } }
internal static void PopulateSelectEventsHaving(SelectExprProcessor exprProcessor, EventBean[] events, ExprEvaluator havingNode, bool isNewData, bool isSynthesize, ICollection <EventBean> result, ExprEvaluatorContext exprEvaluatorContext) { if (events == null) { return; } var eventsPerStream = new EventBean[1]; var evaluateParams = new EvaluateParams(eventsPerStream, isNewData, exprEvaluatorContext); foreach (var theEvent in events) { eventsPerStream[0] = theEvent; if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().QHavingClauseNonJoin(theEvent); } var passesHaving = havingNode.Evaluate(evaluateParams); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().AHavingClauseNonJoin(passesHaving.AsBoxedBoolean()); } if ((passesHaving == null) || (false.Equals(passesHaving))) { continue; } var resultEvent = exprProcessor.Process(eventsPerStream, isNewData, isSynthesize, exprEvaluatorContext); if (resultEvent != null) { result.Add(resultEvent); } } }
private static SelectExprProcessor GetProcessorInternal(ICollection <int> assignedTypeNumberStack, SelectClauseElementCompiled[] selectionList, bool isUsingWildcard, InsertIntoDesc insertIntoDesc, EventType optionalInsertIntoEventType, StreamTypeService typeService, EventAdapterService eventAdapterService, ValueAddEventService valueAddEventService, SelectExprEventTypeRegistry selectExprEventTypeRegistry, EngineImportService engineImportService, int statementId, Attribute[] annotations, ConfigurationInformation configuration, NamedWindowMgmtService namedWindowMgmtService, TableService tableService, GroupByRollupInfo groupByRollupInfo) { // Wildcard not allowed when insert into specifies column order if (isUsingWildcard && insertIntoDesc != null && !insertIntoDesc.ColumnNames.IsEmpty()) { throw new ExprValidationException("Wildcard not allowed when insert-into specifies column order"); } // Determine wildcard processor (select *) if (IsWildcardsOnly(selectionList)) { // For joins if (typeService.StreamNames.Length > 1) { Log.Debug(".getProcessor Using SelectExprJoinWildcardProcessor"); return(SelectExprJoinWildcardProcessorFactory.Create( assignedTypeNumberStack, statementId, typeService.StreamNames, typeService.EventTypes, eventAdapterService, insertIntoDesc, selectExprEventTypeRegistry, engineImportService, annotations, configuration, tableService)); } // Single-table selects with no insert-into // don't need extra processing else if (insertIntoDesc == null) { Log.Debug(".getProcessor Using wildcard processor"); if (typeService.HasTableTypes) { var tableName = TableServiceUtil.GetTableNameFromEventType(typeService.EventTypes[0]); return(new SelectExprWildcardTableProcessor(tableName, tableService)); } return(new SelectExprWildcardProcessor(typeService.EventTypes[0])); } } // Verify the assigned or name used is unique if (insertIntoDesc == null) { VerifyNameUniqueness(selectionList); } // Construct processor var buckets = GetSelectExpressionBuckets(selectionList); var factory = new SelectExprProcessorHelper( assignedTypeNumberStack, buckets.Expressions, buckets.SelectedStreams, insertIntoDesc, optionalInsertIntoEventType, isUsingWildcard, typeService, eventAdapterService, valueAddEventService, selectExprEventTypeRegistry, engineImportService, statementId, annotations, configuration, namedWindowMgmtService, tableService, groupByRollupInfo); SelectExprProcessor processor = factory.Evaluator; // add reference to the type obtained var type = (EventTypeSPI)processor.ResultEventType; if (!typeService.IsOnDemandStreams && type.Metadata.TypeClass != TypeClass.ANONYMOUS) { selectExprEventTypeRegistry.Add(processor.ResultEventType); } return(processor); }
/// <summary>Ctor. </summary> /// <param name="statementResultService">for awareness of listeners and subscribers handles output results</param> /// <param name="syntheticProcessor">is the processor generating synthetic events according to the select clause</param> /// <param name="bindProcessor">for generating natural object column results</param> public SelectExprResultProcessor(StatementResultService statementResultService, SelectExprProcessor syntheticProcessor, BindProcessor bindProcessor) { _statementResultService = statementResultService; _syntheticProcessor = syntheticProcessor; _bindProcessor = bindProcessor; }
public void SetUp() { var selectExprEventTypeRegistry = new SelectExprEventTypeRegistry("abc", new StatementEventTypeRefImpl()); var supportTypes = new SupportStreamTypeSvc3Stream(); _processor = SelectExprJoinWildcardProcessorFactory.Create(Collections.GetEmptyList <int>(), 1, "stmtname", supportTypes.StreamNames, supportTypes.EventTypes, SupportEventAdapterService.Service, null, selectExprEventTypeRegistry, null, null, new Configuration(), new TableServiceImpl(), "default"); }
public EvalInsertWildcardJoinRevision(SelectExprContext selectExprContext, EventType resultEventType, SelectExprProcessor joinWildcardProcessor, ValueAddEventProcessor vaeProcessor) : base(selectExprContext, resultEventType) { _joinWildcardProcessor = joinWildcardProcessor; _vaeProcessor = vaeProcessor; }
public ResultSetProcessorAggregateAll(ResultSetProcessorAggregateAllFactory prototype, SelectExprProcessor selectExprProcessor, OrderByProcessor orderByProcessor, AggregationService aggregationService, ExprEvaluatorContext exprEvaluatorContext) { _prototype = prototype; _selectExprProcessor = selectExprProcessor; _orderByProcessor = orderByProcessor; _aggregationService = aggregationService; _exprEvaluatorContext = exprEvaluatorContext; _outputLastUnordHelper = prototype.IsOutputLast ? new ResultSetProcessorAggregateAllOutputLastHelper(this) : null; _outputAllUnordHelper = prototype.IsOutputAll ? new ResultSetProcessorAggregateAllOutputAllHelper(this) : null; }
public SelectExprJoinWildcardProcessorTableRows(EventType[] types, SelectExprProcessor inner, TableService tableService) { _inner = inner; _eventsPerStreamWTableRows = new EventBean[types.Length]; _tables = new TableMetadata[types.Length]; for (int i = 0; i < types.Length; i++) { _tables[i] = tableService.GetTableMetadataFromEventType(types[i]); } }
/// <summary>Ctor. </summary> /// <param name="selectExprProcessor">for processing the select expression and generting the readonly output rows</param> /// <param name="optionalHavingNode">having clause expression node</param> /// <param name="isSelectRStream">true if remove stream events should be generated</param> public ResultSetProcessorSimpleFactory( SelectExprProcessor selectExprProcessor, ExprEvaluator optionalHavingNode, bool isSelectRStream, OutputLimitSpec outputLimitSpec) { _selectExprProcessor = selectExprProcessor; _optionalHavingExpr = optionalHavingNode; _isSelectRStream = isSelectRStream; _outputLimitSpec = outputLimitSpec; }
/// <summary> /// Applies the select-clause to the given events returning the selected events. The number of events stays /// the same, i.e. this method does not filter e just transforms the result set. /// <para/> /// Also applies a having clause. /// </summary> /// <param name="exprProcessor">processes each input event and returns output event</param> /// <param name="events">input events</param> /// <param name="havingNode">supplies the having-clause expression</param> /// <param name="isNewData">indicates whether we are dealing with new data (istream) or old data (rstream)</param> /// <param name="isSynthesize">set to true to indicate that synthetic events are required for an iterator result set</param> /// <param name="exprEvaluatorContext">context for expression evalauation</param> /// <returns>output events, one for each input event</returns> internal static EventBean[] GetSelectEventsHaving(SelectExprProcessor exprProcessor, EventBean[] events, ExprEvaluator havingNode, bool isNewData, bool isSynthesize, ExprEvaluatorContext exprEvaluatorContext) { if (events == null) { return(null); } ArrayDeque <EventBean> result = null; var eventsPerStream = new EventBean[1]; var evaluateParams = new EvaluateParams(eventsPerStream, isNewData, exprEvaluatorContext); foreach (var theEvent in events) { eventsPerStream[0] = theEvent; if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().QHavingClauseNonJoin(theEvent); } var passesHaving = havingNode.Evaluate(evaluateParams); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().AHavingClauseNonJoin(passesHaving.AsBoxedBoolean()); } if ((passesHaving == null) || (false.Equals(passesHaving))) { continue; } var generated = exprProcessor.Process(eventsPerStream, isNewData, isSynthesize, exprEvaluatorContext); if (generated != null) { if (result == null) { result = new ArrayDeque <EventBean>(events.Length); } result.Add(generated); } } if (result != null) { return(result.ToArray()); } return(null); }
public InfraOnMergeActionIns( ExprEvaluator optionalFilter, SelectExprProcessor insertHelper, Table insertIntoTable, bool audit, bool route) : base(optionalFilter) { this.insertHelper = insertHelper; this.insertIntoTable = insertIntoTable; this.audit = audit; this.route = route; }
public ResultSetProcessorAggregateAll( ResultSetProcessorAggregateAllFactory prototype, SelectExprProcessor selectExprProcessor, OrderByProcessor orderByProcessor, AggregationService aggregationService, AgentInstanceContext agentInstanceContext) { _prototype = prototype; _selectExprProcessor = selectExprProcessor; _orderByProcessor = orderByProcessor; _aggregationService = aggregationService; _exprEvaluatorContext = agentInstanceContext; _outputLastUnordHelper = prototype.IsEnableOutputLimitOpt && prototype.IsOutputLast ? prototype.ResultSetProcessorHelperFactory.MakeRSAggregateAllOutputLast(this, agentInstanceContext) : null; _outputAllUnordHelper = prototype.IsEnableOutputLimitOpt && prototype.IsOutputAll ? prototype.ResultSetProcessorHelperFactory.MakeRSAggregateAllOutputAll(this, agentInstanceContext) : null; }
/// <summary> /// Ctor. /// </summary> /// <param name="selectExprProcessor">for processing the select expression and generting the readonly output rows</param> /// <param name="optionalHavingNode">having clause expression node</param> /// <param name="isSelectRStream">true if remove stream events should be generated</param> /// <param name="isUnidirectional">true if unidirectional join</param> /// <param name="isHistoricalOnly">if set to <c>true</c> [is historical only].</param> public ResultSetProcessorRowForAllFactory( SelectExprProcessor selectExprProcessor, ExprEvaluator optionalHavingNode, bool isSelectRStream, bool isUnidirectional, bool isHistoricalOnly, OutputLimitSpec outputLimitSpec) { _selectExprProcessor = selectExprProcessor; OutputLimitSpec = outputLimitSpec; OptionalHavingNode = optionalHavingNode; IsSelectRStream = isSelectRStream; IsUnidirectional = isUnidirectional; IsHistoricalOnly = isHistoricalOnly; }
/// <summary> /// Applies the select-clause to the given events returning the selected events. The number of events stays the /// same, i.e. this method does not filter e just transforms the result set. <para/>Also applies a having clause. /// </summary> /// <param name="exprProcessor">processes each input event and returns output event</param> /// <param name="orderByProcessor">for sorting output events according to the order-by clause</param> /// <param name="events">input events</param> /// <param name="havingNode">supplies the having-clause expression</param> /// <param name="isNewData">indicates whether we are dealing with new data (istream) or old data (rstream)</param> /// <param name="isSynthesize">set to true to indicate that synthetic events are required for an iterator result set</param> /// <param name="exprEvaluatorContext">context for expression evalauation</param> /// <returns>output events, one for each input event</returns> internal static EventBean[] GetSelectJoinEventsHavingWithOrderBy(SelectExprProcessor exprProcessor, OrderByProcessor orderByProcessor, ICollection <MultiKey <EventBean> > events, ExprEvaluator havingNode, bool isNewData, bool isSynthesize, ExprEvaluatorContext exprEvaluatorContext) { if ((events == null) || (events.IsEmpty())) { return(null); } ArrayDeque <EventBean> result = null; ArrayDeque <EventBean[]> eventGenerators = null; foreach (var key in events) { var eventsPerStream = key.Array; if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().QHavingClauseJoin(eventsPerStream); } var evaluateParams = new EvaluateParams(eventsPerStream, isNewData, exprEvaluatorContext); var passesHaving = havingNode.Evaluate(evaluateParams); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().AHavingClauseJoin(passesHaving.AsBoxedBoolean()); } if ((passesHaving == null) || (false.Equals(passesHaving))) { continue; } var resultEvent = exprProcessor.Process(eventsPerStream, isNewData, isSynthesize, exprEvaluatorContext); if (resultEvent != null) { if (result == null) { result = new ArrayDeque <EventBean>(events.Count); eventGenerators = new ArrayDeque <EventBean[]>(events.Count); } result.Add(resultEvent); eventGenerators.Add(eventsPerStream); } } if (result != null) { return(orderByProcessor.Sort(result.ToArray(), eventGenerators.ToArray(), isNewData, exprEvaluatorContext)); } return(null); }
public ResultSetProcessorRowForAll(ResultSetProcessorRowForAllFactory prototype, SelectExprProcessor selectExprProcessor, OrderByProcessor orderByProcessor, AggregationService aggregationService, ExprEvaluatorContext exprEvaluatorContext) { this.Prototype = prototype; _selectExprProcessor = selectExprProcessor; _orderByProcessor = orderByProcessor; this.AggregationService = aggregationService; this.ExprEvaluatorContext = exprEvaluatorContext; if (prototype.IsOutputLast) { _outputLastHelper = new ResultSetProcessorRowForAllOutputLastHelper(this); } else if (prototype.IsOutputAll) { _outputAllHelper = new ResultSetProcessorRowForAllOutputAllHelper(this); } }
/// <summary> /// Ctor. /// </summary> /// <param name="selectExprProcessor">for processing the select expression and generting the readonly output rows</param> /// <param name="optionalHavingNode">having clause expression node</param> /// <param name="isSelectRStream">true if remove stream events should be generated</param> /// <param name="outputLimitSpec">The output limit spec.</param> /// <param name="enableOutputLimitOpt">if set to <c>true</c> [enable output limit opt].</param> /// <param name="resultSetProcessorHelperFactory">The result set processor helper factory.</param> /// <param name="numStreams">The number streams.</param> public ResultSetProcessorSimpleFactory( SelectExprProcessor selectExprProcessor, ExprEvaluator optionalHavingNode, bool isSelectRStream, OutputLimitSpec outputLimitSpec, bool enableOutputLimitOpt, ResultSetProcessorHelperFactory resultSetProcessorHelperFactory, int numStreams) { _selectExprProcessor = selectExprProcessor; _optionalHavingExpr = optionalHavingNode; _isSelectRStream = isSelectRStream; _outputLimitSpec = outputLimitSpec; IsEnableOutputLimitOpt = enableOutputLimitOpt; ResultSetProcessorHelperFactory = resultSetProcessorHelperFactory; NumStreams = numStreams; }
/// <summary> /// Applies the select-clause to the given events returning the selected events. The number of /// events stays the same, i.e. this method does not filter e just transforms the result set. /// </summary> /// <param name="exprProcessor">processes each input event and returns output event</param> /// <param name="events">input events</param> /// <param name="isNewData">indicates whether we are dealing with new data (istream) or old data (rstream)</param> /// <param name="isSynthesize">set to true to indicate that synthetic events are required for an iterator result set</param> /// <param name="exprEvaluatorContext">context for expression evalauation</param> /// <returns>output events, one for each input event</returns> internal static EventBean[] GetSelectEventsNoHaving(SelectExprProcessor exprProcessor, EventBean[] events, bool isNewData, bool isSynthesize, ExprEvaluatorContext exprEvaluatorContext) { if (events == null) { return(null); } var result = new EventBean[events.Length]; var eventsPerStream = new EventBean[1]; for (var i = 0; i < events.Length; i++) { eventsPerStream[0] = events[i]; result[i] = exprProcessor.Process(eventsPerStream, isNewData, isSynthesize, exprEvaluatorContext); } return(result); }
public TableOnMergeActionIns( ExprEvaluator optionalFilter, SelectExprProcessor insertHelper, InternalEventRouter internalEventRouter, EPStatementHandle statementHandle, InternalEventRouteDest internalEventRouteDest, bool audit, TableStateRowFactory tableStateRowFactory) : base(optionalFilter) { _insertHelper = insertHelper; _internalEventRouter = internalEventRouter; _statementHandle = statementHandle; _internalEventRouteDest = internalEventRouteDest; _audit = audit; _tableStateRowFactory = tableStateRowFactory; }
internal static void PopulateSelectJoinEventsNoHaving(SelectExprProcessor exprProcessor, ICollection <MultiKey <EventBean> > events, bool isNewData, bool isSynthesize, ICollection <EventBean> result, ExprEvaluatorContext exprEvaluatorContext) { var length = (events != null) ? events.Count : 0; if (length == 0) { return; } foreach (var key in events) { var eventsPerStream = key.Array; var resultEvent = exprProcessor.Process(eventsPerStream, isNewData, isSynthesize, exprEvaluatorContext); if (resultEvent != null) { result.Add(resultEvent); } } }
public NamedWindowOnMergeActionIns( ExprEvaluator optionalFilter, SelectExprProcessor insertHelper, InternalEventRouter internalEventRouter, String insertIntoTableName, TableService tableService, EPStatementHandle statementHandle, InternalEventRouteDest internalEventRouteDest, bool audit) : base(optionalFilter) { _insertHelper = insertHelper; _internalEventRouter = internalEventRouter; _insertIntoTableName = insertIntoTableName; _tableService = tableService; _statementHandle = statementHandle; _internalEventRouteDest = internalEventRouteDest; _audit = audit; }
public ResultSetProcessorSimple( ResultSetProcessorSimpleFactory prototype, SelectExprProcessor selectExprProcessor, OrderByProcessor orderByProcessor, ExprEvaluatorContext exprEvaluatorContext) { Prototype = prototype; _selectExprProcessor = selectExprProcessor; _orderByProcessor = orderByProcessor; ExprEvaluatorContext = exprEvaluatorContext; if (prototype.IsOutputLast) { _outputLastHelper = new ResultSetProcessorSimpleOutputLastHelper(this); } else if (prototype.IsOutputAll) { _outputAllHelper = new ResultSetProcessorSimpleOutputAllHelper(this); } }
/// <summary> /// Applies the select-clause to the given events returning the selected events. The number of events stays the /// same, i.e. this method does not filter e just transforms the result set. /// </summary> /// <param name="exprProcessor">processes each input event and returns output event</param> /// <param name="events">input events</param> /// <param name="isNewData">indicates whether we are dealing with new data (istream) or old data (rstream)</param> /// <param name="isSynthesize">set to true to indicate that synthetic events are required for an iterator result set</param> /// <param name="exprEvaluatorContext">context for expression evalauation</param> /// <returns>output events, one for each input event</returns> internal static EventBean[] GetSelectJoinEventsNoHaving(SelectExprProcessor exprProcessor, ICollection <MultiKey <EventBean> > events, bool isNewData, bool isSynthesize, ExprEvaluatorContext exprEvaluatorContext) { if ((events == null) || (events.IsEmpty())) { return(null); } var result = new EventBean[events.Count]; var count = 0; foreach (var key in events) { var eventsPerStream = key.Array; result[count] = exprProcessor.Process(eventsPerStream, isNewData, isSynthesize, exprEvaluatorContext); count++; } return(result); }
public void SetUp() { var selectExprEventTypeRegistry = new SelectExprEventTypeRegistry("abc", new StatementEventTypeRefImpl()); var statementContext = SupportStatementContextFactory.MakeContext(); var factory = new SelectExprProcessorHelper( Collections.GetEmptyList <int>(), SupportSelectExprFactory.MakeNoAggregateSelectList(), Collections.GetEmptyList <SelectExprStreamDesc>(), null, null, false, new SupportStreamTypeSvc1Stream(), SupportEventAdapterService.Service, null, selectExprEventTypeRegistry, statementContext.EngineImportService, 1, "stmtname", null, new Configuration(), null, new TableServiceImpl(), null); _selectExprProcessor = factory.Evaluator; _orderByProcessor = null; var prototype = new ResultSetProcessorSimpleFactory(_selectExprProcessor, null, true, null, false, null, 1); _outputProcessorAll = (ResultSetProcessorSimple)prototype.Instantiate(null, null, null); }
/// <summary> /// Ctor. /// </summary> /// <param name="selectExprProcessor">for processing the select expression and generting the readonly output rows</param> /// <param name="optionalHavingNode">having clause expression node</param> /// <param name="isSelectRStream">true if remove stream events should be generated</param> /// <param name="isUnidirectional">true if unidirectional join</param> /// <param name="isHistoricalOnly">if set to <c>true</c> [is historical only].</param> /// <param name="outputLimitSpec">The output limit spec.</param> /// <param name="enableOutputLimitOpt">if set to <c>true</c> [enable output limit opt].</param> /// <param name="resultSetProcessorHelperFactory">The result set processor helper factory.</param> public ResultSetProcessorAggregateAllFactory( SelectExprProcessor selectExprProcessor, ExprEvaluator optionalHavingNode, bool isSelectRStream, bool isUnidirectional, bool isHistoricalOnly, OutputLimitSpec outputLimitSpec, bool enableOutputLimitOpt, ResultSetProcessorHelperFactory resultSetProcessorHelperFactory) { _selectExprProcessor = selectExprProcessor; OutputLimitSpec = outputLimitSpec; OptionalHavingNode = optionalHavingNode; IsSelectRStream = isSelectRStream; IsUnidirectional = isUnidirectional; IsHistoricalOnly = isHistoricalOnly; IsEnableOutputLimitOpt = enableOutputLimitOpt; ResultSetProcessorHelperFactory = resultSetProcessorHelperFactory; }
internal static void PopulateSelectEventsNoHaving(SelectExprProcessor exprProcessor, EventBean[] events, bool isNewData, bool isSynthesize, ICollection <EventBean> result, ExprEvaluatorContext exprEvaluatorContext) { if (events == null) { return; } var eventsPerStream = new EventBean[1]; foreach (var theEvent in events) { eventsPerStream[0] = theEvent; var resultEvent = exprProcessor.Process(eventsPerStream, isNewData, isSynthesize, exprEvaluatorContext); if (resultEvent != null) { result.Add(resultEvent); } } }