IndexReader (Lucene 10.5.1 core API)
Description: declaration: package: org.apache.lucene.index, class: IndexReader

Package org.apache.lucene.index

# Class IndexReader

java.lang.Object
org.apache.lucene.index.IndexReader

All Implemented Interfaces:
  `Closeable`, `AutoCloseable`

Direct Known Subclasses:
  `CompositeReader`, `LeafReader`

public abstract sealed class IndexReader extends Object implements Closeable permits CompositeReader, LeafReader
IndexReader is an abstract class, providing an interface for accessing a point-in-time view of an index. Any changes made to the index via `IndexWriter` will not be visible until a new `IndexReader` is opened. It's best to use `DirectoryReader.open(IndexWriter)` to obtain an `IndexReader`, if your `IndexWriter` is in-process. When you need to re-open to see changes to the index, it's best to use `DirectoryReader.openIfChanged(DirectoryReader)` since the new reader will share resources with the previous one when possible. Search of an index is done entirely through this abstract interface, so that any subclass which implements it is searchable.

There are two different types of IndexReaders:

- `LeafReader`: These indexes do not consist of several sub-readers, they are atomic. They support retrieval of stored fields, doc values, terms, and postings.
- `CompositeReader`: Instances (like `DirectoryReader`) of this reader can only be used to get stored fields from the underlying LeafReaders, but it is not possible to directly retrieve postings. To do that, get the sub-readers via `CompositeReader.getSequentialSubReaders()`.

IndexReader instances for indexes on disk are usually constructed with a call to one of the static `DirectoryReader.open()` methods, e.g. `DirectoryReader.open(org.apache.lucene.store.Directory)`. `DirectoryReader` implements the `CompositeReader` interface, it is not possible to directly get postings.

For efficiency, in this API documents are often referred to via document numbers, non-negative integers which each name a unique document in the index. These document numbers are ephemeral -- they may change as documents are added to and deleted from an index. Clients should thus not rely on a given document having the same number between sessions.

NOTE: `IndexReader` instances are completely thread safe, meaning multiple threads can call any of its methods, concurrently. If your application requires external synchronization, you should not synchronize on the `IndexReader` instance; use your own (non-Lucene) objects instead.

