org.apache.lucene.search.SortField.setMissingValue java code examples

Common ways to obtain SortField

private void myMethod () {
 SortField s =String field;SortField.Type type;new SortField(field, type, reverse)
Sort sort;sort.getSort()
IndexSearcher searcher;fields[i].rewrite(searcher)
Smart code suggestions by Tabnine
}

sortFields[i].setMissingValue(missingValue);

sortFields[i].setMissingValue(missingValue);

public static SortField readSortField(StreamInput in) throws IOException {
  String field = null;
  if (in.readBoolean()) {
    field = in.readString();
  }
  SortField.Type sortType = readSortType(in);
  Object missingValue = readMissingValue(in);
  boolean reverse = in.readBoolean();
  SortField sortField = new SortField(field, sortType, reverse);
  if (missingValue != null) {
    sortField.setMissingValue(missingValue);
  }
  return sortField;
}

  max ? SortedSetSelector.Type.MAX : SortedSetSelector.Type.MIN);
if (missingFirst != null) {
  fields[i].setMissingValue(missingFirst ?
    SortedSetSortField.STRING_FIRST : SortedSetSortField.STRING_LAST);
  SortedNumericSelector.Type.MAX : SortedNumericSelector.Type.MIN);
if (missing != null) {
  fields[i].setMissingValue(missing);

@Override
public SortField sortField(@Nullable Object missingValue, MultiValueMode sortMode, Nested nested, boolean reverse) {
  XFieldComparatorSource source = new BytesRefFieldComparatorSource(this, missingValue, sortMode, nested);
  /**
   * Check if we can use a simple {@link SortedSetSortField} compatible with index sorting and
   * returns a custom sort field otherwise.
   */
  if (nested != null ||
      (sortMode != MultiValueMode.MAX && sortMode != MultiValueMode.MIN) ||
      (source.sortMissingLast(missingValue) == false && source.sortMissingFirst(missingValue) == false)) {
    return new SortField(getFieldName(), source, reverse);
  }
  SortField sortField = new SortedSetSortField(fieldName, reverse,
    sortMode == MultiValueMode.MAX ? SortedSetSelector.Type.MAX : SortedSetSelector.Type.MIN);
  sortField.setMissingValue(source.sortMissingLast(missingValue) ^ reverse ?
    SortedSetSortField.STRING_LAST : SortedSetSortField.STRING_FIRST);
  return sortField;
}

  newSortField.setMissingValue(sortField.getMissingValue());
  sortField = newSortField;
} else if (sortField.getClass() == SortedSetSortField.class) {
  newSortField.setMissingValue(sortField.getMissingValue());
  sortField = newSortField;
} else if (sortField.getClass() == SortedNumericSortField.class) {
    ((SortedNumericSortField) sortField).getNumericType(),
    sortField.getReverse());
  newSortField.setMissingValue(sortField.getMissingValue());
  sortField = newSortField;

  @Override
  public SortField sortField(@Nullable Object missingValue, MultiValueMode sortMode, XFieldComparatorSource.Nested nested,
      boolean reverse) {
    XFieldComparatorSource source = new BytesRefFieldComparatorSource(this, missingValue, sortMode, nested);
    /**
     * Check if we can use a simple {@link SortedSetSortField} compatible with index sorting and
     * returns a custom sort field otherwise.
     */
    if (nested != null ||
        (sortMode != MultiValueMode.MAX && sortMode != MultiValueMode.MIN) ||
        (source.sortMissingFirst(missingValue) == false && source.sortMissingLast(missingValue) == false)) {
      return new SortField(getFieldName(), source, reverse);
    }
    SortField sortField = new SortedSetSortField(fieldName, reverse,
      sortMode == MultiValueMode.MAX ? SortedSetSelector.Type.MAX : SortedSetSelector.Type.MIN);
    sortField.setMissingValue(source.sortMissingLast(missingValue) ^ reverse ?
      SortedSetSortField.STRING_LAST : SortedSetSortField.STRING_FIRST);
    return sortField;
  }
}

  protected void setEffectiveMissingValue(SortField sortField, Object missingValue, SortOrder order) {
    if ( missingValue == null ) {
      return;
    }

    // TODO so this is to mimic the Elasticsearch behavior, I'm not totally convinced it's the good choice though
    Object effectiveMissingValue;
    if ( missingValue == SortMissingValue.MISSING_FIRST ) {
      effectiveMissingValue = order == SortOrder.DESC ? sortMissingValueLastPlaceholder : sortMissingValueFirstPlaceholder;
    }
    else if ( missingValue == SortMissingValue.MISSING_LAST ) {
      effectiveMissingValue = order == SortOrder.DESC ? sortMissingValueFirstPlaceholder : sortMissingValueLastPlaceholder;
    }
    else {
      effectiveMissingValue = missingValue;
    }

    sortField.setMissingValue( effectiveMissingValue );
  }
}

