public ExprAggMultiFunctionLinearAccessNodeFactoryAccess(ExprAggMultiFunctionLinearAccessNode parent, AggregationAccessor accessor, Type accessorResultType, EventType containedEventType, AggregationStateKey optionalStateKey, AggregationStateFactory optionalStateFactory, AggregationAgent optionalAgent)
{
_parent = parent;
_accessor = accessor;
_accessorResultType = accessorResultType;
_containedEventType = containedEventType;
_optionalStateKey = optionalStateKey;
_optionalStateFactory = optionalStateFactory;
_optionalAgent = optionalAgent;
}
// Obtain those method and state factories for each level
private static AggregationLocalGroupByLevel GetLevel(
int levelNumber,
AggregationGroupByLocalGroupLevel level,
ExprEvaluator[] methodEvaluatorsAll,
AggregationMethodFactory[] methodFactoriesAll,
AggregationStateFactory[] stateFactoriesAll,
AggregationLocalGroupByColumn[] columns,
bool defaultLevel,
AggregationAccessorSlotPair[] accessors)
{
ExprNode[] partitionExpr = level.PartitionExpr;
ExprEvaluator[] partitionEvaluators = ExprNodeUtility.GetEvaluators(partitionExpr);
IList<ExprEvaluator> methodEvaluators = new List<ExprEvaluator>();
IList<AggregationMethodFactory> methodFactories = new List<AggregationMethodFactory>();
IList<AggregationStateFactory> stateFactories = new List<AggregationStateFactory>();
foreach (AggregationServiceAggExpressionDesc expr in level.Expressions)
{
int column = expr.ColumnNum.Value;
int methodOffset = -1;
bool methodAgg = true;
AggregationAccessorSlotPair pair = null;
if (column < methodEvaluatorsAll.Length)
{
methodEvaluators.Add(methodEvaluatorsAll[column]);
methodFactories.Add(methodFactoriesAll[column]);
methodOffset = methodFactories.Count - 1;
}
else
{
// slot gives us the number of the state factory
int absoluteSlot = accessors[column - methodEvaluatorsAll.Length].Slot;
AggregationAccessor accessor = accessors[column - methodEvaluatorsAll.Length].Accessor;
AggregationStateFactory factory = stateFactoriesAll[absoluteSlot];
int relativeSlot = stateFactories.IndexOf(factory);
if (relativeSlot == -1)
{
stateFactories.Add(factory);
relativeSlot = stateFactories.Count - 1;
}
methodAgg = false;
pair = new AggregationAccessorSlotPair(relativeSlot, accessor);
}
columns[column] = new AggregationLocalGroupByColumn(
defaultLevel, partitionEvaluators, methodOffset, methodAgg, pair, levelNumber);
}
return new AggregationLocalGroupByLevel(
methodEvaluators.ToArray(),
methodFactories.ToArray(),
stateFactories.ToArray(), partitionEvaluators, defaultLevel);
}
public ExprAggMultiFunctionSortedMinMaxByNodeFactory(ExprAggMultiFunctionSortedMinMaxByNode parent,
AggregationAccessor accessor, Type accessorResultType, EventType containedEventType,
AggregationStateKey optionalStateKey, SortedAggregationStateFactoryFactory optionalStateFactory,
AggregationAgent optionalAgent)
{
Parent = parent;
Accessor = accessor;
ResultType = accessorResultType;
ContainedEventType = containedEventType;
OptionalStateKey = optionalStateKey;
OptionalStateFactory = optionalStateFactory;
AggregationStateAgent = optionalAgent;
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
if (_tableAccessColumn.AccessAccessorSlotPair == null)
{
throw new ExprValidationException("Invalid combination of aggregation state and aggregation accessor");
}
var mfNode = (ExprAggregateAccessMultiValueNode)_aggregateAccessMultiValueNode;
mfNode.ValidatePositionals();
_accessorFactory = mfNode.ValidateAggregationParamsWBinding(validationContext, _tableAccessColumn);
_accessor = _accessorFactory.Accessor;
return(null);
}
/// <summary>Ctor. </summary>
/// <param name="slot">number of accessor</param>
/// <param name="accessor">accessor</param>
public AggregationAccessorSlotPair(int slot, AggregationAccessor accessor)
{
Slot = slot;
Accessor = accessor;
}
public TableMetadataColumnPairAggAccess(int dest, AggregationAccessor accessor)
: base(dest)
{
Accessor = accessor;
}
public ExprTableEvalStrategyUngroupedAccess(TableAndLockProviderUngrouped provider, int slot, AggregationAccessor accessor)
: base(provider)
{
_slot = slot;
_accessor = accessor;
}
private static BindingMatchResult MatchBindingsAssignColumnNumbers(
IntoTableSpec bindings,
TableMetadata metadata,
IList<AggregationServiceAggExpressionDesc> aggregations,
IDictionary<ExprNode, string> selectClauseNamedNodes,
IList<ExprEvaluator> methodAggEvaluatorsList,
IList<ExprDeclaredNode> declaredExpressions)
{
var methodAggs = new LinkedHashMap<AggregationServiceAggExpressionDesc, TableMetadataColumnAggregation>();
var accessAggs = new LinkedHashMap<AggregationServiceAggExpressionDesc, TableMetadataColumnAggregation>();
foreach (AggregationServiceAggExpressionDesc aggDesc in aggregations)
{
// determine assigned name
string columnName = FindColumnNameForAggregation(
selectClauseNamedNodes, declaredExpressions, aggDesc.AggregationNode);
if (columnName == null)
{
throw new ExprValidationException(
"Failed to find an expression among the select-clause expressions for expression '" +
ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(aggDesc.AggregationNode) + "'");
}
// determine binding metadata
var columnMetadata = (TableMetadataColumnAggregation) metadata.TableColumns.Get(columnName);
if (columnMetadata == null)
{
throw new ExprValidationException(
"Failed to find name '" + columnName + "' among the columns for table '" + bindings.Name + "'");
}
// validate compatible
ValidateIntoTableCompatible(bindings.Name, columnName, columnMetadata, aggDesc);
if (!columnMetadata.Factory.IsAccessAggregation)
{
methodAggs.Put(aggDesc, columnMetadata);
}
else
{
accessAggs.Put(aggDesc, columnMetadata);
}
}
// handle method-aggs
var methodPairs = new TableColumnMethodPair[methodAggEvaluatorsList.Count];
int methodIndex = -1;
foreach (var methodEntry in methodAggs)
{
methodIndex++;
int targetIndex = methodEntry.Value.MethodOffset;
methodPairs[methodIndex] = new TableColumnMethodPair(
methodAggEvaluatorsList[methodIndex], targetIndex, methodEntry.Key.AggregationNode);
methodEntry.Key.ColumnNum = targetIndex;
}
// handle access-aggs
var accessSlots = new LinkedHashMap<int, ExprNode>();
var accessReadPairs = new List<AggregationAccessorSlotPair>();
int accessIndex = -1;
var agents = new List<AggregationAgent>();
foreach (var accessEntry in accessAggs)
{
accessIndex++;
int slot = accessEntry.Value.AccessAccessorSlotPair.Slot;
AggregationMethodFactory aggregationMethodFactory = accessEntry.Key.Factory;
AggregationAccessor accessor = aggregationMethodFactory.Accessor;
accessSlots.Put(slot, accessEntry.Key.AggregationNode);
accessReadPairs.Add(new AggregationAccessorSlotPair(slot, accessor));
accessEntry.Key.ColumnNum = metadata.NumberMethodAggregations + accessIndex;
agents.Add(aggregationMethodFactory.AggregationStateAgent);
}
AggregationAgent[] agentArr = agents.ToArray();
AggregationAccessorSlotPair[] accessReads = accessReadPairs.ToArray();
var targetStates = new int[accessSlots.Count];
var accessStateExpr = new ExprNode[accessSlots.Count];
int count = 0;
foreach (var entry in accessSlots)
{
targetStates[count] = entry.Key;
accessStateExpr[count] = entry.Value;
count++;
}
return new BindingMatchResult(methodPairs, accessReads, targetStates, accessStateExpr, agentArr);
}
private LinearAggregationFactoryDesc HandleTableAccessFirstLast(ExprNode[] childNodes, AggregationStateType stateType, ExprValidationContext validationContext, TableMetadataColumnAggregation tableAccess)
{
var original = (ExprAggMultiFunctionLinearAccessNodeFactoryAccess)tableAccess.Factory;
var resultType = original.ContainedEventType.UnderlyingType;
AggregationAccessor defaultAccessor =
stateType == AggregationStateType.FIRST
? (AggregationAccessor)AggregationAccessorFirstNoEval.INSTANCE
: (AggregationAccessor)AggregationAccessorLastNoEval.INSTANCE;
if (childNodes.Length == 0)
{
var factoryAccess = new ExprAggMultiFunctionLinearAccessNodeFactoryAccess(this, defaultAccessor, resultType, original.ContainedEventType, null, null, null);
return(new LinearAggregationFactoryDesc(factoryAccess, factoryAccess.ContainedEventType, null));
}
if (childNodes.Length == 1)
{
if (childNodes[0] is ExprWildcard)
{
var factoryAccess = new ExprAggMultiFunctionLinearAccessNodeFactoryAccess(this, defaultAccessor, resultType, original.ContainedEventType, null, null, null);
return(new LinearAggregationFactoryDesc(factoryAccess, factoryAccess.ContainedEventType, null));
}
if (childNodes[0] is ExprStreamUnderlyingNode)
{
throw new ExprValidationException("Stream-wildcard is not allowed for table column access");
}
// Expressions apply to events held, thereby validate in terms of event value expressions
var paramNode = childNodes[0];
var streams = TableServiceUtil.StreamTypeFromTableColumn(tableAccess, validationContext.StreamTypeService.EngineURIQualifier);
var localValidationContext = new ExprValidationContext(streams, validationContext);
paramNode = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.AGGPARAM, paramNode, localValidationContext);
var paramNodeEval = paramNode.ExprEvaluator;
AggregationAccessor accessor;
if (stateType == AggregationStateType.FIRST)
{
accessor = new AggregationAccessorFirstWEval(0, paramNodeEval);
}
else
{
accessor = new AggregationAccessorLastWEval(0, paramNodeEval);
}
var factory = new ExprAggMultiFunctionLinearAccessNodeFactoryAccess(this, accessor, paramNodeEval.ReturnType, original.ContainedEventType, null, null, null);
return(new LinearAggregationFactoryDesc(factory, factory.ContainedEventType, null));
}
if (childNodes.Length == 2)
{
var isFirst = stateType == AggregationStateType.FIRST;
var constant = -1;
var indexEvalNode = childNodes[1];
if (indexEvalNode.IsConstantResult)
{
constant = indexEvalNode.ExprEvaluator.Evaluate(new EvaluateParams(null, true, null)).AsInt();
}
var evaluatorIndex = indexEvalNode.ExprEvaluator;
if (evaluatorIndex.ReturnType != typeof(int?))
{
throw new ExprValidationException(GetErrorPrefix(stateType) + " requires a constant index expression that returns an integer value");
}
AggregationAccessor accessor = new AggregationAccessorFirstLastIndexNoEval(evaluatorIndex, constant, isFirst);
var factory = new ExprAggMultiFunctionLinearAccessNodeFactoryAccess(this, accessor, resultType, original.ContainedEventType, null, null, null);
return(new LinearAggregationFactoryDesc(factory, factory.ContainedEventType, null));
}
throw new ExprValidationException("Invalid number of parameters");
}
public ExprTableEvalStrategyUngroupedAccess(ILockable @lock, Atomic <ObjectArrayBackedEventBean> aggregationState, int slot, AggregationAccessor accessor)
: base(@lock, aggregationState)
{
this.slot = slot;
this.accessor = accessor;
}
