public TableMetadataColumnAggregation(string columnName, AggregationMethodFactory factory, int methodOffset, AggregationAccessorSlotPair accessAccessorSlotPair, EPType optionalEnumerationType, EventType optionalEventType) : base(columnName, false) { Factory = factory; MethodOffset = methodOffset; AccessAccessorSlotPair = accessAccessorSlotPair; OptionalEnumerationType = optionalEnumerationType; OptionalEventType = optionalEventType; }
// 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 override object GetValue(int column, int agentInstanceId, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext exprEvaluatorContext) { if (column < Aggregators.Length) { return(_currentAggregatorRow.Methods[column].Value); } else { AggregationAccessorSlotPair pair = _accessorsFactory[column - Aggregators.Length]; return(pair.Accessor.GetValue(_currentAggregatorRow.States[pair.Slot], eventsPerStream, isNewData, exprEvaluatorContext)); } }
public override ICollection <Object> GetCollectionScalar(int column, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext context) { if (column < Aggregators.Length) { return(null); } else { AggregationAccessorSlotPair pair = Accessors[column - Aggregators.Length]; return(pair.Accessor.GetEnumerableScalar(_currentAggregatorStates[pair.Slot], eventsPerStream, isNewData, context)); } }
public override EventBean GetEventBean(int column, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext context) { if (column < Aggregators.Length) { return(null); } else { AggregationAccessorSlotPair pair = _accessorsFactory[column - Aggregators.Length]; return(pair.Accessor.GetEnumerableEvent(_currentAggregatorRow.States[pair.Slot], eventsPerStream, isNewData, context)); } }
public override object GetValue(int column, int agentInstanceId, EvaluateParams evaluateParams) { if (column < Aggregators.Length) { return(_currentAggregatorRow.Methods[column].Value); } else { AggregationAccessorSlotPair pair = _accessorsFactory[column - Aggregators.Length]; return(pair.Accessor.GetValue(_currentAggregatorRow.States[pair.Slot], evaluateParams)); } }
public override EventBean GetEventBean(int column, EvaluateParams evaluateParams) { if (column < Aggregators.Length) { return(null); } else { AggregationAccessorSlotPair pair = _accessors[column - Aggregators.Length]; return(pair.Accessor.GetEnumerableEvent(States[pair.Slot], evaluateParams)); } }
public override ICollection <EventBean> GetCollectionOfEvents(int column, EvaluateParams evaluateParams) { if (column < Aggregators.Length) { return(null); } else { AggregationAccessorSlotPair pair = _accessorsFactory[column - Aggregators.Length]; return(pair.Accessor.GetEnumerableEvents(_currentAggregatorRow.States[pair.Slot], evaluateParams)); } }
public override ICollection <object> GetCollectionScalar(int column, EvaluateParams evaluateParams) { if (column < Aggregators.Length) { return(null); } else { AggregationAccessorSlotPair pair = _accessors[column - Aggregators.Length]; return(pair.Accessor.GetEnumerableScalar(_currentAggregatorStates[pair.Slot], evaluateParams)); } }
public ExprTableExprEvaluatorAccess( ExprNode exprNode, string tableName, string subpropName, int streamNum, Type returnType, AggregationAccessorSlotPair accessAccessorSlotPair, EventType eventTypeColl) : base(exprNode, tableName, subpropName, streamNum, returnType) { _accessAccessorSlotPair = accessAccessorSlotPair; _eventTypeColl = eventTypeColl; }
public override object GetValue(int column, int agentInstanceId, EvaluateParams evaluateParams) { var aggregators = base.Aggregators; if (column < aggregators.Length) { return(aggregators[column].Value); } else { AggregationAccessorSlotPair pair = _accessors[column - aggregators.Length]; return(pair.Accessor.GetValue(States[pair.Slot], evaluateParams)); } }
public override ICollection <EventBean> GetCollectionOfEvents(int column, EvaluateParams evaluateParams) { var aggregators = base.Aggregators; if (column < aggregators.Length) { return(null); } else { AggregationAccessorSlotPair pair = _accessors[column - aggregators.Length]; return(pair.Accessor.GetEnumerableEvents(States[pair.Slot], evaluateParams)); } }
public override object GetValue(int column, int agentInstanceId, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext exprEvaluatorContext) { var aggregators = base.Aggregators; if (column < aggregators.Length) { return(aggregators[column].Value); } else { AggregationAccessorSlotPair pair = _accessors[column - aggregators.Length]; return(pair.Accessor.GetValue(States[pair.Slot], eventsPerStream, isNewData, exprEvaluatorContext)); } }
public override ICollection <EventBean> GetCollectionOfEvents(int column, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext context) { var aggregators = base.Aggregators; if (column < aggregators.Length) { return(null); } else { AggregationAccessorSlotPair pair = _accessors[column - aggregators.Length]; return(pair.Accessor.GetEnumerableEvents(States[pair.Slot], eventsPerStream, isNewData, context)); } }
public AggregationLocalGroupByColumn( bool defaultGroupLevel, ExprEvaluator[] partitionEvaluators, int methodOffset, bool methodAgg, AggregationAccessorSlotPair pair, int levelNum) { IsDefaultGroupLevel = defaultGroupLevel; PartitionEvaluators = partitionEvaluators; MethodOffset = methodOffset; IsMethodAgg = methodAgg; Pair = pair; LevelNum = levelNum; }
public ExprTableEvalStrategyGroupByAccessSingle(TableAndLockProviderGrouped provider, AggregationAccessorSlotPair pair, ExprEvaluator groupExpr) : base(provider, pair) { this._groupExpr = groupExpr; }
internal static ICollection <EventBean> EvalGetROCollectionEvents(AggregationRowPair row, AggregationAccessorSlotPair pair, EventBean[] eventsPerStream, bool newData, ExprEvaluatorContext context) { return(pair.Accessor.GetEnumerableEvents(row.States[pair.Slot], eventsPerStream, newData, context)); }
internal static object EvalAccessorGetValue(AggregationRowPair row, AggregationAccessorSlotPair pair, EventBean[] eventsPerStream, bool newData, ExprEvaluatorContext context) { return(pair.Accessor.GetValue(row.States[pair.Slot], eventsPerStream, newData, context)); }
public EventBean GetEventBean(int column, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext context) { AggregationAccessorSlotPair pair = _accessors[column]; return(pair.Accessor.GetEnumerableEvent(_currentAccesses[pair.Slot], eventsPerStream, isNewData, context)); }
public object GetValue(int column, int agentInstanceId, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext exprEvaluatorContext) { AggregationAccessorSlotPair pair = _accessors[column]; return(pair.Accessor.GetValue(_currentAccesses[pair.Slot], eventsPerStream, isNewData, exprEvaluatorContext)); }
public static ExprTableAccessEvalStrategy GetTableAccessEvalStrategy( ExprTableAccessNode tableNode, TableAndLockProvider provider, TableMetadata tableMetadata) { var groupKeyEvals = tableNode.GroupKeyEvaluators; TableAndLockProviderUngrouped ungrouped; TableAndLockProviderGrouped grouped; if (provider is TableAndLockProviderUngrouped) { ungrouped = (TableAndLockProviderUngrouped)provider; grouped = null; } else { grouped = (TableAndLockProviderGrouped)provider; ungrouped = null; } // handle sub-property access if (tableNode is ExprTableAccessNodeSubprop) { var subprop = (ExprTableAccessNodeSubprop)tableNode; var column = tableMetadata.TableColumns.Get(subprop.SubpropName); return(GetTableAccessSubprop(subprop, column, ungrouped, grouped)); } // handle top-level access if (tableNode is ExprTableAccessNodeTopLevel) { if (ungrouped != null) { return(new ExprTableEvalStrategyUngroupedTopLevel(ungrouped, tableMetadata.TableColumns)); } if (tableNode.GroupKeyEvaluators.Length > 1) { return(new ExprTableEvalStrategyGroupByTopLevelMulti( grouped, tableMetadata.TableColumns, groupKeyEvals)); } return(new ExprTableEvalStrategyGroupByTopLevelSingle( grouped, tableMetadata.TableColumns, groupKeyEvals[0])); } // handle "keys" function access if (tableNode is ExprTableAccessNodeKeys) { return(new ExprTableEvalStrategyGroupByKeys(grouped)); } // handle access-aggregator accessors if (tableNode is ExprTableAccessNodeSubpropAccessor) { var accessorProvider = (ExprTableAccessNodeSubpropAccessor)tableNode; var column = (TableMetadataColumnAggregation)tableMetadata.TableColumns.Get(accessorProvider.SubpropName); if (ungrouped != null) { var pairX = column.AccessAccessorSlotPair; return(new ExprTableEvalStrategyUngroupedAccess(ungrouped, pairX.Slot, accessorProvider.Accessor)); } var pair = new AggregationAccessorSlotPair( column.AccessAccessorSlotPair.Slot, accessorProvider.Accessor); if (tableNode.GroupKeyEvaluators.Length > 1) { return(new ExprTableEvalStrategyGroupByAccessMulti(grouped, pair, groupKeyEvals)); } return(new ExprTableEvalStrategyGroupByAccessSingle(grouped, pair, groupKeyEvals[0])); } throw new IllegalStateException("Unrecognized table access node " + tableNode); }
public ExprTableEvalStrategyGroupByAccessMulti(ILockable @lock, IDictionary <Object, ObjectArrayBackedEventBean> aggregationState, AggregationAccessorSlotPair pair, ExprEvaluator[] groupExpr) : base(@lock, aggregationState, pair) { _groupExpr = groupExpr; }
public ICollection <object> GetCollectionScalar(int column, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext context) { AggregationAccessorSlotPair pair = _accessors[column]; return(pair.Accessor.GetEnumerableScalar(_states[pair.Slot], eventsPerStream, isNewData, context)); }
public EventBean GetEventBean(int column, EvaluateParams evaluateParams) { AggregationAccessorSlotPair pair = _accessors[column]; return(pair.Accessor.GetEnumerableEvent(_states[pair.Slot], evaluateParams)); }
public ICollection <EventBean> GetCollectionOfEvents(int column, EvaluateParams evaluateParams) { AggregationAccessorSlotPair pair = _accessors[column]; return(pair.Accessor.GetEnumerableEvents(_states[pair.Slot], evaluateParams)); }
protected ExprTableEvalStrategyGroupByAccessBase(TableAndLockProviderGrouped provider, AggregationAccessorSlotPair pair) : base(provider) { _pair = pair; }
public ICollection <object> GetCollectionScalar(int column, EvaluateParams evaluateParams) { AggregationAccessorSlotPair pair = _accessors[column]; return(pair.Accessor.GetEnumerableScalar(_states[pair.Slot], evaluateParams)); }
public object GetValue(int column, int agentInstanceId, EvaluateParams evaluateParams) { AggregationAccessorSlotPair pair = _accessors[column]; return(pair.Accessor.GetValue(_states[pair.Slot], evaluateParams)); }
public ExprTableEvalStrategyGroupByAccessSingle(ILockable tableLevelLock, IDictionary <Object, ObjectArrayBackedEventBean> aggregationState, AggregationAccessorSlotPair pair, ExprEvaluator groupExpr) : base(tableLevelLock, aggregationState, pair) { this._groupExpr = groupExpr; }
private TableAccessAnalysisResult AnalyzePlanAggregations( string tableName, StatementContext statementContext, IList <TableColumnDesc> columns, EPServicesContext services, string internalTypeName, string publicTypeName) { // once upfront: obtains aggregation factories for each aggregation // we do this once as a factory may be a heavier object IDictionary <TableColumnDesc, AggregationMethodFactory> aggregationFactories = new Dictionary <TableColumnDesc, AggregationMethodFactory>(); foreach (var column in columns) { if (column is TableColumnDescAgg) { var agg = (TableColumnDescAgg)column; var factory = agg.Aggregation.Factory; aggregationFactories.Put(column, factory); } } // sort into these categories: // plain / method-agg / access-agg // compile all-column public types IList <TableColumnDescTyped> plainColumns = new List <TableColumnDescTyped>(); IList <TableColumnDescAgg> methodAggColumns = new List <TableColumnDescAgg>(); IList <TableColumnDescAgg> accessAggColumns = new List <TableColumnDescAgg>(); IDictionary <string, object> allColumnsPublicTypes = new LinkedHashMap <string, object>(); foreach (var column in columns) { // handle plain types if (column is TableColumnDescTyped) { var typed = (TableColumnDescTyped)column; plainColumns.Add(typed); allColumnsPublicTypes.Put(column.ColumnName, typed.UnresolvedType); continue; } // handle aggs var agg = (TableColumnDescAgg)column; var aggFactory = aggregationFactories.Get(agg); if (aggFactory.IsAccessAggregation) { accessAggColumns.Add(agg); } else { methodAggColumns.Add(agg); } allColumnsPublicTypes.Put(column.ColumnName, agg.Aggregation.ReturnType); } // determine column metadata // IDictionary <string, TableMetadataColumn> columnMetadata = new LinkedHashMap <string, TableMetadataColumn>(); // handle typed columns IDictionary <string, object> allColumnsInternalTypes = new LinkedHashMap <string, object>(); allColumnsInternalTypes.Put(TableServiceConstants.INTERNAL_RESERVED_PROPERTY, typeof(object)); var indexPlain = 1; IList <int> groupKeyIndexes = new List <int>(); var assignPairsPlain = new TableMetadataColumnPairPlainCol[plainColumns.Count]; foreach (var typedColumn in plainColumns) { allColumnsInternalTypes.Put(typedColumn.ColumnName, typedColumn.UnresolvedType); columnMetadata.Put(typedColumn.ColumnName, new TableMetadataColumnPlain(typedColumn.ColumnName, typedColumn.IsKey, indexPlain)); if (typedColumn.IsKey) { groupKeyIndexes.Add(indexPlain); } assignPairsPlain[indexPlain - 1] = new TableMetadataColumnPairPlainCol(typedColumn.PositionInDeclaration, indexPlain); indexPlain++; } // determine internally-used event type // for use by indexes and lookups ObjectArrayEventType internalEventType; ObjectArrayEventType publicEventType; try { internalEventType = (ObjectArrayEventType)services.EventAdapterService.AddNestableObjectArrayType(internalTypeName, allColumnsInternalTypes, null, false, false, false, false, false, true, tableName); publicEventType = (ObjectArrayEventType)services.EventAdapterService.AddNestableObjectArrayType(publicTypeName, allColumnsPublicTypes, null, false, false, false, false, false, false, null); } catch (EPException ex) { throw new ExprValidationException("Invalid type information: " + ex.Message, ex); } services.StatementEventTypeRefService.AddReferences(statementContext.StatementName, new string[] { internalTypeName, publicTypeName }); // handle aggregation-methods single-func first. var methodFactories = new AggregationMethodFactory[methodAggColumns.Count]; var index = 0; var assignPairsMethod = new TableMetadataColumnPairAggMethod[methodAggColumns.Count]; foreach (var column in methodAggColumns) { var factory = aggregationFactories.Get(column); var optionalEnumerationType = EPTypeHelper.OptionalFromEnumerationExpr(statementContext.StatementId, statementContext.EventAdapterService, column.Aggregation); methodFactories[index] = factory; columnMetadata.Put(column.ColumnName, new TableMetadataColumnAggregation(column.ColumnName, factory, index, null, optionalEnumerationType, column.OptionalAssociatedType)); assignPairsMethod[index] = new TableMetadataColumnPairAggMethod(column.PositionInDeclaration); index++; } // handle access-aggregation (sharable, multi-value) aggregations var stateFactories = new AggregationStateFactory[accessAggColumns.Count]; var assignPairsAccess = new TableMetadataColumnPairAggAccess[accessAggColumns.Count]; index = 0; foreach (var column in accessAggColumns) { var factory = aggregationFactories.Get(column); stateFactories[index] = factory.GetAggregationStateFactory(false); var pair = new AggregationAccessorSlotPair(index, factory.Accessor); var optionalEnumerationType = EPTypeHelper.OptionalFromEnumerationExpr(statementContext.StatementId, statementContext.EventAdapterService, column.Aggregation); columnMetadata.Put(column.ColumnName, new TableMetadataColumnAggregation(column.ColumnName, factory, -1, pair, optionalEnumerationType, column.OptionalAssociatedType)); assignPairsAccess[index] = new TableMetadataColumnPairAggAccess(column.PositionInDeclaration, factory.Accessor); index++; } // create state factory var groupKeyIndexesArr = CollectionUtil.IntArray(groupKeyIndexes); var stateRowFactory = new TableStateRowFactory( internalEventType, statementContext.EngineImportService, methodFactories, stateFactories, groupKeyIndexesArr, services.EventAdapterService); // create public event provision var eventToPublic = new TableMetadataInternalEventToPublic(publicEventType, assignPairsPlain, assignPairsMethod, assignPairsAccess, services.EventAdapterService); return(new TableAccessAnalysisResult(stateRowFactory, columnMetadata, methodAggColumns.Count, internalEventType, publicEventType, eventToPublic)); }