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));
}
}
