/// <summary>Process view results for the iterator. </summary>
/// <param name="newData">new events</param>
/// <returns>pair of insert and remove stream</returns>
public UniformPair <EventBean[]> ProcessViewResultIterator(EventBean[] newData)
{
EventBean[] selectNewEvents;
if (Prototype.OptionalHavingExpr == null)
{
// ignore _orderByProcessor
selectNewEvents = ResultSetProcessorUtil.GetSelectEventsNoHaving(_selectExprProcessor, newData, true, true, ExprEvaluatorContext);
}
else
{
// ignore _orderByProcessor
selectNewEvents = ResultSetProcessorUtil.GetSelectEventsHaving(_selectExprProcessor, newData, Prototype.OptionalHavingExpr, true, true, ExprEvaluatorContext);
}
return(new UniformPair <EventBean[]>(selectNewEvents, null));
}
public override UniformPair <EventBean[]> ProcessViewResult(EventBean[] newData, EventBean[] oldData, bool isSynthesize)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QResultSetProcessSimple();
}
EventBean[] selectOldEvents = null;
EventBean[] selectNewEvents;
if (Prototype.OptionalHavingExpr == null)
{
if (Prototype.IsSelectRStream)
{
if (_orderByProcessor == null)
{
selectOldEvents = ResultSetProcessorUtil.GetSelectEventsNoHaving(_selectExprProcessor, oldData, false, isSynthesize, ExprEvaluatorContext);
}
else
{
selectOldEvents = ResultSetProcessorUtil.GetSelectEventsNoHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, oldData, false, isSynthesize, ExprEvaluatorContext);
}
}
if (_orderByProcessor == null)
{
selectNewEvents = ResultSetProcessorUtil.GetSelectEventsNoHaving(_selectExprProcessor, newData, true, isSynthesize, ExprEvaluatorContext);
}
else
{
selectNewEvents = ResultSetProcessorUtil.GetSelectEventsNoHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, newData, true, isSynthesize, ExprEvaluatorContext);
}
}
else
{
if (Prototype.IsSelectRStream)
{
if (_orderByProcessor == null)
{
selectOldEvents = ResultSetProcessorUtil.GetSelectEventsHaving(_selectExprProcessor, oldData, Prototype.OptionalHavingExpr, false, isSynthesize, ExprEvaluatorContext);
}
else
{
selectOldEvents = ResultSetProcessorUtil.GetSelectEventsHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, oldData, Prototype.OptionalHavingExpr, false, isSynthesize, ExprEvaluatorContext);
}
}
if (_orderByProcessor == null)
{
selectNewEvents = ResultSetProcessorUtil.GetSelectEventsHaving(_selectExprProcessor, newData, Prototype.OptionalHavingExpr, true, isSynthesize, ExprEvaluatorContext);
}
else
{
selectNewEvents = ResultSetProcessorUtil.GetSelectEventsHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, newData, Prototype.OptionalHavingExpr, true, isSynthesize, ExprEvaluatorContext);
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AResultSetProcessSimple(selectNewEvents, selectOldEvents);
}
return(new UniformPair <EventBean[]>(selectNewEvents, selectOldEvents));
}
public UniformPair <EventBean[]> ProcessViewResult(EventBean[] newData, EventBean[] oldData, bool isSynthesize)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QResultSetProcessUngroupedNonfullyAgg();
}
EventBean[] selectOldEvents = null;
EventBean[] selectNewEvents;
var eventsPerStream = new EventBean[1];
ResultSetProcessorUtil.ApplyAggViewResult(_aggregationService, _exprEvaluatorContext, newData, oldData, eventsPerStream);
// generate new events using select expressions
if (_prototype.OptionalHavingNode == null)
{
if (_prototype.IsSelectRStream)
{
if (_orderByProcessor == null)
{
selectOldEvents = ResultSetProcessorUtil.GetSelectEventsNoHaving(_selectExprProcessor, oldData, false, isSynthesize, _exprEvaluatorContext);
}
else
{
selectOldEvents = ResultSetProcessorUtil.GetSelectEventsNoHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, oldData, false, isSynthesize, _exprEvaluatorContext);
}
}
if (_orderByProcessor == null)
{
selectNewEvents = ResultSetProcessorUtil.GetSelectEventsNoHaving(_selectExprProcessor, newData, true, isSynthesize, _exprEvaluatorContext);
}
else
{
selectNewEvents = ResultSetProcessorUtil.GetSelectEventsNoHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, newData, true, isSynthesize, _exprEvaluatorContext);
}
}
else
{
if (_prototype.IsSelectRStream)
{
if (_orderByProcessor == null)
{
selectOldEvents = ResultSetProcessorUtil.GetSelectEventsHaving(_selectExprProcessor, oldData, _prototype.OptionalHavingNode, false, isSynthesize, _exprEvaluatorContext);
}
else
{
selectOldEvents = ResultSetProcessorUtil.GetSelectEventsHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, oldData, _prototype.OptionalHavingNode, false, isSynthesize, _exprEvaluatorContext);
}
}
if (_orderByProcessor == null)
{
selectNewEvents = ResultSetProcessorUtil.GetSelectEventsHaving(_selectExprProcessor, newData, _prototype.OptionalHavingNode, true, isSynthesize, _exprEvaluatorContext);
}
else
{
selectNewEvents = ResultSetProcessorUtil.GetSelectEventsHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, newData, _prototype.OptionalHavingNode, true, isSynthesize, _exprEvaluatorContext);
}
}
if ((selectNewEvents == null) && (selectOldEvents == null))
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AResultSetProcessUngroupedNonfullyAgg(null, null);
}
return(null);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AResultSetProcessUngroupedNonfullyAgg(selectNewEvents, selectOldEvents);
}
return(new UniformPair <EventBean[]>(selectNewEvents, selectOldEvents));
}
private UniformPair <EventBean[]> ProcessOutputLimitedViewLast(IList <UniformPair <EventBean[]> > viewEventsList, bool generateSynthetic)
{
EventBean lastOldEvent = null;
EventBean lastNewEvent = null;
var eventsPerStream = new EventBean[1];
foreach (var pair in viewEventsList)
{
var newData = pair.First;
var oldData = pair.Second;
if (newData != null)
{
// apply new data to aggregates
foreach (var aNewData in newData)
{
eventsPerStream[0] = aNewData;
_aggregationService.ApplyEnter(eventsPerStream, null, _exprEvaluatorContext);
}
}
if (oldData != null)
{
// apply old data to aggregates
foreach (var anOldData in oldData)
{
eventsPerStream[0] = anOldData;
_aggregationService.ApplyLeave(eventsPerStream, null, _exprEvaluatorContext);
}
}
EventBean[] selectOldEvents;
if (_prototype.IsSelectRStream)
{
if (_prototype.OptionalHavingNode == null)
{
selectOldEvents = ResultSetProcessorUtil.GetSelectEventsNoHaving(_selectExprProcessor, oldData, false, generateSynthetic, _exprEvaluatorContext);
}
else
{
selectOldEvents = ResultSetProcessorUtil.GetSelectEventsHaving(_selectExprProcessor, oldData, _prototype.OptionalHavingNode, false, generateSynthetic, _exprEvaluatorContext);
}
if ((selectOldEvents != null) && (selectOldEvents.Length > 0))
{
lastOldEvent = selectOldEvents[selectOldEvents.Length - 1];
}
}
// generate new events using select expressions
EventBean[] selectNewEvents;
if (_prototype.OptionalHavingNode == null)
{
selectNewEvents = ResultSetProcessorUtil.GetSelectEventsNoHaving(_selectExprProcessor, newData, true, generateSynthetic, _exprEvaluatorContext);
}
else
{
selectNewEvents = ResultSetProcessorUtil.GetSelectEventsHaving(_selectExprProcessor, newData, _prototype.OptionalHavingNode, true, generateSynthetic, _exprEvaluatorContext);
}
if ((selectNewEvents != null) && (selectNewEvents.Length > 0))
{
lastNewEvent = selectNewEvents[selectNewEvents.Length - 1];
}
}
var lastNew = (lastNewEvent != null) ? new EventBean[] { lastNewEvent } : null;
var lastOld = (lastOldEvent != null) ? new EventBean[] { lastOldEvent } : null;
if ((lastNew == null) && (lastOld == null))
{
return(null);
}
return(new UniformPair <EventBean[]>(lastNew, lastOld));
}
public UniformPair <EventBean[]> ProcessOutputLimitedView(IList <UniformPair <EventBean[]> > viewEventsList, bool generateSynthetic, OutputLimitLimitType outputLimitLimitType)
{
if (outputLimitLimitType == OutputLimitLimitType.LAST)
{
EventBean lastOldEvent = null;
EventBean lastNewEvent = null;
EventBean[] eventsPerStream = new EventBean[1];
foreach (UniformPair <EventBean[]> pair in viewEventsList)
{
EventBean[] newData = pair.First;
EventBean[] oldData = pair.Second;
if (newData != null)
{
// apply new data to aggregates
foreach (EventBean aNewData in newData)
{
eventsPerStream[0] = aNewData;
_aggregationService.ApplyEnter(eventsPerStream, null, _exprEvaluatorContext);
}
}
if (oldData != null)
{
// apply old data to aggregates
foreach (EventBean anOldData in oldData)
{
eventsPerStream[0] = anOldData;
_aggregationService.ApplyLeave(eventsPerStream, null, _exprEvaluatorContext);
}
}
EventBean[] selectOldEvents;
if (_prototype.IsSelectRStream)
{
if (_prototype.OptionalHavingNode == null)
{
selectOldEvents = ResultSetProcessorUtil.GetSelectEventsNoHaving(_selectExprProcessor, oldData, false, generateSynthetic, _exprEvaluatorContext);
}
else
{
selectOldEvents = ResultSetProcessorUtil.GetSelectEventsHaving(_selectExprProcessor, oldData, _prototype.OptionalHavingNode, false, generateSynthetic, _exprEvaluatorContext);
}
if ((selectOldEvents != null) && (selectOldEvents.Length > 0))
{
lastOldEvent = selectOldEvents[selectOldEvents.Length - 1];
}
}
// generate new events using select expressions
EventBean[] selectNewEvents;
if (_prototype.OptionalHavingNode == null)
{
selectNewEvents = ResultSetProcessorUtil.GetSelectEventsNoHaving(_selectExprProcessor, newData, true, generateSynthetic, _exprEvaluatorContext);
}
else
{
selectNewEvents = ResultSetProcessorUtil.GetSelectEventsHaving(_selectExprProcessor, newData, _prototype.OptionalHavingNode, true, generateSynthetic, _exprEvaluatorContext);
}
if ((selectNewEvents != null) && (selectNewEvents.Length > 0))
{
lastNewEvent = selectNewEvents[selectNewEvents.Length - 1];
}
}
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 <EventBean[]> pair in viewEventsList)
{
EventBean[] newData = pair.First;
EventBean[] oldData = pair.Second;
EventBean[] eventsPerStream = new EventBean[1];
if (newData != null)
{
// apply new data to aggregates
foreach (EventBean aNewData in newData)
{
eventsPerStream[0] = aNewData;
_aggregationService.ApplyEnter(eventsPerStream, null, _exprEvaluatorContext);
}
}
if (oldData != null)
{
// apply old data to aggregates
foreach (EventBean anOldData in oldData)
{
eventsPerStream[0] = anOldData;
_aggregationService.ApplyLeave(eventsPerStream, null, _exprEvaluatorContext);
}
}
// generate old events using select expressions
if (_prototype.IsSelectRStream)
{
if (_prototype.OptionalHavingNode == null)
{
if (_orderByProcessor == null)
{
ResultSetProcessorUtil.PopulateSelectEventsNoHaving(_selectExprProcessor, oldData, false, generateSynthetic, oldEvents, _exprEvaluatorContext);
}
else
{
ResultSetProcessorUtil.PopulateSelectEventsNoHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, oldData, false, generateSynthetic, oldEvents, oldEventsSortKey, _exprEvaluatorContext);
}
}
// generate old events using having then select
else
{
if (_orderByProcessor == null)
{
ResultSetProcessorUtil.PopulateSelectEventsHaving(_selectExprProcessor, oldData, _prototype.OptionalHavingNode, false, generateSynthetic, oldEvents, _exprEvaluatorContext);
}
else
{
ResultSetProcessorUtil.PopulateSelectEventsHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, oldData, _prototype.OptionalHavingNode, false, generateSynthetic, oldEvents, oldEventsSortKey, _exprEvaluatorContext);
}
}
}
// generate new events using select expressions
if (_prototype.OptionalHavingNode == null)
{
if (_orderByProcessor == null)
{
ResultSetProcessorUtil.PopulateSelectEventsNoHaving(_selectExprProcessor, newData, true, generateSynthetic, newEvents, _exprEvaluatorContext);
}
else
{
ResultSetProcessorUtil.PopulateSelectEventsNoHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, newData, true, generateSynthetic, newEvents, newEventsSortKey, _exprEvaluatorContext);
}
}
else
{
if (_orderByProcessor == null)
{
ResultSetProcessorUtil.PopulateSelectEventsHaving(_selectExprProcessor, newData, _prototype.OptionalHavingNode, true, generateSynthetic, newEvents, _exprEvaluatorContext);
}
else
{
ResultSetProcessorUtil.PopulateSelectEventsHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, newData, _prototype.OptionalHavingNode, true, generateSynthetic, newEvents, newEventsSortKey, _exprEvaluatorContext);
}
}
}
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 ((newEventsArr == null) && (oldEventsArr == null))
{
return(null);
}
return(new UniformPair <EventBean[]>(newEventsArr, oldEventsArr));
}
}
