public OrderByProcessorOrderedLimitForge( OrderByProcessorForgeImpl orderByProcessorForge, RowLimitProcessorFactoryForge rowLimitProcessorFactoryForge) { this.orderByProcessorForge = orderByProcessorForge; this.rowLimitProcessorFactoryForge = rowLimitProcessorFactoryForge; }
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); }
protected internal static void SortTwoKeysCodegen( OrderByProcessorForgeImpl forge, CodegenMethod method, CodegenClassScope classScope, CodegenNamedMethods namedMethods) { CodegenExpression comparator = classScope.AddOrGetDefaultFieldSharable(forge.IComparer); var compare = ExprDotMethod(comparator, "Compare", REF_ORDERFIRSTSORTKEY, REF_ORDERSECONDSORTKEY); method.Block.IfCondition(Relational(compare, LE, Constant(0))) .BlockReturn(NewArrayWithInit(typeof(EventBean), REF_ORDERFIRSTEVENT, REF_ORDERSECONDEVENT)) .MethodReturn(NewArrayWithInit(typeof(EventBean), REF_ORDERSECONDEVENT, REF_ORDERFIRSTEVENT)); }
protected internal static void SortWOrderKeysCodegen( OrderByProcessorForgeImpl forge, CodegenMethod method, CodegenClassScope classScope) { CodegenExpression comparator = classScope.AddOrGetDefaultFieldSharable(forge.IComparer); method.Block.MethodReturn( StaticMethod( typeof(OrderByProcessorUtil), "SortWOrderKeys", REF_OUTGOINGEVENTS, REF_ORDERKEYS, comparator)); }
public static void GetSortKeyRollupCodegen( OrderByProcessorForgeImpl forge, CodegenMethod method, CodegenClassScope classScope, CodegenNamedMethods namedMethods) { method.Block.DeclareVar<int>("num", ExprDotName(REF_ORDERROLLUPLEVEL, "LevelNumber")); var blocks = method.Block.SwitchBlockOfLength(Ref("num"), forge.OrderByRollup.Length, true); for (var i = 0; i < blocks.Length; i++) { var getSortKey = GenerateOrderKeyCodegen( "GetSortKeyInternal_" + i, forge.OrderByRollup[i], classScope, namedMethods); blocks[i].BlockReturn(LocalMethod(getSortKey, REF_EPS, REF_ISNEWDATA, REF_EXPREVALCONTEXT)); } }
public static void GetSortKeyCodegen( OrderByProcessorForgeImpl forge, CodegenMethod method, CodegenClassScope classScope, CodegenNamedMethods namedMethods) { string[] expressions = null; bool[] descending = null; if (classScope.IsInstrumented) { expressions = forge.ExpressionTexts; descending = forge.DescendingFlags; } method.Block.Apply(Instblock(classScope, "qOrderBy", REF_EPS, Constant(expressions), Constant(descending))); var getSortKey = GenerateOrderKeyCodegen("GetSortKeyInternal", forge.OrderBy, classScope, namedMethods); method.Block .DeclareVar<object>("key", LocalMethod(getSortKey, REF_EPS, REF_ISNEWDATA, REF_EXPREVALCONTEXT)) .Apply(Instblock(classScope, "aOrderBy", Ref("key"))) .MethodReturn(Ref("key")); }
protected internal static void SortWGroupKeysCodegen( OrderByProcessorForgeImpl forge, CodegenMethod method, CodegenClassScope classScope, CodegenNamedMethods namedMethods) { var sortWGroupKeysInternal = SortWGroupKeysInternalCodegen(forge, classScope, namedMethods); method.Block.IfCondition( Or(EqualsNull(REF_OUTGOINGEVENTS), Relational(ArrayLength(REF_OUTGOINGEVENTS), LT, Constant(2)))) .BlockReturn(REF_OUTGOINGEVENTS) .MethodReturn( LocalMethod( sortWGroupKeysInternal, REF_OUTGOINGEVENTS, REF_GENERATINGEVENTS, REF_ORDERGROUPBYKEYS, REF_ISNEWDATA, REF_EXPREVALCONTEXT, MEMBER_AGGREGATIONSVC)); }
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); }
protected internal static void SortRollupCodegen( OrderByProcessorForgeImpl forge, CodegenMethod method, CodegenClassScope classScope, CodegenNamedMethods namedMethods) { var createSortPropertiesWRollup = CreateSortPropertiesWRollupCodegen(forge, classScope, namedMethods); CodegenExpression comparator = classScope.AddOrGetDefaultFieldSharable(forge.IComparer); method.Block.DeclareVar<IList<object>>( "sortValuesMultiKeys", LocalMethod( createSortPropertiesWRollup, REF_ORDERCURRENTGENERATORS, REF_ISNEWDATA, MEMBER_AGENTINSTANCECONTEXT, MEMBER_AGGREGATIONSVC)) .MethodReturn( StaticMethod( typeof(OrderByProcessorUtil), "SortGivenOutgoingAndSortKeys", REF_OUTGOINGEVENTS, Ref("sortValuesMultiKeys"), comparator)); }
public static OrderByProcessorFactoryForge GetProcessor( IList<SelectClauseExprCompiledSpec> selectionList, IList<OrderByItem> orderByList, RowLimitSpec rowLimitSpec, VariableCompileTimeResolver variableCompileTimeResolver, bool isSortUsingCollator, string optionalContextName, OrderByElementForge[][] orderByRollup) { // Get the order by expression nodes IList<ExprNode> orderByNodes = new List<ExprNode>(); foreach (var element in orderByList) { orderByNodes.Add(element.ExprNode); } // No order-by clause if (orderByList.IsEmpty()) { Log.Debug(".getProcessor Using no OrderByProcessor"); if (rowLimitSpec != null) { var rowLimitProcessorFactory = new RowLimitProcessorFactoryForge( rowLimitSpec, variableCompileTimeResolver, optionalContextName); return new OrderByProcessorRowLimitOnlyForge(rowLimitProcessorFactory); } return null; } // Determine aggregate functions used in select, if any IList<ExprAggregateNode> selectAggNodes = new List<ExprAggregateNode>(); foreach (var element in selectionList) { ExprAggregateNodeUtil.GetAggregatesBottomUp(element.SelectExpression, selectAggNodes); } // Get all the aggregate functions occuring in the order-by clause IList<ExprAggregateNode> orderAggNodes = new List<ExprAggregateNode>(); foreach (var orderByNode in orderByNodes) { ExprAggregateNodeUtil.GetAggregatesBottomUp(orderByNode, orderAggNodes); } ValidateOrderByAggregates(selectAggNodes, orderAggNodes); // Tell the order-by processor whether to compute group-by // keys if they are not present var needsGroupByKeys = !selectionList.IsEmpty() && !orderAggNodes.IsEmpty(); Log.Debug(".getProcessor Using OrderByProcessorImpl"); var elements = ToElementArray(orderByList); var comparator = GetComparator(elements, isSortUsingCollator); var orderByProcessorForge = new OrderByProcessorForgeImpl( elements, needsGroupByKeys, orderByRollup, comparator); if (rowLimitSpec == null) { return orderByProcessorForge; } { var rowLimitProcessorFactory = new RowLimitProcessorFactoryForge( rowLimitSpec, variableCompileTimeResolver, optionalContextName); return new OrderByProcessorOrderedLimitForge(orderByProcessorForge, rowLimitProcessorFactory); } }
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); }
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); }