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); }