- ## Nested Class Summary

  Nested Classes
  Modifier and Type
  Class
  Description
  `static interface`
  `IndexReader.CacheHelper`
  A utility class that gives hooks in order to help build a cache based on the data that is contained in this index.
  `static final class`
  `IndexReader.CacheKey`
  A cache key identifying a resource that is being cached on.
  `static interface`
  `IndexReader.ClosedListener`
  A listener that is called when a resource gets closed.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `final void`
  `close()`
  Closes files associated with this index.
  `final void`
  `decRef()`
  Expert: decreases the refCount of this IndexReader instance.
  `abstract int`
  `docFreq(Term term)`
  Returns the number of documents containing the `term`.
  `protected abstract void`
  `doClose()`
  Implements close.
  `protected final void`
  `ensureOpen()`
  Throws AlreadyClosedException if this IndexReader or any of its child readers is closed, otherwise returns.
  `final boolean`
  `equals(Object obj)`
  `abstract IndexReaderContext`
  `getContext()`
  Expert: Returns the root `IndexReaderContext` for this `IndexReader`'s sub-reader tree.
  `abstract int`
  `getDocCount(String field)`
  Returns the number of documents that have at least one term for this field.
  `abstract IndexReader.CacheHelper`
  `getReaderCacheHelper()`
  Optional method: Return a `IndexReader.CacheHelper` that can be used to cache based on the content of this reader.
  `final int`
  `getRefCount()`
  Expert: returns the current refCount for this reader
  `abstract long`
  `getSumDocFreq(String field)`
  Returns the sum of `TermsEnum.docFreq()` for all terms in this field.
  `abstract long`
  `getSumTotalTermFreq(String field)`
  Returns the sum of `TermsEnum.totalTermFreq()` for all terms in this field.
  `boolean`
  `hasDeletions()`
  Returns true if any documents have been deleted.
  `final int`
  `hashCode()`
  `final void`
  `incRef()`
  Expert: increments the refCount of this IndexReader instance.
  `final List<LeafReaderContext>`
  `leaves()`
  Returns the reader's leaves, or itself if this reader is atomic.
  `abstract int`
  `maxDoc()`
  Returns one greater than the largest possible document number.
  `protected void`
  `notifyReaderClosedListeners()`
  For test framework use only.
  `final int`
  `numDeletedDocs()`
  Returns the number of deleted documents.
  `abstract int`
  `numDocs()`
  Returns the number of documents in this index.
  `final void`
  `registerParentReader(IndexReader reader)`
  Expert: This method is called by `IndexReader`s which wrap other readers (e.g.
  `abstract StoredFields`
  `storedFields()`
  Returns a `StoredFields` reader for the stored fields of this index.
  `abstract TermVectors`
  `termVectors()`
  Returns a `TermVectors` reader for the term vectors of this index.
  `abstract long`
  `totalTermFreq(Term term)`
  Returns the total number of occurrences of `term` across all documents (the sum of the freq() for each doc that has this term).
  `final boolean`
  `tryIncRef()`
  Expert: increments the refCount of this IndexReader instance only if the IndexReader has not been closed yet and returns `true` iff the refCount was successfully incremented, otherwise `false`.

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

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

- ## Method Details

  - ### registerParentReader

    public final void registerParentReader(IndexReader reader)
    Expert: This method is called by `IndexReader`s which wrap other readers (e.g. `CompositeReader` or `FilterLeafReader`) to register the parent at the child (this reader) on construction of the parent. When this reader is closed, it will mark all registered parents as closed, too. The references to parent readers are weak only, so they can be GCed once they are no longer in use.
    WARNING: This API is experimental and might change in incompatible ways in the next release.

  - ### notifyReaderClosedListeners

    protected void notifyReaderClosedListeners() throws IOException
    For test framework use only.
    Throws:
      `IOException`
    NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.

  - ### getRefCount

    public final int getRefCount()
    Expert: returns the current refCount for this reader

  - ### incRef

    public final void incRef()
    Expert: increments the refCount of this IndexReader instance. RefCounts are used to determine when a reader can be closed safely, i.e. as soon as there are no more references. Be sure to always call a corresponding `decRef()`, in a finally clause; otherwise the reader may never be closed. Note that `close()` simply calls decRef(), which means that the IndexReader will not really be closed until `decRef()` has been called for all outstanding references.
    See Also:
      - `decRef()`
      - `tryIncRef()`

  - ### tryIncRef

    public final boolean tryIncRef()
    Expert: increments the refCount of this IndexReader instance only if the IndexReader has not been closed yet and returns `true` iff the refCount was successfully incremented, otherwise `false`. If this method returns `false` the reader is either already closed or is currently being closed. Either way this reader instance shouldn't be used by an application unless `true` is returned.

    RefCounts are used to determine when a reader can be closed safely, i.e. as soon as there are no more references. Be sure to always call a corresponding `decRef()`, in a finally clause; otherwise the reader may never be closed. Note that `close()` simply calls decRef(), which means that the IndexReader will not really be closed until `decRef()` has been called for all outstanding references.

    See Also:
      - `decRef()`
      - `incRef()`

  - ### decRef

    public final void decRef() throws IOException
    Expert: decreases the refCount of this IndexReader instance. If the refCount drops to 0, then this reader is closed. If an exception is hit, the refCount is unchanged.
    Throws:
      `IOException` - in case an IOException occurs in doClose()
    See Also:
      - `incRef()`

  - ### ensureOpen

    protected final void ensureOpen() throws AlreadyClosedException
    Throws AlreadyClosedException if this IndexReader or any of its child readers is closed, otherwise returns.
    Throws:
      `AlreadyClosedException`

  - ### equals

    public final boolean equals(Object obj)

    `IndexReader` subclasses are not allowed to implement equals/hashCode, so methods are declared final.

    Overrides:
      `equals` in class `Object`

  - ### hashCode

    public final int hashCode()

    `IndexReader` subclasses are not allowed to implement equals/hashCode, so methods are declared final.

    Overrides:
      `hashCode` in class `Object`

  - ### termVectors

    public abstract TermVectors termVectors() throws IOException
    Returns a `TermVectors` reader for the term vectors of this index.

    This call never returns `null`, even if no term vectors were indexed. The returned instance should only be used by a single thread.

    Example:

         TopDocs hits = searcher.search(query, 10);
         TermVectors termVectors = reader.termVectors();
         for (ScoreDoc hit : hits.scoreDocs) {
           Fields vector = termVectors.get(hit.doc);
         }

    Throws:
      `IOException` - If there is a low-level IO error

  - ### numDocs

    public abstract int numDocs()
    Returns the number of documents in this index.

    NOTE: This operation may run in O(maxDoc). Implementations that can't return this number in constant-time should cache it.

  - ### maxDoc

    public abstract int maxDoc()
    Returns one greater than the largest possible document number. This may be used to, e.g., determine how big to allocate an array which will have an element for every document number in an index.

  - ### numDeletedDocs

    public final int numDeletedDocs()
    Returns the number of deleted documents.

    NOTE: This operation may run in O(maxDoc).

  - ### storedFields

    public abstract StoredFields storedFields() throws IOException
    Returns a `StoredFields` reader for the stored fields of this index.

    This call never returns `null`, even if no stored fields were indexed. The returned instance should only be used by a single thread.

    Example:

         TopDocs hits = searcher.search(query, 10);
         StoredFields storedFields = reader.storedFields();
         for (ScoreDoc hit : hits.scoreDocs) {
           Document doc = storedFields.document(hit.doc);
         }

    Throws:
      `IOException` - If there is a low-level IO error

  - ### hasDeletions

    public boolean hasDeletions()
    Returns true if any documents have been deleted. Implementers should consider overriding this method if `maxDoc()` or `numDocs()` are not constant-time operations.

  - ### close

    public final void close() throws IOException
    Closes files associated with this index. Also saves any new deletions to disk. No other methods should be called after this has been called.
    Specified by:
      `close` in interface `AutoCloseable`
    Specified by:
      `close` in interface `Closeable`
    Throws:
      `IOException` - if there is a low-level IO error

  - ### doClose

    protected abstract void doClose() throws IOException
    Implements close.
    Throws:
      `IOException`

  - ### getContext

    public abstract IndexReaderContext getContext()
    Expert: Returns the root `IndexReaderContext` for this `IndexReader`'s sub-reader tree.

    Iff this reader is composed of sub readers, i.e. this reader being a composite reader, this method returns a `CompositeReaderContext` holding the reader's direct children as well as a view of the reader tree's atomic leaf contexts. All sub- `IndexReaderContext` instances referenced from this readers top-level context are private to this reader and are not shared with another context tree. For example, IndexSearcher uses this API to drive searching by one atomic leaf reader at a time. If this reader is not composed of child readers, this method returns an `LeafReaderContext`.

    Note: Any of the sub-`CompositeReaderContext` instances referenced from this top-level context do not support `CompositeReaderContext.leaves()`. Only the top-level context maintains the convenience leaf-view for performance reasons.

  - ### leaves

    public final List<LeafReaderContext> leaves()
    Returns the reader's leaves, or itself if this reader is atomic. This is a convenience method calling `this.getContext().leaves()`.
    See Also:
      - `IndexReaderContext.leaves()`

  - ### getReaderCacheHelper

    public abstract IndexReader.CacheHelper getReaderCacheHelper()
    Optional method: Return a `IndexReader.CacheHelper` that can be used to cache based on the content of this reader. Two readers that have different data or different sets of deleted documents will be considered different.

    A return value of `null` indicates that this reader is not suited for caching, which is typically the case for short-lived wrappers that alter the content of the wrapped reader.

    WARNING: This API is experimental and might change in incompatible ways in the next release.

  - ### docFreq

    public abstract int docFreq(Term term) throws IOException
    Returns the number of documents containing the `term`. This method returns 0 if the term or field does not exists. This method does not take into account deleted documents that have not yet been merged away.
    Throws:
      `IOException`
    See Also:
      - `TermsEnum.docFreq()`

  - ### totalTermFreq

    public abstract long totalTermFreq(Term term) throws IOException
    Returns the total number of occurrences of `term` across all documents (the sum of the freq() for each doc that has this term). Note that, like other term measures, this measure does not take deleted documents into account.
    Throws:
      `IOException`

  - ### getSumDocFreq

    public abstract long getSumDocFreq(String field) throws IOException
    Returns the sum of `TermsEnum.docFreq()` for all terms in this field. Note that, just like other term measures, this measure does not take deleted documents into account.
    Throws:
      `IOException`
    See Also:
      - `Terms.getSumDocFreq()`

  - ### getDocCount

    public abstract int getDocCount(String field) throws IOException
    Returns the number of documents that have at least one term for this field. Note that, just like other term measures, this measure does not take deleted documents into account.
    Throws:
      `IOException`
    See Also:
      - `Terms.getDocCount()`

  - ### getSumTotalTermFreq

    public abstract long getSumTotalTermFreq(String field) throws IOException
    Returns the sum of `TermsEnum.totalTermFreq()` for all terms in this field. Note that, just like other term measures, this measure does not take deleted documents into account.
    Throws:
      `IOException`
    See Also:
      - `Terms.getSumTotalTermFreq()`