protected Void visitOrderBy(OrderBy node, Integer indentLevel) { for (SortItem sortItem : node.getSortItems()) { process(sortItem, indentLevel); } return null; }
@Override protected R visitOrderBy(OrderBy node, C context) { for (SortItem sortItem : node.getSortItems()) { process(sortItem, context); } return null; }
static String formatOrderBy(OrderBy orderBy, Optional<List<Expression>> parameters) { return "ORDER BY " + formatSortItems(orderBy.getSortItems(), parameters); }
private PlanBuilder sort(PlanBuilder subPlan, Optional<OrderBy> orderBy, Optional<String> limit, List<Expression> orderByExpressions) { if (!orderBy.isPresent()) { return subPlan; } Iterator<SortItem> sortItems = orderBy.get().getSortItems().iterator(); ImmutableList.Builder<Symbol> orderBySymbols = ImmutableList.builder(); Map<Symbol, SortOrder> orderings = new HashMap<>(); for (Expression fieldOrExpression : orderByExpressions) { Symbol symbol = subPlan.translate(fieldOrExpression); SortItem sortItem = sortItems.next(); if (!orderings.containsKey(symbol)) { orderBySymbols.add(symbol); orderings.put(symbol, toSortOrder(sortItem)); } } PlanNode planNode; OrderingScheme orderingScheme = new OrderingScheme(orderBySymbols.build(), orderings); if (limit.isPresent() && !limit.get().equalsIgnoreCase("all")) { planNode = new TopNNode(idAllocator.getNextId(), subPlan.getRoot(), Long.parseLong(limit.get()), orderingScheme, TopNNode.Step.SINGLE); } else { planNode = new SortNode(idAllocator.getNextId(), subPlan.getRoot(), orderingScheme); } return subPlan.withNewRoot(planNode); }
OrderBy orderBy = aggregation.getCall().getOrderBy().get(); sortKeys = orderBy.getSortItems().stream() .map(SortItem::getSortKey) .map(Symbol::from) .collect(toImmutableList()); sortOrders = orderBy.getSortItems().stream() .map(QueryPlanner::toSortOrder) .collect(toImmutableList());
private void verifySelectDistinct(QuerySpecification node, List<Expression> outputExpressions) { for (SortItem item : node.getOrderBy().get().getSortItems()) { Expression expression = item.getSortKey(); if (expression instanceof LongLiteral) { continue; } Expression rewrittenOrderByExpression = ExpressionTreeRewriter.rewriteWith(new OrderByExpressionRewriter(extractNamedOutputExpressions(node.getSelect())), expression); int index = outputExpressions.indexOf(rewrittenOrderByExpression); if (index == -1) { throw new SemanticException(ORDER_BY_MUST_BE_IN_SELECT, node.getSelect(), "For SELECT DISTINCT, ORDER BY expressions must appear in select list"); } if (!isDeterministic(expression)) { throw new SemanticException(NONDETERMINISTIC_ORDER_BY_EXPRESSION_WITH_SELECT_DISTINCT, expression, "Non deterministic ORDER BY expression is not supported with SELECT DISTINCT"); } } }
List<Expression> sortKeys = node.getOrderBy().get().getSortItems().stream() .map(SortItem::getSortKey) .collect(toImmutableList());
toExtract.addAll(windowFunction.getArguments()); toExtract.addAll(window.getPartitionBy()); window.getOrderBy().ifPresent(orderBy -> toExtract.addAll(orderBy.getSortItems())); window.getFrame().ifPresent(toExtract::add);
for (SortItem sortItem : node.getOrderBy().get().getSortItems()) { Type sortKeyType = process(sortItem.getSortKey(), context); if (!sortKeyType.isOrderable()) {
static String formatOrderBy(OrderBy orderBy, Function<QualifiedName, String> tableNameMapper, Optional<Function<String, String>> columnNameMapper, List<String> queryWithTables, char escapeIdentifier) { return "ORDER BY " + formatSortItems(orderBy.getSortItems(), tableNameMapper, columnNameMapper, queryWithTables, escapeIdentifier); }
.collect(Collectors.toList()); } else { orderBy = queryBody.getOrderBy().map(v -> v.getSortItems().stream().map(item -> new Ordering(item.getOrdering(), mapper.apply(item.getSortKey()), item.getSortKey().toString())) .collect(Collectors.toList())).orElse(ImmutableList.of());
statement.getLimit(), statement.getOrderBy().map(v -> v.getSortItems()).orElse(null), map); } else if (statement.getQueryBody() instanceof Union) { Relation relation = ((Union) statement.getQueryBody()).getRelations().get(0); statement.getLimit(), statement.getOrderBy().map(v -> v.getSortItems()).orElse(null), map);
for (SortItem sortItem : orderBy.getSortItems()) { String expression = RakamSqlFormatter.formatExpression(sortItem.getSortKey(), qualifiedNameStringFunction, columnMappingFunction, ' '); reportRequest.orderBys.add(new GARequest.ReportRequest.OrderBy(expression, sortItem.getOrdering()));
protected Void visitOrderBy(OrderBy node, Integer indentLevel) { for (SortItem sortItem : node.getSortItems()) { process(sortItem, indentLevel); } return null; }
@Override protected R visitOrderBy(OrderBy node, C context) { for (SortItem sortItem : node.getSortItems()) { process(sortItem, context); } return null; }
static String formatOrderBy(OrderBy orderBy, Optional<List<Expression>> parameters) { return "ORDER BY " + formatSortItems(orderBy.getSortItems(), parameters); }