/// <summary>
/// Ctor.
/// </summary>
/// <param name="aggregationNode">expression</param>
/// <param name="factory">method factory</param>
public AggregationServiceAggExpressionDesc(
ExprAggregateNode aggregationNode,
AggregationForgeFactory factory)
{
AggregationNode = aggregationNode;
Factory = factory;
}
public AggregatorMethodWDistinctWFilterBase(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
bool hasFilter,
ExprNode optionalFilter)
{
this.optionalDistinctValueType = optionalDistinctValueType;
this.optionalFilter = optionalFilter;
this.hasFilter = hasFilter;
if (optionalDistinctValueType != null) {
distinct = membersColumnized.AddMember(col, typeof(RefCountedSet<object>), "distinctSet");
rowCtor.Block.AssignRef(distinct, NewInstance(typeof(RefCountedSet<object>)));
distinctSerde = classScope.AddOrGetDefaultFieldSharable(
new CodegenSharableSerdeClassTyped(REFCOUNTEDSET, optionalDistinctValueType));
}
else {
distinct = null;
distinctSerde = null;
}
}
public override AggregationForgeFactory ValidateAggregationChild(ExprValidationContext validationContext)
{
AggregationLinearFactoryDesc desc;
// handle table-access expression (state provided, accessor needed)
if (validationContext.StatementRawInfo.StatementType == StatementType.CREATE_TABLE)
{
// handle create-table statements (state creator and default accessor, limited to certain options)
desc = HandleCreateTable(positionalParams, _stateType, validationContext);
}
else if (validationContext.StatementRawInfo.IntoTableName != null)
{
// handle into-table (state provided, accessor and agent needed, validation done by factory)
desc = HandleIntoTable(positionalParams, _stateType, validationContext);
}
else
{
// handle standalone
desc = HandleNonIntoTable(positionalParams, _stateType, validationContext);
}
_containedType = desc.EnumerationEventType;
_scalarCollectionComponentType = desc.ScalarCollectionType;
var streamTypes = validationContext.StreamTypeService.EventTypes;
_streamType = desc.StreamNum >= streamTypes.Length ? streamTypes[0] : streamTypes[desc.StreamNum];
_aggregationForgeFactory = desc.Factory;
return(_aggregationForgeFactory);
}
public AggregatorLastEver(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
DataInputOutputSerdeForge optionalDistinctSerde,
bool hasFilter,
ExprNode optionalFilter,
Type childType,
DataInputOutputSerdeForge serde)
: base(factory, col, rowCtor, membersColumnized, classScope, optionalDistinctValueType, optionalDistinctSerde, hasFilter, optionalFilter)
{
_childType = childType.GetBoxedType();
// NOTE: we had originally set the value of the member to childType which seems correct an
// appropriate. However, the code is not doing proper type checking and cast conversion
// elsewhere which makes assignment problematic. Revisit this problem when we have more
// time.
_lastValue = membersColumnized.AddMember(col, typeof(object), "lastValue");
this._serde = classScope.AddOrGetDefaultFieldSharable(
new CodegenSharableSerdeClassTyped(
CodegenSharableSerdeClassTyped.CodegenSharableSerdeName.VALUE_NULLABLE,
childType,
serde,
classScope));
}
public AggregatorAvedev(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
DataInputOutputSerdeForge optionalDistinctSerde,
bool hasFilter,
ExprNode optionalFilter)
: base(
factory,
col,
rowCtor,
membersColumnized,
classScope,
optionalDistinctValueType,
optionalDistinctSerde,
hasFilter,
optionalFilter)
{
valueSet = membersColumnized.AddMember(col, typeof(RefCountedSet<double>), "valueSet");
sum = membersColumnized.AddMember(col, typeof(double), "sum");
rowCtor.Block.AssignRef(valueSet, NewInstance(typeof(RefCountedSet<double>)));
}
protected override void ValidateIntoTableWFilterWInputType(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
}
public AggregatorSumBig(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
bool hasFilter,
ExprNode optionalFilter,
Type sumType)
: base(
factory,
col,
rowCtor,
membersColumnized,
classScope,
optionalDistinctValueType,
hasFilter,
optionalFilter,
sumType)
{
if (sumType != typeof(BigInteger)) {
throw new ArgumentException("Invalid type " + sumType);
}
}
public AggregatorSumNonBig(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
bool hasFilter,
ExprNode optionalFilter,
Type sumType)
: base(
factory,
col,
rowCtor,
membersColumnized,
classScope,
optionalDistinctValueType,
hasFilter,
optionalFilter,
sumType)
{
var typeSet = Collections.Set(
typeof(decimal?),
typeof(double?),
typeof(long?),
typeof(int?),
typeof(float?));
if (!typeSet.Contains(sumType)) {
throw new ArgumentException("Invalid sum type " + sumType);
}
}
public AggregatorSumBase(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
bool hasFilter,
ExprNode optionalFilter,
Type sumType)
: base(
factory,
col,
rowCtor,
membersColumnized,
classScope,
optionalDistinctValueType,
hasFilter,
optionalFilter)
{
cnt = membersColumnized.AddMember(col, typeof(long), "cnt");
sum = membersColumnized.AddMember(col, sumType.GetPrimitiveType(), "sum");
this.sumType = sumType;
rowCtor.Block.AssignRef(sum, InitOfSum());
}
public void ValidateIntoTableCompatible(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
AggregationValidationUtil.ValidateAggregationType(this, tableExpression, intoTableAgg, intoExpression);
}
public void ValidateIntoTableCompatible(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
AggregationValidationUtil.ValidateAggregationType(this, tableExpression, intoTableAgg, intoExpression);
var other = (AggregationPortableValidationLinear) intoTableAgg;
AggregationValidationUtil.ValidateEventType(ContainedEventType, other.ContainedEventType);
}
public void ValidateIntoTableCompatible(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
AggregationValidationUtil.ValidateAggregationType(this, tableExpression, intoTableAgg, intoExpression);
var that = (AggregationPortableValidationBase) intoTableAgg;
AggregationValidationUtil.ValidateDistinct(IsDistinct, that.IsDistinct);
ValidateIntoTable(tableExpression, intoTableAgg, intoExpression, factory);
}
public AggregationLinearFactoryDesc(
AggregationForgeFactory factory,
EventType enumerationEventType,
Type scalarCollectionType,
int streamNum)
{
Factory = factory;
EnumerationEventType = enumerationEventType;
ScalarCollectionType = scalarCollectionType;
StreamNum = streamNum;
}
protected override void ValidateIntoTable(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
var that = (AggregationPortableValidationWFilterWInputType) intoTableAgg;
AggregationValidationUtil.ValidateAggregationInputType(InputValueType, that.InputValueType);
AggregationValidationUtil.ValidateAggregationFilter(HasFilter, that.HasFilter);
ValidateIntoTableWFilterWInputType(tableExpression, intoTableAgg, intoExpression, factory);
}
public override AggregationForgeFactory ValidateAggregationChild(ExprValidationContext validationContext)
{
if (IsDistinct)
{
throw new ExprValidationException(MessagePrefix + "is not supported with distinct");
}
// for declaration, validate the specification and return the state factory
if (aggType == CountMinSketchAggType.STATE)
{
if (validationContext.StatementRawInfo.StatementType != StatementType.CREATE_TABLE)
{
throw new ExprValidationException(MessagePrefix + "can only be used in create-table statements");
}
CountMinSketchSpecForge specification = ValidateSpecification(validationContext);
AggregationStateCountMinSketchForge stateFactory = new AggregationStateCountMinSketchForge(this, specification);
forgeFactory = new AggregationForgeFactoryAccessCountMinSketchState(this, stateFactory);
return(forgeFactory);
}
if (aggType != CountMinSketchAggType.ADD)
{
// other methods are only used with table-access expressions
throw new ExprValidationException(MessagePrefix + "requires the use of a table-access expression");
}
if (validationContext.StatementRawInfo.IntoTableName == null)
{
throw new ExprValidationException(MessagePrefix + "can only be used with into-table");
}
if (positionalParams.Length == 0 || positionalParams.Length > 1)
{
throw new ExprValidationException(MessagePrefix + "requires a single parameter expression");
}
ExprNodeUtilityValidate.GetValidatedSubtree(ExprNodeOrigin.AGGPARAM, this.ChildNodes, validationContext);
// obtain evaluator
ExprForge addOrFrequencyEvaluator = null;
Type addOrFrequencyEvaluatorReturnType = null;
if (aggType == CountMinSketchAggType.ADD)
{
addOrFrequencyEvaluator = ChildNodes[0].Forge;
addOrFrequencyEvaluatorReturnType = addOrFrequencyEvaluator.EvaluationType;
}
forgeFactory = new AggregationForgeFactoryAccessCountMinSketchAdd(this, addOrFrequencyEvaluator, addOrFrequencyEvaluatorReturnType);
return(forgeFactory);
}
protected override void ValidateIntoTable(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
AggregationPortableValidationPlugin that = (AggregationPortableValidationPlugin) intoTableAgg;
if (!_functionName.Equals(that._functionName))
{
throw new ExprValidationException(
"The aggregation declares '" + _functionName + "' and provided is '" + that._functionName + "'");
}
}
public AggregatorMedian(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
DataInputOutputSerdeForge optionalDistinctSerde,
bool hasFilter,
ExprNode optionalFilter)
: base(factory, col, rowCtor, membersColumnized, classScope, optionalDistinctValueType, optionalDistinctSerde, hasFilter, optionalFilter)
{
_vector = membersColumnized.AddMember(col, typeof(SortedDoubleVector), "vector");
rowCtor.Block.AssignRef(_vector, NewInstance(typeof(SortedDoubleVector)));
}
protected override void ValidateIntoTableWFilterWInputType(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
var that = (AggregationPortableValidationFirstLastEver) intoTableAgg;
if (IsFirst != that.IsFirst) {
throw new ExprValidationException(
"The aggregation declares " +
(IsFirst ? "firstever" : "lastever") +
" and provided is " +
(that.IsFirst ? "firstever" : "lastever"));
}
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
ValidatePositionals(validationContext);
aggregationMethodFactory = ValidateAggregationChild(validationContext);
if (!validationContext.IsAggregationFutureNameAlreadySet) {
aggregationResultFutureMemberName = validationContext.MemberNames.AggregationResultFutureRef();
}
else {
if (aggregationResultFutureMemberName == null) {
throw new ExprValidationException("Aggregation future not set");
}
}
return null;
}
protected override void ValidateIntoTableWFilterWInputType(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
var that = (AggregationPortableValidationRate) intoTableAgg;
if (IntervalTime != that.IntervalTime) {
throw new ExprValidationException(
"The interval-time is " +
IntervalTime +
" and provided is " +
that.IntervalTime);
}
}
protected override void ValidateIntoTableWFilterWInputType(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
AggregationPortableValidationNth that = (AggregationPortableValidationNth) intoTableAgg;
if (Size != that.Size) {
throw new ExprValidationException(
"The size is " +
Size +
" and provided is " +
that.Size);
}
}
public AggregatorCount(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
DataInputOutputSerdeForge optionalDistinctSerde,
bool hasFilter,
ExprNode optionalFilter,
bool isEver)
: base(factory, col, rowCtor, membersColumnized, classScope, optionalDistinctValueType, optionalDistinctSerde, hasFilter, optionalFilter)
{
_isEver = isEver;
_cnt = membersColumnized.AddMember(col, typeof(long), "cnt");
}
protected override void ValidateIntoTableWFilterWInputType(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
var that = (AggregationPortableValidationMinMax) intoTableAgg;
if (MinMax != that.MinMax) {
throw new ExprValidationException(
"The aggregation declares " +
MinMax.GetExpressionText() +
" and provided is " +
that.MinMax.GetExpressionText());
}
AggregationValidationUtil.ValidateAggregationUnbound(IsUnbound, that.IsUnbound);
}
public AggregatorMethodWDistinctWFilterWValueBase(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
bool hasFilter,
ExprNode optionalFilter)
: base(
factory,
col,
rowCtor,
membersColumnized,
classScope,
optionalDistinctValueType,
hasFilter,
optionalFilter)
{
}
public AggregatorSumNumeric(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
DataInputOutputSerdeForge optionalDistinctSerde,
bool hasFilter,
ExprNode optionalFilter,
Type sumType)
: base(factory, col, rowCtor, membersColumnized, classScope, optionalDistinctValueType, optionalDistinctSerde, hasFilter, optionalFilter, sumType)
{
if (!sumType.IsInt32() &&
!sumType.IsInt64() &&
!sumType.IsDecimal() &&
!sumType.IsDouble() &&
!sumType.IsSingle()) {
throw new ArgumentException("Invalid sum type " + sumType);
}
}
public AggregatorStddev(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
bool hasFilter,
ExprNode optionalFilter)
: base(
factory,
col,
rowCtor,
membersColumnized,
classScope,
optionalDistinctValueType,
hasFilter,
optionalFilter)
{
mean = membersColumnized.AddMember(col, typeof(double), "mean");
qn = membersColumnized.AddMember(col, typeof(double), "qn");
cnt = membersColumnized.AddMember(col, typeof(long), "cnt");
}
public override AggregationForgeFactory ValidateAggregationChild(ExprValidationContext validationContext)
{
AggregationForgeFactoryAccessSorted factory;
if (validationContext.StatementRawInfo.StatementType == StatementType.CREATE_TABLE)
{
// handle create-table statements (state creator and default accessor, limited to certain options)
factory = HandleCreateTable(validationContext);
}
else if (validationContext.StatementRawInfo.IntoTableName != null)
{
// handle into-table (state provided, accessor and agent needed, validation done by factory)
factory = HandleIntoTable(validationContext);
}
else
{
// handle standalone
factory = HandleNonTable(validationContext);
}
_containedType = factory.ContainedEventType;
_aggregationForgeFactory = factory;
return(factory);
}
private TableAccessAnalysisResult AnalyzePlanAggregations(
string tableName,
IList<TableColumnDesc> columns,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
// once upfront: obtains aggregation factories for each aggregation
// we do this once as a factory may be a heavier object
IDictionary<TableColumnDesc, AggregationForgeFactory> aggregationFactories =
new Dictionary<TableColumnDesc, AggregationForgeFactory>();
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>();
var 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.EvaluationType);
}
// determine column metadata
//
var columnMetadata = new LinkedHashMap<string, TableMetadataColumn>();
// handle typed columns
var allColumnsInternalTypes = new LinkedHashMap<string, object>();
allColumnsInternalTypes.Put(INTERNAL_RESERVED_PROPERTY, typeof(object));
var indexPlain = 1;
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));
assignPairsPlain[indexPlain - 1] = new TableMetadataColumnPairPlainCol(
typedColumn.PositionInDeclaration,
indexPlain);
indexPlain++;
}
// determine internally-used event type
var visibility = services.ModuleVisibilityRules.GetAccessModifierTable(@base, tableName);
var internalName = EventTypeNameUtil.GetTableInternalTypeName(tableName);
var internalMetadata = new EventTypeMetadata(
internalName,
@base.ModuleName,
EventTypeTypeClass.TABLE_INTERNAL,
EventTypeApplicationType.OBJECTARR,
visibility,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var internalEventType = BaseNestableEventUtil.MakeOATypeCompileTime(
internalMetadata,
allColumnsInternalTypes,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(internalEventType);
// for use by indexes and lookups
var publicName = EventTypeNameUtil.GetTablePublicTypeName(tableName);
var publicMetadata = new EventTypeMetadata(
publicName,
@base.ModuleName,
EventTypeTypeClass.TABLE_PUBLIC,
EventTypeApplicationType.OBJECTARR,
visibility,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var publicEventType = BaseNestableEventUtil.MakeOATypeCompileTime(
publicMetadata,
allColumnsPublicTypes,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(publicEventType);
// handle aggregation-methods single-func first.
var methodFactories = new AggregationForgeFactory[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(
statementRawInfo,
services,
column.Aggregation);
methodFactories[index] = factory;
var bindingInfo = factory.AggregationPortableValidation;
var expression =
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(factory.AggregationExpression);
columnMetadata.Put(
column.ColumnName,
new TableMetadataColumnAggregation(
column.ColumnName,
false,
index,
bindingInfo,
expression,
true,
optionalEnumerationType));
assignPairsMethod[index] = new TableMetadataColumnPairAggMethod(column.PositionInDeclaration);
index++;
}
// handle access-aggregation (sharable, multi-value) aggregations
var stateFactories = new AggregationStateFactoryForge[accessAggColumns.Count];
var accessAccessorForges = new AggregationAccessorSlotPairForge[accessAggColumns.Count];
var assignPairsAccess = new TableMetadataColumnPairAggAccess[accessAggColumns.Count];
var accessNum = 0;
foreach (var column in accessAggColumns) {
var factory = aggregationFactories.Get(column);
var forge = factory.GetAggregationStateFactory(false);
stateFactories[accessNum] = forge;
var accessor = factory.AccessorForge;
var bindingInfo = factory.AggregationPortableValidation;
accessAccessorForges[accessNum] = new AggregationAccessorSlotPairForge(accessNum, accessor);
var expression =
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(factory.AggregationExpression);
var optionalEnumerationType = EPTypeHelper.OptionalFromEnumerationExpr(
statementRawInfo,
services,
column.Aggregation);
columnMetadata.Put(
column.ColumnName,
new TableMetadataColumnAggregation(
column.ColumnName,
false,
index,
bindingInfo,
expression,
false,
optionalEnumerationType));
assignPairsAccess[accessNum] =
new TableMetadataColumnPairAggAccess(column.PositionInDeclaration, accessor);
index++;
accessNum++;
}
// determine primary key index information
var primaryKeyColumns = new List<string>();
var primaryKeyTypes = new List<Type>();
var primaryKeyGetters = new List<EventPropertyGetterSPI>();
var primaryKeyColNums = new List<int>();
var colNum = -1;
foreach (var typedColumn in plainColumns) {
colNum++;
if (typedColumn.IsKey) {
primaryKeyColumns.Add(typedColumn.ColumnName);
primaryKeyTypes.Add(internalEventType.GetPropertyType(typedColumn.ColumnName));
primaryKeyGetters.Add(internalEventType.GetGetterSPI(typedColumn.ColumnName));
primaryKeyColNums.Add(colNum + 1);
}
}
string[] primaryKeyColumnArray = null;
Type[] primaryKeyTypeArray = null;
EventPropertyGetterSPI[] primaryKeyGetterArray = null;
int[] primaryKeyColNumsArray = null;
if (!primaryKeyColumns.IsEmpty()) {
primaryKeyColumnArray = primaryKeyColumns.ToArray();
primaryKeyTypeArray = primaryKeyTypes.ToArray();
primaryKeyGetterArray = primaryKeyGetters.ToArray();
primaryKeyColNumsArray = primaryKeyColNums.ToArray();
}
var forgeDesc = new AggregationRowStateForgeDesc(
methodFactories,
null,
stateFactories,
accessAccessorForges,
new AggregationUseFlags(false, false, false));
var multiKeyPlan = MultiKeyPlanner.PlanMultiKey(
primaryKeyTypeArray, false, statementRawInfo, services.SerdeResolver);
var propertyForges = new DataInputOutputSerdeForge[internalEventType.PropertyNames.Length - 1];
var additionalForgeables = new List<StmtClassForgeableFactory>(multiKeyPlan.MultiKeyForgeables);
for (var i = 1; i < internalEventType.PropertyNames.Length; i++) {
var propertyName = internalEventType.PropertyNames[i];
var propertyType = internalEventType.Types.Get(propertyName);
var desc = SerdeEventPropertyUtility.ForgeForEventProperty(
publicEventType, propertyName, propertyType, statementRawInfo, services.SerdeResolver);
propertyForges[i - 1] = desc.Forge;
// plan serdes for nested types
foreach (var eventType in desc.NestedTypes) {
var serdeForgeables = SerdeEventTypeUtility.Plan(
eventType,
statementRawInfo,
services.SerdeEventTypeRegistry,
services.SerdeResolver);
additionalForgeables.AddAll(serdeForgeables);
}
}
return new TableAccessAnalysisResult(
columnMetadata,
internalEventType,
propertyForges,
publicEventType,
assignPairsPlain,
assignPairsMethod,
assignPairsAccess,
forgeDesc,
primaryKeyColumnArray,
primaryKeyGetterArray,
primaryKeyTypeArray,
primaryKeyColNumsArray,
multiKeyPlan.ClassRef,
additionalForgeables);
}
public static AggregationServiceForgeDesc GetService(
IList<ExprAggregateNode> selectAggregateExprNodes,
IDictionary<ExprNode, string> selectClauseNamedNodes,
IList<ExprDeclaredNode> declaredExpressions,
ExprNode[] groupByNodes,
MultiKeyClassRef groupByMultiKey,
IList<ExprAggregateNode> havingAggregateExprNodes,
IList<ExprAggregateNode> orderByAggregateExprNodes,
IList<ExprAggregateNodeGroupKey> groupKeyExpressions,
bool hasGroupByClause,
Attribute[] annotations,
VariableCompileTimeResolver variableCompileTimeResolver,
bool isDisallowNoReclaim,
ExprNode whereClause,
ExprNode havingClause,
EventType[] typesPerStream,
AggregationGroupByRollupDescForge groupByRollupDesc,
string optionalContextName,
IntoTableSpec intoTableSpec,
TableCompileTimeResolver tableCompileTimeResolver,
bool isUnidirectional,
bool isFireAndForget,
bool isOnSelect,
ImportServiceCompileTime importService,
StatementRawInfo raw,
SerdeCompileTimeResolver serdeResolver)
{
// No aggregates used, we do not need this service
if (selectAggregateExprNodes.IsEmpty() && havingAggregateExprNodes.IsEmpty()) {
if (intoTableSpec != null) {
throw new ExprValidationException("Into-table requires at least one aggregation function");
}
return new AggregationServiceForgeDesc(
AggregationServiceNullFactory.INSTANCE,
EmptyList<AggregationServiceAggExpressionDesc>.Instance,
EmptyList<ExprAggregateNodeGroupKey>.Instance,
EmptyList<StmtClassForgeableFactory>.Instance);
}
// Validate the absence of "prev" function in where-clause:
// Since the "previous" function does not post remove stream results, disallow when used with aggregations.
if (whereClause != null || havingClause != null) {
var visitor = new ExprNodePreviousVisitorWParent();
whereClause?.Accept(visitor);
havingClause?.Accept(visitor);
if (visitor.Previous != null && !visitor.Previous.IsEmpty()) {
string funcname = visitor.Previous[0]
.Second.PreviousType.ToString()
.ToLowerInvariant();
throw new ExprValidationException(
"The '" +
funcname +
"' function may not occur in the where-clause or having-clause of a statement with aggregations as 'previous' does not provide remove stream data; Use the 'first','last','window' or 'count' aggregation functions instead");
}
}
// Compile a map of aggregation nodes and equivalent-to aggregation nodes.
// Equivalent-to functions are for example "select sum(a*b), 5*sum(a*b)".
// Reducing the total number of aggregation functions.
var aggregations = new List<AggregationServiceAggExpressionDesc>();
var intoTableNonRollup = groupByRollupDesc == null && intoTableSpec != null;
foreach (var selectAggNode in selectAggregateExprNodes) {
AddEquivalent(selectAggNode, aggregations, intoTableNonRollup);
}
foreach (var havingAggNode in havingAggregateExprNodes) {
AddEquivalent(havingAggNode, aggregations, intoTableNonRollup);
}
foreach (var orderByAggNode in orderByAggregateExprNodes) {
AddEquivalent(orderByAggNode, aggregations, intoTableNonRollup);
}
// Construct a list of evaluation node for the aggregation functions (regular agg).
// For example "sum(2 * 3)" would make the sum an evaluation node.
IList<ExprForge[]> methodAggForgesList = new List<ExprForge[]>();
foreach (var aggregation in aggregations) {
var aggregateNode = aggregation.AggregationNode;
if (!aggregateNode.Factory.IsAccessAggregation) {
var forges = aggregateNode.Factory.GetMethodAggregationForge(
typesPerStream.Length > 1,
typesPerStream);
methodAggForgesList.Add(forges);
}
}
// determine local group-by, report when hook provided
var localGroupDesc = AnalyzeLocalGroupBy(aggregations, groupByNodes, groupByRollupDesc, intoTableSpec);
// determine binding
if (intoTableSpec != null) {
// obtain metadata
var metadata = tableCompileTimeResolver.Resolve(intoTableSpec.Name);
if (metadata == null) {
throw new ExprValidationException(
"Invalid into-table clause: Failed to find table by name '" + intoTableSpec.Name + "'");
}
EPLValidationUtil.ValidateContextName(
true,
intoTableSpec.Name,
metadata.OptionalContextName,
optionalContextName,
false);
// validate group keys
var groupByTypes = ExprNodeUtilityQuery.GetExprResultTypes(groupByNodes);
var keyTypes = metadata.IsKeyed ? metadata.KeyTypes : new Type[0];
ExprTableNodeUtil.ValidateExpressions(
intoTableSpec.Name,
groupByTypes,
"group-by",
groupByNodes,
keyTypes,
"group-by");
// determine how this binds to existing aggregations, assign column numbers
var bindingMatchResult = MatchBindingsAssignColumnNumbers(
intoTableSpec,
metadata,
aggregations,
selectClauseNamedNodes,
methodAggForgesList,
declaredExpressions,
importService,
raw.StatementName);
// return factory
AggregationServiceFactoryForge serviceForgeX = new AggregationServiceFactoryForgeTable(
metadata,
bindingMatchResult.MethodPairs,
bindingMatchResult.TargetStates,
bindingMatchResult.Agents,
groupByRollupDesc);
return new AggregationServiceForgeDesc(serviceForgeX, aggregations, groupKeyExpressions, EmptyList<StmtClassForgeableFactory>.Instance);
}
// Assign a column number to each aggregation node. The regular aggregation goes first followed by access-aggregation.
var columnNumber = 0;
foreach (var entry in aggregations) {
if (!entry.Factory.IsAccessAggregation) {
entry.SetColumnNum(columnNumber++);
}
}
foreach (var entry in aggregations) {
if (entry.Factory.IsAccessAggregation) {
entry.SetColumnNum(columnNumber++);
}
}
// determine method aggregation factories and evaluators(non-access)
var methodAggForges = methodAggForgesList.ToArray();
var methodAggFactories = new AggregationForgeFactory[methodAggForges.Length];
var count = 0;
foreach (var aggregation in aggregations) {
var aggregateNode = aggregation.AggregationNode;
if (!aggregateNode.Factory.IsAccessAggregation) {
methodAggFactories[count] = aggregateNode.Factory;
count++;
}
}
// handle access aggregations
var multiFunctionAggPlan = AggregationMultiFunctionAnalysisHelper.AnalyzeAccessAggregations(
aggregations,
importService,
isFireAndForget,
raw.StatementName,
groupByNodes);
var accessorPairsForge = multiFunctionAggPlan.AccessorPairsForge;
var accessFactories = multiFunctionAggPlan.StateFactoryForges;
var hasAccessAgg = accessorPairsForge.Length > 0;
var hasMethodAgg = methodAggFactories.Length > 0;
AggregationServiceFactoryForge serviceForge;
var useFlags = new AggregationUseFlags(isUnidirectional, isFireAndForget, isOnSelect);
var additionalForgeables = new List<StmtClassForgeableFactory>();
// analyze local group by
AggregationLocalGroupByPlanForge localGroupByPlan = null;
if (localGroupDesc != null) {
AggregationLocalGroupByPlanDesc plan = AggregationGroupByLocalGroupByAnalyzer.Analyze(
methodAggForges,
methodAggFactories,
accessFactories,
localGroupDesc,
groupByNodes,
groupByMultiKey,
accessorPairsForge,
raw,
serdeResolver);
localGroupByPlan = plan.Forge;
additionalForgeables.AddAll(plan.AdditionalForgeables);
try {
var hook = (AggregationLocalLevelHook) ImportUtil.GetAnnotationHook(
annotations,
HookType.INTERNAL_AGGLOCALLEVEL,
typeof(AggregationLocalLevelHook),
importService);
hook?.Planned(localGroupDesc, localGroupByPlan);
}
catch (ExprValidationException) {
throw new EPException("Failed to obtain hook for " + HookType.INTERNAL_AGGLOCALLEVEL);
}
}
// Handle without a group-by clause: we group all into the same pot
var rowStateDesc = new AggregationRowStateForgeDesc(
hasMethodAgg ? methodAggFactories : null,
hasMethodAgg ? methodAggForges : null,
hasAccessAgg ? accessFactories : null,
hasAccessAgg ? accessorPairsForge : null,
useFlags);
if (!hasGroupByClause) {
if (localGroupByPlan != null) {
serviceForge = new AggSvcLocalGroupByForge(false, localGroupByPlan, useFlags);
}
else {
serviceForge = new AggregationServiceGroupAllForge(rowStateDesc);
}
}
else {
var groupDesc = new AggGroupByDesc(
rowStateDesc,
isUnidirectional,
isFireAndForget,
isOnSelect,
groupByNodes,
groupByMultiKey);
var hasNoReclaim = HintEnum.DISABLE_RECLAIM_GROUP.GetHint(annotations) != null;
var reclaimGroupAged = HintEnum.RECLAIM_GROUP_AGED.GetHint(annotations);
var reclaimGroupFrequency = HintEnum.RECLAIM_GROUP_AGED.GetHint(annotations);
if (localGroupByPlan != null) {
serviceForge = new AggSvcLocalGroupByForge(true, localGroupByPlan, useFlags);
}
else {
if (!isDisallowNoReclaim && hasNoReclaim) {
if (groupByRollupDesc != null) {
throw GetRollupReclaimEx();
}
serviceForge = new AggregationServiceGroupByForge(groupDesc, importService.TimeAbacus);
}
else if (!isDisallowNoReclaim && reclaimGroupAged != null) {
if (groupByRollupDesc != null) {
throw GetRollupReclaimEx();
}
CompileReclaim(
groupDesc,
reclaimGroupAged,
reclaimGroupFrequency,
variableCompileTimeResolver,
optionalContextName);
serviceForge = new AggregationServiceGroupByForge(groupDesc, importService.TimeAbacus);
}
else if (groupByRollupDesc != null) {
serviceForge = new AggSvcGroupByRollupForge(rowStateDesc, groupByRollupDesc, groupByNodes);
}
else {
groupDesc.IsRefcounted = true;
serviceForge = new AggregationServiceGroupByForge(groupDesc, importService.TimeAbacus);
}
}
}
return new AggregationServiceForgeDesc(serviceForge, aggregations, groupKeyExpressions, additionalForgeables);
}
protected abstract void ValidateIntoTable(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory);