/** * Create an OrderSpecifier for ascending order of this expression * * @return ascending order by this */ public final OrderSpecifier<T> asc() { if (asc == null) { asc = new OrderSpecifier<T>(Order.ASC, mixin); } return asc; }
@SuppressWarnings("unchecked") public final T orderBy(OrderSpecifier<?> spec) { Expression<?> e = convert(spec.getTarget(), Role.ORDER_BY); if (!spec.getTarget().equals(e)) { metadata.addOrderBy(new OrderSpecifier(spec.getOrder(), e, spec.getNullHandling())); } else { metadata.addOrderBy(spec); } return self; }
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; } }
String order = os.getOrder() == Order.ASC ? templates.getAsc() : templates.getDesc(); 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); } else if (os.getNullHandling() == OrderSpecifier.NullHandling.NullsLast) { if (templates.getNullsLast() != null) { 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);
@Override public Set<Expression<?>> visit(SubQueryExpression<?> expr, Set<Expression<?>> known) { Set<Expression<?>> old = known; final QueryMetadata md = expr.getMetadata(); known = visitJoins(md.getJoins(), known); if (md.getProjection() != null) { known = md.getProjection().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; }
@Test public void orderBy_nullsLast() { QCat cat = QCat.cat; mixin.from(cat); mixin.orderBy(cat.mate.name.asc().nullsLast()); assertEquals( OrderSpecifier.NullHandling.NullsLast, mixin.getMetadata().getOrderBy().get(0).getNullHandling()); } }
/** * Create the MongoDB specific sort document. * * @param orderBys must not be {@literal null}. * @return empty {@link Document} by default. */ Document toSort(List<OrderSpecifier<?>> orderBys) { Document sort = new Document(); orderBys.forEach(orderSpecifier -> { Object key = orderSpecifier.getTarget().accept(this, null); Assert.notNull(key, () -> String.format("Mapped sort key for %s must not be null!", orderSpecifier)); sort.append(key.toString(), orderSpecifier.getOrder() == Order.ASC ? 1 : -1); }); return sort; }
append(COMMA); handle(os.getTarget()); append(os.getOrder() == Order.ASC ? " asc" : " desc"); if (os.getNullHandling() == OrderSpecifier.NullHandling.NullsFirst) { append(" nulls first"); } else if (os.getNullHandling() == OrderSpecifier.NullHandling.NullsLast) { append(" nulls last");
@Override public Expression<?> getExpression(OrderSpecifier<?> order) { return order.getTarget(); }
/** * Create a new OrderSpecifier instance with null first enabled * * @return new instance with null first enabled */ public OrderSpecifier<T> nullsFirst() { return new OrderSpecifier<T>(order, target, NullHandling.NullsFirst); }
OrderSpecifier<?> os2 = new OrderSpecifier(os.getOrder(), os.getTarget().accept(this, context), os.getNullHandling()); md.addOrderBy(os2);
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), SortField.Type.STRING, reverse)); } } Sort sort = new Sort(); sort.setSort(sorts.toArray(new SortField[sorts.size()])); return sort; } }
public static Set<RelationalPath<?>> extract(QueryMetadata md) { Set<RelationalPath<?>> known = ImmutableSet.of(); known = DEFAULT.visitJoins(md.getJoins(), known); if (md.getProjection() != null) { known = md.getProjection().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; }
/** * Create an OrderSpecifier for descending order of this expression * * @return descending order by this */ public final OrderSpecifier<T> desc() { if (desc == null) { desc = new OrderSpecifier<T>(Order.DESC, mixin); } return desc; }
@SuppressWarnings("unchecked") public final T orderBy(OrderSpecifier<?> spec) { Expression<?> e = convert(spec.getTarget(), Role.ORDER_BY); if (!spec.getTarget().equals(e)) { metadata.addOrderBy(new OrderSpecifier(spec.getOrder(), e, spec.getNullHandling())); } else { metadata.addOrderBy(spec); } return self; }
/** * Create the MongoDB specific sort document. * * @param orderBys must not be {@literal null}. * @return empty {@link Document} by default. */ Document toSort(List<OrderSpecifier<?>> orderBys) { Document sort = new Document(); orderBys.forEach(orderSpecifier -> { Object key = orderSpecifier.getTarget().accept(this, null); Assert.notNull(key, () -> String.format("Mapped sort key for %s must not be null!", orderSpecifier)); sort.append(key.toString(), orderSpecifier.getOrder() == Order.ASC ? 1 : -1); }); return sort; }
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 SortedNumericSortField(toField(path), sortFields.get(type), reverse)); } else { sorts.add(new SortField(toField(path), SortField.Type.STRING, reverse)); } } Sort sort = new Sort(); sort.setSort(sorts.toArray(new SortField[sorts.size()])); return sort; } }
@Override public Set<Expression<?>> visit(SubQueryExpression<?> expr, Set<Expression<?>> known) { Set<Expression<?>> old = known; final QueryMetadata md = expr.getMetadata(); known = visitJoins(md.getJoins(), known); if (md.getProjection() != null) { known = md.getProjection().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; }