private static IQueryPlanNode PlanGroup(IQueryPlanNode node, QuerySelectColumnSet columnSet, ObjectName groupmaxColumn, int gsz, ObjectName[] groupByList, IList <Expression> groupByFunctions, int fsz, string[] defFunNames, Expression[] defFunList) { // If there is more than 1 aggregate function or there is a group by // clause, then we must add a grouping plan. if (columnSet.AggregateCount > 0 || gsz > 0) { // If there is no GROUP BY clause then assume the entire result is the // group. if (gsz == 0) { node = new GroupNode(node, groupmaxColumn, defFunList, defFunNames); } else { // Do we have any group by functions that need to be planned first? int gfsz = groupByFunctions.Count; if (gfsz > 0) { var groupFunList = new Expression[gfsz]; var groupFunName = new String[gfsz]; for (int i = 0; i < gfsz; ++i) { groupFunList[i] = groupByFunctions[i]; groupFunName[i] = "#GROUPBY-" + i; } node = new CreateFunctionsNode(node, groupFunList, groupFunName); } // Otherwise we provide the 'group_by_list' argument node = new GroupNode(node, groupByList, groupmaxColumn, defFunList, defFunNames); } } else { // Otherwise no grouping is occuring. We simply need create a function // node with any functions defined in the SELECT. // Plan a FunctionsNode with the functions defined in the SELECT. if (fsz > 0) { node = new CreateFunctionsNode(node, defFunList, defFunNames); } } return(node); }
/// <summary> /// Plans an ORDER BY set. /// </summary> /// <param name="plan"></param> /// <param name="orderBy"></param> /// <param name="fromSet"></param> /// <param name="selectedColumns"></param> /// <remarks> /// This is given its own function because we may want to plan /// this at the end of a number of composite functions. /// </remarks> /// <returns></returns> private static IQueryPlanNode PlanForOrderBy(IQueryPlanNode plan, IList <ByColumn> orderBy, TableExpressionFromSet fromSet, IList <SelectColumn> selectedColumns) { var functionTable = new ObjectName("FUNCTIONTABLE"); // Sort on the ORDER BY clause if (orderBy.Count > 0) { int sz = orderBy.Count; var orderList = new ObjectName[sz]; var ascendingList = new bool[sz]; var functionOrders = new List <Expression>(); for (int i = 0; i < sz; ++i) { ByColumn column = orderBy[i]; Expression exp = column.Expression; ascendingList[i] = column.Ascending; ObjectName v = exp.AsVariable(); if (v != null) { ObjectName newV = fromSet.ResolveReference(v); if (newV == null) { throw new ApplicationException("Can not resolve ORDER BY variable: " + v); } newV = SubstituteAliasedVariable(newV, selectedColumns); orderList[i] = newV; } else { // Otherwise we must be ordering by an expression such as // '0 - a'. // Resolve the expression, exp = exp.Prepare(fromSet.ExpressionQualifier); // Make sure we substitute any aliased columns in the order by // columns. exp = SubstituteAliasedVariables(exp, selectedColumns); // The new ordering functions are called 'FUNCTIONTABLE.#ORDER-n' // where n is the number of the ordering expression. orderList[i] = new ObjectName(functionTable, "#ORDER-" + functionOrders.Count); functionOrders.Add(exp); } } // If there are functional orderings, // For this we must define a new FunctionTable with the expressions, // then order by those columns, and then use another SubsetNode // command node. int fsz = functionOrders.Count; if (fsz > 0) { var funs = new Expression[fsz]; var fnames = new String[fsz]; for (int n = 0; n < fsz; ++n) { funs[n] = functionOrders[n]; fnames[n] = "#ORDER-" + n; } if (plan is SubsetNode) { // If the top plan is a QueryPlan.SubsetNode then we use the // information from it to create a new SubsetNode that // doesn't include the functional orders we have attached here. var topSubsetNode = (SubsetNode)plan; ObjectName[] mappedNames = topSubsetNode.NewColumnNames; // Defines the sort functions plan = new CreateFunctionsNode(plan, funs, fnames); // Then plan the sort plan = new SortNode(plan, orderList, ascendingList); // Then plan the subset plan = new SubsetNode(plan, mappedNames, mappedNames); } else { // Defines the sort functions plan = new CreateFunctionsNode(plan, funs, fnames); // Plan the sort plan = new SortNode(plan, orderList, ascendingList); } } else { // No functional orders so we only need to sort by the columns // defined. plan = new SortNode(plan, orderList, ascendingList); } } return(plan); }
private static IQueryPlanNode PlanGroup(IQueryPlanNode node, QuerySelectColumnSet columnSet, ObjectName groupmaxColumn, int gsz, ObjectName[] groupByList, IList<Expression> groupByFunctions, int fsz, string[] defFunNames, Expression[] defFunList) { // If there is more than 1 aggregate function or there is a group by // clause, then we must add a grouping plan. if (columnSet.AggregateCount > 0 || gsz > 0) { // If there is no GROUP BY clause then assume the entire result is the // group. if (gsz == 0) { node = new GroupNode(node, groupmaxColumn, defFunList, defFunNames); } else { // Do we have any group by functions that need to be planned first? int gfsz = groupByFunctions.Count; if (gfsz > 0) { var groupFunList = new Expression[gfsz]; var groupFunName = new String[gfsz]; for (int i = 0; i < gfsz; ++i) { groupFunList[i] = groupByFunctions[i]; groupFunName[i] = "#GROUPBY-" + i; } node = new CreateFunctionsNode(node, groupFunList, groupFunName); } // Otherwise we provide the 'group_by_list' argument node = new GroupNode(node, groupByList, groupmaxColumn, defFunList, defFunNames); } } else { // Otherwise no grouping is occuring. We simply need create a function // node with any functions defined in the SELECT. // Plan a FunctionsNode with the functions defined in the SELECT. if (fsz > 0) node = new CreateFunctionsNode(node, defFunList, defFunNames); } return node; }
/// <summary> /// Plans an ORDER BY set. /// </summary> /// <param name="plan"></param> /// <param name="orderBy"></param> /// <param name="fromSet"></param> /// <param name="selectedColumns"></param> /// <remarks> /// This is given its own function because we may want to plan /// this at the end of a number of composite functions. /// </remarks> /// <returns></returns> private static IQueryPlanNode PlanForOrderBy(IQueryPlanNode plan, IList<ByColumn> orderBy, TableExpressionFromSet fromSet, IList<SelectColumn> selectedColumns) { var functionTable = new ObjectName("FUNCTIONTABLE"); // Sort on the ORDER BY clause if (orderBy.Count > 0) { int sz = orderBy.Count; var orderList = new ObjectName[sz]; var ascendingList = new bool[sz]; var functionOrders = new List<Expression>(); for (int i = 0; i < sz; ++i) { ByColumn column = orderBy[i]; Expression exp = column.Expression; ascendingList[i] = column.Ascending; ObjectName v = exp.AsVariable(); if (v != null) { ObjectName newV = fromSet.ResolveReference(v); if (newV == null) throw new ApplicationException("Can not resolve ORDER BY variable: " + v); newV = SubstituteAliasedVariable(newV, selectedColumns); orderList[i] = newV; } else { // Otherwise we must be ordering by an expression such as // '0 - a'. // Resolve the expression, exp = exp.Prepare(fromSet.ExpressionQualifier); // Make sure we substitute any aliased columns in the order by // columns. exp = SubstituteAliasedVariables(exp, selectedColumns); // The new ordering functions are called 'FUNCTIONTABLE.#ORDER-n' // where n is the number of the ordering expression. orderList[i] = new ObjectName(functionTable, "#ORDER-" + functionOrders.Count); functionOrders.Add(exp); } } // If there are functional orderings, // For this we must define a new FunctionTable with the expressions, // then order by those columns, and then use another SubsetNode // command node. int fsz = functionOrders.Count; if (fsz > 0) { var funs = new Expression[fsz]; var fnames = new String[fsz]; for (int n = 0; n < fsz; ++n) { funs[n] = functionOrders[n]; fnames[n] = "#ORDER-" + n; } if (plan is SubsetNode) { // If the top plan is a QueryPlan.SubsetNode then we use the // information from it to create a new SubsetNode that // doesn't include the functional orders we have attached here. var topSubsetNode = (SubsetNode)plan; ObjectName[] mappedNames = topSubsetNode.NewColumnNames; // Defines the sort functions plan = new CreateFunctionsNode(plan, funs, fnames); // Then plan the sort plan = new SortNode(plan, orderList, ascendingList); // Then plan the subset plan = new SubsetNode(plan, mappedNames, mappedNames); } else { // Defines the sort functions plan = new CreateFunctionsNode(plan, funs, fnames); // Plan the sort plan = new SortNode(plan, orderList, ascendingList); } } else { // No functional orders so we only need to sort by the columns // defined. plan = new SortNode(plan, orderList, ascendingList); } } return plan; }