public override void Update(EventBean[] newData, EventBean[] oldData)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QSubselectAggregation(null);
}
if (newData != null)
{
foreach (EventBean theEvent in newData)
{
EventsPerStream[0] = theEvent;
AggregationService.ApplyEnter(EventsPerStream, null, ExprEvaluatorContext);
}
}
if (oldData != null)
{
foreach (EventBean theEvent in oldData)
{
EventsPerStream[0] = theEvent;
AggregationService.ApplyLeave(EventsPerStream, null, ExprEvaluatorContext);
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().ASubselectAggregation();
}
}
/// <summary>
/// NOTE: Code-generation-invoked method, method name and parameter order matters
/// </summary>
/// <param name="aggregationService">aggs</param>
/// <param name="agentInstanceContext">ctx</param>
/// <param name="newEvents">new data</param>
/// <param name="newDataMultiKey">new data keys</param>
/// <param name="oldEvents">old data</param>
/// <param name="oldDataMultiKey">old data keys</param>
public static void ApplyAggJoinResultKeyedJoin(
AggregationService aggregationService,
AgentInstanceContext agentInstanceContext,
ISet<MultiKeyArrayOfKeys<EventBean>> newEvents,
object[] newDataMultiKey,
ISet<MultiKeyArrayOfKeys<EventBean>> oldEvents,
object[] oldDataMultiKey)
{
// update aggregates
if (!newEvents.IsEmpty()) {
// apply old data to aggregates
var count = 0;
foreach (var eventsPerStream in newEvents) {
aggregationService.ApplyEnter(eventsPerStream.Array, newDataMultiKey[count], agentInstanceContext);
count++;
}
}
if (oldEvents != null && !oldEvents.IsEmpty()) {
// apply old data to aggregates
var count = 0;
foreach (var eventsPerStream in oldEvents) {
aggregationService.ApplyLeave(eventsPerStream.Array, oldDataMultiKey[count], agentInstanceContext);
count++;
}
}
}
public override void ApplyViewResult(EventBean[] newData, EventBean[] oldData)
{
var eventsPerStream = new EventBean[1];
if (newData != null)
{
var groupReps = _groupReps;
var newDataLength = newData.Length;
for (var ii = 0; ii < newDataLength; ii++)
{
eventsPerStream[0] = newData[ii];
var mk = GenerateGroupKey(eventsPerStream, true);
groupReps.Put(mk, eventsPerStream[0]);
AggregationService.ApplyEnter(eventsPerStream, mk, AgentInstanceContext);
}
}
if (oldData != null)
{
var oldDataLength = oldData.Length;
for (var ii = 0; ii < oldDataLength; ii++)
{
eventsPerStream[0] = oldData[ii];
var mk = GenerateGroupKey(eventsPerStream, false);
AggregationService.ApplyLeave(eventsPerStream, mk, AgentInstanceContext);
}
}
}
public override void Evaluate(
EventBean[] eventsPerStream,
ICollection <EventBean> matchingEvents,
ExprEvaluatorContext exprEvaluatorContext)
{
AggregationService.ClearResults(exprEvaluatorContext);
if (matchingEvents == null)
{
return;
}
var events = new EventBean[eventsPerStream.Length + 1];
Array.Copy(eventsPerStream, 0, events, 1, eventsPerStream.Length);
var evaluateParams = new EvaluateParams(events, true, exprEvaluatorContext);
foreach (EventBean subselectEvent in matchingEvents)
{
events[0] = subselectEvent;
var pass = (bool?)FilterExpr.Evaluate(evaluateParams);
if (pass ?? false)
{
AggregationService.ApplyEnter(events, null, exprEvaluatorContext);
}
}
}
/// <summary>
/// NOTE: Code-generation-invoked method, method name and parameter order matters
/// </summary>
/// <param name="aggregationService">aggs</param>
/// <param name="agentInstanceContext">ctx</param>
/// <param name="newData">new data</param>
/// <param name="newDataMultiKey">new data keys</param>
/// <param name="oldData">old data</param>
/// <param name="oldDataMultiKey">old data keys</param>
/// <param name="eventsPerStream">event buffer, transient buffer</param>
public static void ApplyAggViewResultKeyedView(
AggregationService aggregationService,
AgentInstanceContext agentInstanceContext,
EventBean[] newData,
object[] newDataMultiKey,
EventBean[] oldData,
object[] oldDataMultiKey,
EventBean[] eventsPerStream)
{
// update aggregates
if (newData != null) {
// apply new data to aggregates
for (var i = 0; i < newData.Length; i++) {
eventsPerStream[0] = newData[i];
aggregationService.ApplyEnter(eventsPerStream, newDataMultiKey[i], agentInstanceContext);
}
}
if (oldData != null) {
// apply old data to aggregates
for (var i = 0; i < oldData.Length; i++) {
eventsPerStream[0] = oldData[i];
aggregationService.ApplyLeave(eventsPerStream, oldDataMultiKey[i], agentInstanceContext);
}
}
}
public override void ApplyViewResult(EventBean[] newData, EventBean[] oldData)
{
var newDataMultiKey = GenerateGroupKeysView(newData, EventPerGroupBuf, true);
var oldDataMultiKey = GenerateGroupKeysView(oldData, EventPerGroupBuf, false);
// update aggregates
var eventsPerStream = new EventBean[1];
if (newData != null)
{
for (var i = 0; i < newData.Length; i++)
{
eventsPerStream[0] = newData[i];
AggregationService.ApplyEnter(eventsPerStream, newDataMultiKey[i], AgentInstanceContext);
}
}
if (oldData != null)
{
for (var i = 0; i < oldData.Length; i++)
{
eventsPerStream[0] = oldData[i];
AggregationService.ApplyLeave(eventsPerStream, oldDataMultiKey[i], AgentInstanceContext);
}
}
}
public static void ApplyAggViewResult(
AggregationService aggregationService,
ExprEvaluatorContext exprEvaluatorContext,
EventBean[] newData,
EventBean[] oldData,
EventBean[] eventsPerStream)
{
if (newData != null)
{
// apply new data to aggregates
for (int i = 0; i < newData.Length; i++)
{
eventsPerStream[0] = newData[i];
aggregationService.ApplyEnter(eventsPerStream, null, exprEvaluatorContext);
}
}
if (oldData != null)
{
// apply old data to aggregates
for (int i = 0; i < oldData.Length; i++)
{
eventsPerStream[0] = oldData[i];
aggregationService.ApplyLeave(eventsPerStream, null, exprEvaluatorContext);
}
}
}
public void ApplyEnter(
EventBean[] eventsPerStream,
Object optionalGroupKeyPerRow,
ExprEvaluatorContext exprEvaluatorContext)
{
_service.ApplyEnter(eventsPerStream, optionalGroupKeyPerRow, exprEvaluatorContext);
}
public override void Evaluate(
EventBean[] eventsPerStream,
ICollection<EventBean> matchingEvents,
ExprEvaluatorContext exprEvaluatorContext)
{
AggregationService.ClearResults(exprEvaluatorContext);
if (matchingEvents == null)
{
return;
}
var events = new EventBean[eventsPerStream.Length + 1];
Array.Copy(eventsPerStream, 0, events, 1, eventsPerStream.Length);
var evaluateParams = new EvaluateParams(events, true, exprEvaluatorContext);
foreach (EventBean subselectEvent in matchingEvents)
{
events[0] = subselectEvent;
var pass = FilterEval.Evaluate(evaluateParams);
if (true.Equals(pass))
{
Object groupKey = GenerateGroupKey(events, true, exprEvaluatorContext);
AggregationService.ApplyEnter(events, groupKey, exprEvaluatorContext);
}
}
}
public override UniformPair <EventBean[]> ProcessViewResult(EventBean[] newData, EventBean[] oldData, bool isSynthesize)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QResultSetProcessGroupedRowPerGroup();
}
var newDataMultiKey = GenerateGroupKeysView(newData, EventPerGroupBuf, true);
var oldDataMultiKey = GenerateGroupKeysView(oldData, EventPerGroupBuf, false);
EventBean[] selectOldEvents = null;
if (Prototype.IsSelectRStream)
{
selectOldEvents = GenerateOutputEventsView(EventPerGroupBuf, false, isSynthesize);
}
// update aggregates
var eventsPerStream = new EventBean[1];
if (newData != null)
{
for (var i = 0; i < newData.Length; i++)
{
eventsPerStream[0] = newData[i];
AggregationService.ApplyEnter(eventsPerStream, newDataMultiKey[i], AgentInstanceContext);
}
}
if (oldData != null)
{
for (var i = 0; i < oldData.Length; i++)
{
eventsPerStream[0] = oldData[i];
AggregationService.ApplyLeave(eventsPerStream, oldDataMultiKey[i], AgentInstanceContext);
}
}
// generate new events using select expressions
var selectNewEvents = GenerateOutputEventsView(EventPerGroupBuf, true, isSynthesize);
if ((selectNewEvents != null) || (selectOldEvents != null))
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AResultSetProcessGroupedRowPerGroup(selectNewEvents, selectOldEvents);
}
return(new UniformPair <EventBean[]>(selectNewEvents, selectOldEvents));
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AResultSetProcessGroupedRowPerGroup(null, null);
}
return(null);
}
public static void ClearAndAggregateUngrouped(ExprEvaluatorContext exprEvaluatorContext, AggregationService aggregationService, Viewable parent)
{
aggregationService.ClearResults(exprEvaluatorContext);
var ee = parent.GetEnumerator();
var eventsPerStream = new EventBean[1];
while (ee.MoveNext())
{
eventsPerStream[0] = ee.Current;
aggregationService.ApplyEnter(eventsPerStream, null, exprEvaluatorContext);
}
}
public override UniformPair <EventBean[]> ProcessViewResult(EventBean[] newData, EventBean[] oldData, bool isSynthesize)
{
// Generate group-by keys for all events, collect all keys in a set for later event generation
IDictionary <Object, EventBean> keysAndEvents = new Dictionary <Object, EventBean>();
var newDataMultiKey = GenerateGroupKeys(newData, keysAndEvents, true);
var oldDataMultiKey = GenerateGroupKeys(oldData, keysAndEvents, false);
EventBean[] selectOldEvents = null;
if (Prototype.IsSelectRStream)
{
selectOldEvents = GenerateOutputEventsView(keysAndEvents, false, isSynthesize);
}
// update aggregates
var eventsPerStream = new EventBean[1];
if (newData != null)
{
// apply new data to aggregates
for (var i = 0; i < newData.Length; i++)
{
eventsPerStream[0] = newData[i];
_groupReps.Put(newDataMultiKey[i], eventsPerStream[0]);
AggregationService.ApplyEnter(eventsPerStream, newDataMultiKey[i], AgentInstanceContext);
}
}
if (oldData != null)
{
// apply old data to aggregates
for (var i = 0; i < oldData.Length; i++)
{
eventsPerStream[0] = oldData[i];
AggregationService.ApplyLeave(eventsPerStream, oldDataMultiKey[i], AgentInstanceContext);
}
}
// generate new events using select expressions
var selectNewEvents = GenerateOutputEventsView(keysAndEvents, true, isSynthesize);
if ((selectNewEvents != null) || (selectOldEvents != null))
{
return(new UniformPair <EventBean[]>(selectNewEvents, selectOldEvents));
}
return(null);
}
public override void Update(EventBean[] newData, EventBean[] oldData)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewProcessIRStream(this, _dataWindowViewFactory.ViewName, newData, oldData);
}
// add data points to the window
if (newData != null)
{
foreach (EventBean newEvent in newData)
{
var pair = new ExpressionWindowTimestampEventPair(AgentInstanceContext.TimeProvider.Time, newEvent);
_window.Add(pair);
InternalHandleAdd(pair);
}
if (AggregationService != null)
{
AggregationService.ApplyEnter(newData, null, AgentInstanceContext);
}
}
if (oldData != null)
{
_window.RemoveWhere(
pair => oldData.Any(anOldData => pair.TheEvent == anOldData),
pair => InternalHandleRemoved(pair));
if (AggregationService != null)
{
AggregationService.ApplyLeave(oldData, null, AgentInstanceContext);
}
}
// expire events
Expire(newData, oldData);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewProcessIRStream();
}
}
public override void Update(EventBean[] newData, EventBean[] oldData)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QSubselectAggregation(_filterExprNode);
}
if (newData != null)
{
foreach (EventBean theEvent in newData)
{
EventsPerStream[0] = theEvent;
bool isPass = Filter(true);
if (isPass)
{
Object groupKey = GenerateGroupKey(true);
AggregationService.ApplyEnter(EventsPerStream, groupKey, ExprEvaluatorContext);
}
}
}
if (oldData != null)
{
foreach (EventBean theEvent in oldData)
{
EventsPerStream[0] = theEvent;
bool isPass = Filter(false);
if (isPass)
{
Object groupKey = GenerateGroupKey(false);
AggregationService.ApplyLeave(EventsPerStream, groupKey, ExprEvaluatorContext);
}
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().ASubselectAggregation();
}
}
public static void ApplyAggJoinResult(
AggregationService aggregationService,
ExprEvaluatorContext exprEvaluatorContext,
ISet <MultiKey <EventBean> > newEvents,
ISet <MultiKey <EventBean> > oldEvents)
{
if (!newEvents.IsEmpty())
{
// apply new data to aggregates
foreach (MultiKey <EventBean> events in newEvents)
{
aggregationService.ApplyEnter(events.Array, null, exprEvaluatorContext);
}
}
if (!oldEvents.IsEmpty())
{
// apply old data to aggregates
foreach (MultiKey <EventBean> events in oldEvents)
{
aggregationService.ApplyLeave(events.Array, null, exprEvaluatorContext);
}
}
}
public override void Update(EventBean[] newData, EventBean[] oldData)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewProcessIRStream(this, _dataWindowViewFactory.ViewName, newData, oldData);
}
bool fireBatch = false;
// remove points from data window
if (oldData != null)
{
foreach (EventBean anOldData in oldData)
{
Window.Remove(anOldData);
}
if (AggregationService != null)
{
AggregationService.ApplyLeave(oldData, null, AgentInstanceContext);
}
if (Window.IsNotEmpty())
{
OldestEvent = Window.First();
}
else
{
OldestEvent = null;
}
fireBatch = EvaluateExpression(null, Window.Count);
}
// add data points to the window
int numEventsInBatch = -1;
if (newData != null && newData.Length > 0)
{
if (Window.IsEmpty())
{
OldestEventTimestamp = AgentInstanceContext.StatementContext.SchedulingService.Time;
}
NewestEventTimestamp = AgentInstanceContext.StatementContext.SchedulingService.Time;
if (OldestEvent == null)
{
OldestEvent = newData[0];
}
foreach (EventBean newEvent in newData)
{
Window.Add(newEvent);
if (AggregationService != null)
{
AggregationService.ApplyEnter(new EventBean[] { newEvent }, null, AgentInstanceContext);
}
NewestEvent = newEvent;
if (!fireBatch)
{
fireBatch = EvaluateExpression(newEvent, Window.Count);
if (fireBatch && !_dataWindowViewFactory.IsIncludeTriggeringEvent)
{
numEventsInBatch = Window.Count - 1;
}
}
}
}
// may fire the batch
if (fireBatch)
{
Expire(numEventsInBatch);
}
else
{
if (newData != null)
{
Window.AddAll(newData);
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewProcessIRStream();
}
}
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)
{
var newData = pair.First;
var oldData = pair.Second;
if (_prototype.IsUnidirectional)
{
Clear();
}
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);
}
}
// generate old events using select expressions
if (_prototype.IsSelectRStream)
{
if (_prototype.OptionalHavingNode == null)
{
if (_orderByProcessor == null)
{
ResultSetProcessorUtil.PopulateSelectJoinEventsNoHaving(_selectExprProcessor, oldData, false, generateSynthetic, oldEvents, _exprEvaluatorContext);
}
else
{
ResultSetProcessorUtil.PopulateSelectJoinEventsNoHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, oldData, false, generateSynthetic, oldEvents, oldEventsSortKey, _exprEvaluatorContext);
}
}
// generate old events using having then select
else
{
if (_orderByProcessor == null)
{
ResultSetProcessorUtil.PopulateSelectJoinEventsHaving(_selectExprProcessor, oldData, _prototype.OptionalHavingNode, false, generateSynthetic, oldEvents, _exprEvaluatorContext);
}
else
{
ResultSetProcessorUtil.PopulateSelectJoinEventsHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, oldData, _prototype.OptionalHavingNode, false, generateSynthetic, oldEvents, oldEventsSortKey, _exprEvaluatorContext);
}
}
}
// generate new events using select expressions
if (_prototype.OptionalHavingNode == null)
{
if (_orderByProcessor == null)
{
ResultSetProcessorUtil.PopulateSelectJoinEventsNoHaving(_selectExprProcessor, newData, true, generateSynthetic, newEvents, _exprEvaluatorContext);
}
else
{
ResultSetProcessorUtil.PopulateSelectJoinEventsNoHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, newData, true, generateSynthetic, newEvents, newEventsSortKey, _exprEvaluatorContext);
}
}
else
{
if (_orderByProcessor == null)
{
ResultSetProcessorUtil.PopulateSelectJoinEventsHaving(_selectExprProcessor, newData, _prototype.OptionalHavingNode, true, generateSynthetic, newEvents, _exprEvaluatorContext);
}
else
{
ResultSetProcessorUtil.PopulateSelectJoinEventsHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, newData, _prototype.OptionalHavingNode, true, generateSynthetic, newEvents, newEventsSortKey, _exprEvaluatorContext);
}
}
}
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 ((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));
}
}
public UniformPair <EventBean[]> ProcessOutputLimitedJoin(IList <UniformPair <ISet <MultiKey <EventBean> > > > joinEventsSet, bool generateSynthetic, OutputLimitLimitType outputLimitLimitType)
{
if (outputLimitLimitType == OutputLimitLimitType.LAST)
{
EventBean lastOldEvent = null;
EventBean lastNewEvent = null;
foreach (UniformPair <ISet <MultiKey <EventBean> > > pair in joinEventsSet)
{
ICollection <MultiKey <EventBean> > newData = pair.First;
ICollection <MultiKey <EventBean> > oldData = pair.Second;
if (_prototype.IsUnidirectional)
{
Clear();
}
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);
}
}
EventBean[] selectOldEvents;
if (_prototype.IsSelectRStream)
{
if (_prototype.OptionalHavingNode == null)
{
selectOldEvents = ResultSetProcessorUtil.GetSelectJoinEventsNoHaving(_selectExprProcessor, oldData, false, generateSynthetic, _exprEvaluatorContext);
}
else
{
selectOldEvents = ResultSetProcessorUtil.GetSelectJoinEventsHaving(_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.GetSelectJoinEventsNoHaving(_selectExprProcessor, newData, true, generateSynthetic, _exprEvaluatorContext);
}
else
{
selectNewEvents = ResultSetProcessorUtil.GetSelectJoinEventsHaving(_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
{
IList <EventBean> newEvents = new List <EventBean>();
IList <EventBean> oldEvents = null;
if (_prototype.IsSelectRStream)
{
oldEvents = new List <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)
{
ICollection <MultiKey <EventBean> > newData = pair.First;
ICollection <MultiKey <EventBean> > oldData = pair.Second;
if (_prototype.IsUnidirectional)
{
Clear();
}
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);
}
}
// generate old events using select expressions
if (_prototype.IsSelectRStream)
{
if (_prototype.OptionalHavingNode == null)
{
if (_orderByProcessor == null)
{
ResultSetProcessorUtil.PopulateSelectJoinEventsNoHaving(_selectExprProcessor, oldData, false, generateSynthetic, oldEvents, _exprEvaluatorContext);
}
else
{
ResultSetProcessorUtil.PopulateSelectJoinEventsNoHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, oldData, false, generateSynthetic, oldEvents, oldEventsSortKey, _exprEvaluatorContext);
}
}
// generate old events using having then select
else
{
if (_orderByProcessor == null)
{
ResultSetProcessorUtil.PopulateSelectJoinEventsHaving(_selectExprProcessor, oldData, _prototype.OptionalHavingNode, false, generateSynthetic, oldEvents, _exprEvaluatorContext);
}
else
{
ResultSetProcessorUtil.PopulateSelectJoinEventsHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, oldData, _prototype.OptionalHavingNode, false, generateSynthetic, oldEvents, oldEventsSortKey, _exprEvaluatorContext);
}
}
}
// generate new events using select expressions
if (_prototype.OptionalHavingNode == null)
{
if (_orderByProcessor == null)
{
ResultSetProcessorUtil.PopulateSelectJoinEventsNoHaving(_selectExprProcessor, newData, true, generateSynthetic, newEvents, _exprEvaluatorContext);
}
else
{
ResultSetProcessorUtil.PopulateSelectJoinEventsNoHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, newData, true, generateSynthetic, newEvents, newEventsSortKey, _exprEvaluatorContext);
}
}
else
{
if (_orderByProcessor == null)
{
ResultSetProcessorUtil.PopulateSelectJoinEventsHaving(_selectExprProcessor, newData, _prototype.OptionalHavingNode, true, generateSynthetic, newEvents, _exprEvaluatorContext);
}
else
{
ResultSetProcessorUtil.PopulateSelectJoinEventsHavingWithOrderBy(_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));
}
}
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));
}
