private Sorter.DocMap maybeSortSegment(SegmentWriteState state) throws IOException { Sort indexSort = state.segmentInfo.getIndexSort(); if (indexSort == null) { return null; } List<Sorter.DocComparator> comparators = new ArrayList<>(); for (int i = 0; i < indexSort.getSort().length; i++) { SortField sortField = indexSort.getSort()[i]; PerField perField = getPerField(sortField.getField()); if (perField != null && perField.docValuesWriter != null && finishedDocValues.contains(perField.fieldInfo.name) == false) { perField.docValuesWriter.finish(state.segmentInfo.maxDoc()); Sorter.DocComparator cmp = perField.docValuesWriter.getDocComparator(state.segmentInfo.maxDoc(), sortField); comparators.add(cmp); finishedDocValues.add(perField.fieldInfo.name); } else { // safe to ignore, sort field with no values or already seen before } } Sorter sorter = new Sorter(indexSort); // returns null if the documents are already sorted return sorter.sort(state.segmentInfo.maxDoc(), comparators.toArray(new Sorter.DocComparator[comparators.size()])); }
/** Wraps a {@link SortedSetDocValues} as a single-valued view if the field is an instance of {@link SortedSetSortField}, * returns {@link SortedDocValues} for the field otherwise. */ static SortedDocValues getOrWrapSorted(LeafReader reader, SortField sortField) throws IOException { if (sortField instanceof SortedSetSortField) { SortedSetSortField sf = (SortedSetSortField) sortField; return SortedSetSelector.wrap(DocValues.getSortedSet(reader, sf.getField()), sf.getSelector()); } else { return DocValues.getSorted(reader, sortField.getField()); } }
private void validateIndexSortDVType(Sort indexSort, String fieldName, DocValuesType dvType) { for (SortField sortField : indexSort.getSort()) { if (sortField.getField().equals(fieldName)) { switch (dvType) { case NUMERIC:
/** Wraps a {@link SortedNumericDocValues} as a single-valued view if the field is an instance of {@link SortedNumericSortField}, * returns {@link NumericDocValues} for the field otherwise. */ static NumericDocValues getOrWrapNumeric(LeafReader reader, SortField sortField) throws IOException { if (sortField instanceof SortedNumericSortField) { SortedNumericSortField sf = (SortedNumericSortField) sortField; return SortedNumericSelector.wrap(DocValues.getSortedNumeric(reader, sf.getField()), sf.getSelector(), sf.getNumericType()); } else { return DocValues.getNumeric(reader, sortField.getField()); } }
private void validateIndexSortField(SortField sortField) { SortField.Type type = getSortFieldType(sortField); if (ALLOWED_INDEX_SORT_TYPES.contains(type) == false) { throw new IllegalArgumentException("invalid index sort field:[" + sortField.getField() + "]"); } }
SortField sortField = indexSort.getSort()[i]; SortField.Type sortType = sortField.getType(); output.writeString(sortField.getField()); int sortTypeID; switch (sortField.getType()) { output.writeByte((byte) 2); } else { throw new AssertionError("unrecognized missing value for STRING field \"" + sortField.getField() + "\": " + missingValue);
static Object convertValueFromSortField(Object value, SortField sortField, DocValueFormat format) { SortField.Type sortType = extractSortType(sortField); return convertValueFromSortType(sortField.getField(), sortType, value, format); }
for (final SortField field : sortFields) { final JSONObject col = new JSONObject(); col.put("field", field.getField()); col.put("reverse", field.getReverse());
private static void toXContent(XContentBuilder builder, Sort sort) throws IOException { builder.startArray("sort"); for (SortField field : sort.getSort()) { builder.startObject(); builder.field("field", field.getField()); if (field instanceof SortedNumericSortField) { builder.field("mode", ((SortedNumericSortField) field).getSelector() .toString().toLowerCase(Locale.ROOT)); } else if (field instanceof SortedSetSortField) { builder.field("mode", ((SortedSetSortField) field).getSelector() .toString().toLowerCase(Locale.ROOT)); } if (field.getMissingValue() != null) { builder.field("missing", field.getMissingValue().toString()); } builder.field("reverse", field.getReverse()); builder.endObject(); } builder.endArray(); }
SortField newSortField = new SortField(sortField.getField(), SortField.Type.DOUBLE); newSortField.setMissingValue(sortField.getMissingValue()); sortField = newSortField; SortField newSortField = new SortField(sortField.getField(), SortField.Type.STRING, sortField.getReverse()); newSortField.setMissingValue(sortField.getMissingValue()); sortField = newSortField; SortField newSortField = new SortField(sortField.getField(), ((SortedNumericSortField) sortField).getNumericType(), sortField.getReverse()); throw new IllegalArgumentException("Cannot serialize SortField impl [" + sortField + "]"); if (sortField.getField() == null) { out.writeBoolean(false); } else { out.writeBoolean(true); out.writeString(sortField.getField());
out.writeString(field.getField()); if (field instanceof SortedSetSortField) { out.writeByte((byte) 0);
private void validateIndexSortField(SortField sortField) { SortField.Type type = getSortFieldType(sortField); if (ALLOWED_INDEX_SORT_TYPES.contains(type) == false) { throw new IllegalArgumentException("invalid index sort field:[" + sortField.getField() + "]"); } }
private void validateDistanceSortField(Iterable<EntityIndexBinding> targetedBindings, SortField sortField) { DocumentFieldMetadata documentFieldMetadata = findFieldMetadata( targetedBindings, sortField.getField() ); if ( documentFieldMetadata == null ) { throw LOG.sortRequiresIndexedField( sortField.getClass(), sortField.getField() ); } if ( !documentFieldMetadata.isSpatial() ) { throw LOG.distanceSortRequiresSpatialField( sortField.getField() ); } }
private void validateNumericEncodingType(SortField sortField, NumericEncodingType sortEncodingType, NumericEncodingType indexEncodingType) { if ( sortEncodingType != indexEncodingType ) { throw LOG.sortTypeDoesNotMatchFieldType( String.valueOf( sortField.getType() ), String.valueOf( indexEncodingType ), sortField.getField() ); } }
private void assertType(SortField sortField, FieldType actual, FieldType expected) { if ( actual != expected ) { throw LOG.sortTypeDoesNotMatchFieldType( String.valueOf( sortField.getType() ), String.valueOf( actual ), sortField.getField() ); } }
private SortField getAvailableSortField(String propertyName, org.springframework.data.domain.Sort.Direction direction) { if(sortFieldMap.containsKey(propertyName)) { SortField availableSortField = sortFieldMap.get(propertyName); boolean reverse = direction == org.springframework.data.domain.Sort.Direction.DESC ? true : false; if(availableSortField.getType() != null) { return new SortField(availableSortField.getField(), availableSortField.getType(), reverse); } else { return new SortField(availableSortField.getField(), availableSortField.getComparatorSource(), reverse); } } else { return sortFieldMap.get("name"); } }
private void validateNullSortField(SortField sortField) { if ( sortField.getType() != SortField.Type.DOC && sortField.getType() != SortField.Type.SCORE ) { throw LOG.sortRequiresIndexedField( sortField.getClass(), sortField.getField() ); } }
@Test public void testBuildSortForNullEncoding() { LuceneQueryParsingResult<Class<?>> result = parseAndTransform("select e from org.infinispan.query.dsl.embedded.impl.model.Employee e order by e.code DESC"); Sort sort = result.getSort(); assertThat(sort).isNotNull(); assertThat(sort.getSort().length).isEqualTo(1); assertThat(sort.getSort()[0].getField()).isEqualTo("code"); assertThat(sort.getSort()[0].getType()).isEqualTo(SortField.Type.LONG); }
public Object visit(LowerCaseImpl node, Object data) throws Exception { SortField sf = (SortField) ((DynamicOperandImpl) node.getOperand()).accept(this, data); selectorName[0] = node.getSelectorQName(); return new SortField(sf.getField(), new LowerCaseSortComparator(sf.getComparatorSource()), !ordering.isAscending()); }
public Object visit(UpperCaseImpl node, Object data) throws Exception { SortField sf = (SortField) ((DynamicOperandImpl) node.getOperand()).accept(this, data); selectorName[0] = node.getSelectorQName(); return new SortField(sf.getField(), new UpperCaseSortComparator(sf.getComparatorSource()), !ordering.isAscending()); }