public IEnumerator <EventBean> ObtainEnumerator(Viewable parent) { if (_orderByProcessor == null) { return(ResultSetAggregateAllEnumerator.New(parent, this, _exprEvaluatorContext)); } // Pull all parent events, generate order keys var eventsPerStream = new EventBean[1]; var outgoingEvents = new List <EventBean>(); var orderKeys = new List <object>(); var evaluateParams = new EvaluateParams(eventsPerStream, true, _exprEvaluatorContext); foreach (var candidate in parent) { eventsPerStream[0] = candidate; object pass = true; if (_prototype.OptionalHavingNode != null) { pass = _prototype.OptionalHavingNode.Evaluate(evaluateParams); } if ((pass == null) || (false.Equals(pass))) { continue; } outgoingEvents.Add(_selectExprProcessor.Process(eventsPerStream, true, true, _exprEvaluatorContext)); var orderKey = _orderByProcessor.GetSortKey(eventsPerStream, true, _exprEvaluatorContext); orderKeys.Add(orderKey); } // sort var outgoingEventsArr = outgoingEvents.ToArray(); var orderKeysArr = orderKeys.ToArray(); var orderedEvents = _orderByProcessor.Sort(outgoingEventsArr, orderKeysArr, _exprEvaluatorContext) ?? EMPTY_EVENT_BEAN_LIST; return(orderedEvents.GetEnumerator()); }
public IEnumerator <EventBean> ObtainIterator(Viewable parent) { if (_orderByProcessor == null) { return(ResultSetAggregateAllEnumerator.New(parent, this, _exprEvaluatorContext)); } // Pull all parent events, generate order keys EventBean[] eventsPerStream = new EventBean[1]; IList <EventBean> outgoingEvents = new List <EventBean>(); IList <Object> orderKeys = new List <Object>(); var evaluateParams = new EvaluateParams(eventsPerStream, true, _exprEvaluatorContext); foreach (EventBean candidate in parent) { eventsPerStream[0] = candidate; bool?pass = true; if (_prototype.OptionalHavingNode != null) { pass = (bool?)_prototype.OptionalHavingNode.Evaluate(evaluateParams); } if ((pass == null) || (!pass.Value)) { continue; } outgoingEvents.Add(_selectExprProcessor.Process(eventsPerStream, true, true, _exprEvaluatorContext)); Object orderKey = _orderByProcessor.GetSortKey(eventsPerStream, true, _exprEvaluatorContext); orderKeys.Add(orderKey); } // sort EventBean[] outgoingEventsArr = outgoingEvents.ToArray(); Object[] orderKeysArr = orderKeys.ToArray(); EventBean[] orderedEvents = _orderByProcessor.Sort(outgoingEventsArr, orderKeysArr, _exprEvaluatorContext); return(((IEnumerable <EventBean>)orderedEvents).GetEnumerator()); }
/// <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[] GetSelectEventsHavingWithOrderBy(SelectExprProcessor exprProcessor, OrderByProcessor orderByProcessor, EventBean[] events, ExprEvaluator havingNode, bool isNewData, bool isSynthesize, ExprEvaluatorContext exprEvaluatorContext) { if (events == null) { return(null); } ArrayDeque <EventBean> result = null; ArrayDeque <EventBean[]> eventGenerators = 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); eventGenerators = new ArrayDeque <EventBean[]>(events.Length); } result.Add(generated); eventGenerators.Add(new EventBean[] { theEvent }); } } if (result != null) { return(orderByProcessor.Sort(result.ToArray(), eventGenerators.ToArray(), isNewData, exprEvaluatorContext)); } return(null); }
/// <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 override IEnumerator <EventBean> GetEnumerator(Viewable parent) { if (_orderByProcessor != null) { // Pull all events, generate order keys var eventsPerStream = new EventBean[1]; var events = new List <EventBean>(); var orderKeys = new List <Object>(); var parentEnumerator = parent.GetEnumerator(); if (parentEnumerator.MoveNext() == false) { return(CollectionUtil.NULL_EVENT_ITERATOR); } do { var aParent = parentEnumerator.Current; eventsPerStream[0] = aParent; var orderKey = _orderByProcessor.GetSortKey(eventsPerStream, true, ExprEvaluatorContext); var pair = ProcessViewResultIterator(eventsPerStream); var result = pair.First; if (result != null && result.Length != 0) { events.Add(result[0]); } orderKeys.Add(orderKey); } while (parentEnumerator.MoveNext()); // sort var outgoingEvents = events.ToArray(); var orderKeysArr = orderKeys.ToArray(); var orderedEvents = _orderByProcessor.Sort(outgoingEvents, orderKeysArr, ExprEvaluatorContext); if (orderedEvents == null) { return(EnumerationHelper <EventBean> .CreateEmptyEnumerator()); } return(((IEnumerable <EventBean>)orderedEvents).GetEnumerator()); } // Return an iterator that gives row-by-row a result var transform = new ResultSetProcessorSimpleTransform(this); return(parent.Select(transform.Transform).GetEnumerator()); }
/// <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="orderByProcessor">orders the outgoing events according to the order-by clause</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[] GetSelectEventsNoHavingWithOrderBy(SelectExprProcessor exprProcessor, OrderByProcessor orderByProcessor, EventBean[] events, bool isNewData, bool isSynthesize, ExprEvaluatorContext exprEvaluatorContext) { if (events == null) { return(null); } var result = new EventBean[events.Length]; var eventGenerators = 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); eventGenerators[i] = new EventBean[] { events[i] }; } return(orderByProcessor.Sort(result, eventGenerators, isNewData, exprEvaluatorContext)); }
/// <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="orderByProcessor">for sorting output events according to the order-by clause</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[] GetSelectJoinEventsNoHavingWithOrderBy(SelectExprProcessor exprProcessor, OrderByProcessor orderByProcessor, ICollection <MultiKey <EventBean> > events, bool isNewData, bool isSynthesize, ExprEvaluatorContext exprEvaluatorContext) { if ((events == null) || (events.IsEmpty())) { return(null); } var result = new EventBean[events.Count]; var eventGenerators = new EventBean[events.Count][]; var count = 0; foreach (var key in events) { var eventsPerStream = key.Array; result[count] = exprProcessor.Process(eventsPerStream, isNewData, isSynthesize, exprEvaluatorContext); eventGenerators[count] = eventsPerStream; count++; } return(orderByProcessor.Sort(result, eventGenerators, isNewData, exprEvaluatorContext)); }
private UniformPair <EventBean[]> ProcessOutputLimitedJoinDefault(IList <UniformPair <ISet <MultiKey <EventBean> > > > joinEventsSet, bool generateSynthetic) { IList <EventBean> newEvents = new List <EventBean>(); IList <EventBean> oldEvents = null; if (_prototype.IsSelectRStream) { oldEvents = new List <EventBean>(); } IList <object> newEventsSortKey = null; IList <object> oldEventsSortKey = null; if (_orderByProcessor != null) { newEventsSortKey = new List <object>(); if (_prototype.IsSelectRStream) { oldEventsSortKey = new List <object>(); } } foreach (var pair in joinEventsSet) { if (_prototype.IsUnidirectional) { Clear(); } var newData = pair.First; var oldData = pair.Second; if (_prototype.IsSelectRStream) { GetSelectListEvent(false, generateSynthetic, oldEvents, true); } if (newData != null) { // apply new data to aggregates foreach (var row in newData) { _aggregationService.ApplyEnter(row.Array, null, _exprEvaluatorContext); } } if (oldData != null) { // apply old data to aggregates foreach (var row in oldData) { _aggregationService.ApplyLeave(row.Array, null, _exprEvaluatorContext); } } GetSelectListEvent(false, generateSynthetic, newEvents, true); } var newEventsArr = (newEvents.IsEmpty()) ? null : newEvents.ToArray(); EventBean[] oldEventsArr = null; if (_prototype.IsSelectRStream) { oldEventsArr = (oldEvents.IsEmpty()) ? null : oldEvents.ToArray(); } if (_orderByProcessor != null) { var sortKeysNew = (newEventsSortKey.IsEmpty()) ? null : newEventsSortKey.ToArray(); newEventsArr = _orderByProcessor.Sort(newEventsArr, sortKeysNew, _exprEvaluatorContext); if (_prototype.IsSelectRStream) { var sortKeysOld = (oldEventsSortKey.IsEmpty()) ? null : oldEventsSortKey.ToArray(); oldEventsArr = _orderByProcessor.Sort(oldEventsArr, sortKeysOld, _exprEvaluatorContext); } } if (joinEventsSet.IsEmpty()) { if (_prototype.IsSelectRStream) { oldEventsArr = GetSelectListEvents(false, generateSynthetic, true); } newEventsArr = GetSelectListEvents(true, generateSynthetic, true); } if ((newEventsArr == null) && (oldEventsArr == null)) { return(null); } return(new UniformPair <EventBean[]>(newEventsArr, oldEventsArr)); }
public UniformPair <EventBean[]> ProcessOutputLimitedJoin(IList <UniformPair <ISet <MultiKey <EventBean> > > > joinEventsSet, bool generateSynthetic, OutputLimitLimitType outputLimitLimitType) { if (outputLimitLimitType == OutputLimitLimitType.LAST) { EventBean lastOldEvent = null; EventBean lastNewEvent = null; // if empty (nothing to post) if (joinEventsSet.IsEmpty()) { if (Prototype.IsSelectRStream) { lastOldEvent = GetSelectListEvent(false, generateSynthetic, true); lastNewEvent = lastOldEvent; } else { lastNewEvent = GetSelectListEvent(false, generateSynthetic, true); } } foreach (UniformPair <ISet <MultiKey <EventBean> > > pair in joinEventsSet) { if (Prototype.IsUnidirectional) { Clear(); } ICollection <MultiKey <EventBean> > newData = pair.First; ICollection <MultiKey <EventBean> > oldData = pair.Second; if ((lastOldEvent == null) && (Prototype.IsSelectRStream)) { lastOldEvent = GetSelectListEvent(false, generateSynthetic, true); } if (newData != null) { // apply new data to aggregates foreach (MultiKey <EventBean> eventsPerStream in newData) { AggregationService.ApplyEnter(eventsPerStream.Array, null, ExprEvaluatorContext); } } if (oldData != null) { // apply old data to aggregates foreach (MultiKey <EventBean> eventsPerStream in oldData) { AggregationService.ApplyLeave(eventsPerStream.Array, null, ExprEvaluatorContext); } } lastNewEvent = GetSelectListEvent(true, generateSynthetic, true); } EventBean[] lastNew = (lastNewEvent != null) ? new EventBean[] { lastNewEvent } : null; EventBean[] lastOld = (lastOldEvent != null) ? new EventBean[] { lastOldEvent } : null; if ((lastNew == null) && (lastOld == null)) { return(null); } return(new UniformPair <EventBean[]>(lastNew, lastOld)); } else { ICollection <EventBean> newEvents = new List <EventBean>(); ICollection <EventBean> oldEvents = null; if (Prototype.IsSelectRStream) { oldEvents = new LinkedList <EventBean>(); } ICollection <Object> newEventsSortKey = null; ICollection <Object> oldEventsSortKey = null; if (_orderByProcessor != null) { newEventsSortKey = new LinkedList <Object>(); if (Prototype.IsSelectRStream) { oldEventsSortKey = new LinkedList <Object>(); } } foreach (UniformPair <ISet <MultiKey <EventBean> > > pair in joinEventsSet) { if (Prototype.IsUnidirectional) { Clear(); } ICollection <MultiKey <EventBean> > newData = pair.First; ICollection <MultiKey <EventBean> > oldData = pair.Second; if (Prototype.IsSelectRStream) { GetSelectListEvent(false, generateSynthetic, oldEvents, true); } if (newData != null) { // apply new data to aggregates foreach (MultiKey <EventBean> row in newData) { AggregationService.ApplyEnter(row.Array, null, ExprEvaluatorContext); } } if (oldData != null) { // apply old data to aggregates foreach (MultiKey <EventBean> row in oldData) { AggregationService.ApplyLeave(row.Array, null, ExprEvaluatorContext); } } GetSelectListEvent(false, generateSynthetic, newEvents, true); } EventBean[] newEventsArr = (newEvents.IsEmpty()) ? null : newEvents.ToArray(); EventBean[] oldEventsArr = null; if (Prototype.IsSelectRStream) { oldEventsArr = (oldEvents.IsEmpty()) ? null : oldEvents.ToArray(); } if (_orderByProcessor != null) { Object[] sortKeysNew = (newEventsSortKey.IsEmpty()) ? null : newEventsSortKey.ToArray(); newEventsArr = _orderByProcessor.Sort(newEventsArr, sortKeysNew, ExprEvaluatorContext); if (Prototype.IsSelectRStream) { Object[] sortKeysOld = (oldEventsSortKey.IsEmpty()) ? null : oldEventsSortKey.ToArray(); oldEventsArr = _orderByProcessor.Sort(oldEventsArr, sortKeysOld, ExprEvaluatorContext); } } if (joinEventsSet.IsEmpty()) { if (Prototype.IsSelectRStream) { oldEventsArr = GetSelectListEvents(false, generateSynthetic, true); } newEventsArr = GetSelectListEvents(true, generateSynthetic, true); } if ((newEventsArr == null) && (oldEventsArr == null)) { return(null); } return(new UniformPair <EventBean[]>(newEventsArr, oldEventsArr)); } }