/** * Add a dynamic part of query for the sorting support. * * @param sql SQL text string. * @param sort Sort method. */ public static StringBuilder addSorting(StringBuilder sql, Sort sort) { if (sort != null) { sql.append(" ORDER BY "); for (Sort.Order order : sort) { sql.append(order.getProperty()).append(" ").append(order.getDirection()); if (order.getNullHandling() != Sort.NullHandling.NATIVE) { sql.append(" ").append("NULL "); switch (order.getNullHandling()) { case NULLS_FIRST: sql.append("FIRST"); break; case NULLS_LAST: sql.append("LAST"); break; } } sql.append(", "); } sql.delete(sql.length() - 2, sql.length()); } return sql; }
/** * Add a dynamic part of query for the sorting support. * * @param sql SQL text string. * @param sort Sort method. * @return Sorting criteria in StringBuilder. */ public static StringBuilder addSorting(StringBuilder sql, Sort sort) { if (sort != null && sort != Sort.unsorted()) { sql.append(" ORDER BY "); for (Sort.Order order : sort) { sql.append(order.getProperty()).append(" ").append(order.getDirection()); if (order.getNullHandling() != Sort.NullHandling.NATIVE) { sql.append(" ").append("NULL "); switch (order.getNullHandling()) { case NULLS_FIRST: sql.append("FIRST"); break; case NULLS_LAST: sql.append("LAST"); break; } } sql.append(", "); } sql.delete(sql.length() - 2, sql.length()); } return sql; }
private static List<FieldSortBuilder> sort(Query query, ElasticsearchPersistentEntity<?> entity) { if (query.getSort() == null || query.getSort().isUnsorted()) { return Collections.emptyList(); } List<FieldSortBuilder> mappedSort = new ArrayList<>(); for (Sort.Order order : query.getSort()) { ElasticsearchPersistentProperty property = entity.getPersistentProperty(order.getProperty()); String fieldName = property != null ? property.getFieldName() : order.getProperty(); FieldSortBuilder sort = SortBuilders.fieldSort(fieldName) .order(order.getDirection().isDescending() ? SortOrder.DESC : SortOrder.ASC); if (order.getNullHandling() == Sort.NullHandling.NULLS_FIRST) { sort.missing("_first"); } else if (order.getNullHandling() == Sort.NullHandling.NULLS_LAST) { sort.missing("_last"); } mappedSort.add(sort); } return mappedSort; }
if (!NullHandling.NATIVE.equals(order.getNullHandling())) { spelSort = NullHandling.NULLS_FIRST.equals(order.getNullHandling()) ? spelSort.nullsFirst() : spelSort.nullsLast();
if (!NullHandling.NATIVE.equals(order.getNullHandling())) { spelSort = NullHandling.NULLS_FIRST.equals(order.getNullHandling()) ? spelSort.nullsFirst() : spelSort.nullsLast();
if (!NullHandling.NATIVE.equals(order.getNullHandling())) { spelSort = NullHandling.NULLS_FIRST.equals(order.getNullHandling()) ? spelSort.nullsFirst() : spelSort.nullsLast();
/** * <p> * Sort on a sequence of fields, possibly none. * </P> * * @param query If not null, will contain one of more {@link Sort.Order} objects. * @return A sequence of comparators or {@code null} */ public Comparator<Entry<?, ?>> resolve(KeyValueQuery<?> query) { if (query == null || query.getSort() == Sort.unsorted()) { return null; } CompoundComparator<Entry<?, ?>> compoundComparator = new CompoundComparator<>(); for (Order order : query.getSort()) { if (order.getProperty().indexOf('.') > -1) { throw new UnsupportedOperationException("Embedded fields not implemented: " + order); } if (order.isIgnoreCase()) { throw new UnsupportedOperationException("Ignore case not implemented: " + order); } if (NullHandling.NATIVE != order.getNullHandling()) { throw new UnsupportedOperationException("Null handling not implemented: " + order); } HazelcastPropertyComparator hazelcastPropertyComparator = new HazelcastPropertyComparator(order.getProperty(), order.isAscending()); compoundComparator.addComparator(hazelcastPropertyComparator); } return compoundComparator; }
@Override public Sort getMappedSort(Class<?> typeToRead, Sort sort) { RelationalPersistentEntity<?> entity = getPersistentEntity(typeToRead); if (entity == null) { return sort; } List<Order> mappedOrder = new ArrayList<>(); for (Order order : sort) { RelationalPersistentProperty persistentProperty = entity.getPersistentProperty(order.getProperty()); if (persistentProperty == null) { mappedOrder.add(order); } else { mappedOrder .add(Order.by(persistentProperty.getColumnName()).with(order.getNullHandling()).with(order.getDirection())); } } return Sort.by(mappedOrder); }
@Override public Sort getMappedSort(Class<?> typeToRead, Sort sort) { RelationalPersistentEntity<?> entity = getPersistentEntity(typeToRead); if (entity == null) { return sort; } List<Order> mappedOrder = new ArrayList<>(); for (Order order : sort) { RelationalPersistentProperty persistentProperty = entity.getPersistentProperty(order.getProperty()); if (persistentProperty == null) { mappedOrder.add(order); } else { mappedOrder .add(Order.by(persistentProperty.getColumnName()).with(order.getNullHandling()).with(order.getDirection())); } } return Sort.by(mappedOrder); }
/** * Given a sort parameter from the Spring Data framework, will determine the appropriate sort metadata compatible * with this framework * @param sort the sort specification * @return converted sort metadata */ protected Sort getSort(org.springframework.data.domain.Sort sort) { final List<Order> orders = new ArrayList<>(); for (org.springframework.data.domain.Sort.Order order : sort) { final SortDirection sortDirection = order.getDirection().equals(ASC) ? SortDirection.ASCENDING : SortDirection.DESCENDING; final NullHandling nullHandling = order.getNullHandling().equals(NULLS_FIRST) ? NullHandling.NULLS_FIRST : (order.getNullHandling().equals(NULLS_LAST) ? NullHandling.NULLS_LAST : NullHandling.DEFAULT); orders.add(new ImmutableOrder(sortDirection, order.getProperty(), nullHandling)); } return new ImmutableSort(orders); }
private static StructuredQuery.OrderBy createOrderBy(DatastorePersistentEntity<?> persistentEntity, Sort.Order order) { if (order.isIgnoreCase()) { throw new DatastoreDataException("Datastore doesn't support sorting ignoring case"); } if (!order.getNullHandling().equals(Sort.NullHandling.NATIVE)) { throw new DatastoreDataException("Datastore supports only NullHandling.NATIVE null handling"); } return new StructuredQuery.OrderBy( persistentEntity.getPersistentProperty(order.getProperty()).getFieldName(), (order.getDirection() == Sort.Direction.DESC) ? StructuredQuery.OrderBy.Direction.DESCENDING : StructuredQuery.OrderBy.Direction.ASCENDING); }
/** * Given a sort parameter from the Spring Data framework, will determine the appropriate sort metadata compatible * with this framework * @param sort the sort specification * @return converted sort metadata */ protected Sort getSort(org.springframework.data.domain.Sort sort) { final List<Order> orders = new ArrayList<>(); for (org.springframework.data.domain.Sort.Order order : sort) { final SortDirection sortDirection = order.getDirection().equals(ASC) ? SortDirection.ASCENDING : SortDirection.DESCENDING; final NullHandling nullHandling = order.getNullHandling().equals(NULLS_FIRST) ? NullHandling.NULLS_FIRST : (order.getNullHandling().equals(NULLS_LAST) ? NullHandling.NULLS_LAST : NullHandling.DEFAULT); orders.add(new ImmutableOrder(sortDirection, order.getProperty(), nullHandling)); } return new ImmutableSort(orders); }
private static StructuredQuery.OrderBy createOrderBy(DatastorePersistentEntity<?> persistentEntity, Sort.Order order) { if (order.isIgnoreCase()) { throw new DatastoreDataException("Datastore doesn't support sorting ignoring case"); } if (!order.getNullHandling().equals(Sort.NullHandling.NATIVE)) { throw new DatastoreDataException("Datastore supports only NullHandling.NATIVE null handling"); } return new StructuredQuery.OrderBy( persistentEntity.getPersistentProperty(order.getProperty()).getFieldName(), (order.getDirection() == Sort.Direction.DESC) ? StructuredQuery.OrderBy.Direction.DESCENDING : StructuredQuery.OrderBy.Direction.ASCENDING); }
/** * Transforms a {@code Sort.Order} object into a comparator item. * * @param sortOrder * the {@code Sort.Order} object * @return the comparator item */ public static ComparatorItem fromSortOrder(Sort.Order sortOrder) { if (sortOrder == null || sortOrder.getProperty() == null || sortOrder.getProperty().trim().length() == 0) { return null; } boolean nullIsFirst = Sort.NullHandling.NULLS_FIRST.equals(sortOrder.getNullHandling()); return new ComparatorItem(sortOrder.getProperty(), sortOrder.isAscending(), sortOrder.isIgnoreCase(), nullIsFirst); }
@SuppressWarnings({ "rawtypes", "unchecked" }) private static OrderSpecifier<?> toOrderSpecifier(Order order, PathBuilder<?> builder) { return new OrderSpecifier( order.isAscending() ? com.querydsl.core.types.Order.ASC : com.querydsl.core.types.Order.DESC, buildOrderPropertyPathFrom(order, builder), toQueryDslNullHandling(order.getNullHandling())); }
@SuppressWarnings({ "rawtypes", "unchecked" }) private static OrderSpecifier<?> toOrderSpecifier(Order order, PathBuilder<?> builder) { return new OrderSpecifier( order.isAscending() ? com.querydsl.core.types.Order.ASC : com.querydsl.core.types.Order.DESC, buildOrderPropertyPathFrom(order, builder), toQueryDslNullHandling(order.getNullHandling())); }
@SuppressWarnings({ "rawtypes", "unchecked" }) private static OrderSpecifier<?> toOrderSpecifier(Order order, PathBuilder<?> builder) { return new OrderSpecifier( order.isAscending() ? com.querydsl.core.types.Order.ASC : com.querydsl.core.types.Order.DESC, buildOrderPropertyPathFrom(order, builder), toQueryDslNullHandling(order.getNullHandling())); }
/** * Transforms a plain {@link Order} into a QueryDsl specific {@link OrderSpecifier}. * * @param order must not be {@literal null}. * @return */ @SuppressWarnings({ "rawtypes", "unchecked" }) private OrderSpecifier<?> toOrderSpecifier(Order order) { return new OrderSpecifier( order.isAscending() ? com.querydsl.core.types.Order.ASC : com.querydsl.core.types.Order.DESC, buildOrderPropertyPathFrom(order), toQueryDslNullHandling(order.getNullHandling())); }
FieldSortBuilder sort = SortBuilders.fieldSort(order.getProperty()) .order(order.getDirection().isDescending() ? SortOrder.DESC : SortOrder.ASC); if (order.getNullHandling() == Sort.NullHandling.NULLS_FIRST) { sort.missing("_first"); } else if (order.getNullHandling() == Sort.NullHandling.NULLS_LAST) { sort.missing("_last");
/** * Transforms a plain {@link Order} into a QueryDsl specific {@link OrderSpecifier}. * * @param order must not be {@literal null}. * @return */ @SuppressWarnings({ "rawtypes", "unchecked" }) private OrderSpecifier<?> toOrderSpecifier(Order order) { return new OrderSpecifier( order.isAscending() ? com.querydsl.core.types.Order.ASC : com.querydsl.core.types.Order.DESC, buildOrderPropertyPathFrom(order), toQueryDslNullHandling(order.getNullHandling())); }