public static CodegenMethod GenerateGroupKeyArrayJoinCodegen(
CodegenMethod generateGroupKeySingle,
CodegenClassScope classScope,
CodegenInstanceAux instance)
{
Consumer<CodegenMethod> code = method => {
method.Block.IfCondition(ExprDotMethod(Ref("resultSet"), "IsEmpty"))
.BlockReturn(ConstantNull())
.DeclareVar<object[]>(
"keys",
NewArrayByLength(typeof(object), ExprDotName(Ref("resultSet"), "Count")))
.DeclareVar<int>("count", Constant(0))
.ForEach(typeof(MultiKeyArrayOfKeys<EventBean>), "eventsPerStream", Ref("resultSet"))
.AssignArrayElement(
"keys",
Ref("count"),
LocalMethod(
generateGroupKeySingle,
ExprDotName(Ref("eventsPerStream"), "Array"),
ExprForgeCodegenNames.REF_ISNEWDATA))
.IncrementRef("count")
.BlockEnd()
.MethodReturn(Ref("keys"));
};
return instance.Methods.AddMethod(
typeof(object[]),
"GenerateGroupKeyArrayJoin",
CodegenNamedParam.From(typeof(ISet<MultiKeyArrayOfKeys<EventBean>>), "resultSet", typeof(bool), "isNewData"),
typeof(ResultSetProcessorRowPerEventImpl),
classScope,
code);
}
private static CodegenExpression CodegenMultikeyGetterBeanGet(
EventPropertyGetterSPI[] getters,
Type[] getterResultTypes,
MultiKeyClassRef multiKeyClassRef,
CodegenMethod method,
CodegenClassScope classScope)
{
var get = new CodegenExpressionLambda(method.Block)
.WithParams(CodegenNamedParam.From(typeof(EventBean), "bean"));
var lambda = NewInstance <ProxyEventPropertyValueGetter>(get);
var expressions = new CodegenExpression[getters.Length];
for (var i = 0; i < getters.Length; i++)
{
expressions[i] = getters[i].EventBeanGetCodegen(Ref("bean"), method, classScope);
var mkType = multiKeyClassRef.MKTypes[i];
var getterType = getterResultTypes[i];
expressions[i] = ExprNodeUtilityCodegen.CodegenCoerce(expressions[i], getterType, mkType, true);
}
var instance = multiKeyClassRef.ClassNameMK.Type != null
? NewInstance(multiKeyClassRef.ClassNameMK.Type, expressions)
: NewInstanceInner(multiKeyClassRef.ClassNameMK.Name, expressions);
get.Block.BlockReturn(instance);
return(lambda);
}
protected internal static CodegenMethod CreateSortPropertiesWRollupCodegen(
OrderByProcessorForgeImpl forge,
CodegenClassScope classScope,
CodegenNamedMethods namedMethods)
{
Consumer<CodegenMethod> code = method => {
method.Block.DeclareVar<object[]>(
"sortProperties",
NewArrayByLength(typeof(object), ExprDotName(REF_ORDERCURRENTGENERATORS, "Count")))
.DeclareVar<int>("count", Constant(0));
var forEach = method.Block.ForEach(typeof(GroupByRollupKey), "rollup", REF_ORDERCURRENTGENERATORS);
if (forge.IsNeedsGroupByKeys) {
forEach.ExprDotMethod(
MEMBER_AGGREGATIONSVC,
"SetCurrentAccess",
ExprDotName(Ref("rollup"), "GroupKey"),
ExprDotName(REF_EXPREVALCONTEXT, "AgentInstanceId"),
ExprDotName(Ref("rollup"), "Level"));
}
forEach.DeclareVar<int>(
"num",
ExprDotMethodChain(Ref("rollup")).Get("Level").Get("LevelNumber"));
var blocks = forEach.SwitchBlockOfLength(Ref("num"), forge.OrderByRollup.Length, false);
for (var i = 0; i < blocks.Length; i++) {
var getSortKey = GenerateOrderKeyCodegen(
"GetSortKeyInternal_" + i,
forge.OrderByRollup[i],
classScope,
namedMethods);
blocks[i]
.AssignArrayElement(
"sortProperties",
Ref("count"),
LocalMethod(
getSortKey,
ExprDotName(Ref("rollup"), "Generator"),
REF_ISNEWDATA,
REF_EXPREVALCONTEXT));
}
forEach.IncrementRef("count");
method.Block.MethodReturn(StaticMethod(typeof(CompatExtensions), "AsList", Ref("sortProperties")));
};
return namedMethods.AddMethod(
typeof(IList<object>),
"CreateSortPropertiesWRollup",
CodegenNamedParam.From(
typeof(IList<GroupByRollupKey>), REF_ORDERCURRENTGENERATORS.Ref,
typeof(bool), REF_ISNEWDATA.Ref,
typeof(ExprEvaluatorContext), REF_EXPREVALCONTEXT.Ref,
typeof(AggregationService), MEMBER_AGGREGATIONSVC.Ref),
typeof(OrderByProcessorImpl),
classScope,
code);
}
private static CodegenMethod GetComparableWMultiKeyCodegen(
ExprNode[] criteria,
CodegenExpressionRef @ref,
CodegenNamedMethods namedMethods,
CodegenClassScope classScope)
{
var methodName = "GetComparable_" + @ref.Ref;
Consumer<CodegenMethod> code = method => {
if (criteria.Length == 1) {
method.Block.MethodReturn(
LocalMethod(
CodegenLegoMethodExpression.CodegenExpression(
criteria[0].Forge,
method,
classScope,
true),
REF_EPS,
REF_ISNEWDATA,
REF_EXPREVALCONTEXT));
}
else {
var exprSymbol = new ExprForgeCodegenSymbol(true, null);
var expressions = new CodegenExpression[criteria.Length];
for (var i = 0; i < criteria.Length; i++) {
expressions[i] = criteria[i]
.Forge.EvaluateCodegen(
typeof(object),
method,
exprSymbol,
classScope);
}
exprSymbol.DerivedSymbolsCodegen(method, method.Block, classScope);
method.Block.DeclareVar<object[]>(
"result",
NewArrayByLength(typeof(object), Constant(criteria.Length)));
for (var i = 0; i < criteria.Length; i++) {
method.Block.AssignArrayElement(Ref("result"), Constant(i), expressions[i]);
}
method.Block.MethodReturn(NewInstance<HashableMultiKey>(Ref("result")));
}
};
return namedMethods.AddMethod(
typeof(object),
methodName,
CodegenNamedParam.From(
typeof(EventBean[]),
NAME_EPS,
typeof(bool),
NAME_ISNEWDATA,
typeof(ExprEvaluatorContext),
NAME_EXPREVALCONTEXT),
typeof(AggregatorAccessSortedImpl),
classScope,
code);
}
public CodegenMethod AddParam(CodegenNamedParam param)
{
if (LocalParams.IsEmpty()) {
LocalParams = new List<CodegenNamedParam>();
}
LocalParams.Add(param);
return this;
}
public static CodegenMethod ComputeMultiKeyCodegen(
int idNumber,
ExprForge[] partitionForges,
CodegenClassScope classScope,
CodegenNamedMethods namedMethods)
{
var exprSymbol = new ExprForgeCodegenSymbol(true, null);
Consumer<CodegenMethod> code = method => {
if (partitionForges.Length == 1) {
CodegenExpression expression = partitionForges[0]
.EvaluateCodegen(
typeof(object),
method,
exprSymbol,
classScope);
exprSymbol.DerivedSymbolsCodegen(method, method.Block, classScope);
method.Block.MethodReturn(expression);
}
else {
var expressions = new CodegenExpression[partitionForges.Length];
for (var i = 0; i < partitionForges.Length; i++) {
expressions[i] = partitionForges[i]
.EvaluateCodegen(
typeof(object),
method,
exprSymbol,
classScope);
}
exprSymbol.DerivedSymbolsCodegen(method, method.Block, classScope);
method.Block.DeclareVar<object[]>(
"keys",
NewArrayByLength(typeof(object), Constant(partitionForges.Length)));
for (var i = 0; i < expressions.Length; i++) {
method.Block.AssignArrayElement("keys", Constant(i), expressions[i]);
}
method.Block.MethodReturn(NewInstance<HashableMultiKey>(Ref("keys")));
}
};
return namedMethods.AddMethodWithSymbols(
typeof(object),
"ComputeKeyArrayCodegen_" + idNumber,
CodegenNamedParam.From(
typeof(EventBean[]),
NAME_EPS,
typeof(bool),
NAME_ISNEWDATA,
typeof(ExprEvaluatorContext),
NAME_EXPREVALCONTEXT),
typeof(AggregationServiceCodegenUtil),
classScope,
code,
exprSymbol);
}
public static CodegenMethod GenerateGroupKeySingleCodegen(
ExprNode[] groupKeyExpressions,
MultiKeyClassRef optionalMultiKeyClasses,
CodegenClassScope classScope,
CodegenInstanceAux instance)
{
Consumer<CodegenMethod> code = methodNode => {
string[] expressions = null;
if (classScope.IsInstrumented) {
expressions = ExprNodeUtilityPrint.ToExpressionStringsMinPrecedence(groupKeyExpressions);
}
methodNode.Block.Apply(
Instblock(
classScope,
"qResultSetProcessComputeGroupKeys",
ExprForgeCodegenNames.REF_ISNEWDATA,
Constant(expressions),
REF_EPS));
if (optionalMultiKeyClasses != null && optionalMultiKeyClasses.ClassNameMK != null) {
var method = MultiKeyCodegen.CodegenMethod(groupKeyExpressions, optionalMultiKeyClasses, methodNode, classScope);
methodNode
.Block
.DeclareVar<object>("key", LocalMethod(method, REF_EPS, ExprForgeCodegenNames.REF_ISNEWDATA, MEMBER_AGENTINSTANCECONTEXT))
.Apply(Instblock(classScope, "aResultSetProcessComputeGroupKeys", ExprForgeCodegenNames.REF_ISNEWDATA, Ref("key")))
.MethodReturn(Ref("key"));
return;
}
if (groupKeyExpressions.Length > 1) {
throw new IllegalStateException("Multiple group-by expression and no multikey");
}
var expression = CodegenLegoMethodExpression.CodegenExpression(groupKeyExpressions[0].Forge, methodNode, classScope);
methodNode
.Block
.DeclareVar<object>("key", LocalMethod(expression, REF_EPS, ExprForgeCodegenNames.REF_ISNEWDATA, MEMBER_AGENTINSTANCECONTEXT))
.Apply(Instblock(classScope, "aResultSetProcessComputeGroupKeys", ExprForgeCodegenNames.REF_ISNEWDATA, Ref("key")))
.MethodReturn(Ref("key"));
};
return instance.Methods.AddMethod(
typeof(object),
"GenerateGroupKeySingle",
CodegenNamedParam.From(
typeof(EventBean[]),
NAME_EPS,
typeof(bool),
ResultSetProcessorCodegenNames.NAME_ISNEWDATA),
typeof(ResultSetProcessorUtil),
classScope,
code);
}
protected internal static CodegenMethod GenerateOrderKeyCodegen(
string methodName,
OrderByElementForge[] orderBy,
CodegenClassScope classScope,
CodegenNamedMethods namedMethods)
{
Consumer<CodegenMethod> code = methodNode => {
if (orderBy.Length == 1) {
var expression = CodegenLegoMethodExpression.CodegenExpression(
orderBy[0].ExprNode.Forge,
methodNode,
classScope,
true);
methodNode.Block.MethodReturn(
LocalMethod(
expression,
EnumForgeCodegenNames.REF_EPS,
ResultSetProcessorCodegenNames.REF_ISNEWDATA,
REF_EXPREVALCONTEXT));
return;
}
methodNode.Block.DeclareVar<object[]>(
"keys",
NewArrayByLength(typeof(object), Constant(orderBy.Length)));
for (var i = 0; i < orderBy.Length; i++) {
var expression = CodegenLegoMethodExpression.CodegenExpression(
orderBy[i].ExprNode.Forge,
methodNode,
classScope,
true);
methodNode.Block.AssignArrayElement(
"keys",
Constant(i),
LocalMethod(
expression,
EnumForgeCodegenNames.REF_EPS,
ResultSetProcessorCodegenNames.REF_ISNEWDATA,
REF_EXPREVALCONTEXT));
}
methodNode.Block.MethodReturn(NewInstance<HashableMultiKey>(Ref("keys")));
};
return namedMethods.AddMethod(
typeof(object),
methodName,
CodegenNamedParam.From(
typeof(EventBean[]), NAME_EPS,
typeof(bool), NAME_ISNEWDATA,
typeof(ExprEvaluatorContext), NAME_EXPREVALCONTEXT),
typeof(ResultSetProcessorUtil),
classScope,
code);
}
public static CodegenMethod ComputeMultiKeyCodegen(
int idNumber,
ExprNode[] partitionForges,
MultiKeyClassRef optionalMultiKey,
CodegenClassScope classScope,
CodegenNamedMethods namedMethods)
{
var exprSymbol = new ExprForgeCodegenSymbol(true, null);
Consumer<CodegenMethod> code = method => {
if (optionalMultiKey == null || optionalMultiKey.ClassNameMK == null) {
var expression = partitionForges[0].Forge.EvaluateCodegen(typeof(object), method, exprSymbol, classScope);
exprSymbol.DerivedSymbolsCodegen(method, method.Block, classScope);
method.Block.MethodReturn(expression);
return;
}
var expressions = new CodegenExpression[partitionForges.Length];
for (var i = 0; i < partitionForges.Length; i++) {
expressions[i] = partitionForges[i].Forge
.EvaluateCodegen(
typeof(object),
method,
exprSymbol,
classScope);
}
var instance = optionalMultiKey.ClassNameMK.Type != null
? NewInstance(optionalMultiKey.ClassNameMK.Type, expressions)
: NewInstanceInner(optionalMultiKey.ClassNameMK.Name, expressions);
exprSymbol.DerivedSymbolsCodegen(method, method.Block, classScope);
method.Block.MethodReturn(instance);
};
return namedMethods.AddMethodWithSymbols(
typeof(object),
"ComputeKeyArrayCodegen_" + idNumber,
CodegenNamedParam.From(
typeof(EventBean[]),
NAME_EPS,
typeof(bool),
NAME_ISNEWDATA,
typeof(ExprEvaluatorContext),
NAME_EXPREVALCONTEXT),
typeof(AggregationServiceCodegenUtil),
classScope,
code,
exprSymbol);
}
public virtual CodegenMethod MakeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbolWEventType symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(
typeof(ExprFilterSpecLookupable),
typeof(ExprFilterSpecLookupableForge),
classScope);
CodegenExpression getterExpr;
if (optionalEventPropForge != null) {
var get = new CodegenExpressionLambda(method.Block)
.WithParams(CodegenNamedParam.From(typeof(EventBean), "bean"));
var anonymous = NewInstance<ProxyEventPropertyValueGetter>(get);
//var anonymous = NewAnonymousClass(method.Block, typeof(EventPropertyValueGetter));
//var get = CodegenMethod.MakeParentNode(typeof(object), GetType(), classScope)
// .AddParam(CodegenNamedParam.From(typeof(EventBean), "bean"));
//anonymous.AddMethod("Get", get);
get.Block.BlockReturn(optionalEventPropForge.EventBeanGetCodegen(Ref("bean"), method, classScope));
getterExpr = anonymous;
}
else {
getterExpr = ConstantNull();
}
method.Block.DeclareVar<EventPropertyValueGetter>("getter", getterExpr);
method.Block
.DeclareVar<ExprFilterSpecLookupable>(
"lookupable",
NewInstance<ExprFilterSpecLookupable>(
Constant(expression),
Ref("getter"),
Typeof(returnType),
Constant(isNonPropertyGetter)))
.Expression(
ExprDotMethodChain(symbols.GetAddInitSvc(method))
.Get(EPStatementInitServicesConstants.FILTERSHAREDLOOKUPABLEREGISTERY)
.Add(
"RegisterLookupable",
symbols.GetAddEventType(method),
Ref("lookupable")))
.MethodReturn(Ref("lookupable"));
return method;
}
public static EventPropertyGetter Compile(
this ICodegenContext codegenContext,
string engineURI,
ClassLoaderProvider classLoaderProvider,
EventPropertyGetterSPI getterSPI,
string propertyExpression)
{
var get = getterSPI.CodegenEventBeanGet(Ref("bean"), codegenContext);
var exists = getterSPI.CodegenEventBeanExists(Ref("bean"), codegenContext);
var fragment = getterSPI.CodegenEventBeanFragment(Ref("bean"), codegenContext);
var singleBeanParam = CodegenNamedParam.From(typeof(EventBean), "bean");
// For: public object Get(EventBean eventBean) ;
// For: public bool IsExistsProperty(EventBean eventBean);
// For: public object GetFragment(EventBean eventBean) ;
var getMethod = new CodegenMethod(typeof(object), "Get", singleBeanParam, null);
getMethod.Statements.MethodReturn(get);
var isExistsPropertyMethod = new CodegenMethod(typeof(bool), "IsExistsProperty", singleBeanParam, null);
isExistsPropertyMethod.Statements.MethodReturn(exists);
var fragmentMethod = new CodegenMethod(typeof(object), "GetFragment", singleBeanParam, null);
fragmentMethod.Statements.MethodReturn(fragment);
var clazz = new CodegenClass(
"com.espertech.esper.codegen.uri_" + engineURI,
typeof(EventPropertyGetter).Name + "_" + CodeGenerationIDGenerator.GenerateClass(),
typeof(EventPropertyGetter),
codegenContext.Members,
new [] { getMethod, isExistsPropertyMethod, fragmentMethod },
codegenContext.Methods
);
string debugInfo = null;
if (codegenContext.IsDebugEnabled)
{
debugInfo = getterSPI.GetType().FullName + " for property '" + propertyExpression + "'";
}
return(codegenContext.Compiler.Compile(
clazz, classLoaderProvider, typeof(EventPropertyGetter), debugInfo));
}
protected internal static CodegenMethod GetSelectListEventsAsArrayCodegen(
ResultSetProcessorRowForAllForge forge,
CodegenClassScope classScope,
CodegenInstanceAux instance)
{
Consumer<CodegenMethod> code = method => {
if (forge.OptionalHavingNode != null) {
method.Block.IfCondition(
Not(
LocalMethod(
instance.Methods.GetMethod("EvaluateHavingClause"),
ConstantNull(),
REF_ISNEWDATA,
MEMBER_AGENTINSTANCECONTEXT)))
.BlockReturn(ConstantNull());
}
method.Block.DeclareVar<EventBean>(
"theEvent",
ExprDotMethod(
MEMBER_SELECTEXPRPROCESSOR,
"Process",
EnumValue(typeof(CollectionUtil), "EVENTBEANARRAY_EMPTY"),
REF_ISNEWDATA,
REF_ISSYNTHESIZE,
MEMBER_AGENTINSTANCECONTEXT))
.DeclareVar<EventBean[]>("result", NewArrayByLength(typeof(EventBean), Constant(1)))
.AssignArrayElement("result", Constant(0), Ref("theEvent"))
.MethodReturn(Ref("result"));
};
return instance.Methods.AddMethod(
typeof(EventBean[]),
"GetSelectListEventsAsArray",
CodegenNamedParam.From(
typeof(bool), NAME_ISNEWDATA,
typeof(bool), NAME_ISSYNTHESIZE,
typeof(bool), "join"),
typeof(ResultSetProcessorRowForAllImpl),
classScope,
code);
}
public static void RowCtorCodegen(
CodegenNamedMethods namedMethods,
CodegenClassScope classScope,
IList<CodegenTypedParam> rowMembers)
{
rowMembers.Add(new CodegenTypedParam(typeof(long), "lastUpdateTime"));
namedMethods.AddMethod(
typeof(void),
"SetLastUpdateTime",
CodegenNamedParam.From(typeof(long), "time"),
typeof(AggSvcGroupByReclaimAgedImpl),
classScope,
method => method.Block.AssignRef("lastUpdateTime", Ref("time")));
namedMethods.AddMethod(
typeof(long),
"GetLastUpdateTime",
Collections.GetEmptyList<CodegenNamedParam>(),
typeof(AggSvcGroupByReclaimAgedImpl),
classScope,
method => method.Block.MethodReturn(Ref("lastUpdateTime")));
}
protected internal static CodegenMethod SortWGroupKeysInternalCodegen(
OrderByProcessorForgeImpl forge,
CodegenClassScope classScope,
CodegenNamedMethods namedMethods)
{
var createSortProperties = CreateSortPropertiesCodegen(forge, classScope, namedMethods);
CodegenExpression comparator = classScope.AddOrGetDefaultFieldSharable(forge.IComparer);
Consumer<CodegenMethod> code = method => {
method.Block.DeclareVar<IList<object>>(
"sortValuesMultiKeys",
LocalMethod(
createSortProperties,
REF_GENERATINGEVENTS,
Ref("groupByKeys"),
REF_ISNEWDATA,
REF_EXPREVALCONTEXT,
MEMBER_AGGREGATIONSVC))
.MethodReturn(
StaticMethod(
typeof(OrderByProcessorUtil),
"SortGivenOutgoingAndSortKeys",
REF_OUTGOINGEVENTS,
Ref("sortValuesMultiKeys"),
comparator));
};
return namedMethods.AddMethod(
typeof(EventBean[]),
"SortWGroupKeysInternal",
CodegenNamedParam.From(
typeof(EventBean[]), REF_OUTGOINGEVENTS.Ref,
typeof(EventBean[][]), REF_GENERATINGEVENTS.Ref,
typeof(object[]), "groupByKeys",
typeof(bool), REF_ISNEWDATA.Ref,
typeof(ExprEvaluatorContext), REF_EXPREVALCONTEXT.Ref,
typeof(AggregationService), MEMBER_AGGREGATIONSVC.Ref),
typeof(OrderByProcessorImpl),
classScope,
code);
}
public static CodegenMethod GenerateGroupKeyArrayViewCodegen(
CodegenMethod generateGroupKeySingle,
CodegenClassScope classScope,
CodegenInstanceAux instance)
{
Consumer<CodegenMethod> code = method => {
method.Block.IfRefNullReturnNull("events")
.DeclareVar<EventBean[]>(
"eventsPerStream",
NewArrayByLength(typeof(EventBean), Constant(1)))
.DeclareVar<object[]>("keys", NewArrayByLength(typeof(object), ArrayLength(Ref("events"))));
{
var forLoop = method.Block.ForLoopIntSimple("i", ArrayLength(Ref("events")));
forLoop.AssignArrayElement("eventsPerStream", Constant(0), ArrayAtIndex(Ref("events"), Ref("i")))
.AssignArrayElement(
"keys",
Ref("i"),
LocalMethod(
generateGroupKeySingle,
Ref("eventsPerStream"),
ExprForgeCodegenNames.REF_ISNEWDATA));
}
method.Block.MethodReturn(Ref("keys"));
};
return instance.Methods.AddMethod(
typeof(object[]),
"GenerateGroupKeyArrayView",
CodegenNamedParam.From(
typeof(EventBean[]),
"events",
typeof(bool),
ResultSetProcessorCodegenNames.NAME_ISNEWDATA),
typeof(ResultSetProcessorRowPerGroup),
classScope,
code);
}
public static void GenerateIncidentals(
bool hasRefcount,
bool hasLastUpdTime,
AggregationRowCtorDesc rowCtorDesc)
{
var namedMethods = rowCtorDesc.NamedMethods;
var classScope = rowCtorDesc.ClassScope;
IList<CodegenTypedParam> rowMembers = rowCtorDesc.RowMembers;
if (hasRefcount) {
rowMembers.Add(new CodegenTypedParam(typeof(int), "refcount").WithFinal(false));
}
namedMethods.AddMethod(
typeof(void),
"IncreaseRefcount",
NIL_NAMED_PARAM,
typeof(AggregationServiceCodegenUtil),
classScope,
hasRefcount ? method => method.Block.Increment(Ref("refcount")) : NIL_METHOD_CONSUMER);
namedMethods.AddMethod(
typeof(void),
"DecreaseRefcount",
NIL_NAMED_PARAM,
typeof(AggregationServiceCodegenUtil),
classScope,
hasRefcount ? method => method.Block.Decrement(Ref("refcount")) : NIL_METHOD_CONSUMER);
namedMethods.AddMethod(
typeof(long),
"GetRefcount",
NIL_NAMED_PARAM,
typeof(AggregationServiceCodegenUtil),
classScope,
hasRefcount
? new Consumer<CodegenMethod>(method => method.Block.MethodReturn(Ref("refcount")))
: new Consumer<CodegenMethod>(method => method.Block.MethodReturn(Constant(1))));
if (hasLastUpdTime) {
rowMembers.Add(new CodegenTypedParam(typeof(long), "lastUpd").WithFinal(false));
}
namedMethods.AddMethod(
typeof(void),
"SetLastUpdateTime",
CodegenNamedParam.From(typeof(long), "time"),
typeof(AggregationServiceCodegenUtil),
classScope,
hasLastUpdTime
? new Consumer<CodegenMethod>(method => method.Block.AssignRef("lastUpd", Ref("time")))
: new Consumer<CodegenMethod>(method => method.Block.MethodThrowUnsupported()));
namedMethods.AddMethod(
typeof(long),
"GetLastUpdateTime",
NIL_NAMED_PARAM,
typeof(AggregationServiceCodegenUtil),
classScope,
hasLastUpdTime
? new Consumer<CodegenMethod>(method => method.Block.MethodReturn(Ref("lastUpd")))
: new Consumer<CodegenMethod>(method => method.Block.MethodThrowUnsupported()));
}
public static CodegenMethod DetermineLocalMinMaxCodegen(
OrderByProcessorForgeImpl forge,
CodegenClassScope classScope,
CodegenNamedMethods namedMethods)
{
var elements = forge.OrderBy;
CodegenExpression comparator = classScope.AddOrGetDefaultFieldSharable(forge.IComparer);
Consumer<CodegenMethod> code = method => {
method.Block.DeclareVar<object>("localMinMax", ConstantNull())
.DeclareVar<EventBean>("outgoingMinMaxBean", ConstantNull())
.DeclareVar<int>("count", Constant(0));
if (elements.Length == 1) {
var forEach = method.Block.ForEach(typeof(EventBean[]), "eventsPerStream", REF_GENERATINGEVENTS);
forEach.DeclareVar<object>(
"sortKey",
LocalMethod(
CodegenLegoMethodExpression.CodegenExpression(
elements[0].ExprNode.Forge,
method,
classScope,
true),
Ref("eventsPerStream"),
REF_ISNEWDATA,
REF_EXPREVALCONTEXT))
.IfCondition(
Or(
EqualsNull(Ref("localMinMax")),
Relational(
ExprDotMethod(comparator, "Compare", Ref("localMinMax"), Ref("sortKey")),
GT,
Constant(0))))
.AssignRef("localMinMax", Ref("sortKey"))
.AssignRef("outgoingMinMaxBean", ArrayAtIndex(REF_OUTGOINGEVENTS, Ref("count")))
.BlockEnd()
.IncrementRef("count");
}
else {
method.Block.DeclareVar<object[]>(
"values",
NewArrayByLength(typeof(object), Constant(elements.Length)))
.DeclareVar<HashableMultiKey>(
"valuesMk",
NewInstance<HashableMultiKey>(Ref("values")));
var forEach = method.Block.ForEach(typeof(EventBean[]), "eventsPerStream", REF_GENERATINGEVENTS);
if (forge.IsNeedsGroupByKeys) {
forEach.ExprDotMethod(
MEMBER_AGGREGATIONSVC,
"SetCurrentAccess",
ArrayAtIndex(Ref("groupByKeys"), Ref("count")),
ExprDotMethod(REF_EXPREVALCONTEXT, "GetAgentInstanceId", ConstantNull()));
}
for (var i = 0; i < elements.Length; i++) {
forEach.AssignArrayElement(
"values",
Constant(i),
LocalMethod(
CodegenLegoMethodExpression.CodegenExpression(
elements[i].ExprNode.Forge,
method,
classScope,
true),
Ref("eventsPerStream"),
REF_ISNEWDATA,
REF_EXPREVALCONTEXT));
}
forEach.IfCondition(
Or(
EqualsNull(Ref("localMinMax")),
Relational(
ExprDotMethod(comparator, "Compare", Ref("localMinMax"), Ref("valuesMk")),
GT,
Constant(0))))
.AssignRef("localMinMax", Ref("valuesMk"))
.AssignRef("values", NewArrayByLength(typeof(object), Constant(elements.Length)))
.AssignRef("valuesMk", NewInstance<HashableMultiKey>(Ref("values")))
.AssignRef("outgoingMinMaxBean", ArrayAtIndex(REF_OUTGOINGEVENTS, Ref("count")))
.BlockEnd()
.IncrementRef("count");
}
method.Block.MethodReturn(Ref("outgoingMinMaxBean"));
};
return namedMethods.AddMethod(
typeof(EventBean),
"DetermineLocalMinMax",
CodegenNamedParam.From(
typeof(EventBean[]), REF_OUTGOINGEVENTS.Ref,
typeof(EventBean[][]), REF_GENERATINGEVENTS.Ref,
typeof(bool), NAME_ISNEWDATA,
typeof(ExprEvaluatorContext), NAME_EXPREVALCONTEXT,
typeof(AggregationService), MEMBER_AGGREGATIONSVC.Ref),
typeof(OrderByProcessorImpl),
classScope,
code);
}
public CodegenExpressionLambda WithParam(CodegenNamedParam param)
{
ParamNames.Add(param);
return this;
}
protected internal static CodegenMethod CreateSortPropertiesCodegen(
OrderByProcessorForgeImpl forge,
CodegenClassScope classScope,
CodegenNamedMethods namedMethods)
{
Consumer<CodegenMethod> code = method => {
string[] expressions = null;
bool[] descending = null;
if (classScope.IsInstrumented) {
expressions = forge.ExpressionTexts;
descending = forge.DescendingFlags;
}
method.Block.DeclareVar<object[]>(
"sortProperties",
NewArrayByLength(typeof(object), ArrayLength(REF_GENERATINGEVENTS)));
var elements = forge.OrderBy;
var forEach = method.Block.DeclareVar<int>("count", Constant(0))
.ForEach(typeof(EventBean[]), "eventsPerStream", REF_GENERATINGEVENTS);
if (forge.IsNeedsGroupByKeys) {
forEach.ExprDotMethod(
MEMBER_AGGREGATIONSVC,
"SetCurrentAccess",
ArrayAtIndex(Ref("groupByKeys"), Ref("count")),
ExprDotName(REF_EXPREVALCONTEXT, "AgentInstanceId"),
ConstantNull());
}
forEach.Apply(
Instblock(
classScope,
"qOrderBy",
Ref("eventsPerStream"),
Constant(expressions),
Constant(descending)));
if (elements.Length == 1) {
forEach.AssignArrayElement(
"sortProperties",
Ref("count"),
LocalMethod(
CodegenLegoMethodExpression.CodegenExpression(
elements[0].ExprNode.Forge,
method,
classScope,
true),
Ref("eventsPerStream"),
REF_ISNEWDATA,
REF_EXPREVALCONTEXT));
}
else {
forEach.DeclareVar<object[]>(
"values",
NewArrayByLength(typeof(object), Constant(forge.OrderBy.Length)));
for (var i = 0; i < forge.OrderBy.Length; i++) {
forEach.AssignArrayElement(
"values",
Constant(i),
LocalMethod(
CodegenLegoMethodExpression.CodegenExpression(
elements[i].ExprNode.Forge,
method,
classScope,
true),
Ref("eventsPerStream"),
REF_ISNEWDATA,
REF_EXPREVALCONTEXT));
}
forEach.AssignArrayElement(
"sortProperties",
Ref("count"),
NewInstance<HashableMultiKey>(Ref("values")));
}
forEach.Apply(Instblock(classScope, "aOrderBy", Ref("sortProperties")))
.IncrementRef("count");
method.Block.MethodReturn(StaticMethod(typeof(CompatExtensions), "AsList", Ref("sortProperties")));
};
return namedMethods.AddMethod(
typeof(IList<object>),
"CreateSortProperties",
CodegenNamedParam.From(
typeof(EventBean[][]), REF_GENERATINGEVENTS.Ref,
typeof(object[]), "groupByKeys",
typeof(bool), REF_ISNEWDATA.Ref,
typeof(ExprEvaluatorContext), REF_EXPREVALCONTEXT.Ref,
typeof(AggregationService), MEMBER_AGGREGATIONSVC.Ref),
typeof(OrderByProcessorImpl),
classScope,
code);
}
protected internal static CodegenMethod ProcessViewResultNewDepthOneUnboundCodegen(
ResultSetProcessorRowPerGroupForge forge,
CodegenClassScope classScope,
CodegenInstanceAux instance)
{
CodegenMethod shortcutEvalGivenKey =
ResultSetProcessorRowPerGroupImpl.ShortcutEvalGivenKeyCodegen(
forge.OptionalHavingNode,
classScope,
instance);
Consumer<CodegenMethod> code = methodNode => {
methodNode.Block.DeclareVar<object>(
"groupKey",
LocalMethod(forge.GenerateGroupKeySingle, REF_NEWDATA, ConstantTrue()));
if (forge.IsSelectRStream) {
methodNode.Block.DeclareVar<EventBean>(
"rstream",
LocalMethod(
shortcutEvalGivenKey,
REF_NEWDATA,
Ref("groupKey"),
ConstantFalse(),
REF_ISSYNTHESIZE));
}
methodNode.Block.ExprDotMethod(
MEMBER_AGGREGATIONSVC,
"ApplyEnter",
REF_NEWDATA,
Ref("groupKey"),
MEMBER_AGENTINSTANCECONTEXT)
.ExprDotMethod(Ref("groupReps"), "Put", Ref("groupKey"), ArrayAtIndex(REF_NEWDATA, Constant(0)))
.DeclareVar<EventBean>(
"istream",
LocalMethod(
shortcutEvalGivenKey,
REF_NEWDATA,
Ref("groupKey"),
ConstantTrue(),
REF_ISSYNTHESIZE));
if (forge.IsSelectRStream) {
methodNode.Block.MethodReturn(
StaticMethod(
typeof(ResultSetProcessorUtil),
"ToPairNullIfAllNullSingle",
Ref("istream"),
Ref("rstream")));
}
else {
methodNode.Block.MethodReturn(
StaticMethod(typeof(ResultSetProcessorUtil), "ToPairNullIfNullIStream", Ref("istream")));
}
};
return instance.Methods.AddMethod(
typeof(UniformPair<EventBean[]>),
"ProcessViewResultNewDepthOneUnboundCodegen",
CodegenNamedParam.From(typeof(EventBean[]), NAME_NEWDATA, typeof(bool), NAME_ISSYNTHESIZE),
typeof(ResultSetProcessorRowPerGroupImpl),
classScope,
code);
}
