private AggregationCodegenRowDetailDesc MapDesc(
bool top,
int levelNum,
AggregationLocalGroupByColumnForge[] columns,
AggregationLocalGroupByLevelForge level)
{
IList<AggregationAccessorSlotPairForge> accessAccessors = new List<AggregationAccessorSlotPairForge>(4);
for (var i = 0; i < columns.Length; i++) {
var column = columns[i];
if (column.Pair != null) {
if (top && column.IsDefaultGroupLevel) {
accessAccessors.Add(column.Pair);
}
else if (column.LevelNum == levelNum) {
accessAccessors.Add(column.Pair);
}
}
}
AggregationAccessorSlotPairForge[] pairs = accessAccessors.ToArray();
return new AggregationCodegenRowDetailDesc(
new AggregationCodegenRowDetailStateDesc(
level.MethodForges,
level.MethodFactories,
level.AccessStateForges),
pairs,
level.PartitionMKClasses);
}
public AggregationGroupByLocalGroupLevelDesc(
AggregationLocalGroupByLevelForge forge,
IList<StmtClassForgeableFactory> additionalForgeables)
{
Forge = forge;
AdditionalForgeables = additionalForgeables;
}
public static AggregationLocalGroupByPlanForge Analyze(
ExprForge[][] methodForges,
AggregationForgeFactory[] methodFactories,
AggregationStateFactoryForge[] accessAggregations,
AggregationGroupByLocalGroupDesc localGroupDesc,
ExprNode[] groupByExpressions,
AggregationAccessorSlotPairForge[] accessors,
ImportService importService,
bool fireAndForget,
string statementName)
{
if (groupByExpressions == null) {
groupByExpressions = ExprNodeUtilityQuery.EMPTY_EXPR_ARRAY;
}
var columns = new AggregationLocalGroupByColumnForge[localGroupDesc.NumColumns];
IList<AggregationLocalGroupByLevelForge> levelsList = new List<AggregationLocalGroupByLevelForge>();
AggregationLocalGroupByLevelForge optionalTopLevel = null;
// determine optional top level (level number is -1)
for (var i = 0; i < localGroupDesc.Levels.Length; i++) {
var levelDesc = localGroupDesc.Levels[i];
if (levelDesc.PartitionExpr.Length == 0) {
optionalTopLevel = GetLevel(
-1,
levelDesc,
methodForges,
methodFactories,
accessAggregations,
columns,
groupByExpressions.Length == 0,
accessors,
importService,
fireAndForget,
statementName);
}
}
// determine default (same as group-by) level, if any, assign level number 0
var levelNumber = 0;
for (var i = 0; i < localGroupDesc.Levels.Length; i++) {
var levelDesc = localGroupDesc.Levels[i];
if (levelDesc.PartitionExpr.Length == 0) {
continue;
}
var isDefaultLevel = groupByExpressions != null &&
ExprNodeUtilityCompare.DeepEqualsIgnoreDupAndOrder(
groupByExpressions,
levelDesc.PartitionExpr);
if (isDefaultLevel) {
var level = GetLevel(
0,
levelDesc,
methodForges,
methodFactories,
accessAggregations,
columns,
isDefaultLevel,
accessors,
importService,
fireAndForget,
statementName);
levelsList.Add(level);
levelNumber++;
break;
}
}
// determine all other levels, assign level numbers
for (var i = 0; i < localGroupDesc.Levels.Length; i++) {
var levelDesc = localGroupDesc.Levels[i];
if (levelDesc.PartitionExpr.Length == 0) {
continue;
}
var isDefaultLevel = groupByExpressions != null &&
ExprNodeUtilityCompare.DeepEqualsIgnoreDupAndOrder(
groupByExpressions,
levelDesc.PartitionExpr);
if (isDefaultLevel) {
continue;
}
var level = GetLevel(
levelNumber,
levelDesc,
methodForges,
methodFactories,
accessAggregations,
columns,
isDefaultLevel,
accessors,
importService,
fireAndForget,
statementName);
levelsList.Add(level);
levelNumber++;
}
// totals
var numMethods = 0;
var numAccesses = 0;
if (optionalTopLevel != null) {
numMethods += optionalTopLevel.MethodFactories.Length;
numAccesses += optionalTopLevel.AccessStateForges.Length;
}
foreach (var level in levelsList) {
numMethods += level.MethodFactories.Length;
numAccesses += level.AccessStateForges.Length;
}
AggregationLocalGroupByLevelForge[] levels = levelsList.ToArray();
return new AggregationLocalGroupByPlanForge(numMethods, numAccesses, columns, optionalTopLevel, levels);
}
public static AggregationLocalGroupByPlanDesc Analyze(
ExprForge[][] methodForges,
AggregationForgeFactory[] methodFactories,
AggregationStateFactoryForge[] accessAggregations,
AggregationGroupByLocalGroupDesc localGroupDesc,
ExprNode[] groupByExpressions,
MultiKeyClassRef groupByMultiKey,
AggregationAccessorSlotPairForge[] accessors,
StatementRawInfo raw,
SerdeCompileTimeResolver serdeResolver)
{
if (groupByExpressions == null) {
groupByExpressions = ExprNodeUtilityQuery.EMPTY_EXPR_ARRAY;
}
var columns = new AggregationLocalGroupByColumnForge[localGroupDesc.NumColumns];
var levelsList = new List<AggregationLocalGroupByLevelForge>();
AggregationLocalGroupByLevelForge optionalTopLevel = null;
var additionalForgeables = new List<StmtClassForgeableFactory>();
// determine optional top level (level number is -1)
for (var i = 0; i < localGroupDesc.Levels.Length; i++) {
var levelDesc = localGroupDesc.Levels[i];
if (levelDesc.PartitionExpr.Length == 0) {
AggregationGroupByLocalGroupLevelDesc top = GetLevel(
-1,
levelDesc,
methodForges,
methodFactories,
accessAggregations,
columns,
groupByExpressions.Length == 0,
accessors,
groupByExpressions,
groupByMultiKey,
raw,
serdeResolver);
optionalTopLevel = top.Forge;
additionalForgeables.AddRange(top.AdditionalForgeables);
}
}
// determine default (same as group-by) level, if any, assign level number 0
var levelNumber = 0;
for (var i = 0; i < localGroupDesc.Levels.Length; i++) {
var levelDesc = localGroupDesc.Levels[i];
if (levelDesc.PartitionExpr.Length == 0) {
continue;
}
var isDefaultLevel = groupByExpressions != null &&
ExprNodeUtilityCompare.DeepEqualsIgnoreDupAndOrder(
groupByExpressions,
levelDesc.PartitionExpr);
if (isDefaultLevel) {
AggregationGroupByLocalGroupLevelDesc level = GetLevel(
0,
levelDesc,
methodForges,
methodFactories,
accessAggregations,
columns,
isDefaultLevel,
accessors,
groupByExpressions,
groupByMultiKey,
raw,
serdeResolver);
additionalForgeables.AddRange(level.AdditionalForgeables);
levelsList.Add(level.Forge);
levelNumber++;
break;
}
}
// determine all other levels, assign level numbers
for (var i = 0; i < localGroupDesc.Levels.Length; i++) {
var levelDesc = localGroupDesc.Levels[i];
if (levelDesc.PartitionExpr.Length == 0) {
continue;
}
var isDefaultLevel = groupByExpressions != null &&
ExprNodeUtilityCompare.DeepEqualsIgnoreDupAndOrder(
groupByExpressions,
levelDesc.PartitionExpr);
if (isDefaultLevel) {
continue;
}
AggregationGroupByLocalGroupLevelDesc level = GetLevel(
levelNumber,
levelDesc,
methodForges,
methodFactories,
accessAggregations,
columns,
isDefaultLevel,
accessors,
groupByExpressions,
groupByMultiKey,
raw,
serdeResolver);
levelsList.Add(level.Forge);
additionalForgeables.AddRange(level.AdditionalForgeables);
levelNumber++;
}
// totals
var numMethods = 0;
var numAccesses = 0;
if (optionalTopLevel != null) {
numMethods += optionalTopLevel.MethodFactories.Length;
numAccesses += optionalTopLevel.AccessStateForges.Length;
}
foreach (var level in levelsList) {
numMethods += level.MethodFactories.Length;
numAccesses += level.AccessStateForges.Length;
}
AggregationLocalGroupByLevelForge[] levels = levelsList.ToArray();
AggregationLocalGroupByPlanForge forge = new AggregationLocalGroupByPlanForge(numMethods, numAccesses, columns, optionalTopLevel, levels);
return new AggregationLocalGroupByPlanDesc(forge, additionalForgeables);
}
// Obtain those method and state factories for each level
private static AggregationGroupByLocalGroupLevelDesc GetLevel(
int levelNumber,
AggregationGroupByLocalGroupLevel level,
ExprForge[][] methodForgesAll,
AggregationForgeFactory[] methodFactoriesAll,
AggregationStateFactoryForge[] accessForges,
AggregationLocalGroupByColumnForge[] columns,
bool defaultLevel,
AggregationAccessorSlotPairForge[] accessors,
ExprNode[] groupByExpressions,
MultiKeyClassRef optionalGroupByMultiKey,
StatementRawInfo raw,
SerdeCompileTimeResolver serdeResolver)
{
var partitionExpr = level.PartitionExpr;
MultiKeyPlan multiKeyPlan;
if (defaultLevel && optionalGroupByMultiKey != null) { // use default multi-key that is already generated
multiKeyPlan = new MultiKeyPlan(EmptyList<StmtClassForgeableFactory>.Instance, optionalGroupByMultiKey);
partitionExpr = groupByExpressions;
} else {
multiKeyPlan = MultiKeyPlanner.PlanMultiKey(partitionExpr, false, raw, serdeResolver);
}
IList<ExprForge[]> methodForges = new List<ExprForge[]>();
IList<AggregationForgeFactory> methodFactories = new List<AggregationForgeFactory>();
IList<AggregationStateFactoryForge> stateFactories = new List<AggregationStateFactoryForge>();
foreach (var expr in level.Expressions) {
int column = expr.AggregationNode.Column;
var methodOffset = -1;
var methodAgg = true;
AggregationAccessorSlotPairForge pair = null;
if (column < methodForgesAll.Length) {
methodForges.Add(methodForgesAll[column]);
methodFactories.Add(methodFactoriesAll[column]);
methodOffset = methodFactories.Count - 1;
}
else {
// slot gives us the number of the state factory
int absoluteSlot = accessors[column - methodForgesAll.Length].Slot;
AggregationAccessorForge accessor = accessors[column - methodForgesAll.Length].AccessorForge;
var factory = accessForges[absoluteSlot];
var relativeSlot = stateFactories.IndexOf(factory);
if (relativeSlot == -1) {
stateFactories.Add(factory);
relativeSlot = stateFactories.Count - 1;
}
methodAgg = false;
pair = new AggregationAccessorSlotPairForge(relativeSlot, accessor);
}
columns[column] = new AggregationLocalGroupByColumnForge(
defaultLevel,
partitionExpr,
methodOffset,
methodAgg,
pair,
levelNumber);
}
var forge = new AggregationLocalGroupByLevelForge(
methodForges.ToArray(),
methodFactories.ToArray(),
stateFactories.ToArray(),
partitionExpr,
multiKeyPlan.ClassRef,
defaultLevel);
// NOTE: The original code tests for multiKeyPlan being null, but if it was null it would have caused
// a null pointer exception on the previous statement since it dereferences ClassRef.
var additionalForgeables = multiKeyPlan?.MultiKeyForgeables ?? EmptyList<StmtClassForgeableFactory>.Instance;
return new AggregationGroupByLocalGroupLevelDesc(forge, additionalForgeables);
}
public void ProviderCodegen(
CodegenMethod method,
CodegenClassScope classScope,
AggregationClassNames classNames)
{
method.Block.DeclareVar<AggregationLocalGroupByLevel>("optionalTop", ConstantNull());
if (localGroupByPlan.OptionalLevelTopForge != null) {
method.Block.AssignRef(
"optionalTop",
localGroupByPlan.OptionalLevelTopForge.ToExpression(
classNames.RowFactoryTop,
classNames.RowSerdeTop,
ConstantNull(),
method,
classScope));
}
int numLevels = localGroupByPlan.AllLevelsForges.Length;
method.Block.DeclareVar<AggregationLocalGroupByLevel[]>(
"levels",
NewArrayByLength(typeof(AggregationLocalGroupByLevel), Constant(numLevels)));
for (var i = 0; i < numLevels; i++) {
AggregationLocalGroupByLevelForge forge = localGroupByPlan.AllLevelsForges[i];
CodegenExpression eval = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(
forge.PartitionForges,
null,
forge.PartitionMKClasses,
method,
classScope);
method.Block.AssignArrayElement(
"levels",
Constant(i),
localGroupByPlan.AllLevelsForges[i]
.ToExpression(
classNames.GetRowFactoryPerLevel(i),
classNames.GetRowSerdePerLevel(i),
eval,
method,
classScope));
}
method.Block.DeclareVar<AggregationLocalGroupByColumn[]>(
"columns",
NewArrayByLength(
typeof(AggregationLocalGroupByColumn),
Constant(localGroupByPlan.ColumnsForges.Length)));
var rowLevelDesc = RowLevelDesc;
for (var i = 0; i < localGroupByPlan.ColumnsForges.Length; i++) {
AggregationLocalGroupByColumnForge col = localGroupByPlan.ColumnsForges[i];
int fieldNum;
if (hasGroupBy && col.IsDefaultGroupLevel) {
AggregationCodegenRowDetailDesc levelDesc = rowLevelDesc.OptionalAdditionalRows[col.LevelNum];
fieldNum = GetRowFieldNum(col, levelDesc);
}
else if (col.LevelNum == -1) {
AggregationCodegenRowDetailDesc levelDesc = rowLevelDesc.OptionalTopRow;
fieldNum = GetRowFieldNum(col, levelDesc);
}
else {
AggregationCodegenRowDetailDesc levelDesc = rowLevelDesc.OptionalAdditionalRows[col.LevelNum];
fieldNum = GetRowFieldNum(col, levelDesc);
}
method.Block.AssignArrayElement(
"columns",
Constant(i),
localGroupByPlan.ColumnsForges[i].ToExpression(fieldNum));
}
method.Block
.DeclareVar<AggregationServiceFactory>(
"svcFactory",
NewInstanceInner(classNames.ServiceFactory, Ref("this")))
.MethodReturn(
ExprDotMethodChain(EPStatementInitServicesConstants.REF)
.Get(AGGREGATIONSERVICEFACTORYSERVICE)
.Add(
"GroupLocalGroupBy",
Ref("svcFactory"),
useFlags.ToExpression(),
Constant(hasGroupBy),
Ref("optionalTop"),
Ref("levels"),
Ref("columns")));
}
private void ApplyCodegen(
bool enter,
CodegenMethod method,
CodegenClassScope classScope,
CodegenNamedMethods namedMethods,
AggregationClassNames classNames)
{
if (enter) {
method.Block.LocalMethod(HandleRemovedKeysCodegen(method, classScope));
}
if (localGroupByPlan.OptionalLevelTopForge != null) {
method.Block.IfCondition(EqualsNull(MEMBER_AGGREGATORSTOPLEVEL))
.AssignRef(MEMBER_AGGREGATORSTOPLEVEL, NewInstanceInner(classNames.RowTop, Ref("o")))
.BlockEnd()
.ExprDotMethod(
MEMBER_AGGREGATORSTOPLEVEL,
enter ? "ApplyEnter" : "ApplyLeave",
REF_EPS,
REF_EXPREVALCONTEXT);
}
for (var levelNum = 0; levelNum < localGroupByPlan.AllLevelsForges.Length; levelNum++) {
AggregationLocalGroupByLevelForge level = localGroupByPlan.AllLevelsForges[levelNum];
ExprNode[] partitionForges = level.PartitionForges;
var groupKeyName = "groupKeyLvl_" + levelNum;
var rowName = "row_" + levelNum;
CodegenExpression groupKeyExp;
if (hasGroupBy && level.IsDefaultLevel) {
groupKeyExp = AggregationServiceCodegenNames.REF_GROUPKEY;
}
else {
groupKeyExp = LocalMethod(
AggregationServiceCodegenUtil.ComputeMultiKeyCodegen(
levelNum,
partitionForges,
level.PartitionMKClasses,
classScope,
namedMethods),
REF_EPS,
ConstantTrue(),
REF_EXPREVALCONTEXT);
}
method.Block.CommentFullLine("--about to declare var--");
method.Block
.DeclareVar<object>(groupKeyName, groupKeyExp)
.DeclareVar<AggregationRow>(
rowName,
Cast(
typeof(AggregationRow),
ExprDotMethod(
ArrayAtIndex(MEMBER_AGGREGATORSPERLEVELANDGROUP, Constant(levelNum)),
"Get",
Ref(groupKeyName))))
.IfCondition(EqualsNull(Ref(rowName)))
.AssignRef(rowName, NewInstanceInner(classNames.GetRowPerLevel(levelNum), Ref("o")))
.ExprDotMethod(
ArrayAtIndex(MEMBER_AGGREGATORSPERLEVELANDGROUP, Constant(levelNum)),
"Put",
Ref(groupKeyName),
Ref(rowName))
.BlockEnd()
.ExprDotMethod(Ref(rowName), enter ? "IncreaseRefcount" : "DecreaseRefcount")
.ExprDotMethod(Ref(rowName), enter ? "ApplyEnter" : "ApplyLeave", REF_EPS, REF_EXPREVALCONTEXT);
if (!enter) {
method.Block.IfCondition(Relational(ExprDotMethod(Ref(rowName), "GetRefcount"), LE, Constant(0)))
.ExprDotMethod(
MEMBER_REMOVEDKEYS,
"Add",
NewInstance<AggSvcLocalGroupLevelKeyPair>(Constant(levelNum), Ref(groupKeyName)));
}
}
}
