public void SetCurrentAccess(
object groupKey,
int agentInstanceId,
AggregationGroupByRollupLevel rollupLevel)
{
service.SetCurrentAccess(groupKey, agentInstanceId, null);
}
public static IEnumerator<EventBean> For(
IEnumerator<EventBean> sourceIterator,
ResultSetProcessorRowPerGroup resultSetProcessor,
AggregationService aggregationService,
ExprEvaluatorContext exprEvaluatorContext)
{
var eventsPerStream = new EventBean[1];
var priorSeenGroups = new HashSet<object>();
var hasHavingClause = resultSetProcessor.HasHavingClause;
while (sourceIterator.MoveNext()) {
eventsPerStream[0] = sourceIterator.Current;
var groupKey = resultSetProcessor.GenerateGroupKeySingle(eventsPerStream, true);
aggregationService.SetCurrentAccess(groupKey, exprEvaluatorContext.AgentInstanceId, null);
if (hasHavingClause) {
var pass = resultSetProcessor.EvaluateHavingClause(eventsPerStream, true, exprEvaluatorContext);
if (!pass) {
continue;
}
}
if (priorSeenGroups.Contains(groupKey)) {
continue;
}
priorSeenGroups.Add(groupKey);
yield return resultSetProcessor.SelectExprProcessor.Process(
eventsPerStream,
true,
true,
exprEvaluatorContext);
}
}
/// <summary>
/// Advances the enumerator to the next element of the collection.
/// </summary>
/// <returns>
/// true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection.
/// </returns>
public bool MoveNext()
{
while (_iterate && _sourceIterator.MoveNext())
{
var candidate = _sourceIterator.Current;
_eventsPerStream[0] = candidate;
var groupKey = _resultSetProcessor.GenerateGroupKey(_eventsPerStream, true);
_aggregationService.SetCurrentAccess(groupKey, _exprEvaluatorContext.AgentInstanceId, null);
bool?pass = true;
if (_resultSetProcessor.OptionalHavingNode != null)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QHavingClauseJoin(_eventsPerStream);
}
pass = _resultSetProcessor.OptionalHavingNode.Evaluate(new EvaluateParams(_eventsPerStream, true, _exprEvaluatorContext)).AsBoxedBoolean();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AHavingClauseJoin(pass);
}
}
if (false.Equals(pass))
{
continue;
}
_currResult = _resultSetProcessor.SelectExprProcessor.Process(_eventsPerStream, true, true, _exprEvaluatorContext);
return(true);
}
return(_iterate = false);
}
/// <summary>
/// Creates an aggregated group enumerator.
/// </summary>
/// <param name="sourceIterator">The source iterator.</param>
/// <param name="resultSetProcessor">The result set processor.</param>
/// <param name="aggregationService">The aggregation service.</param>
/// <param name="exprEvaluatorContext">The expr evaluator context.</param>
/// <returns></returns>
public static IEnumerator<EventBean> Create(
IEnumerator<EventBean> sourceIterator,
ResultSetProcessorAggregateGrouped resultSetProcessor,
AggregationService aggregationService,
ExprEvaluatorContext exprEvaluatorContext)
{
EventBean[] eventsPerStream = new EventBean[1];
while (sourceIterator.MoveNext()) {
eventsPerStream[0] = sourceIterator.Current;
var groupKey = resultSetProcessor.GenerateGroupKeySingle(eventsPerStream, true);
aggregationService.SetCurrentAccess(groupKey, exprEvaluatorContext.AgentInstanceId, null);
if (resultSetProcessor.HasHavingClause) {
var pass = resultSetProcessor.EvaluateHavingClause(eventsPerStream, true, exprEvaluatorContext);
if (!pass) {
continue;
}
}
yield return resultSetProcessor.SelectExprProcessor.Process(
eventsPerStream,
true,
true,
exprEvaluatorContext);
}
}
public override ICollection<EventBean> EvaluateGetCollEvents(
EventBean[] eventsPerStream,
bool newData,
ICollection<EventBean> matchingEvents,
ExprEvaluatorContext context,
ExprSubselectRowNode parent)
{
AggregationService aggregationService =
parent.SubselectAggregationService.GetContextPartitionAggregationService(context.AgentInstanceId);
ICollection<object> groupKeys = aggregationService.GetGroupKeys(context);
if (groupKeys.IsEmpty())
{
return null;
}
var events = EventBeanUtility.AllocatePerStreamShift(eventsPerStream);
var evaluateParams = new EvaluateParams(events, newData, context);
var result = new ArrayDeque<EventBean>(groupKeys.Count);
foreach (object groupKey in groupKeys)
{
aggregationService.SetCurrentAccess(groupKey, context.AgentInstanceId, null);
var pass = _havingClause.Evaluate(evaluateParams);
if (true.Equals(pass))
{
IDictionary<string, object> row = parent.EvaluateRow(events, true, context);
EventBean @event = parent.SubselectMultirowType.EventAdapterService.AdapterForTypedMap(
row, parent.SubselectMultirowType.EventType);
result.Add(@event);
}
}
return result;
}
/// <summary>
/// Creates a new enumeration wrapper.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="resultSetProcessor">The result set processor.</param>
/// <param name="aggregationService">The aggregation service.</param>
/// <param name="exprEvaluatorContext">The expr evaluator context.</param>
/// <returns></returns>
public static IEnumerator <EventBean> New(
IEnumerator <EventBean> source,
ResultSetProcessorRowPerGroup resultSetProcessor,
AggregationService aggregationService,
ExprEvaluatorContext exprEvaluatorContext)
{
var eventsPerStream = new EventBean[1];
var priorSeenGroups = new HashSet <object>();
var evaluateParams = new EvaluateParams(eventsPerStream, true, exprEvaluatorContext);
var optionHavingNode = resultSetProcessor.OptionalHavingNode;
var selectExprProcessor = resultSetProcessor.SelectExprProcessor;
while (source.MoveNext())
{
var candidate = source.Current;
eventsPerStream[0] = candidate;
var groupKey = resultSetProcessor.GenerateGroupKey(eventsPerStream, true);
aggregationService.SetCurrentAccess(groupKey, exprEvaluatorContext.AgentInstanceId, null);
if (optionHavingNode != null)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QHavingClauseNonJoin(candidate);
}
var pass = resultSetProcessor.OptionalHavingNode.Evaluate(evaluateParams);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AHavingClauseJoin(pass.AsBoxedBoolean());
}
if ((pass != null) && false.Equals(pass))
{
continue;
}
}
if (priorSeenGroups.Contains(groupKey))
{
continue;
}
priorSeenGroups.Add(groupKey);
yield return(selectExprProcessor.Process(eventsPerStream, true, true, exprEvaluatorContext));
}
}
private IList <Object> CreateSortProperties(EventBean[][] generatingEvents, Object[] groupByKeys, bool isNewData, ExprEvaluatorContext exprEvaluatorContext)
{
var sortProperties = new Object[generatingEvents.Length];
var elements = _factory.OrderBy;
if (elements.Length == 1)
{
var count = 0;
foreach (var eventsPerStream in generatingEvents)
{
var evaluateParams = new EvaluateParams(eventsPerStream, isNewData, exprEvaluatorContext);
// Make a new multikey that contains the sort-by values.
if (_factory.IsNeedsGroupByKeys)
{
_aggregationService.SetCurrentAccess(groupByKeys[count], exprEvaluatorContext.AgentInstanceId, null);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QOrderBy(eventsPerStream, _factory.OrderBy);
}
sortProperties[count] = elements[0].Expr.Evaluate(evaluateParams);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOrderBy(sortProperties[count]);
}
count++;
}
}
else
{
var count = 0;
foreach (var eventsPerStream in generatingEvents)
{
var evaluateParams = new EvaluateParams(eventsPerStream, isNewData, exprEvaluatorContext);
// Make a new multikey that contains the sort-by values.
if (_factory.IsNeedsGroupByKeys)
{
_aggregationService.SetCurrentAccess(groupByKeys[count], exprEvaluatorContext.AgentInstanceId, null);
}
var values = new Object[_factory.OrderBy.Length];
var countTwo = 0;
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QOrderBy(eventsPerStream, _factory.OrderBy);
}
foreach (var sortPair in _factory.OrderBy)
{
values[countTwo++] = sortPair.Expr.Evaluate(evaluateParams);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOrderBy(values);
}
sortProperties[count] = new MultiKeyUntyped(values);
count++;
}
}
return(sortProperties);
}
protected override Object EvaluateInternal(
Object leftResult,
EventBean[] events,
bool isNewData,
ICollection <EventBean> matchingEvents,
ExprEvaluatorContext exprEvaluatorContext,
AggregationService aggregationServiceAnyPartition)
{
if (leftResult == null)
{
return(null);
}
AggregationService aggregationService =
aggregationServiceAnyPartition.GetContextPartitionAggregationService(
exprEvaluatorContext.AgentInstanceId);
ICollection <Object> groupKeys = aggregationService.GetGroupKeys(exprEvaluatorContext);
var evaluateParams = new EvaluateParams(events, true, exprEvaluatorContext);
// Evaluate each select until we have a match
bool hasNullRow = false;
foreach (Object groupKey in groupKeys)
{
aggregationService.SetCurrentAccess(groupKey, exprEvaluatorContext.AgentInstanceId, null);
if (_havingEval != null)
{
var pass = (bool?)_havingEval.Evaluate(evaluateParams);
if ((pass == null) || (false.Equals(pass)))
{
continue;
}
}
Object rightResult;
if (SelectEval != null)
{
rightResult = SelectEval.Evaluate(evaluateParams);
}
else
{
rightResult = events[0].Underlying;
}
if (rightResult != null)
{
if (Coercer == null)
{
if (leftResult.Equals(rightResult))
{
return(!IsNotIn);
}
}
else
{
var left = Coercer.Invoke(leftResult);
var right = Coercer.Invoke(rightResult);
if (left.Equals(right))
{
return(!IsNotIn);
}
}
}
else
{
hasNullRow = true;
}
}
if (hasNullRow)
{
return(null);
}
return(IsNotIn);
}
protected override Object EvaluateInternal(
Object leftResult,
EventBean[] events,
bool isNewData,
ICollection <EventBean> matchingEvents,
ExprEvaluatorContext exprEvaluatorContext,
AggregationService aggregationServiceAnyPartition)
{
AggregationService aggregationService =
aggregationServiceAnyPartition.GetContextPartitionAggregationService(
exprEvaluatorContext.AgentInstanceId);
ICollection <Object> groupKeys = aggregationService.GetGroupKeys(exprEvaluatorContext);
bool hasRows = false;
bool hasNullRow = false;
var evaluateParams = new EvaluateParams(events, true, exprEvaluatorContext);
foreach (Object groupKey in groupKeys)
{
aggregationService.SetCurrentAccess(groupKey, exprEvaluatorContext.AgentInstanceId, null);
if (_havingEval != null)
{
var pass = _havingEval.Evaluate(evaluateParams);
if ((pass == null) || (false.Equals(pass)))
{
continue;
}
}
hasRows = true;
Object valueRight;
if (SelectEval != null)
{
valueRight = SelectEval.Evaluate(evaluateParams);
}
else
{
valueRight = events[0].Underlying;
}
if (valueRight == null)
{
hasNullRow = true;
}
else
{
if (leftResult != null)
{
if (!Computer.Invoke(leftResult, valueRight))
{
return(false);
}
}
}
}
if (!hasRows)
{
return(true);
}
if (leftResult == null)
{
return(null);
}
if (hasNullRow)
{
return(null);
}
return(true);
}