static void sortDoubleMissingValue(QueryDefinition.SortEnum sortEnum, SortField sortField) {
  if (sortEnum == null)
    return;
  switch (sortEnum) {
  case ascending:
  case descending:
    return;
  case ascending_missing_last:
  case descending_missing_first:
    sortField.setMissingValue(Double.MAX_VALUE);
    return;
  case ascending_missing_first:
  case descending_missing_last:
    sortField.setMissingValue(Double.MIN_VALUE);
    return;
  default:
    break;
  }
}

static void sortStringMissingValue(QueryDefinition.SortEnum sortEnum, SortField sortField) {
  if (sortEnum == null)
    return;
  switch (sortEnum) {
  case ascending:
  case descending:
    return;
  case ascending_missing_last:
  case descending_missing_first:
    sortField.setMissingValue(SortField.STRING_LAST);
    return;
  case ascending_missing_first:
  case descending_missing_last:
    sortField.setMissingValue(SortField.STRING_FIRST);
    return;
  default:
    break;
  }
}

static void sortLongMissingValue(QueryDefinition.SortEnum sortEnum, SortField sortField) {
  if (sortEnum == null)
    return;
  switch (sortEnum) {
  case ascending:
  case descending:
    return;
  case ascending_missing_last:
  case descending_missing_first:
    sortField.setMissingValue(Long.MAX_VALUE);
    return;
  case ascending_missing_first:
  case descending_missing_last:
    sortField.setMissingValue(Long.MIN_VALUE);
    return;
  default:
    break;
  }
}

static void sortFloatMissingValue(QueryDefinition.SortEnum sortEnum, SortField sortField) {
  if (sortEnum == null)
    return;
  switch (sortEnum) {
  case ascending:
  case descending:
    return;
  case ascending_missing_last:
  case descending_missing_first:
    sortField.setMissingValue(Float.MAX_VALUE);
    return;
  case ascending_missing_first:
  case descending_missing_last:
    sortField.setMissingValue(Float.MIN_VALUE);
    return;
  default:
    break;
  }
}

    break;
sortField.setMissingValue(source.missingObject(missingValue, reverse));
return sortField;

public static SortField readSortField(StreamInput in) throws IOException {
  String field = null;
  if (in.readBoolean()) {
    field = in.readString();
  }
  SortField.Type sortType = readSortType(in);
  Object missingValue = readMissingValue(in);
  boolean reverse = in.readBoolean();
  SortField sortField = new SortField(field, sortType, reverse);
  if (missingValue != null) {
    sortField.setMissingValue(missingValue);
  }
  return sortField;
}

public static SortField readSortField(StreamInput in) throws IOException {
  String field = null;
  if (in.readBoolean()) {
    field = in.readString();
  }
  SortField.Type sortType = readSortType(in);
  Object missingValue = readMissingValue(in);
  boolean reverse = in.readBoolean();
  SortField sortField = new SortField(field, sortType, reverse);
  if (missingValue != null) {
    sortField.setMissingValue(missingValue);
  }
  return sortField;
}

@Override
public SortField sortField(@Nullable Object missingValue, MultiValueMode sortMode, Nested nested, boolean reverse) {
  XFieldComparatorSource source = new BytesRefFieldComparatorSource(this, missingValue, sortMode, nested);
  /**
   * Check if we can use a simple {@link SortedSetSortField} compatible with index sorting and
   * returns a custom sort field otherwise.
   */
  if (nested != null ||
      (sortMode != MultiValueMode.MAX && sortMode != MultiValueMode.MIN) ||
      (source.sortMissingLast(missingValue) == false && source.sortMissingFirst(missingValue) == false)) {
    return new SortField(getFieldName(), source, reverse);
  }
  SortField sortField = new SortedSetSortField(fieldName, reverse,
    sortMode == MultiValueMode.MAX ? SortedSetSelector.Type.MAX : SortedSetSelector.Type.MIN);
  sortField.setMissingValue(source.sortMissingLast(missingValue) ^ reverse ?
    SortedSetSortField.STRING_LAST : SortedSetSortField.STRING_FIRST);
  return sortField;
}

@Override
public SortField sortField(@Nullable Object missingValue, MultiValueMode sortMode, Nested nested, boolean reverse) {
  XFieldComparatorSource source = new BytesRefFieldComparatorSource(this, missingValue, sortMode, nested);
  /**
   * Check if we can use a simple {@link SortedSetSortField} compatible with index sorting and
   * returns a custom sort field otherwise.
   */
  if (nested != null ||
      (sortMode != MultiValueMode.MAX && sortMode != MultiValueMode.MIN) ||
      (source.sortMissingLast(missingValue) == false && source.sortMissingFirst(missingValue) == false)) {
    return new SortField(getFieldName(), source, reverse);
  }
  SortField sortField = new SortedSetSortField(fieldName, reverse,
    sortMode == MultiValueMode.MAX ? SortedSetSelector.Type.MAX : SortedSetSelector.Type.MIN);
  sortField.setMissingValue(source.sortMissingLast(missingValue) ^ reverse ?
    SortedSetSortField.STRING_LAST : SortedSetSortField.STRING_FIRST);
  return sortField;
}

  @Override
  public SortField sortField(@Nullable Object missingValue, MultiValueMode sortMode, XFieldComparatorSource.Nested nested, boolean reverse) {
    XFieldComparatorSource source = new BytesRefFieldComparatorSource(this, missingValue, sortMode, nested);
    /**
     * Check if we can use a simple {@link SortedSetSortField} compatible with index sorting and
     * returns a custom sort field otherwise.
     */
    if (nested != null ||
        (sortMode != MultiValueMode.MAX && sortMode != MultiValueMode.MIN) ||
        (source.sortMissingFirst(missingValue) == false && source.sortMissingLast(missingValue) == false)) {
      return new SortField(getFieldName(), source, reverse);
    }
    SortField sortField = new SortedSetSortField(fieldName, reverse,
      sortMode == MultiValueMode.MAX ? SortedSetSelector.Type.MAX : SortedSetSelector.Type.MIN);
    sortField.setMissingValue(source.sortMissingLast(missingValue) ^ reverse ?
      SortedSetSortField.STRING_LAST : SortedSetSortField.STRING_FIRST);
    return sortField;
  }
}

