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; }