org.apache.lucene.search

## Class FieldComparator.TermOrdValComparator

- java.lang.Object
- - org.apache.lucene.search.FieldComparator<BytesRef>
  - - org.apache.lucene.search.FieldComparator.TermOrdValComparator

- All Implemented Interfaces:
    LeafFieldComparator
  Enclosing class:
    FieldComparator<T>

      public static class FieldComparator.TermOrdValComparator
      extends FieldComparator<BytesRef>
      implements LeafFieldComparator

  Sorts by field's natural Term sort order, using ordinals. This is functionally equivalent to `FieldComparator.TermValComparator`, but it first resolves the string to their relative ordinal positions (using the index returned by `LeafReader.getSortedDocValues(String)`), and does most comparisons using the ordinals. For medium to large results, this comparator will be much faster than `FieldComparator.TermValComparator`. For very small result sets it may be slower.

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class org.apache.lucene.search.FieldComparator

      `FieldComparator.DocComparator, FieldComparator.DoubleComparator, FieldComparator.FloatComparator, FieldComparator.IntComparator, FieldComparator.LongComparator, FieldComparator.NumericComparator<T extends Number>, FieldComparator.RelevanceComparator, FieldComparator.TermOrdValComparator, FieldComparator.TermValComparator`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `TermOrdValComparator(int numHits, String field)` Creates this, sorting missing values first.
    `TermOrdValComparator(int numHits, String field, boolean sortMissingLast)` Creates this, with control over how missing values are sorted.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `int` | `compare(int slot1, int slot2)` Compare hit at slot1 with hit at slot2.
    `int` | `compareBottom(int doc)` Compare the bottom of the queue with this doc.
    `int` | `compareTop(int doc)` Compare the top value with this doc.
    `int` | `compareValues(BytesRef val1, BytesRef val2)` Returns a negative integer if first is less than second, 0 if they are equal and a positive integer otherwise.
    `void` | `copy(int slot, int doc)` This method is called when a new hit is competitive.
    `LeafFieldComparator` | `getLeafComparator(LeafReaderContext context)` Get a per-segment `LeafFieldComparator` to collect the given `LeafReaderContext`.
    `protected SortedDocValues` | `getSortedDocValues(LeafReaderContext context, String field)` Retrieves the SortedDocValues for the field in this segment
    `void` | `setBottom(int bottom)` Set the bottom slot, ie the "weakest" (sorted last) entry in the queue.
    `void` | `setScorer(Scorer scorer)` Sets the Scorer to use in case a document's score is needed.
    `void` | `setTopValue(BytesRef value)` Record the top value, for future calls to `LeafFieldComparator.compareTop(int)`.
    `BytesRef` | `value(int slot)` Return the actual value in the slot.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### TermOrdValComparator

          public TermOrdValComparator(int numHits,
                                      String field)

      Creates this, sorting missing values first.

    - #### TermOrdValComparator

          public TermOrdValComparator(int numHits,
                                      String field,
                                      boolean sortMissingLast)

      Creates this, with control over how missing values are sorted. Pass sortMissingLast=true to put missing values at the end.

  - ### Method Detail

    - #### compare

          public int compare(int slot1,
                             int slot2)

      Description copied from class: `FieldComparator`
      Compare hit at slot1 with hit at slot2.
      Specified by:
        `compare` in class `FieldComparator<BytesRef>`
      Parameters:
        `slot1` - first slot to compare
        `slot2` - second slot to compare
      Returns:
        any `N < 0` if slot2's value is sorted after slot1, any `N > 0` if the slot2's value is sorted before slot1 and `0` if they are equal

    - #### compareBottom

          public int compareBottom(int doc)
                            throws IOException

      Description copied from interface: `LeafFieldComparator`
      Compare the bottom of the queue with this doc. This will only invoked after setBottom has been called. This should return the same result as `FieldComparator.compare(int,int)`} as if bottom were slot1 and the new document were slot 2.

      For a search that hits many results, this method will be the hotspot (invoked by far the most frequently).

      Specified by:
        `compareBottom` in interface `LeafFieldComparator`
      Parameters:
        `doc` - that was hit
      Returns:
        any `N < 0` if the doc's value is sorted after the bottom entry (not competitive), any `N > 0` if the doc's value is sorted before the bottom entry and `0` if they are equal.
      Throws:
        `IOException`

    - #### copy

          public void copy(int slot,
                           int doc)
                    throws IOException

      Description copied from interface: `LeafFieldComparator`
      This method is called when a new hit is competitive. You should copy any state associated with this document that will be required for future comparisons, into the specified slot.
      Specified by:
        `copy` in interface `LeafFieldComparator`
      Parameters:
        `slot` - which slot to copy the hit to
        `doc` - docID relative to current reader
      Throws:
        `IOException`

    - #### getSortedDocValues

          protected SortedDocValues getSortedDocValues(LeafReaderContext context,
                                                       String field)
                                                throws IOException

      Retrieves the SortedDocValues for the field in this segment
      Throws:
        `IOException`

    - #### getLeafComparator

          public LeafFieldComparator getLeafComparator(LeafReaderContext context)
                                                throws IOException

      Description copied from class: `FieldComparator`
      Get a per-segment `LeafFieldComparator` to collect the given `LeafReaderContext`. All docIDs supplied to this `LeafFieldComparator` are relative to the current reader (you must add docBase if you need to map it to a top-level docID).
      Specified by:
        `getLeafComparator` in class `FieldComparator<BytesRef>`
      Parameters:
        `context` - current reader context
      Returns:
        the comparator to use for this segment
      Throws:
        `IOException` - if there is a low-level IO error

    - #### setBottom

          public void setBottom(int bottom)
                         throws IOException

      Description copied from interface: `LeafFieldComparator`
      Set the bottom slot, ie the "weakest" (sorted last) entry in the queue. When `LeafFieldComparator.compareBottom(int)` is called, you should compare against this slot. This will always be called before `LeafFieldComparator.compareBottom(int)`.
      Specified by:
        `setBottom` in interface `LeafFieldComparator`
      Parameters:
        `bottom` - the currently weakest (sorted last) slot in the queue
      Throws:
        `IOException`

    - #### setTopValue

          public void setTopValue(BytesRef value)

      Description copied from class: `FieldComparator`
      Record the top value, for future calls to `LeafFieldComparator.compareTop(int)`. This is only called for searches that use searchAfter (deep paging), and is called before any calls to `FieldComparator.getLeafComparator(LeafReaderContext)`.
      Specified by:
        `setTopValue` in class `FieldComparator<BytesRef>`

    - #### value

          public BytesRef value(int slot)

      Description copied from class: `FieldComparator`
      Return the actual value in the slot.
      Specified by:
        `value` in class `FieldComparator<BytesRef>`
      Parameters:
        `slot` - the value
      Returns:
        value in this slot

    - #### compareTop

          public int compareTop(int doc)
                         throws IOException

      Description copied from interface: `LeafFieldComparator`
      Compare the top value with this doc. This will only invoked after setTopValue has been called. This should return the same result as `FieldComparator.compare(int,int)`} as if topValue were slot1 and the new document were slot 2. This is only called for searches that use searchAfter (deep paging).
      Specified by:
        `compareTop` in interface `LeafFieldComparator`
      Parameters:
        `doc` - that was hit
      Returns:
        any `N < 0` if the doc's value is sorted after the top entry (not competitive), any `N > 0` if the doc's value is sorted before the top entry and `0` if they are equal.
      Throws:
        `IOException`

    - #### compareValues

          public int compareValues(BytesRef val1,
                                   BytesRef val2)

      Description copied from class: `FieldComparator`
      Returns a negative integer if first is less than second, 0 if they are equal and a positive integer otherwise. Default impl to assume the type implements Comparable and invoke .compareTo; be sure to override this method if your FieldComparator's type isn't a Comparable or if your values may sometimes be null
      Overrides:
        `compareValues` in class `FieldComparator<BytesRef>`

    - #### setScorer

          public void setScorer(Scorer scorer)

      Description copied from interface: `LeafFieldComparator`
      Sets the Scorer to use in case a document's score is needed.
      Specified by:
        `setScorer` in interface `LeafFieldComparator`
      Parameters:
        `scorer` - Scorer instance that you should use to obtain the current hit's score, if necessary.

Copyright © 2000-2018 Apache Software Foundation. All Rights Reserved.