private int GetRowFieldNum(
AggregationLocalGroupByColumnForge col,
AggregationCodegenRowDetailDesc levelDesc)
{
return col.IsMethodAgg
? col.MethodOffset
: levelDesc.StateDesc.MethodFactories.Length + AccessorIndex(levelDesc.AccessAccessors, col.Pair);
}
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);
}
// Obtain those method and state factories for each level
private static AggregationLocalGroupByLevelForge GetLevel(
int levelNumber,
AggregationGroupByLocalGroupLevel level,
ExprForge[][] methodForgesAll,
AggregationForgeFactory[] methodFactoriesAll,
AggregationStateFactoryForge[] accessForges,
AggregationLocalGroupByColumnForge[] columns,
bool defaultLevel,
AggregationAccessorSlotPairForge[] accessors,
ImportService importService,
bool isFireAndForget,
string statementName)
{
var partitionExpr = level.PartitionExpr;
ExprForge[] partitionForges = ExprNodeUtilityQuery.GetForges(partitionExpr);
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,
partitionForges,
methodOffset,
methodAgg,
pair,
levelNumber);
}
return new AggregationLocalGroupByLevelForge(
methodForges.ToArray(),
methodFactories.ToArray(),
stateFactories.ToArray(),
partitionForges,
defaultLevel);
}
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 GetterCodegen(
string methodName,
CodegenMethod method,
CodegenClassScope classScope,
CodegenNamedMethods namedMethods)
{
var rowLevelDesc = RowLevelDesc;
var blocks = method.Block.SwitchBlockOfLength(
AggregationServiceCodegenNames.REF_COLUMN,
localGroupByPlan.ColumnsForges.Length,
true);
for (var i = 0; i < blocks.Length; i++) {
AggregationLocalGroupByColumnForge col = localGroupByPlan.ColumnsForges[i];
if (hasGroupBy && col.IsDefaultGroupLevel) {
AggregationCodegenRowDetailDesc levelDesc = rowLevelDesc.OptionalAdditionalRows[col.LevelNum];
var num = GetRowFieldNum(col, levelDesc);
blocks[i]
.BlockReturn(
ExprDotMethod(
MEMBER_CURRENTROW,
methodName,
Constant(num),
REF_EPS,
REF_ISNEWDATA,
REF_EXPREVALCONTEXT));
}
else if (col.LevelNum == -1) {
AggregationCodegenRowDetailDesc levelDesc = rowLevelDesc.OptionalTopRow;
var num = GetRowFieldNum(col, levelDesc);
blocks[i]
.BlockReturn(
ExprDotMethod(
MEMBER_AGGREGATORSTOPLEVEL,
methodName,
Constant(num),
REF_EPS,
REF_ISNEWDATA,
REF_EXPREVALCONTEXT));
}
else {
AggregationCodegenRowDetailDesc levelDesc = rowLevelDesc.OptionalAdditionalRows[col.LevelNum];
var num = GetRowFieldNum(col, levelDesc);
blocks[i]
.DeclareVar<object>(
"groupByKey",
LocalMethod(
AggregationServiceCodegenUtil.ComputeMultiKeyCodegen(
col.LevelNum,
col.PartitionForges,
levelDesc.MultiKeyClassRef,
classScope,
namedMethods),
REF_EPS,
REF_ISNEWDATA,
REF_EXPREVALCONTEXT))
.DeclareVar<AggregationRow>(
"row",
Cast(
typeof(AggregationRow),
ExprDotMethod(
ArrayAtIndex(MEMBER_AGGREGATORSPERLEVELANDGROUP, Constant(col.LevelNum)),
"Get",
Ref("groupByKey"))))
.BlockReturn(
ExprDotMethod(
Ref("row"),
methodName,
Constant(num),
REF_EPS,
REF_ISNEWDATA,
REF_EXPREVALCONTEXT));
}
}
}
