/// <summary>Processes batched events in case of output-rate limiting.</summary> /// <param name="joinEventsSet">the join results</param> /// <param name="generateSynthetic">flag to indicate whether synthetic events must be generated</param> /// <param name="outputLimitLimitType">the type of output rate limiting</param> /// <returns>results for dispatch</returns> public virtual UniformPair <EventBean[]> ProcessOutputLimitedJoin(IList <UniformPair <ISet <MultiKey <EventBean> > > > joinEventsSet, bool generateSynthetic, OutputLimitLimitType outputLimitLimitType) { if (outputLimitLimitType != OutputLimitLimitType.LAST) { var flattened = EventBeanUtility.FlattenBatchJoin(joinEventsSet); return(ProcessJoinResult(flattened.First, flattened.Second, generateSynthetic)); } throw new IllegalStateException("Output last is provided by " + typeof(OutputProcessViewConditionLastAllUnord).Name); }
public UniformPair<EventBean[]> OutputView(bool isSynthesize) { var pair = processor.ProcessViewResult( EventBeanUtility.ToArrayNullIfEmpty(eventsNewView), EventBeanUtility.ToArrayNullIfEmpty(eventsOldView), isSynthesize); eventsNewView.Clear(); eventsOldView.Clear(); return pair; }
public UniformPair<EventBean[]> OutputJoin(bool isSynthesize) { var pair = processor.ProcessJoinResult( EventBeanUtility.ToLinkedHashSetNullIfEmpty(eventsNewJoin), EventBeanUtility.ToLinkedHashSetNullIfEmpty(eventsOldJoin), isSynthesize); eventsNewJoin.Clear(); eventsOldJoin.Clear(); return pair; }
public EPPreparedQueryResult Execute( FAFQueryMethodSelect select, ContextPartitionSelector[] contextPartitionSelectors, FAFQueryMethodAssignerSetter assignerSetter, ContextManagementService contextManagementService) { var processor = select.Processors[0]; var singleSelector = contextPartitionSelectors != null && contextPartitionSelectors.Length > 0 ? contextPartitionSelectors[0] : null; var agentInstanceIds = AgentInstanceIds(processor, singleSelector, contextManagementService); IList<ContextPartitionResult> contextPartitionResults = new List<ContextPartitionResult>(); foreach (var agentInstanceId in agentInstanceIds) { var processorInstance = processor.GetProcessorInstanceContextById(agentInstanceId); if (processorInstance != null) { var coll = processorInstance.SnapshotBestEffort(select.QueryGraph, select.Annotations); contextPartitionResults.Add( new ContextPartitionResult(coll, processorInstance.AgentInstanceContext)); } } // process context partitions var events = new ArrayDeque<EventBean[]>(); ResultSetProcessor resultSetProcessor = null; foreach (var contextPartitionResult in contextPartitionResults) { resultSetProcessor = ProcessorWithAssign( select.ResultSetProcessorFactoryProvider, contextPartitionResult.Context, assignerSetter, select.TableAccesses, select.Subselects); var snapshot = contextPartitionResult.Events; if (select.WhereClause != null) { snapshot = Filtered( snapshot, select.WhereClause, contextPartitionResult.Context); } var rows = snapshot.ToArray(); resultSetProcessor.SetAgentInstanceContext(contextPartitionResult.Context); var results = resultSetProcessor.ProcessViewResult(rows, null, true); if (results != null && results.First != null && results.First.Length > 0) { events.Add(results.First); } } var distinct = EventBeanUtility.GetDistinctByProp( EventBeanUtility.Flatten(events), select.DistinctKeyGetter); return new EPPreparedQueryResult(select.EventType, distinct); }
/// <summary> /// Ctor. /// </summary> /// <param name="eventType">event type to expect for lookup</param> /// <param name="property">The property.</param> /// <param name="index">index to look up in</param> public IndexedTableLookupStrategySingle(EventType eventType, String property, PropertyIndexedEventTableSingle index) { _eventType = eventType; _property = property; if (index == null) { throw new ArgumentException("Unexpected null index received"); } _index = index; _propertyGetter = EventBeanUtility.GetAssertPropertyGetter(eventType, property); }
public void SaveDeclaredExpressionLastColl( object node, EventBean[] eventsPerStream, FlexCollection result) { var copy = EventBeanUtility.CopyArray(eventsPerStream); var entry = new ExpressionResultCacheEntryEventBeanArrayAndCollBean(copy, result: result); exprDeclCacheCollection.Put( node, new SoftReference<ExpressionResultCacheEntryEventBeanArrayAndCollBean>(entry)); }
public void Remove(EventBean theEvent, AnyMap parent) { Object sortable = _propertyGetter.Get(theEvent); if (sortable == null) { if (_nullKeys != null) { _nullKeys.Remove(theEvent); } return; } sortable = EventBeanUtility.Coerce(sortable, _coercionType); // if this is a leaf, remove event if (_next == null) { var eventMap = parent; if (eventMap == null) { return; } var events = eventMap.Get(sortable) as ICollection <EventBean>; if (events == null) { return; } if (!events.Remove(theEvent)) { return; } if (events.IsEmpty()) { parent.Remove(sortable); } } else { var innerIndex = (AnyMap)parent.Get(sortable); if (innerIndex == null) { return; } _next.Remove(theEvent, innerIndex); if (innerIndex.IsEmpty()) { parent.Remove(sortable); } } }
public UniformPair <EventBean[]> OutputView(bool isSynthesize) { if (_outputLastIStreamBufView == null && _outputLastRStreamBufView == null) { return(null); } UniformPair <EventBean[]> pair = _processor.ProcessViewResult(EventBeanUtility.ToArrayIfNotNull(_outputLastIStreamBufView), EventBeanUtility.ToArrayIfNotNull(_outputLastRStreamBufView), isSynthesize); _outputLastIStreamBufView = null; _outputLastRStreamBufView = null; return(pair); }
public void Enter(EventBean theEvent, AnyMap parent) { var mk = EventBeanUtility.GetMultiKey(theEvent, _propertyGetters, _keyCoercionTypes); var innerIndex = (AnyMap)parent.Get(mk); if (innerIndex == null) { innerIndex = new OrderedDictionary <Object, Object>(); parent.Put(mk, innerIndex); } _next.Enter(theEvent, innerIndex); }
protected override Object GetKey(EventBean theEvent) { var keyValue = base.GetKey(theEvent); if ((keyValue != null) && (keyValue.GetType() != _coercionType)) { keyValue = keyValue.IsNumber() ? _coercer.Invoke(keyValue) : EventBeanUtility.Coerce(keyValue, _coercionType); } return(keyValue); }
public ICollection <EventBean> Get(EventBean theEvent, DataMap parent, ExprEvaluatorContext context) { _events[_lookupStream] = theEvent; var mk = EventBeanUtility.GetMultiKey(_events, _evaluators, context, _keyCoercionTypes); var innerIndex = (DataMap)parent.Get(mk); if (innerIndex == null) { return(null); } return(_next.Get(theEvent, innerIndex, context)); }
public UniformPair <EventBean[]> OutputJoin(bool isSynthesize) { if (_outputLastIStreamBufJoin == null && _outputLastRStreamBufJoin == null) { return(null); } UniformPair <EventBean[]> pair = _processor.ProcessJoinResult(EventBeanUtility.ToSingletonSetIfNotNull(_outputLastIStreamBufJoin), EventBeanUtility.ToSingletonSetIfNotNull(_outputLastRStreamBufJoin), isSynthesize); _outputLastIStreamBufJoin = null; _outputLastRStreamBufJoin = null; return(pair); }
private void PrintList(EventBean[] events) { if (events == null) { log.Debug(".printList : null-value events array"); return; } log.Debug(".printList : " + events.Length + " elements..."); for (var i = 0; i < events.Length; i++) { log.Debug(" " + EventBeanUtility.PrintEvent(events[i])); } }
/// <summary>Processes batched events in case of output-rate limiting.</summary> /// <param name="viewEventsList">the view results</param> /// <param name="generateSynthetic">flag to indicate whether synthetic events must be generated</param> /// <param name="outputLimitLimitType">the type of output rate limiting</param> /// <returns>results for dispatch</returns> public virtual UniformPair <EventBean[]> ProcessOutputLimitedView(IList <UniformPair <EventBean[]> > viewEventsList, bool generateSynthetic, OutputLimitLimitType outputLimitLimitType) { if (outputLimitLimitType != OutputLimitLimitType.LAST) { UniformPair <EventBean[]> pair = EventBeanUtility.FlattenBatchStream(viewEventsList); return(ProcessViewResult(pair.First, pair.Second, generateSynthetic)); } throw new IllegalStateException("Output last is provided by " + typeof(OutputProcessViewConditionLastAllUnord).Name); }
// No filter and with select clause public virtual ICollection <object> EvaluateGetCollScalar(EventBean[] eventsPerStream, bool isNewData, ICollection <EventBean> matchingEvents, ExprEvaluatorContext context, ExprSubselectRowNode parent) { var result = new List <Object>(); var events = EventBeanUtility.AllocatePerStreamShift(eventsPerStream); var evaluateParams = new EvaluateParams(events, isNewData, context); foreach (var subselectEvent in matchingEvents) { events[0] = subselectEvent; result.Add(parent.SelectClauseEvaluator[0].Evaluate(evaluateParams)); } return(result); }
public void ProcessJoin(ISet <MultiKey <EventBean> > newEvents, ISet <MultiKey <EventBean> > oldEvents, bool isGenerateSynthetic) { if (processor.Prototype.IsSelectRStream) { EventBean[] eventsX = processor.GetSelectListEvents(false, isGenerateSynthetic, true); EventBeanUtility.AddToCollection(eventsX, eventsOld); } ResultSetProcessorUtil.ApplyAggJoinResult(processor.AggregationService, processor._exprEvaluatorContext, newEvents, oldEvents); EventBean[] events = processor.GetSelectListEvents(true, isGenerateSynthetic, true); EventBeanUtility.AddToCollection(events, eventsNew); }
public ExpressionResultCacheEntryEventBeanArrayAndObj GetDeclaredExpressionLastValue( object node, EventBean[] eventsPerStream) { var cacheRef = exprDeclCacheObject.Get(node); var entry = cacheRef?.Get(); if (entry == null) { return null; } return EventBeanUtility.CompareEventReferences(entry.Reference, eventsPerStream) ? entry : null; }
// Filter and Select public EventBean EvaluateGetEventBean(EventBean[] eventsPerStream, bool isNewData, ICollection <EventBean> matchingEvents, ExprEvaluatorContext context, ExprSubselectRowNode parent) { var events = EventBeanUtility.AllocatePerStreamShift(eventsPerStream); var subSelectResult = ExprSubselectRowNodeUtility.EvaluateFilterExpectSingleMatch(events, isNewData, matchingEvents, context, parent); if (subSelectResult == null) { return(null); } var row = parent.EvaluateRow(events, true, context); return(parent.subselectMultirowType.EventAdapterService.AdapterForTypedMap(row, parent.subselectMultirowType.EventType)); }
public UniformPair<EventBean[]> OutputView(bool isSynthesize) { if (outputLastIStreamBufView == null && outputLastRStreamBufView == null) { return null; } var pair = processor.ProcessViewResult( EventBeanUtility.ToArrayIfNotNull(outputLastIStreamBufView), EventBeanUtility.ToArrayIfNotNull(outputLastRStreamBufView), isSynthesize); outputLastIStreamBufView = null; outputLastRStreamBufView = null; return pair; }
public void ProcessView(EventBean[] newData, EventBean[] oldData, bool isGenerateSynthetic) { if (processor.Prototype.IsSelectRStream) { EventBean[] eventsX = processor.GetSelectListEvents(false, isGenerateSynthetic, false); EventBeanUtility.AddToCollection(eventsX, eventsOld); } EventBean[] eventsPerStream = new EventBean[1]; ResultSetProcessorUtil.ApplyAggViewResult(processor.AggregationService, processor._exprEvaluatorContext, newData, oldData, eventsPerStream); EventBean[] events = processor.GetSelectListEvents(true, isGenerateSynthetic, false); EventBeanUtility.AddToCollection(events, eventsNew); }
/// <summary> /// Ctor. /// </summary> /// <param name="streamNum">the stream number that is indexed</param> /// <param name="eventType">types of events indexed</param> /// <param name="propertyNames">The property names.</param> /// <param name="unique">if set to <c>true</c> [unique].</param> /// <param name="optionalIndexName">Name of the optional index.</param> public PropertyIndexedEventTableSingleArrayFactory(int streamNum, EventType eventType, String[] propertyNames, bool unique, String optionalIndexName) { StreamNum = streamNum; PropertyNames = propertyNames; Unique = unique; OptionalIndexName = optionalIndexName; // Init getters PropertyGetters = new EventPropertyGetter[propertyNames.Length]; for (var i = 0; i < propertyNames.Length; i++) { PropertyGetters[i] = EventBeanUtility.GetAssertPropertyGetter(eventType, propertyNames[i]); } }
// No filter and no select-clause: return underlying event public virtual Object Evaluate( EventBean[] eventsPerStream, bool newData, ICollection <EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext, ExprSubselectRowNode parent) { if (matchingEvents.Count > 1) { Log.Warn(parent.GetMultirowMessage()); return(null); } return(EventBeanUtility.GetNonemptyFirstEventUnderlying(matchingEvents)); }
private void ContinueOutputProcessingViewAndJoin( bool doOutput, bool forceUpdate, UniformPair<EventBean[]> newOldEvents) { if (_parent.IsDistinct && newOldEvents != null) { newOldEvents.First = EventBeanUtility.GetDistinctByProp(newOldEvents.First, _parent.DistinctKeyGetter); newOldEvents.Second = EventBeanUtility.GetDistinctByProp(newOldEvents.Second, _parent.DistinctKeyGetter); } if (doOutput) { Output(forceUpdate, newOldEvents); } }
private void GetGroupedResults( IDictionary<object, UniformPair<EventBean[]>> groups, EventBean[] events, bool insertStream, EventBean[] eventsPerStream) { if (events == null) { return; } foreach (var theEvent in events) { var evalEvent = theEvent; if (evalEvent is NaturalEventBean) { evalEvent = ((NaturalEventBean) evalEvent).OptionalSynthetic; } eventsPerStream[0] = evalEvent; var key = _groupDeliveryExpressions.Evaluate(eventsPerStream, true, _epStatement.StatementContext); var groupEntry = groups.Get(key); if (groupEntry == null) { if (insertStream) { groupEntry = new UniformPair<EventBean[]>(new[] {theEvent}, null); } else { groupEntry = new UniformPair<EventBean[]>(null, new[] {theEvent}); } groups.Put(key, groupEntry); } else { if (insertStream) { if (groupEntry.First == null) { groupEntry.First = new[] {theEvent}; } else { groupEntry.First = EventBeanUtility.AddToArray(groupEntry.First, theEvent); } } else { if (groupEntry.Second == null) { groupEntry.Second = new[] {theEvent}; } else { groupEntry.Second = EventBeanUtility.AddToArray(groupEntry.Second, theEvent); } } } } }
// No filter and with select clause public virtual EventBean EvaluateGetEventBean( EventBean[] eventsPerStream, bool newData, ICollection <EventBean> matchingEvents, ExprEvaluatorContext context, ExprSubselectRowNode parent) { EventBean[] events = EventBeanUtility.AllocatePerStreamShift(eventsPerStream); events[0] = EventBeanUtility.GetNonemptyFirstEvent(matchingEvents); var row = parent.EvaluateRow(events, true, context); return(parent.subselectMultirowType.EventAdapterService.AdapterForTypedMap( row, parent.subselectMultirowType.EventType)); }
public UniformPair<EventBean[]> Output() { EventBean[] oldEvents = EventBeanUtility.ToArrayNullIfEmpty(eventsOld); EventBean[] newEvents = EventBeanUtility.ToArrayNullIfEmpty(eventsNew); UniformPair<EventBean[]> result = null; if (oldEvents != null || newEvents != null) { result = new UniformPair<EventBean[]>(newEvents, oldEvents); } eventsOld.Clear(); eventsNew.Clear(); return result; }
public ISet <EventBean> GetCollectKeys(EventBean theEvent, DataMap parent, ExprEvaluatorContext context, IList <Object> keys) { _events[_lookupStream] = theEvent; var mk = EventBeanUtility.GetMultiKey(_events, _evaluators, context, _keyCoercionTypes); keys.AddAll(mk.Keys); var innerIndex = (DataMap)parent.Get(mk); if (innerIndex == null) { return(null); } return(_next.GetCollectKeys(theEvent, innerIndex, context, keys)); }
/// <summary> /// Called once the output condition has been met. /// Invokes the result set processor. /// Used for join event data. /// </summary> /// <param name="doOutput">- true if the batched events should actually be output as well as processed, false if they should just be processed</param> /// <param name="forceUpdate">- true if output should be made even when no updating events have arrived</param> protected void ContinueOutputProcessingJoin(bool doOutput, bool forceUpdate) { if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().QOutputRateConditionOutputNow(); } if ((ExecutionPathDebugLog.IsEnabled) && (Log.IsDebugEnabled)) { Log.Debug(".continueOutputProcessingJoin"); } bool isGenerateSynthetic = _parent.StatementResultService.IsMakeSynthetic; bool isGenerateNatural = _parent.StatementResultService.IsMakeNatural; // Process the events and get the result UniformPair <EventBean[]> newOldEvents = ResultSetProcessor.ProcessOutputLimitedJoin( _deltaSet.JoinEventsSet, isGenerateSynthetic, _parent.OutputLimitLimitType); if (_parent.IsDistinct && newOldEvents != null) { newOldEvents.First = EventBeanUtility.GetDistinctByProp(newOldEvents.First, _parent.EventBeanReader); newOldEvents.Second = EventBeanUtility.GetDistinctByProp(newOldEvents.Second, _parent.EventBeanReader); } if ((!isGenerateSynthetic) && (!isGenerateNatural)) { if (AuditPath.IsAuditEnabled) { OutputStrategyUtil.IndicateEarlyReturn(_parent.StatementContext, newOldEvents); } ResetEventBatches(); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().AOutputRateConditionOutputNow(false); } return; } if (doOutput) { Output(forceUpdate, newOldEvents); } ResetEventBatches(); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().AOutputRateConditionOutputNow(true); } }
public UniformPair<EventBean[]> OutputJoin(bool isSynthesize) { if (outputLastIStreamBufJoin == null && outputLastRStreamBufJoin == null) { return null; } var pair = processor.ProcessJoinResult( EventBeanUtility.ToSingletonSetIfNotNull(outputLastIStreamBufJoin), EventBeanUtility.ToSingletonSetIfNotNull(outputLastRStreamBufJoin), isSynthesize); outputLastIStreamBufJoin = null; outputLastRStreamBufJoin = null; return pair; }
/// <summary> /// Ctor. /// </summary> /// <param name="streamNum">the stream number that is indexed</param> /// <param name="eventType">types of events indexed</param> /// <param name="propertyName">Name of the property.</param> /// <param name="unique">if set to <c>true</c> [unique].</param> /// <param name="optionalIndexName">Name of the optional index.</param> public PropertyIndexedEventTableSingleFactory( int streamNum, EventType eventType, String propertyName, bool unique, String optionalIndexName) { StreamNum = streamNum; PropertyName = propertyName; Unique = unique; OptionalIndexName = optionalIndexName; // Init getters PropertyGetter = EventBeanUtility.GetAssertPropertyGetter(eventType, propertyName); }