public CodegenMethod InitializeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
// add aggregation row+factory+serde as inner classes
var aggregationClassNames = new AggregationClassNames();
var inners = AggregationServiceFactoryCompiler.MakeTable(
AggregationCodegenRowLevelDesc.FromTopOnly(_plan.AggDesc),
GetType(),
classScope,
aggregationClassNames,
_className);
classScope.AddInnerClasses(inners);
var method = parent.MakeChild(typeof(StatementAgentInstanceFactoryCreateTable), GetType(), classScope);
CodegenExpression primaryKeyGetter = MultiKeyCodegen.CodegenGetterMayMultiKey(
_plan.InternalEventType,
_plan.PrimaryKeyGetters,
_plan.PrimaryKeyTypes,
null,
_plan.PrimaryKeyMultikeyClasses,
method,
classScope);
CodegenExpression fafTransform = MultiKeyCodegen.CodegenMultiKeyFromArrayTransform(
_plan.PrimaryKeyMultikeyClasses,
method,
classScope);
CodegenExpression intoTableTransform = MultiKeyCodegen.CodegenMultiKeyFromMultiKeyTransform(
_plan.PrimaryKeyMultikeyClasses,
method,
classScope);
var propertyForgeEval = DataInputOutputSerdeForgeExtensions.CodegenArray(
_plan.InternalEventTypePropertySerdes,
method,
classScope,
ExprDotName(symbols.GetAddInitSvc(method), EPStatementInitServicesConstants.EVENTTYPERESOLVER));
method.Block
.DeclareVar<StatementAgentInstanceFactoryCreateTable>("saiff", NewInstance(typeof(StatementAgentInstanceFactoryCreateTable)))
.SetProperty(Ref("saiff"), "TableName", Constant(_tableName))
.SetProperty(Ref("saiff"), "PublicEventType", EventTypeUtility.ResolveTypeCodegen(_plan.PublicEventType, symbols.GetAddInitSvc(method)))
.SetProperty(Ref("saiff"), "EventToPublic", MakeEventToPublic(method, symbols, classScope))
.SetProperty(Ref("saiff"), "AggregationRowFactory", NewInstanceInner(aggregationClassNames.RowFactoryTop, Ref("this")))
.SetProperty(Ref("saiff"), "AggregationSerde", NewInstanceInner(aggregationClassNames.RowSerdeTop, Ref("this")))
.SetProperty(Ref("saiff"), "PrimaryKeyGetter", primaryKeyGetter)
.SetProperty(Ref("saiff"), "PrimaryKeySerde", _plan.PrimaryKeyMultikeyClasses.GetExprMKSerde(method, classScope))
.SetProperty(Ref("saiff"), "PropertyForges", propertyForgeEval)
.SetProperty(Ref("saiff"), "PrimaryKeyObjectArrayTransform", fafTransform)
.SetProperty(Ref("saiff"), "PrimaryKeyIntoTableTransform", intoTableTransform)
.ExprDotMethod(symbols.GetAddInitSvc(method), "AddReadyCallback", Ref("saiff"))
.MethodReturn(Ref("saiff"));
return method;
}
public void SetCurrentAccessCodegen(
CodegenMethod method,
CodegenClassScope classScope,
AggregationClassNames classNames)
{
method.Block.AssignRef(MEMBER_CURRENTGROUPKEY, REF_GROUPKEY)
.AssignRef(
MEMBER_CURRENTROW,
Cast(classNames.RowTop, ExprDotMethod(MEMBER_AGGREGATORSPERGROUP, "Get", REF_GROUPKEY)))
.IfCondition(EqualsNull(MEMBER_CURRENTROW))
.AssignRef(MEMBER_CURRENTROW, NewInstanceInner(classNames.RowTop, Ref("o")));
}
public CodegenMethod InitializeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
// add aggregation row+factory+serde as inner classes
var aggregationClassNames = new AggregationClassNames();
var inners = AggregationServiceFactoryCompiler.MakeTable(
AggregationCodegenRowLevelDesc.FromTopOnly(plan.AggDesc),
GetType(),
classScope,
aggregationClassNames,
className);
classScope.AddInnerClasses(inners);
var method = parent.MakeChild(typeof(StatementAgentInstanceFactoryCreateTable), GetType(), classScope);
var primaryKeyGetter = ConstantNull();
if (plan.PrimaryKeyGetters != null) {
primaryKeyGetter = EventTypeUtility.CodegenGetterMayMultiKeyWCoerce(
plan.InternalEventType,
plan.PrimaryKeyGetters,
plan.PrimaryKeyTypes,
null,
method,
GetType(),
classScope);
}
method.Block
.DeclareVar<StatementAgentInstanceFactoryCreateTable>(
"saiff",
NewInstance(typeof(StatementAgentInstanceFactoryCreateTable)))
.SetProperty(Ref("saiff"), "TableName", Constant(tableName))
.SetProperty(
Ref("saiff"),
"PublicEventType",
EventTypeUtility.ResolveTypeCodegen(plan.PublicEventType, symbols.GetAddInitSvc(method)))
.SetProperty(Ref("saiff"), "EventToPublic", MakeEventToPublic(method, symbols, classScope))
.SetProperty(
Ref("saiff"),
"AggregationRowFactory",
NewInstance(aggregationClassNames.RowFactoryTop, Ref("this")))
.SetProperty(
Ref("saiff"),
"AggregationSerde",
NewInstance(aggregationClassNames.RowSerdeTop, Ref("this")))
.SetProperty(Ref("saiff"), "PrimaryKeyGetter", primaryKeyGetter)
.ExprDotMethod(symbols.GetAddInitSvc(method), "AddReadyCallback", Ref("saiff"))
.MethodReturn(Ref("saiff"));
return method;
}
public void ApplyLeaveCodegen(
CodegenMethod method,
CodegenClassScope classScope,
CodegenNamedMethods namedMethods,
AggregationClassNames classNames)
{
method.Block
.Apply(
Instblock(
classScope,
"qAggregationUngroupedApplyEnterLeave",
ConstantFalse(),
Constant(rowStateDesc.NumMethods),
Constant(rowStateDesc.NumAccess)))
.ExprDotMethod(MEMBER_ROW, "ApplyLeave", REF_EPS, REF_EXPREVALCONTEXT)
.Apply(Instblock(classScope, "aAggregationUngroupedApplyEnterLeave", ConstantFalse()));
}
public void ProviderCodegen(
CodegenMethod method,
CodegenClassScope classScope,
AggregationClassNames classNames)
{
var groupByTypes = ExprNodeUtilityQuery.GetExprResultTypes(aggGroupByDesc.GroupByNodes);
if (aggGroupByDesc.IsReclaimAged) {
reclaimAge = aggGroupByDesc.ReclaimEvaluationFunctionMaxAge.Make(classScope);
reclaimFreq = aggGroupByDesc.ReclaimEvaluationFunctionFrequency.Make(classScope);
}
else {
reclaimAge = ConstantNull();
reclaimFreq = ConstantNull();
}
var stmtFields = ResultSetProcessorCodegenNames.REF_STATEMENT_FIELDS;
var timeAbacus = classScope.AddOrGetDefaultFieldSharable(TimeAbacusField.INSTANCE);
method.Block
.DeclareVar<AggregationRowFactory>(
"rowFactory",
NewInstanceInner(classNames.RowFactoryTop, Ref("this")))
.DeclareVar<DataInputOutputSerde<AggregationRow>>(
"rowSerde",
NewInstanceInner(classNames.RowSerdeTop, Ref("this")))
.DeclareVar<AggregationServiceFactory>(
"svcFactory",
NewInstanceInner(classNames.ServiceFactory, Ref("this")))
.DeclareVar<DataInputOutputSerde>(
"serde", aggGroupByDesc.GroupByMultiKey.GetExprMKSerde(method, classScope))
.MethodReturn(
ExprDotMethodChain(EPStatementInitServicesConstants.REF)
.Get(EPStatementInitServicesConstants.AGGREGATIONSERVICEFACTORYSERVICE)
.Add(
"GroupBy",
Ref("svcFactory"),
Ref("rowFactory"),
aggGroupByDesc.RowStateForgeDescs.UseFlags.ToExpression(),
Ref("rowSerde"),
Constant(groupByTypes),
reclaimAge,
reclaimFreq,
timeAbacus,
Ref("serde")));
}
public void ApplyLeaveCodegen(
CodegenMethod method,
CodegenClassScope classScope,
CodegenNamedMethods namedMethods,
AggregationClassNames classNames)
{
method.Block.Apply(
Instblock(
classScope,
"qAggregationGroupedApplyEnterLeave",
ConstantFalse(),
Constant(-1),
Constant(-1),
REF_GROUPKEY));
ApplyCodegen(false, method, classScope, namedMethods, classNames);
method.Block.Apply(Instblock(classScope, "aAggregationGroupedApplyEnterLeave", ConstantFalse()));
}
public void ApplyLeaveCodegen(
CodegenMethod method,
CodegenClassScope classScope,
CodegenNamedMethods namedMethods,
AggregationClassNames classNames)
{
method.Block
.Apply(
Instblock(
classScope,
"qAggregationGroupedApplyEnterLeave",
ConstantFalse(),
Constant(aggGroupByDesc.NumMethods),
Constant(aggGroupByDesc.NumAccess),
REF_GROUPKEY))
.AssignRef(
MEMBER_CURRENTROW,
Cast(classNames.RowTop, ExprDotMethod(MEMBER_AGGREGATORSPERGROUP, "Get", REF_GROUPKEY)))
.IfCondition(EqualsNull(MEMBER_CURRENTROW))
.AssignRef(MEMBER_CURRENTROW, NewInstanceInner(classNames.RowTop, Ref("o")))
.ExprDotMethod(MEMBER_AGGREGATORSPERGROUP, "Put", REF_GROUPKEY, MEMBER_CURRENTROW);
if (HasRefCounting) {
method.Block.ExprDotMethod(MEMBER_CURRENTROW, "DecreaseRefcount");
}
if (aggGroupByDesc.IsReclaimAged) {
method.Block.ExprDotMethod(
MEMBER_CURRENTROW,
"SetLastUpdateTime",
ExprDotMethodChain(REF_EXPREVALCONTEXT).Get("TimeProvider").Get("Time"));
}
method.Block.ExprDotMethod(MEMBER_CURRENTROW, "ApplyLeave", REF_EPS, REF_EXPREVALCONTEXT);
if (HasRefCounting) {
method.Block.IfCondition(Relational(ExprDotMethod(MEMBER_CURRENTROW, "GetRefcount"), LE, Constant(0)))
.ExprDotMethod(MEMBER_REMOVEDKEYS, "Add", REF_GROUPKEY);
}
method.Block.Apply(Instblock(classScope, "aAggregationGroupedApplyEnterLeave", ConstantFalse()));
}
public void ApplyEnterCodegen(
CodegenMethod method,
CodegenClassScope classScope,
CodegenNamedMethods namedMethods,
AggregationClassNames classNames)
{
method.Block
.Apply(
Instblock(
classScope,
"qAggregationGroupedApplyEnterLeave",
ConstantTrue(),
Constant(aggGroupByDesc.NumMethods),
Constant(aggGroupByDesc.NumAccess),
REF_GROUPKEY));
if (aggGroupByDesc.IsReclaimAged) {
AggSvcGroupByReclaimAgedImpl.ApplyEnterCodegenSweep(method, classScope, classNames);
}
if (HasRefCounting) {
method.Block.LocalMethod(HandleRemovedKeysCodegen(method, classScope));
}
var block = method.Block.AssignRef(
MEMBER_CURRENTROW,
Cast(classNames.RowTop, ExprDotMethod(MEMBER_AGGREGATORSPERGROUP, "Get", REF_GROUPKEY)));
block.IfCondition(EqualsNull(MEMBER_CURRENTROW))
.AssignRef(MEMBER_CURRENTROW, NewInstanceInner(classNames.RowTop, Ref("o")))
.ExprDotMethod(MEMBER_AGGREGATORSPERGROUP, "Put", REF_GROUPKEY, MEMBER_CURRENTROW);
if (HasRefCounting) {
block.ExprDotMethod(MEMBER_CURRENTROW, "IncreaseRefcount");
}
if (aggGroupByDesc.IsReclaimAged) {
block.ExprDotMethod(MEMBER_CURRENTROW, "SetLastUpdateTime", Ref("currentTime"));
}
block.ExprDotMethod(MEMBER_CURRENTROW, "ApplyEnter", REF_EPS, REF_EXPREVALCONTEXT)
.Apply(Instblock(classScope, "aAggregationGroupedApplyEnterLeave", ConstantTrue()));
}
public void SetCurrentAccessCodegen(
CodegenMethod method,
CodegenClassScope classScope,
AggregationClassNames classNames)
{
method.Block.IfCondition(ExprDotName(AggregationServiceCodegenNames.REF_ROLLUPLEVEL, "IsAggregationTop"))
.AssignRef(MEMBER_CURRENTROW, MEMBER_AGGREGATORTOPGROUP)
.IfElse()
.AssignRef(
MEMBER_CURRENTROW,
Cast(
typeof(AggregationRow),
ExprDotMethod(
ArrayAtIndex(
MEMBER_AGGREGATORSPERGROUP,
ExprDotName(AggregationServiceCodegenNames.REF_ROLLUPLEVEL, "AggregationOffset")),
"Get",
AggregationServiceCodegenNames.REF_GROUPKEY)))
.IfCondition(EqualsNull(MEMBER_CURRENTROW))
.AssignRef(MEMBER_CURRENTROW, NewInstanceInner(classNames.RowTop, Ref("o")))
.BlockEnd()
.BlockEnd()
.AssignRef(MEMBER_CURRENTGROUPKEY, AggregationServiceCodegenNames.REF_GROUPKEY);
}
public CodegenClass Forge(bool includeDebugSymbols)
{
Supplier<string> debugInformationProvider = () => {
var writer = new StringWriter();
_statementRawInfo.AppendCodeDebugInfo(writer);
writer.Write(" result-set-processor ");
writer.Write(_spec.ResultSetProcessorFactoryForge.GetType().FullName);
return writer.ToString();
};
try {
IList<CodegenInnerClass> innerClasses = new List<CodegenInnerClass>();
// build ctor
IList<CodegenTypedParam> ctorParms = new List<CodegenTypedParam>();
ctorParms.Add(
new CodegenTypedParam(
typeof(EPStatementInitServices),
EPStatementInitServicesConstants.REF.Ref,
false));
ctorParms.Add(
new CodegenTypedParam(
_namespaceScope.FieldsClassName,
null,
MEMBERNAME_STATEMENT_FIELDS,
true,
false));
var providerCtor = new CodegenCtor(
typeof(StmtClassForgableRSPFactoryProvider),
ClassName,
includeDebugSymbols,
ctorParms);
var classScope = new CodegenClassScope(includeDebugSymbols, _namespaceScope, ClassName);
var providerExplicitMembers = new List<CodegenTypedParam>(2);
// add event type
providerExplicitMembers.Add(new CodegenTypedParam(typeof(EventType), MEMBERNAME_RESULTEVENTTYPE));
providerCtor.Block.AssignRef(
MEMBERNAME_RESULTEVENTTYPE,
EventTypeUtility.ResolveTypeCodegen(_spec.ResultEventType, EPStatementInitServicesConstants.REF));
MakeResultSetProcessorFactory(
classScope,
innerClasses,
providerExplicitMembers,
providerCtor,
ClassName);
MakeResultSetProcessor(
classScope,
innerClasses,
providerExplicitMembers,
providerCtor,
ClassName,
_spec);
OrderByProcessorCompiler.MakeOrderByProcessors(
_spec.OrderByProcessorFactoryForge,
classScope,
innerClasses,
providerExplicitMembers,
providerCtor,
ClassName,
MEMBERNAME_ORDERBYFACTORY);
providerExplicitMembers.Add(
new CodegenTypedParam(typeof(AggregationServiceFactory), MEMBERNAME_AGGREGATIONSVCFACTORY));
var aggregationClassNames = new AggregationClassNames();
var aggResult = AggregationServiceFactoryCompiler.MakeInnerClassesAndInit(
_spec.IsJoin,
_spec.AggregationServiceForgeDesc.AggregationServiceFactoryForge,
providerCtor,
classScope,
ClassName,
aggregationClassNames);
providerCtor.Block.AssignRef(
MEMBERNAME_AGGREGATIONSVCFACTORY,
LocalMethod(aggResult.InitMethod, EPStatementInitServicesConstants.REF));
innerClasses.AddAll(aggResult.InnerClasses);
MakeSelectExprProcessors(
classScope,
innerClasses,
providerExplicitMembers,
providerCtor,
ClassName,
_spec.IsRollup,
_spec.SelectExprProcessorForges);
// make provider methods
var propResultSetProcessorFactoryMethod = CodegenProperty.MakePropertyNode(
typeof(ResultSetProcessorFactory),
GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
propResultSetProcessorFactoryMethod
.GetterBlock
.BlockReturn(Ref(MEMBERNAME_RESULTSETPROCESSORFACTORY));
var propAggregationServiceFactoryMethod = CodegenProperty.MakePropertyNode(
typeof(AggregationServiceFactory),
GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
propAggregationServiceFactoryMethod
.GetterBlock
.BlockReturn(Ref(MEMBERNAME_AGGREGATIONSVCFACTORY));
var propOrderByProcessorFactoryMethod = CodegenProperty.MakePropertyNode(
typeof(OrderByProcessorFactory),
GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
propOrderByProcessorFactoryMethod
.GetterBlock
.BlockReturn(Ref(MEMBERNAME_ORDERBYFACTORY));
var propResultSetProcessorTypeMethod = CodegenProperty.MakePropertyNode(
typeof(ResultSetProcessorType),
GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
propResultSetProcessorTypeMethod
.GetterBlock
.BlockReturn(EnumValue(typeof(ResultSetProcessorType), _spec.ResultSetProcessorType.GetName()));
var propResultEventTypeMethod = CodegenProperty.MakePropertyNode(
typeof(EventType),
GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
propResultEventTypeMethod
.GetterBlock
.BlockReturn(Ref(MEMBERNAME_RESULTEVENTTYPE));
var properties = new CodegenClassProperties();
var methods = new CodegenClassMethods();
CodegenStackGenerator.RecursiveBuildStack(providerCtor, "ctor", methods, properties);
CodegenStackGenerator.RecursiveBuildStack(
propResultSetProcessorFactoryMethod,
"ResultSetProcessorFactory",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
propAggregationServiceFactoryMethod,
"AggregationServiceFactory",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
propOrderByProcessorFactoryMethod,
"OrderByProcessorFactory",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
propResultSetProcessorTypeMethod,
"ResultSetProcessorType",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
propResultEventTypeMethod,
"ResultEventType",
methods,
properties);
// render and compile
return new CodegenClass(
typeof(ResultSetProcessorFactoryProvider),
_namespaceScope.Namespace,
ClassName,
classScope,
providerExplicitMembers,
providerCtor,
methods,
properties,
innerClasses);
}
catch (Exception t) {
throw new EPException(
"Fatal exception during code-generation for " +
debugInformationProvider.Invoke() +
" : " +
t.Message,
t);
}
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(RowRecogDesc), GetType(), classScope);
var desc = Ref("desc");
CodegenExpression init = symbols.GetAddInitSvc(method);
var startStateNums = new int[_startStates.Length];
for (var i = 0; i < _startStates.Length; i++) {
startStateNums[i] = _startStates[i].NodeNumFlat;
}
var aggregationServiceFactories = ConstantNull();
if (_aggregationServices != null) {
var initAggsSvcs = new CodegenExpression[_aggregationServices.Length];
for (var i = 0; i < _aggregationServices.Length; i++) {
initAggsSvcs[i] = ConstantNull();
if (_aggregationServices[i] != null) {
var aggSvc = _aggregationServices[i];
var aggregationClassNames = new AggregationClassNames("_mra" + i);
var result = AggregationServiceFactoryCompiler.MakeInnerClassesAndInit(
false,
aggSvc.AggregationServiceFactoryForge,
method,
classScope,
classScope.OutermostClassName,
aggregationClassNames);
classScope.AddInnerClasses(result.InnerClasses);
initAggsSvcs[i] = LocalMethod(result.InitMethod, symbols.GetAddInitSvc(parent));
}
}
aggregationServiceFactories = NewArrayWithInit(typeof(AggregationServiceFactory), initAggsSvcs);
}
method.Block
.DeclareVar<RowRecogDesc>(desc.Ref, NewInstance(typeof(RowRecogDesc)))
.SetProperty(desc, "ParentEventType", EventTypeUtility.ResolveTypeCodegen(_parentEventType, init))
.SetProperty(desc, "RowEventType", EventTypeUtility.ResolveTypeCodegen(RowEventType, init))
.SetProperty(desc, "CompositeEventType", EventTypeUtility.ResolveTypeCodegen(_compositeEventType, init))
.SetProperty(
desc,
"MultimatchEventType",
_multimatchEventType == null
? ConstantNull()
: EventTypeUtility.ResolveTypeCodegen(_multimatchEventType, init))
.SetProperty(desc, "MultimatchStreamNumToVariable", Constant(_multimatchStreamNumToVariable))
.SetProperty(desc, "MultimatchVariableToStreamNum", Constant(_multimatchVariableToStreamNum))
.SetProperty(
desc,
"PartitionEvalMayNull",
MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(_partitionBy, null, _partitionByMultiKey, method, classScope))
.SetProperty(
desc,
"PartitionEvalTypes",
_partitionBy == null
? ConstantNull()
: Constant(ExprNodeUtilityQuery.GetExprResultTypes(_partitionBy)))
.SetProperty(desc, "PartitionEvalSerde", _partitionBy == null ? ConstantNull() : _partitionByMultiKey.GetExprMKSerde(method, classScope))
.SetProperty(desc, "VariableStreams", MakeVariableStreams(method, symbols, classScope))
.SetProperty(desc, "HasInterval", Constant(_hasInterval))
.SetProperty(desc, "IsIterateOnly", Constant(_iterateOnly))
.SetProperty(desc, "IsUnbound", Constant(_unbound))
.SetProperty(desc, "IsOrTerminated", Constant(_orTerminated))
.SetProperty(desc, "IsCollectMultimatches", Constant(_collectMultimatches))
.SetProperty(desc, "IsDefineAsksMultimatches", Constant(_defineAsksMultimatches))
.SetProperty(desc, "NumEventsEventsPerStreamDefine", Constant(_numEventsEventsPerStreamDefine))
.SetProperty(desc, "MultimatchVariablesArray", Constant(_multimatchVariablesArray))
.SetProperty(desc, "StatesOrdered", MakeStates(method, symbols, classScope))
.SetProperty(desc, "NextStatesPerState", MakeNextStates(method, classScope))
.SetProperty(desc, "StartStates", Constant(startStateNums))
.SetProperty(desc, "IsAllMatches", Constant(_allMatches))
.SetProperty(desc, "Skip", Constant(_skip))
.SetProperty(
desc,
"ColumnEvaluators",
ExprNodeUtilityCodegen.CodegenEvaluators(_columnEvaluators, method, GetType(), classScope))
.SetProperty(desc, "ColumnNames", Constant(_columnNames))
.SetProperty(
desc,
"IntervalCompute",
_intervalCompute == null ? ConstantNull() : _intervalCompute.MakeEvaluator(method, classScope))
.SetProperty(desc, "PreviousRandomAccessIndexes", Constant(_previousRandomAccessIndexes))
.SetProperty(desc, "AggregationServiceFactories", aggregationServiceFactories)
.SetProperty(
desc,
"AggregationResultFutureAssignables",
_aggregationServices == null ? ConstantNull() : MakeAggAssignables(method, classScope))
.MethodReturn(desc);
return LocalMethod(method);
}
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)));
}
}
}
private void ApplyCodegen(
bool enter,
CodegenMethod method,
CodegenClassScope classScope,
AggregationClassNames classNames)
{
if (enter) {
method.Block.LocalMethod(HandleRemovedKeysCodegen(method, classScope));
}
method.Block.DeclareVar<object[]>(
"groupKeyPerLevel",
Cast(typeof(object[]), AggregationServiceCodegenNames.REF_GROUPKEY));
for (var i = 0; i < rollupDesc.NumLevels; i++) {
var level = rollupDesc.Levels[i];
var groupKeyName = "groupKey_" + i;
method.Block.DeclareVar<object>(
groupKeyName,
ArrayAtIndex(Ref("groupKeyPerLevel"), Constant(i)));
if (level.IsAggregationTop) {
method.Block.AssignRef(MEMBER_CURRENTROW, MEMBER_AGGREGATORTOPGROUP)
.ExprDotMethod(MEMBER_CURRENTROW, enter ? "IncreaseRefcount" : "DecreaseRefcount");
}
else {
if (enter) {
method.Block.AssignRef(
MEMBER_CURRENTROW,
Cast(
typeof(AggregationRow),
ExprDotMethod(
ArrayAtIndex(MEMBER_AGGREGATORSPERGROUP, Constant(level.AggregationOffset)),
"Get",
Ref(groupKeyName))))
.IfCondition(EqualsNull(MEMBER_CURRENTROW))
.AssignRef(MEMBER_CURRENTROW, NewInstanceInner(classNames.RowTop, Ref("o")))
.ExprDotMethod(
ArrayAtIndex(MEMBER_AGGREGATORSPERGROUP, Constant(level.AggregationOffset)),
"Put",
Ref(groupKeyName),
MEMBER_CURRENTROW)
.BlockEnd()
.ExprDotMethod(MEMBER_CURRENTROW, "IncreaseRefcount");
}
else {
method.Block.AssignRef(
MEMBER_CURRENTROW,
Cast(
typeof(AggregationRow),
ExprDotMethod(
ArrayAtIndex(MEMBER_AGGREGATORSPERGROUP, Constant(level.AggregationOffset)),
"Get",
Ref(groupKeyName))))
.IfCondition(EqualsNull(MEMBER_CURRENTROW))
.AssignRef(MEMBER_CURRENTROW, NewInstanceInner(classNames.RowTop, Ref("o")))
.ExprDotMethod(
ArrayAtIndex(MEMBER_AGGREGATORSPERGROUP, Constant(level.AggregationOffset)),
"Put",
Ref(groupKeyName),
MEMBER_CURRENTROW)
.BlockEnd()
.ExprDotMethod(MEMBER_CURRENTROW, "DecreaseRefcount");
}
}
method.Block.ExprDotMethod(
MEMBER_CURRENTROW,
enter ? "ApplyEnter" : "ApplyLeave",
REF_EPS,
REF_EXPREVALCONTEXT);
if (!enter && !level.IsAggregationTop) {
var ifCanDelete = method.Block.IfCondition(
Relational(ExprDotMethod(MEMBER_CURRENTROW, "GetRefcount"), LE, Constant(0)));
ifCanDelete.AssignRef(MEMBER_HASREMOVEDKEY, ConstantTrue());
if (!level.IsAggregationTop) {
var removedKeyForLevel = ArrayAtIndex(MEMBER_REMOVEDKEYS, Constant(level.AggregationOffset));
ifCanDelete.ExprDotMethod(removedKeyForLevel, "Add", Ref(groupKeyName));
}
}
}
}
