org.apache.lucene.index

## Class OrdinalMap

- java.lang.Object
- - org.apache.lucene.index.OrdinalMap

- All Implemented Interfaces:
    Accountable

      public class OrdinalMap
      extends Object
      implements Accountable

  Maps per-segment ordinals to/from global ordinal space, using a compact packed-ints representation.

  NOTE: this is a costly operation, as it must merge sort all terms, and may require non-trivial RAM once done. It's better to operate in segment-private ordinal space instead when possible.

  NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `IndexReader.CacheKey` | `owner` Cache key of whoever asked for this awful thing

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static OrdinalMap` | `build(IndexReader.CacheKey owner, SortedDocValues[] values, float acceptableOverheadRatio)` Create an ordinal map that uses the number of unique values of each `SortedDocValues` instance as a weight.
    `static OrdinalMap` | `build(IndexReader.CacheKey owner, SortedSetDocValues[] values, float acceptableOverheadRatio)` Create an ordinal map that uses the number of unique values of each `SortedSetDocValues` instance as a weight.
    `static OrdinalMap` | `build(IndexReader.CacheKey owner, TermsEnum[] subs, long[] weights, float acceptableOverheadRatio)` Creates an ordinal map that allows mapping ords to/from a merged space from `subs`.
    `Collection<Accountable>` | `getChildResources()` Returns nested resources of this class.
    `int` | `getFirstSegmentNumber(long globalOrd)` Given a global ordinal, returns the index of the first segment that contains this term.
    `long` | `getFirstSegmentOrd(long globalOrd)` Given global ordinal, returns the ordinal of the first segment which contains this ordinal (the corresponding to the segment return `getFirstSegmentNumber(long)`).
    `LongValues` | `getGlobalOrds(int segmentIndex)` Given a segment number, return a `LongValues` instance that maps segment ordinals to global ordinals.
    `long` | `getValueCount()` Returns the total number of unique terms in global ord space.
    `long` | `ramBytesUsed()` Return the memory usage of this object in bytes.

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

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

- - ### Field Detail

    - #### owner

          public final IndexReader.CacheKey owner

      Cache key of whoever asked for this awful thing

  - ### Method Detail

    - #### build

          public static OrdinalMap build(IndexReader.CacheKey owner,
                                         SortedDocValues[] values,
                                         float acceptableOverheadRatio)
                                  throws IOException

      Create an ordinal map that uses the number of unique values of each `SortedDocValues` instance as a weight.
      Throws:
        `IOException`
      See Also:
        `build(IndexReader.CacheKey, TermsEnum[], long[], float)`

    - #### build

          public static OrdinalMap build(IndexReader.CacheKey owner,
                                         SortedSetDocValues[] values,
                                         float acceptableOverheadRatio)
                                  throws IOException

      Create an ordinal map that uses the number of unique values of each `SortedSetDocValues` instance as a weight.
      Throws:
        `IOException`
      See Also:
        `build(IndexReader.CacheKey, TermsEnum[], long[], float)`

    - #### build

          public static OrdinalMap build(IndexReader.CacheKey owner,
                                         TermsEnum[] subs,
                                         long[] weights,
                                         float acceptableOverheadRatio)
                                  throws IOException

      Creates an ordinal map that allows mapping ords to/from a merged space from `subs`.
      Parameters:
        `owner` - a cache key
        `subs` - TermsEnums that support `TermsEnum.ord()`. They need not be dense (e.g. can be FilteredTermsEnums}.
        `weights` - a weight for each sub. This is ideally correlated with the number of unique terms that each sub introduces compared to the other subs
      Throws:
        `IOException` - if an I/O error occurred.

    - #### getGlobalOrds

          public LongValues getGlobalOrds(int segmentIndex)

      Given a segment number, return a `LongValues` instance that maps segment ordinals to global ordinals.

    - #### getFirstSegmentOrd

          public long getFirstSegmentOrd(long globalOrd)

      Given global ordinal, returns the ordinal of the first segment which contains this ordinal (the corresponding to the segment return `getFirstSegmentNumber(long)`).

    - #### getFirstSegmentNumber

          public int getFirstSegmentNumber(long globalOrd)

      Given a global ordinal, returns the index of the first segment that contains this term.

    - #### getValueCount

          public long getValueCount()

      Returns the total number of unique terms in global ord space.

    - #### ramBytesUsed

          public long ramBytesUsed()

      Description copied from interface: `Accountable`
      Return the memory usage of this object in bytes. Negative values are illegal.
      Specified by:
        `ramBytesUsed` in interface `Accountable`

    - #### getChildResources

          public Collection<Accountable> getChildResources()

      Description copied from interface: `Accountable`
      Returns nested resources of this class. The result should be a point-in-time snapshot (to avoid race conditions).
      Specified by:
        `getChildResources` in interface `Accountable`
      See Also:
        `Accountables`

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