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