public EventBean Process(EventBean[] eventsPerStream, bool isNewData, bool isSynthesize, ExprEvaluatorContext exprEvaluatorContext) { ObjectArrayBackedEventBean theEvent = (ObjectArrayBackedEventBean)eventsPerStream[_underlyingStreamNumber]; Object[] props = new Object[_items.Length]; foreach (Item item in _items) { Object value; if (item.OptionalFromIndex != -1) { value = theEvent.Properties[item.OptionalFromIndex]; } else { value = item.Evaluator.Evaluate(new EvaluateParams(eventsPerStream, isNewData, exprEvaluatorContext)); if (item.OptionalWidener != null) { value = item.OptionalWidener.Invoke(value); } } props[item.ToIndex] = value; } return(_manufacturer.Make(props)); }
protected void ApplyEnterTableKey( EventBean[] eventsPerStream, Object tableKey, ExprEvaluatorContext exprEvaluatorContext) { ObjectArrayBackedEventBean bean = tableInstance.GetCreateRowIntoTable(tableKey, exprEvaluatorContext); currentAggregationRow = (AggregationRow) bean.Properties[0]; InstrumentationCommon instrumentationCommon = exprEvaluatorContext.InstrumentationProvider; instrumentationCommon.QAggregationGroupedApplyEnterLeave(true, methodPairs.Length, accessAgents.Length, tableKey); for (int i = 0; i < methodPairs.Length; i++) { TableColumnMethodPairEval methodPair = methodPairs[i]; instrumentationCommon.QAggNoAccessEnterLeave(true, i, null, null); Object columnResult = methodPair.Evaluator.Evaluate(eventsPerStream, true, exprEvaluatorContext); currentAggregationRow.EnterAgg(methodPair.Column, columnResult); instrumentationCommon.AAggNoAccessEnterLeave(true, i, null); } for (int i = 0; i < accessAgents.Length; i++) { instrumentationCommon.QAggAccessEnterLeave(true, i, null); accessAgents[i].ApplyEnter(eventsPerStream, exprEvaluatorContext, currentAggregationRow, accessColumnsZeroOffset[i]); instrumentationCommon.AAggAccessEnterLeave(true, i); } tableInstance.HandleRowUpdated(bean); instrumentationCommon.AAggregationGroupedApplyEnterLeave(true); }
internal static object[] EvalTypable(ObjectArrayBackedEventBean @event, AggregationRowPair row, IDictionary <String, TableMetadataColumn> items, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext exprEvaluatorContext) { var values = new object[items.Count]; var count = 0; foreach (var entry in items) { if (entry.Value is TableMetadataColumnPlain) { var plain = (TableMetadataColumnPlain)entry.Value; values[count] = @event.Properties[plain.IndexPlain]; } else { var aggcol = (TableMetadataColumnAggregation)entry.Value; if (!aggcol.Factory.IsAccessAggregation) { values[count] = row.Methods[aggcol.MethodOffset].Value; } else { var pair = aggcol.AccessAccessorSlotPair; values[count] = pair.Accessor.GetValue(row.States[pair.Slot], eventsPerStream, isNewData, exprEvaluatorContext); } } count++; } return(values); }
internal static IDictionary <String, object> EvalMap(ObjectArrayBackedEventBean @event, AggregationRowPair row, IDictionary <String, TableMetadataColumn> items, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext exprEvaluatorContext) { var cols = new Dictionary <string, object>(); foreach (var entry in items) { if (entry.Value is TableMetadataColumnPlain) { var plain = (TableMetadataColumnPlain)entry.Value; cols.Put(entry.Key, @event.Properties[plain.IndexPlain]); } else { var aggcol = (TableMetadataColumnAggregation)entry.Value; if (!aggcol.Factory.IsAccessAggregation) { cols.Put(entry.Key, row.Methods[aggcol.MethodOffset].Value); } else { var pair = aggcol.AccessAccessorSlotPair; var value = pair.Accessor.GetValue(row.States[pair.Slot], eventsPerStream, isNewData, exprEvaluatorContext); cols.Put(entry.Key, value); } } } return(cols); }
protected internal static object[] EvalTypable( ObjectArrayBackedEventBean @event, AggregationRow row, IDictionary<string, TableMetadataColumn> items, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext exprEvaluatorContext) { object[] values = new object[items.Count]; int count = 0; foreach (KeyValuePair<string, TableMetadataColumn> entry in items) { if (entry.Value is TableMetadataColumnPlain) { TableMetadataColumnPlain plain = (TableMetadataColumnPlain) entry.Value; values[count] = @event.Properties[plain.IndexPlain]; } else { TableMetadataColumnAggregation aggcol = (TableMetadataColumnAggregation) entry.Value; values[count] = row.GetValue(aggcol.Column, eventsPerStream, isNewData, exprEvaluatorContext); } count++; } return values; }
public void HandleRowUpdated(ObjectArrayBackedEventBean row) { if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().QaTableUpdatedEvent(row); } }
protected ObjectArrayBackedEventBean CreateRowIntoTable(object groupKeys) { EventType eventType = table.MetaData.InternalEventType; AggregationRow aggregationRow = table.AggregationRowFactory.Make(); var data = new object[eventType.PropertyDescriptors.Count]; data[0] = aggregationRow; int[] groupKeyColNums = table.MetaData.KeyColNums; if (groupKeyColNums.Length == 1) { if (groupKeys is MultiKeyArrayWrap multiKeyArrayWrap) { data[groupKeyColNums[0]] = multiKeyArrayWrap.Array; } else { data[groupKeyColNums[0]] = groupKeys; } } else { var mk = (MultiKey) groupKeys; for (var i = 0; i < groupKeyColNums.Length; i++) { data[groupKeyColNums[i]] = mk.GetKey(i); } } ObjectArrayBackedEventBean row = agentInstanceContext.EventBeanTypedEventFactory.AdapterForTypedObjectArray(data, eventType); AddEvent(row); return row; }
public override void HandleRowUpdated(ObjectArrayBackedEventBean updatedEvent) { // no action if (agentInstanceContext.InstrumentationProvider.Activated()) { agentInstanceContext.InstrumentationProvider.QTableUpdatedEvent(updatedEvent); agentInstanceContext.InstrumentationProvider.ATableUpdatedEvent(); } }
public virtual void HandleRowUpdateKeyAfterUpdate(ObjectArrayBackedEventBean updatedEvent) { if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().QaTableUpdatedEventWKeyAfter(updatedEvent); } // no action }
public void AddEventUnadorned(EventBean @event) { ObjectArrayBackedEventBean oa = (ObjectArrayBackedEventBean)@event; AggregationRowPair aggs = _tableMetadata.RowFactory.MakeAggs(_agentInstanceContext.AgentInstanceId, null, null, AggregationServicePassThru); oa.Properties[0] = aggs; AddEvent(oa); }
public object Evaluate(EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext context) { ObjectArrayBackedEventBean @event = LockTableReadAndGet(context); if (@event == null) { return(null); } AggregationState aggregationState = GetAndLock(@event, context); return(_accessor.GetValue(aggregationState, eventsPerStream, isNewData, context)); }
public ICollection <object> EvaluateGetROCollectionScalar(EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext context) { ObjectArrayBackedEventBean @event = LockTableReadAndGet(context); if (@event == null) { return(null); } AggregationState aggregationState = GetAndLock(@event, context); return(_accessor.GetEnumerableScalar(aggregationState, eventsPerStream, isNewData, context)); }
public EventBean EvaluateGetEventBean(EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext context) { ObjectArrayBackedEventBean @event = LockTableReadAndGet(context); if (@event == null) { return(null); } AggregationState aggregationState = GetAndLock(@event, context); return(_accessor.GetEnumerableEvent(aggregationState, new EvaluateParams(eventsPerStream, isNewData, context))); }
public AggregationRow GetAggregationRow( EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext context) { ObjectArrayBackedEventBean row = LockTableReadAndGet(context); if (row == null) { return null; } return ExprTableEvalStrategyUtil.GetRow(row); }
public override ICollection<EventBean> EvaluateGetROCollectionEvents( EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext context) { ObjectArrayBackedEventBean row = LockTableReadAndGet(context); if (row == null) { return null; } AggregationRow aggs = ExprTableEvalStrategyUtil.GetRow(row); return aggs.GetCollectionOfEvents(Factory.AggColumnNum, eventsPerStream, isNewData, context); }
public override object Evaluate( EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext exprEvaluatorContext) { ObjectArrayBackedEventBean row = LockTableReadAndGet(exprEvaluatorContext); if (row == null) { return null; } AggregationRow aggs = ExprTableEvalStrategyUtil.GetRow(row); return aggs.GetValue(Factory.AggColumnNum, eventsPerStream, isNewData, exprEvaluatorContext); }
public override object[] EvaluateTypableSingle( EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext context) { ObjectArrayBackedEventBean @event = LockTableReadAndGet(context); if (@event == null) { return null; } AggregationRow row = ExprTableEvalStrategyUtil.GetRow(@event); IDictionary<string, TableMetadataColumn> items = Factory.Table.MetaData.Columns; return ExprTableEvalStrategyUtil.EvalTypable(@event, row, items, eventsPerStream, isNewData, context); }
public override object Evaluate( EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext context) { ObjectArrayBackedEventBean @event = LockTableReadAndGet(context); if (@event == null) { return null; } AggregationRow row = ExprTableEvalStrategyUtil.GetRow(@event); return ExprTableEvalStrategyUtil.EvalMap( @event, row, Factory.Table.MetaData.Columns, eventsPerStream, isNewData, context); }
protected internal static IDictionary<string, object> EvalMap( ObjectArrayBackedEventBean @event, AggregationRow row, IDictionary<string, TableMetadataColumn> items, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext exprEvaluatorContext) { Dictionary<string, object> cols = new Dictionary<string, object>(); foreach (KeyValuePair<string, TableMetadataColumn> entry in items) { if (entry.Value is TableMetadataColumnPlain) { TableMetadataColumnPlain plain = (TableMetadataColumnPlain) entry.Value; cols.Put(entry.Key, @event.Properties[plain.IndexPlain]); } else { TableMetadataColumnAggregation aggcol = (TableMetadataColumnAggregation) entry.Value; cols.Put(entry.Key, row.GetValue(aggcol.Column, eventsPerStream, isNewData, exprEvaluatorContext)); } } return cols; }
public void UpdateTable( ICollection<EventBean> eventsUnsafeIter, TableInstance instance, EventBean[] eventsPerStream, ExprEvaluatorContext exprEvaluatorContext) { // update (no-copy unless original values required) foreach (EventBean @event in eventsUnsafeIter) { eventsPerStream[0] = @event; ObjectArrayBackedEventBean updatedEvent = (ObjectArrayBackedEventBean) @event; // if "initial.property" is part of the assignment expressions, provide initial value event if (updateHelper.IsRequiresStream2InitialValueEvent) { object[] prev = new object[updatedEvent.Properties.Length]; Array.Copy(updatedEvent.Properties, 0, prev, 0, prev.Length); eventsPerStream[2] = new ObjectArrayEventBean(prev, updatedEvent.EventType); } // apply in-place updates updateHelper.UpdateNoCopy(updatedEvent, eventsPerStream, exprEvaluatorContext); instance.HandleRowUpdated(updatedEvent); } }
public abstract void HandleRowUpdateKeyAfterUpdate(ObjectArrayBackedEventBean updatedEvent);
public static AggregationRow GetRow(ObjectArrayBackedEventBean eventBean) { return GetRow(eventBean.Properties); }
public static AggregationRowPair GetRow(ObjectArrayBackedEventBean eventBean) { return((AggregationRowPair)eventBean.Properties[0]); }
private AggregationState GetAndLock(ObjectArrayBackedEventBean @event, ExprEvaluatorContext exprEvaluatorContext) { AggregationRowPair row = ExprTableEvalStrategyUtil.GetRow(@event); return(row.States[_slot]); }
public override void HandleRowUpdateKeyAfterUpdate(ObjectArrayBackedEventBean updatedEvent) { }
public override void HandleRowUpdateKeyAfterUpdate(ObjectArrayBackedEventBean updatedEvent) { agentInstanceContext.InstrumentationProvider.QaTableUpdatedEventWKeyAfter(updatedEvent); }
/// <summary> /// Ctor. /// </summary> /// <param name="viewChain">views</param> /// <param name="matchRecognizeSpec">specification</param> /// <param name="agentInstanceContext">The agent instance context.</param> /// <param name="isUnbound">true for unbound stream</param> /// <param name="annotations">annotations</param> /// <exception cref="ExprValidationException"> /// Variable ' + defineItem.Identifier + ' has already been defined /// or /// An aggregate function may not appear in a DEFINE clause /// or /// Failed to validate condition expression for variable ' + defineItem.Identifier + ': + ex.Message /// or /// Aggregation functions in the measure-clause must only refer to properties of exactly one group variable returning multiple events /// or /// Aggregation functions in the measure-clause must refer to one or more properties of exactly one group variable returning multiple events /// or /// The measures clause requires that each expression utilizes the AS keyword to assign a column name /// </exception> /// <throws>ExprValidationException if validation fails</throws> public EventRowRegexNFAViewFactory( ViewFactoryChain viewChain, MatchRecognizeSpec matchRecognizeSpec, AgentInstanceContext agentInstanceContext, bool isUnbound, Attribute[] annotations, ConfigurationEngineDefaults.MatchRecognizeConfig matchRecognizeConfig) { var parentViewType = viewChain.EventType; _matchRecognizeSpec = matchRecognizeSpec; _isUnbound = isUnbound; _isIterateOnly = HintEnum.ITERATE_ONLY.GetHint(annotations) != null; _matchRecognizeConfig = matchRecognizeConfig; var statementContext = agentInstanceContext.StatementContext; // Expand repeats and permutations _expandedPatternNode = RegexPatternExpandUtil.Expand(matchRecognizeSpec.Pattern); // Determine single-row and multiple-row variables _variablesSingle = new LinkedHashSet <string>(); ISet <string> variablesMultiple = new LinkedHashSet <string>(); EventRowRegexHelper.RecursiveInspectVariables(_expandedPatternNode, false, _variablesSingle, variablesMultiple); // each variable gets associated with a stream number (multiple-row variables as well to hold the current event for the expression). var streamNum = 0; _variableStreams = new LinkedHashMap <string, Pair <int, bool> >(); foreach (var variableSingle in _variablesSingle) { _variableStreams.Put(variableSingle, new Pair <int, bool>(streamNum, false)); streamNum++; } foreach (var variableMultiple in variablesMultiple) { _variableStreams.Put(variableMultiple, new Pair <int, bool>(streamNum, true)); streamNum++; } // mapping of stream to variable _streamVariables = new SortedDictionary <int, string>(); foreach (var entry in _variableStreams) { _streamVariables.Put(entry.Value.First, entry.Key); } // determine visibility rules var visibility = EventRowRegexHelper.DetermineVisibility(_expandedPatternNode); // assemble all single-row variables for expression validation var allStreamNames = new string[_variableStreams.Count]; var allTypes = new EventType[_variableStreams.Count]; streamNum = 0; foreach (var variableSingle in _variablesSingle) { allStreamNames[streamNum] = variableSingle; allTypes[streamNum] = parentViewType; streamNum++; } foreach (var variableMultiple in variablesMultiple) { allStreamNames[streamNum] = variableMultiple; allTypes[streamNum] = parentViewType; streamNum++; } // determine type service for use with DEFINE // validate each DEFINE clause expression ISet <string> definedVariables = new HashSet <string>(); IList <ExprAggregateNode> aggregateNodes = new List <ExprAggregateNode>(); var exprEvaluatorContext = new ExprEvaluatorContextStatement(statementContext, false); _isExprRequiresMultimatchState = new bool[_variableStreams.Count]; for (var defineIndex = 0; defineIndex < matchRecognizeSpec.Defines.Count; defineIndex++) { var defineItem = matchRecognizeSpec.Defines[defineIndex]; if (definedVariables.Contains(defineItem.Identifier)) { throw new ExprValidationException("Variable '" + defineItem.Identifier + "' has already been defined"); } definedVariables.Add(defineItem.Identifier); // stream-type visibilities handled here var typeServiceDefines = EventRowRegexNFAViewFactoryHelper.BuildDefineStreamTypeServiceDefine(statementContext, _variableStreams, defineItem, visibility, parentViewType); var exprNodeResult = HandlePreviousFunctions(defineItem.Expression); var validationContext = new ExprValidationContext( typeServiceDefines, statementContext.EngineImportService, statementContext.StatementExtensionServicesContext, null, statementContext.SchedulingService, statementContext.VariableService, statementContext.TableService, exprEvaluatorContext, statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, true, false, true, false, null, false); ExprNode validated; try { // validate validated = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.MATCHRECOGDEFINE, exprNodeResult, validationContext); // check aggregates defineItem.Expression = validated; ExprAggregateNodeUtil.GetAggregatesBottomUp(validated, aggregateNodes); if (!aggregateNodes.IsEmpty()) { throw new ExprValidationException("An aggregate function may not appear in a DEFINE clause"); } } catch (ExprValidationException ex) { throw new ExprValidationException("Failed to validate condition expression for variable '" + defineItem.Identifier + "': " + ex.Message, ex); } // determine access to event properties from multi-matches var visitor = new ExprNodeStreamRequiredVisitor(); validated.Accept(visitor); var streamsRequired = visitor.StreamsRequired; foreach (var streamRequired in streamsRequired) { if (streamRequired >= _variableStreams.Count) { var streamNumIdent = _variableStreams.Get(defineItem.Identifier).First; _isExprRequiresMultimatchState[streamNumIdent] = true; break; } } } _isDefineAsksMultimatches = CollectionUtil.IsAnySet(_isExprRequiresMultimatchState); _defineMultimatchEventBean = _isDefineAsksMultimatches ? EventRowRegexNFAViewFactoryHelper.GetDefineMultimatchBean(statementContext, _variableStreams, parentViewType) : null; // assign "prev" node indexes // Since an expression such as "prior(2, price), prior(8, price)" translates into {2, 8} the relative index is {0, 1}. // Map the expression-supplied index to a relative index var countPrev = 0; foreach (var entry in _callbacksPerIndex) { foreach (var callback in entry.Value) { callback.AssignedIndex = countPrev; } countPrev++; } // determine type service for use with MEASURE IDictionary <string, object> measureTypeDef = new LinkedHashMap <string, object>(); foreach (var variableSingle in _variablesSingle) { measureTypeDef.Put(variableSingle, parentViewType); } foreach (var variableMultiple in variablesMultiple) { measureTypeDef.Put(variableMultiple, new EventType[] { parentViewType }); } var outputEventTypeName = statementContext.StatementId + "_rowrecog"; _compositeEventType = (ObjectArrayEventType)statementContext.EventAdapterService.CreateAnonymousObjectArrayType(outputEventTypeName, measureTypeDef); StreamTypeService typeServiceMeasure = new StreamTypeServiceImpl(_compositeEventType, "MATCH_RECOGNIZE", true, statementContext.EngineURI); // find MEASURE clause aggregations var measureReferencesMultivar = false; IList <ExprAggregateNode> measureAggregateExprNodes = new List <ExprAggregateNode>(); foreach (var measureItem in matchRecognizeSpec.Measures) { ExprAggregateNodeUtil.GetAggregatesBottomUp(measureItem.Expr, measureAggregateExprNodes); } if (!measureAggregateExprNodes.IsEmpty()) { var isIStreamOnly = new bool[allStreamNames.Length]; CompatExtensions.Fill(isIStreamOnly, true); var typeServiceAggregateMeasure = new StreamTypeServiceImpl(allTypes, allStreamNames, isIStreamOnly, statementContext.EngineURI, false); var measureExprAggNodesPerStream = new Dictionary <int, IList <ExprAggregateNode> >(); foreach (var aggregateNode in measureAggregateExprNodes) { // validate absence of group-by aggregateNode.ValidatePositionals(); if (aggregateNode.OptionalLocalGroupBy != null) { throw new ExprValidationException("Match-recognize does not allow aggregation functions to specify a group-by"); } // validate node and params var count = 0; var visitor = new ExprNodeIdentifierVisitor(true); var validationContext = new ExprValidationContext( typeServiceAggregateMeasure, statementContext.EngineImportService, statementContext.StatementExtensionServicesContext, null, statementContext.SchedulingService, statementContext.VariableService, statementContext.TableService, exprEvaluatorContext, statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, false, false, true, false, null, false); for (int ii = 0; ii < aggregateNode.ChildNodes.Count; ii++) { var child = aggregateNode.ChildNodes[ii]; var validated = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.MATCHRECOGMEASURE, child, validationContext); validated.Accept(visitor); aggregateNode.SetChildNode(count++, new ExprNodeValidated(validated)); } validationContext = new ExprValidationContext( typeServiceMeasure, statementContext.EngineImportService, statementContext.StatementExtensionServicesContext, null, statementContext.SchedulingService, statementContext.VariableService, statementContext.TableService, exprEvaluatorContext, statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, false, false, true, false, null, false); aggregateNode.Validate(validationContext); // verify properties used within the aggregation var aggregatedStreams = new HashSet <int>(); foreach (var pair in visitor.ExprProperties) { aggregatedStreams.Add(pair.First); } int?multipleVarStream = null; foreach (int streamNumAggregated in aggregatedStreams) { var variable = _streamVariables.Get(streamNumAggregated); if (variablesMultiple.Contains(variable)) { measureReferencesMultivar = true; if (multipleVarStream == null) { multipleVarStream = streamNumAggregated; continue; } throw new ExprValidationException("Aggregation functions in the measure-clause must only refer to properties of exactly one group variable returning multiple events"); } } if (multipleVarStream == null) { throw new ExprValidationException("Aggregation functions in the measure-clause must refer to one or more properties of exactly one group variable returning multiple events"); } var aggNodesForStream = measureExprAggNodesPerStream.Get(multipleVarStream.Value); if (aggNodesForStream == null) { aggNodesForStream = new List <ExprAggregateNode>(); measureExprAggNodesPerStream.Put(multipleVarStream.Value, aggNodesForStream); } aggNodesForStream.Add(aggregateNode); } var factoryDesc = AggregationServiceFactoryFactory.GetServiceMatchRecognize(_streamVariables.Count, measureExprAggNodesPerStream, typeServiceAggregateMeasure.EventTypes); _aggregationService = factoryDesc.AggregationServiceFactory.MakeService(agentInstanceContext); _aggregationExpressions = factoryDesc.Expressions; } else { _aggregationService = null; _aggregationExpressions = Collections.GetEmptyList <AggregationServiceAggExpressionDesc>(); } // validate each MEASURE clause expression IDictionary <string, object> rowTypeDef = new LinkedHashMap <string, object>(); var streamRefVisitor = new ExprNodeStreamUseCollectVisitor(); foreach (var measureItem in matchRecognizeSpec.Measures) { if (measureItem.Name == null) { throw new ExprValidationException("The measures clause requires that each expression utilizes the AS keyword to assign a column name"); } var validated = ValidateMeasureClause(measureItem.Expr, typeServiceMeasure, variablesMultiple, _variablesSingle, statementContext); measureItem.Expr = validated; rowTypeDef.Put(measureItem.Name, validated.ExprEvaluator.ReturnType); validated.Accept(streamRefVisitor); } // Determine if any of the multi-var streams are referenced in the measures (non-aggregated only) foreach (var @ref in streamRefVisitor.Referenced) { var rootPropName = @ref.RootPropertyNameIfAny; if (rootPropName != null) { if (variablesMultiple.Contains(rootPropName)) { measureReferencesMultivar = true; break; } } var streamRequired = @ref.StreamReferencedIfAny; if (streamRequired != null) { var streamVariable = _streamVariables.Get(streamRequired.Value); if (streamVariable != null) { var def = _variableStreams.Get(streamVariable); if (def != null && def.Second) { measureReferencesMultivar = true; break; } } } } _isCollectMultimatches = measureReferencesMultivar || _isDefineAsksMultimatches; // create rowevent type var rowEventTypeName = statementContext.StatementId + "_rowrecogrow"; _rowEventType = statementContext.EventAdapterService.CreateAnonymousMapType(rowEventTypeName, rowTypeDef, true); // validate partition-by expressions, if any if (!matchRecognizeSpec.PartitionByExpressions.IsEmpty()) { var typeServicePartition = new StreamTypeServiceImpl(parentViewType, "MATCH_RECOGNIZE_PARTITION", true, statementContext.EngineURI); var validated = new List <ExprNode>(); var validationContext = new ExprValidationContext( typeServicePartition, statementContext.EngineImportService, statementContext.StatementExtensionServicesContext, null, statementContext.SchedulingService, statementContext.VariableService, statementContext.TableService, exprEvaluatorContext, statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, false, false, true, false, null, false); foreach (var partitionExpr in matchRecognizeSpec.PartitionByExpressions) { validated.Add(ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.MATCHRECOGPARTITION, partitionExpr, validationContext)); } matchRecognizeSpec.PartitionByExpressions = validated; } // validate interval if present if (matchRecognizeSpec.Interval != null) { var validationContext = new ExprValidationContext( new StreamTypeServiceImpl(statementContext.EngineURI, false), statementContext.EngineImportService, statementContext.StatementExtensionServicesContext, null, statementContext.SchedulingService, statementContext.VariableService, statementContext.TableService, exprEvaluatorContext, statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, false, false, true, false, null, false); matchRecognizeSpec.Interval.Validate(validationContext); } }
public EventBean Process(EventBean[] eventsPerStream, bool isNewData, bool isSynthesize, ExprEvaluatorContext exprEvaluatorContext) { ObjectArrayBackedEventBean theEvent = (ObjectArrayBackedEventBean)eventsPerStream[_underlyingStreamNumber]; return(_selectExprContext.EventAdapterService.AdapterForTypedObjectArray(theEvent.Properties, _resultType)); }