public DBObject toSort(List<OrderSpecifier<?>> orderBys) { BasicDBObject sort = new BasicDBObject(); for (OrderSpecifier<?> orderBy : orderBys) { Object key = orderBy.getTarget().accept(this, null); sort.append(key.toString(), orderBy.getOrder() == Order.ASC ? 1 : -1); } return sort; }
private void order(QueryMetadata metadata, List<Expression<?>> sources, List<?> list) { // create a projection for the order List<OrderSpecifier<?>> orderBy = metadata.getOrderBy(); Expression<Object>[] orderByExpr = new Expression[orderBy.size()]; boolean[] directions = new boolean[orderBy.size()]; for (int i = 0; i < orderBy.size(); i++) { orderByExpr[i] = (Expression) orderBy.get(i).getTarget(); directions[i] = orderBy.get(i).getOrder() == Order.ASC; } Expression<?> expr = new ArrayConstructorExpression<Object>(Object[].class, orderByExpr); Evaluator orderEvaluator = evaluatorFactory.create(metadata, sources, expr); Collections.sort(list, new MultiComparator(orderEvaluator, directions)); }
public Sort toSort(List<? extends OrderSpecifier<?>> orderBys) { List<SortField> sorts = new ArrayList<SortField>(orderBys.size()); for (OrderSpecifier<?> order : orderBys) { if (!(order.getTarget() instanceof Path<?>)) { throw new IllegalArgumentException("argument was not of type Path."); } Class<?> type = order.getTarget().getType(); boolean reverse = !order.isAscending(); Path<?> path = getPath(order.getTarget()); if (Number.class.isAssignableFrom(type)) { sorts.add(new SortField(toField(path), sortFields.get(type), reverse)); } else { sorts.add(new SortField(toField(path), sortLocale, reverse)); } } Sort sort = new Sort(); sort.setSort(sorts.toArray(new SortField[sorts.size()])); return sort; } }
@SuppressWarnings("unchecked") private OrderSpecifier<?> transform(Filters filters, OrderSpecifier<?> os) { return new OrderSpecifier(os.getOrder(), transform(os.getTarget(), filters)); }
if (os.getNullHandling() == OrderSpecifier.NullHandling.NullsFirst) { if (templates.getNullsFirst() != null) { handle(os.getTarget()); append(order); append(templates.getNullsFirst()); } else { append("(case when "); handle(os.getTarget()); append(" is null then 0 else 1 end), "); handle(os.getTarget()); append(order); handle(os.getTarget()); append(order); append(templates.getNullsLast()); } else { append("(case when "); handle(os.getTarget()); append(" is null then 1 else 0 end), "); handle(os.getTarget()); append(order); handle(os.getTarget()); append(order);
append(COMMA); handle(os.getTarget()); append(" " + os.getOrder()); first = false;
public static Set<RelationalPath<?>> extract(QueryMetadata md) { Set<RelationalPath<?>> known = ImmutableSet.of(); known = DEFAULT.visitJoins(md.getJoins(), known); for (Expression<?> p : md.getProjection()) { known = p.accept(DEFAULT, known); } for (OrderSpecifier<?> o : md.getOrderBy()) { known = o.getTarget().accept(DEFAULT, known); } for (Expression<?> g : md.getGroupBy()) { known = g.accept(DEFAULT, known); } if (md.getHaving() != null) { known = md.getHaving().accept(DEFAULT, known); } if (md.getWhere() != null) { known = md.getWhere().accept(DEFAULT, known); } return known; }
List<OrderElem> orderElements = new ArrayList<OrderElem>(); for (OrderSpecifier<?> os : md.getOrderBy()){ orderElements.add(new OrderElem(toValue(os.getTarget(), md), os.isAscending()));
List<OrderElem> orderElements = new ArrayList<OrderElem>(); for (OrderSpecifier<?> os : md.getOrderBy()) { orderElements.add(new OrderElem(toValue(os.getTarget(), md), os.isAscending()));
List<OrderElem> orderElements = new ArrayList<OrderElem>(); for (OrderSpecifier<?> os : md.getOrderBy()) { orderElements.add(new OrderElem(toValue(os.getTarget(), md), os.isAscending()));
append(COMMA); handle(os.getTarget()); append(" " + os.getOrder().toString().toLowerCase(Locale.ENGLISH)); first = false;
@Override public Set<RelationalPath<?>> visit(SubQueryExpression<?> expr, Set<RelationalPath<?>> known) { Set<RelationalPath<?>> old = known; final QueryMetadata md = expr.getMetadata(); known = visitJoins(md.getJoins(), known); for (Expression<?> p : md.getProjection()) { known = p.accept(this, known); } for (OrderSpecifier<?> o : md.getOrderBy()) { known = o.getTarget().accept(this, known); } for (Expression<?> g : md.getGroupBy()) { known = g.accept(this, known); } if (md.getHaving() != null) { known = md.getHaving().accept(this, known); } if (md.getWhere() != null) { md.getWhere().accept(this, known); } return old; }
@Override public Set<Expression<?>> visit(SubQueryExpression<?> expr, Set<Expression<?>> known) { Set<Expression<?>> old = known; final QueryMetadata md = expr.getMetadata(); known = visitJoins(md.getJoins(), known); for (Expression<?> p : md.getProjection()) { known = p.accept(this, known); } for (OrderSpecifier<?> o : md.getOrderBy()) { known = o.getTarget().accept(this, known); } for (Expression<?> g : md.getGroupBy()) { known = g.accept(this, known); } if (md.getHaving() != null) { known = md.getHaving().accept(this, known); } if (md.getWhere() != null) { known = md.getWhere().accept(this, known); } return old; }
OrderSpecifier<?> os2 = new OrderSpecifier(os.getOrder(), os.getTarget().accept(this, null), os.getNullHandling()); md.addOrderBy(os2);