How to use

getField

method

in

org.apache.lucene.search.SortField

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());
}