@Override
public SortField sortField(@Nullable Object missingValue, MultiValueMode sortMode, Nested nested, boolean reverse) {
  XFieldComparatorSource source = new BytesRefFieldComparatorSource(this, missingValue, sortMode, nested);
  /**
   * Check if we can use a simple {@link SortedSetSortField} compatible with index sorting and
   * returns a custom sort field otherwise.
   */
  if (nested != null ||
      (sortMode != MultiValueMode.MAX && sortMode != MultiValueMode.MIN) ||
      (source.sortMissingLast(missingValue) == false && source.sortMissingFirst(missingValue) == false)) {
    return new SortField(getFieldName(), source, reverse);
  }
  SortField sortField = new SortedSetSortField(fieldName, reverse,
    sortMode == MultiValueMode.MAX ? SortedSetSelector.Type.MAX : SortedSetSelector.Type.MIN);
  sortField.setMissingValue(source.sortMissingLast(missingValue) ^ reverse ?
    SortedSetSortField.STRING_LAST : SortedSetSortField.STRING_FIRST);
  return sortField;
}

  @Override
  public SortField sortField(@Nullable Object missingValue, MultiValueMode sortMode, XFieldComparatorSource.Nested nested, boolean reverse) {
    XFieldComparatorSource source = new BytesRefFieldComparatorSource(this, missingValue, sortMode, nested);
    /**
     * Check if we can use a simple {@link SortedSetSortField} compatible with index sorting and
     * returns a custom sort field otherwise.
     */
    if (nested != null ||
        (sortMode != MultiValueMode.MAX && sortMode != MultiValueMode.MIN) ||
        (source.sortMissingFirst(missingValue) == false && source.sortMissingLast(missingValue) == false)) {
      return new SortField(getFieldName(), source, reverse);
    }
    SortField sortField = new SortedSetSortField(fieldName, reverse,
      sortMode == MultiValueMode.MAX ? SortedSetSelector.Type.MAX : SortedSetSelector.Type.MIN);
    sortField.setMissingValue(source.sortMissingLast(missingValue) ^ reverse ?
      SortedSetSortField.STRING_LAST : SortedSetSortField.STRING_FIRST);
    return sortField;
  }
}

Javadoc

Set the value to use for documents that don't have a value.

Popular methods of SortField

<init>
Creates a sort, possibly in reverse, by terms in the given field where the type of term value is det
getField
Returns the name of the field. Could return null if the sort is by SCORE or DOC.
getReverse
Returns whether the sort should be reversed.
getType
Returns the type of contents in the field.
equals
Returns true if o is equal to this. If a FieldComparatorSource was provided, it must properly implem
getComparator
Returns the FieldComparator to use for sorting.
getComparatorSource
Returns the FieldComparatorSource used for custom sorting
getMissingValue
Return the value to use for documents that don't have a value. A value of null indicates that defaul
toString
hashCode
Returns a hash code for this SortField instance. If a FieldComparatorSource was provided, it must pr
needsScores
Whether the relevance score is needed to sort documents.
getFactory

Popular in Java

Making http requests using okhttp
getResourceAsStream (ClassLoader)
putExtra (Intent)
runOnUiThread (Activity)
FileWriter (java.io)
A specialized Writer that writes to a file in the file system. All write requests made by calling me
SimpleDateFormat (java.text)
Formats and parses dates in a locale-sensitive manner. Formatting turns a Date into a String, and pa
Calendar (java.util)
Calendar is an abstract base class for converting between a Date object and a set of integer fields
Pattern (java.util.regex)
Patterns are compiled regular expressions. In many cases, convenience methods such as String#matches
ZipFile (java.util.zip)
This class provides random read access to a zip file. You pay more to read the zip file's central di
Servlet (javax.servlet)
Defines methods that all servlets must implement. A servlet is a small Java program that runs within
Top 17 Free Sublime Text Plugins

How to use setMissingValuemethodin org.apache.lucene.search.SortField

Best Java code snippets using org.apache.lucene.search.SortField.setMissingValue (Showing top 20 results out of 315)

How to use
setMissingValue
method
in
org.apache.lucene.search.SortField