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

Reading from database using SQL prepared statement
requestLocationUpdates (LocationManager)
onCreateOptionsMenu (Activity)
findViewById (Activity)
FileOutputStream (java.io)
An output stream that writes bytes to a file. If the output file exists, it can be replaced or appen
SocketTimeoutException (java.net)
This exception is thrown when a timeout expired on a socket read or accept operation.
GregorianCalendar (java.util)
GregorianCalendar is a concrete subclass of Calendarand provides the standard calendar used by most
Stack (java.util)
Stack is a Last-In/First-Out(LIFO) data structure which represents a stack of objects. It enables u
ThreadPoolExecutor (java.util.concurrent)
An ExecutorService that executes each submitted task using one of possibly several pooled threads, n
TimeUnit (java.util.concurrent)
A TimeUnit represents time durations at a given unit of granularity and provides utility methods to
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