public ResultSetProcessor Instantiate(OrderByProcessor orderByProcessor,
AggregationService aggregationService,
AgentInstanceContext agentInstanceContext)
{
return(new ResultSetProcessorAggregateAll(this, _selectExprProcessor, orderByProcessor, aggregationService,
agentInstanceContext));
}
public static Pair<ResultSetProcessor, AggregationService> StartResultSetAndAggregation(
ResultSetProcessorFactoryProvider resultSetProcessorPrototype,
AgentInstanceContext agentInstanceContext,
bool isSubquery,
int? subqueryNumber)
{
AggregationService aggregationService = null;
if (resultSetProcessorPrototype.AggregationServiceFactory != null) {
aggregationService = resultSetProcessorPrototype.AggregationServiceFactory.MakeService(
agentInstanceContext,
null,
isSubquery,
subqueryNumber,
null);
}
OrderByProcessor orderByProcessor = null;
if (resultSetProcessorPrototype.OrderByProcessorFactory != null) {
orderByProcessor = resultSetProcessorPrototype.OrderByProcessorFactory
.Instantiate(agentInstanceContext);
}
var resultSetProcessor = resultSetProcessorPrototype.ResultSetProcessorFactory.Instantiate(
orderByProcessor,
aggregationService,
agentInstanceContext);
return new Pair<ResultSetProcessor, AggregationService>(resultSetProcessor, aggregationService);
}
public static ResultSetProcessor GetAssignResultSetProcessor(AgentInstanceContext agentInstanceContext, ResultSetProcessorFactoryDesc resultSetProcessorPrototype)
{
AggregationService aggregationService = null;
if (resultSetProcessorPrototype.AggregationServiceFactoryDesc != null)
{
aggregationService = resultSetProcessorPrototype.AggregationServiceFactoryDesc.AggregationServiceFactory.MakeService(agentInstanceContext, agentInstanceContext.StatementContext.MethodResolutionService);
}
OrderByProcessor orderByProcessor = null;
if (resultSetProcessorPrototype.OrderByProcessorFactory != null)
{
orderByProcessor = resultSetProcessorPrototype.OrderByProcessorFactory.Instantiate(
aggregationService, agentInstanceContext);
}
var processor = resultSetProcessorPrototype.ResultSetProcessorFactory.Instantiate(orderByProcessor, aggregationService, agentInstanceContext);
// initialize aggregation expression nodes
if (resultSetProcessorPrototype.AggregationServiceFactoryDesc != null)
{
foreach (var aggregation in resultSetProcessorPrototype.AggregationServiceFactoryDesc.Expressions)
{
aggregation.AssignFuture(aggregationService);
}
}
return(processor);
}
public static EventsAndSortKeysPair GetOldEventsSortKeys(
int oldEventCount,
EventArrayAndSortKeyArray rstreamEventSortArrayBuf,
OrderByProcessor orderByProcessor,
AggregationGroupByRollupDesc rollupDesc)
{
var oldEventsArr = new EventBean[oldEventCount];
object[] oldEventsSortKeys = null;
if (orderByProcessor != null) {
oldEventsSortKeys = new object[oldEventCount];
}
var countEvents = 0;
var countSortKeys = 0;
foreach (var level in rollupDesc.Levels) {
var events = rstreamEventSortArrayBuf.EventsPerLevel[level.LevelNumber];
foreach (var @event in events) {
oldEventsArr[countEvents++] = @event;
}
if (orderByProcessor != null) {
var sortKeys = rstreamEventSortArrayBuf.SortKeyPerLevel[level.LevelNumber];
foreach (var sortKey in sortKeys) {
oldEventsSortKeys[countSortKeys++] = sortKey;
}
}
}
return new EventsAndSortKeysPair(oldEventsArr, oldEventsSortKeys);
}
public ResultSetProcessor Instantiate(OrderByProcessor orderByProcessor, AggregationService aggregationService, AgentInstanceContext agentInstanceContext)
{
if (_noDataWindowSingleSnapshot && !IsHistoricalOnly)
{
return(new ResultSetProcessorRowPerGroupRollupUnbound(this, orderByProcessor, aggregationService, agentInstanceContext));
}
return(new ResultSetProcessorRowPerGroupRollup(this, orderByProcessor, aggregationService, agentInstanceContext));
}
public ResultSetProcessorAggregateAll(ResultSetProcessorAggregateAllFactory prototype, SelectExprProcessor selectExprProcessor, OrderByProcessor orderByProcessor, AggregationService aggregationService, ExprEvaluatorContext exprEvaluatorContext)
{
_prototype = prototype;
_selectExprProcessor = selectExprProcessor;
_orderByProcessor = orderByProcessor;
_aggregationService = aggregationService;
_exprEvaluatorContext = exprEvaluatorContext;
_outputLastUnordHelper = prototype.IsOutputLast ? new ResultSetProcessorAggregateAllOutputLastHelper(this) : null;
_outputAllUnordHelper = prototype.IsOutputAll ? new ResultSetProcessorAggregateAllOutputAllHelper(this) : null;
}
public ResultSetProcessorAggregateAll(
ResultSetProcessorAggregateAllFactory prototype,
SelectExprProcessor selectExprProcessor,
OrderByProcessor orderByProcessor,
AggregationService aggregationService,
AgentInstanceContext agentInstanceContext)
{
_prototype = prototype;
_selectExprProcessor = selectExprProcessor;
_orderByProcessor = orderByProcessor;
_aggregationService = aggregationService;
_exprEvaluatorContext = agentInstanceContext;
_outputLastUnordHelper = prototype.IsEnableOutputLimitOpt && prototype.IsOutputLast ? prototype.ResultSetProcessorHelperFactory.MakeRSAggregateAllOutputLast(this, agentInstanceContext) : null;
_outputAllUnordHelper = prototype.IsEnableOutputLimitOpt && prototype.IsOutputAll ? prototype.ResultSetProcessorHelperFactory.MakeRSAggregateAllOutputAll(this, agentInstanceContext) : null;
}
public ResultSetProcessorRowForAll(ResultSetProcessorRowForAllFactory prototype, SelectExprProcessor selectExprProcessor, OrderByProcessor orderByProcessor, AggregationService aggregationService, ExprEvaluatorContext exprEvaluatorContext)
{
this.Prototype = prototype;
_selectExprProcessor = selectExprProcessor;
_orderByProcessor = orderByProcessor;
this.AggregationService = aggregationService;
this.ExprEvaluatorContext = exprEvaluatorContext;
if (prototype.IsOutputLast)
{
_outputLastHelper = new ResultSetProcessorRowForAllOutputLastHelper(this);
}
else if (prototype.IsOutputAll)
{
_outputAllHelper = new ResultSetProcessorRowForAllOutputAllHelper(this);
}
}
public ResultSetProcessorSimple(
ResultSetProcessorSimpleFactory prototype,
SelectExprProcessor selectExprProcessor,
OrderByProcessor orderByProcessor,
ExprEvaluatorContext exprEvaluatorContext)
{
Prototype = prototype;
_selectExprProcessor = selectExprProcessor;
_orderByProcessor = orderByProcessor;
ExprEvaluatorContext = exprEvaluatorContext;
if (prototype.IsOutputLast)
{
_outputLastHelper = new ResultSetProcessorSimpleOutputLastHelper(this);
}
else if (prototype.IsOutputAll)
{
_outputAllHelper = new ResultSetProcessorSimpleOutputAllHelper(this);
}
}
public void SetUp()
{
var selectExprEventTypeRegistry = new SelectExprEventTypeRegistry("abc", new StatementEventTypeRefImpl());
var statementContext = SupportStatementContextFactory.MakeContext();
var factory = new SelectExprProcessorHelper(
Collections.GetEmptyList <int>(), SupportSelectExprFactory.MakeNoAggregateSelectList(),
Collections.GetEmptyList <SelectExprStreamDesc>(), null, null, false,
new SupportStreamTypeSvc1Stream(), SupportEventAdapterService.Service, null,
selectExprEventTypeRegistry, statementContext.EngineImportService, 1, "stmtname", null,
new Configuration(), null, new TableServiceImpl(), null);
_selectExprProcessor = factory.Evaluator;
_orderByProcessor = null;
var prototype = new ResultSetProcessorSimpleFactory(_selectExprProcessor, null, true, null, false, null, 1);
_outputProcessorAll = (ResultSetProcessorSimple)prototype.Instantiate(null, null, null);
}
public static Pair <ResultSetProcessor, AggregationService> StartResultSetAndAggregation(ResultSetProcessorFactoryDesc resultSetProcessorPrototype, AgentInstanceContext agentInstanceContext)
{
AggregationService aggregationService = null;
if (resultSetProcessorPrototype.AggregationServiceFactoryDesc != null)
{
aggregationService = resultSetProcessorPrototype.AggregationServiceFactoryDesc.AggregationServiceFactory.MakeService(agentInstanceContext, agentInstanceContext.StatementContext.MethodResolutionService);
}
OrderByProcessor orderByProcessor = null;
if (resultSetProcessorPrototype.OrderByProcessorFactory != null)
{
orderByProcessor = resultSetProcessorPrototype.OrderByProcessorFactory.Instantiate(aggregationService, agentInstanceContext);
}
ResultSetProcessor resultSetProcessor = resultSetProcessorPrototype.ResultSetProcessorFactory.Instantiate(orderByProcessor, aggregationService, agentInstanceContext);
return(new Pair <ResultSetProcessor, AggregationService>(resultSetProcessor, aggregationService));
}
public ResultSetProcessorRowForAll(
ResultSetProcessorRowForAllFactory prototype,
SelectExprProcessor selectExprProcessor,
OrderByProcessor orderByProcessor,
AggregationService aggregationService,
AgentInstanceContext agentInstanceContext)
{
_prototype = prototype;
_selectExprProcessor = selectExprProcessor;
_orderByProcessor = orderByProcessor;
_aggregationService = aggregationService;
_exprEvaluatorContext = agentInstanceContext;
if (prototype.IsOutputLast)
{
_outputLastHelper = prototype.ResultSetProcessorHelperFactory.MakeRSRowForAllOutputLast(this, prototype, agentInstanceContext);
}
else if (prototype.IsOutputAll)
{
_outputAllHelper = prototype.ResultSetProcessorHelperFactory.MakeRSRowForAllOutputAll(this, prototype, agentInstanceContext);
}
}
public static Pair <ResultSetProcessor, AggregationService> StartResultSetAndAggregation(ResultSetProcessorFactoryDesc resultSetProcessorPrototype, AgentInstanceContext agentInstanceContext, bool isSubquery, int?subqueryNumber)
{
AggregationService aggregationService = null;
if (resultSetProcessorPrototype.AggregationServiceFactoryDesc != null)
{
aggregationService =
resultSetProcessorPrototype.AggregationServiceFactoryDesc.AggregationServiceFactory.MakeService(
agentInstanceContext, agentInstanceContext.StatementContext.EngineImportService, isSubquery, subqueryNumber);
}
OrderByProcessor orderByProcessor = null;
if (resultSetProcessorPrototype.OrderByProcessorFactory != null)
{
orderByProcessor = resultSetProcessorPrototype.OrderByProcessorFactory.Instantiate(aggregationService, agentInstanceContext);
}
ResultSetProcessor resultSetProcessor = resultSetProcessorPrototype.ResultSetProcessorFactory.Instantiate(orderByProcessor, aggregationService, agentInstanceContext);
return(new Pair <ResultSetProcessor, AggregationService>(resultSetProcessor, aggregationService));
}
public ResultSetProcessorSimple(
ResultSetProcessorSimpleFactory prototype,
SelectExprProcessor selectExprProcessor,
OrderByProcessor orderByProcessor,
AgentInstanceContext agentInstanceContext)
{
Prototype = prototype;
_selectExprProcessor = selectExprProcessor;
_orderByProcessor = orderByProcessor;
ExprEvaluatorContext = agentInstanceContext;
if (prototype.IsOutputLast)
{
// output-last always uses this mechanism
_outputLastHelper = prototype.ResultSetProcessorHelperFactory
.MakeRSSimpleOutputLast(prototype, this, agentInstanceContext);
}
else if (prototype.IsOutputAll && prototype.IsEnableOutputLimitOpt)
{
_outputAllHelper = prototype.ResultSetProcessorHelperFactory
.MakeRSSimpleOutputAll(prototype, this, agentInstanceContext);
}
}
public static ResultSetProcessor GetAssignResultSetProcessor(
AgentInstanceContext agentInstanceContext,
ResultSetProcessorFactoryDesc resultSetProcessorPrototype,
bool isSubquery,
int? subqueryNumber,
bool isFireAndForget)
{
AggregationService aggregationService = null;
if (resultSetProcessorPrototype.AggregationServiceFactoryDesc != null)
{
aggregationService =
resultSetProcessorPrototype.AggregationServiceFactoryDesc.AggregationServiceFactory.MakeService(
agentInstanceContext, agentInstanceContext.StatementContext.EngineImportService, isSubquery,
subqueryNumber);
}
OrderByProcessor orderByProcessor = null;
if (resultSetProcessorPrototype.OrderByProcessorFactory != null)
{
orderByProcessor = resultSetProcessorPrototype.OrderByProcessorFactory.Instantiate(
aggregationService, agentInstanceContext);
}
var processor = resultSetProcessorPrototype.ResultSetProcessorFactory.Instantiate(
orderByProcessor, aggregationService, agentInstanceContext);
// initialize aggregation expression nodes
if (resultSetProcessorPrototype.AggregationServiceFactoryDesc != null)
{
foreach (var aggregation in resultSetProcessorPrototype.AggregationServiceFactoryDesc.Expressions)
{
aggregation.AssignFuture(aggregationService);
}
}
return processor;
}
internal static void PopulateSelectJoinEventsNoHavingWithOrderBy(SelectExprProcessor exprProcessor, OrderByProcessor orderByProcessor, ICollection <MultiKey <EventBean> > events, bool isNewData, bool isSynthesize, ICollection <EventBean> result, ICollection <Object> optSortKeys, ExprEvaluatorContext exprEvaluatorContext)
{
var length = (events != null) ? events.Count : 0;
if (length == 0)
{
return;
}
foreach (var key in events)
{
var eventsPerStream = key.Array;
var resultEvent = exprProcessor.Process(eventsPerStream, isNewData, isSynthesize, exprEvaluatorContext);
if (resultEvent != null)
{
result.Add(resultEvent);
optSortKeys.Add(orderByProcessor.GetSortKey(eventsPerStream, isNewData, exprEvaluatorContext));
}
}
}
internal static void PopulateSelectJoinEventsHavingWithOrderBy(SelectExprProcessor exprProcessor, OrderByProcessor orderByProcessor, ICollection <MultiKey <EventBean> > events, ExprEvaluator havingNode, bool isNewData, bool isSynthesize, ICollection <EventBean> result, ICollection <Object> sortKeys, ExprEvaluatorContext exprEvaluatorContext)
{
if (events == null)
{
return;
}
foreach (var key in events)
{
var eventsPerStream = key.Array;
var evaluateParams = new EvaluateParams(eventsPerStream, isNewData, exprEvaluatorContext);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QHavingClauseJoin(eventsPerStream);
}
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)
{
result.Add(resultEvent);
sortKeys.Add(orderByProcessor.GetSortKey(eventsPerStream, isNewData, exprEvaluatorContext));
}
}
}
internal static void PopulateSelectEventsNoHavingWithOrderBy(SelectExprProcessor exprProcessor, OrderByProcessor orderByProcessor, EventBean[] events, bool isNewData, bool isSynthesize, ICollection <EventBean> result, ICollection <Object> sortKeys, ExprEvaluatorContext exprEvaluatorContext)
{
if (events == null)
{
return;
}
var eventsPerStream = new EventBean[1];
foreach (var theEvent in events)
{
eventsPerStream[0] = theEvent;
var resultEvent = exprProcessor.Process(eventsPerStream, isNewData, isSynthesize, exprEvaluatorContext);
if (resultEvent != null)
{
result.Add(resultEvent);
sortKeys.Add(orderByProcessor.GetSortKey(eventsPerStream, 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. <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);
}
/// <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));
}
/// <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.
/// </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));
}
public ResultSetProcessorRowPerGroupRollupUnbound(ResultSetProcessorRowPerGroupRollupFactory prototype, OrderByProcessor orderByProcessor, AggregationService aggregationService, AgentInstanceContext agentInstanceContext)
: base(prototype, orderByProcessor, aggregationService, agentInstanceContext)
{
_unboundHelper = prototype.ResultSetProcessorHelperFactory.MakeRSRowPerGroupRollupSnapshotUnbound(agentInstanceContext, prototype);
}
public ResultSetProcessorRowPerGroupUnbound(ResultSetProcessorRowPerGroupFactory prototype, SelectExprProcessor selectExprProcessor, OrderByProcessor orderByProcessor, AggregationService aggregationService, AgentInstanceContext agentInstanceContext)
: base(prototype, selectExprProcessor, orderByProcessor, aggregationService, agentInstanceContext)
{
_groupReps = prototype.ResultSetProcessorHelperFactory.MakeRSRowPerGroupUnboundGroupRep(agentInstanceContext, prototype);
aggregationService.SetRemovedCallback(_groupReps);
}
public ResultSetProcessorRowPerGroupUnbound(ResultSetProcessorRowPerGroupFactory prototype, SelectExprProcessor selectExprProcessor, OrderByProcessor orderByProcessor, AggregationService aggregationService, AgentInstanceContext agentInstanceContext)
: base(prototype, selectExprProcessor, orderByProcessor, aggregationService, agentInstanceContext)
{
aggregationService.SetRemovedCallback(this);
}
public ResultSetProcessorRowPerGroupRollupUnbound(ResultSetProcessorRowPerGroupRollupFactory prototype, OrderByProcessor orderByProcessor, AggregationService aggregationService, AgentInstanceContext agentInstanceContext)
: base(prototype, orderByProcessor, aggregationService, agentInstanceContext)
{
}
