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

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

Running tasks concurrently on multiple threads
compareTo (BigDecimal)
addToBackStack (FragmentTransaction)
startActivity (Activity)
PrintStream (java.io)
Fake signature of an existing Java class.
ConnectException (java.net)
A ConnectException is thrown if a connection cannot be established to a remote host on a specific po
BitSet (java.util)
The BitSet class implements abit array [http://en.wikipedia.org/wiki/Bit_array]. Each element is eit
PriorityQueue (java.util)
A PriorityQueue holds elements on a priority heap, which orders the elements according to their natu
ImageIO (javax.imageio)
StringUtils (org.apache.commons.lang)
Operations on java.lang.String that arenull safe. * IsEmpty/IsBlank - checks if a String contains
Top Vim 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