Refine search
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 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; } }
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; } }
@Test void shouldReturnIndexHitsInGivenSortOrder() throws Exception { // given DocValuesCollector collector = new DocValuesCollector( false ); IndexReaderStub readerStub = indexReaderWithMaxDocs( 43 ); // when collector.doSetNextReader( readerStub.getContext() ); collector.collect( 1 ); collector.collect( 3 ); collector.collect( 37 ); collector.collect( 42 ); // then Sort byIdDescending = new Sort( new SortField( "id", SortField.Type.LONG, true ) ); IndexHits<Document> indexHits = collector.getIndexHits( byIdDescending ); assertEquals( 4, indexHits.size() ); assertEquals( "42", indexHits.next().get( "id" ) ); assertEquals( "37", indexHits.next().get( "id" ) ); assertEquals( "3", indexHits.next().get( "id" ) ); assertEquals( "1", indexHits.next().get( "id" ) ); assertFalse( indexHits.hasNext() ); }
@Test void shouldReturnDocValuesInGivenOrder() throws Exception { // given DocValuesCollector collector = new DocValuesCollector( false ); IndexReaderStub readerStub = indexReaderWithMaxDocs( 42 ); // when collector.doSetNextReader( readerStub.getContext() ); collector.collect( 1 ); collector.collect( 2 ); // then Sort byIdDescending = new Sort( new SortField( "id", SortField.Type.LONG, true ) ); LongIterator valuesIterator = collector.getSortedValuesIterator( "id", byIdDescending ); assertEquals( 2, valuesIterator.next() ); assertEquals( 1, valuesIterator.next() ); assertFalse( valuesIterator.hasNext() ); }
private TopDocs searchOperations(ScoreDoc after) throws IOException { final Query rangeQuery = LongPoint.newRangeQuery(SeqNoFieldMapper.NAME, Math.max(fromSeqNo, lastSeenSeqNo), toSeqNo); final Sort sortedBySeqNoThenByTerm = new Sort( new SortField(SeqNoFieldMapper.NAME, SortField.Type.LONG), new SortField(SeqNoFieldMapper.PRIMARY_TERM_NAME, SortField.Type.LONG, true) ); return indexSearcher.searchAfter(after, rangeQuery, searchBatchSize, sortedBySeqNoThenByTerm); }
sortFields[i] = new SortedNumericSortField(fieldName, sortType, reverse, sortedNumericSelector); } else { sortFields[i] = new SortField(fieldName, sortType, reverse); indexSort = new Sort(sortFields); } else if (numSortFields < 0) { throw new CorruptIndexException("invalid index sort field count: " + numSortFields, input);
public static Sort toSort(final String sort) throws ParseException { if (sort == null) { return null; } else { final String[] split = sort.split(","); final SortField[] sort_fields = new SortField[split.length]; for (int i = 0; i < split.length; i++) { String tmp = split[i]; final boolean reverse = tmp.charAt(0) == '\\'; // Strip sort order character. if (tmp.charAt(0) == '\\' || tmp.charAt(0) == '/') { tmp = tmp.substring(1); } final SortField sortField; if ("_score".equals(tmp)) { sortField = new SortField(null, SortField.Type.SCORE, reverse); } else if ("_doc".equals(tmp)) { sortField = new SortField(null, SortField.Type.DOC, reverse); } else { final TypedField typedField = new TypedField(tmp); sortField = new SortField(typedField.getName(), typedField .toSortField(), reverse); } sort_fields[i] = sortField; } return new Sort(sort_fields); } }
sortFields[i] = new SortedNumericSortField(fieldName, sortType, reverse, sortedNumericSelector); } else { sortFields[i] = new SortField(fieldName, sortType, reverse); indexSort = new Sort(sortFields); } else if (numSortFields < 0) { throw new CorruptIndexException("invalid index sort field count: " + numSortFields, input);
/** * Creates new predicate search query. * * @param predicate The predicate for this query. * @param analyzer The analyzer to use for the query, should be the same as the one used to write the Index. * @param sortField The field name to use to order the results. * * @throws IllegalArgumentException If the predicate is <code>null</code>. */ public PredicateSearchQuery(String predicate, Analyzer analyzer, String sortField) throws IllegalArgumentException { this(predicate, analyzer, sortField == null ? Sort.INDEXORDER : new Sort(new SortField(sortField, Type.STRING))); }
/** * Creates new predicate search query. * * @param predicate The predicate for this query. * @param sortField The field name to use to order the results. * * @throws IllegalArgumentException If the predicate is <code>null</code>. */ public PredicateSearchQuery(String predicate, String sortField) throws IllegalArgumentException { this(predicate, sortField == null ? Sort.INDEXORDER : new Sort(new SortField(sortField, Type.STRING))); }
Sort sorter = new Sort(); // new sort object String field = "fieldName"; // enter the field to sort by Type type = Type.Long; // since your field is long type boolean descending = false; // ascending by default SortField sortField = new SortField(field, type, descending); sorter.setSort(sortField); // now set the sort field