Package org.apache.lucene.search

## Class IndexOrDocValuesQuery

- java.lang.Object
- - org.apache.lucene.search.Query
  - - org.apache.lucene.search.IndexOrDocValuesQuery

-     public final class IndexOrDocValuesQuery
      extends Query

  A query that uses either an index structure (points or terms) or doc values in order to run a query, depending which one is more efficient. This is typically useful for range queries, whose `Weight.scorer(org.apache.lucene.index.LeafReaderContext)` is costly to create since it usually needs to sort large lists of doc ids. For instance, for a field that both indexed `LongPoint`s and `SortedNumericDocValuesField`s with the same values, an efficient range query could be created by doing:

         String field;
         long minValue, maxValue;
         Query pointQuery = LongPoint.newRangeQuery(field, minValue, maxValue);
         Query dvQuery = SortedNumericDocValuesField.newSlowRangeQuery(field, minValue, maxValue);
         Query query = new IndexOrDocValuesQuery(pointQuery, dvQuery);

  The above query will be efficient as it will use points in the case that they perform better, ie. when we need a good lead iterator that will be almost entirely consumed; and doc values otherwise, ie. in the case that another part of the query is already leading iteration but we still need the ability to verify that some documents match.

  Some field types that work well with `IndexOrDocValuesQuery` are `IntField`, `LongField`, `FloatField`, `DoubleField`, and `KeywordField`. These fields provide both an indexed structure and doc values.

  NOTEThis query currently only works well with point range/exact queries and their equivalent doc values queries.

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

- - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `IndexOrDocValuesQuery​(Query indexQuery, Query dvQuery)` | Create an `IndexOrDocValuesQuery`.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `Weight` | `createWeight​(IndexSearcher searcher, ScoreMode scoreMode, float boost)` | Expert: Constructs an appropriate Weight implementation for this query.
    `boolean` | `equals​(Object obj)` | Override and implement query instance equivalence properly in a subclass.
    `Query` | `getIndexQuery()` | Return the wrapped query that may be costly to initialize but has a good iterator.
    `Query` | `getRandomAccessQuery()` | Return the wrapped query that may be slow at identifying all matching documents, but which is cheap to initialize and can efficiently verify that some documents match.
    `int` | `hashCode()` | Override and implement query hash code properly in a subclass.
    `Query` | `rewrite​(IndexSearcher indexSearcher)` | Expert: called to re-write queries into primitive queries.
    `String` | `toString​(String field)` | Prints a query to a string, with `field` assumed to be the default field and omitted.
    `void` | `visit​(QueryVisitor visitor)` | Recurse through the query tree, visiting any child queries.

    - ### Methods inherited from class org.apache.lucene.search.Query

      `classHash, rewrite, sameClassAs, toString`

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

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

- - ### Constructor Detail

    - #### IndexOrDocValuesQuery

          public IndexOrDocValuesQuery​(Query indexQuery,
                                       Query dvQuery)

      Create an `IndexOrDocValuesQuery`. Both provided queries must match the same documents and give the same scores.
      Parameters:
        `indexQuery` - a query that has a good iterator but whose scorer may be costly to create
        `dvQuery` - a query whose scorer is cheap to create that can quickly check whether a given document matches

  - ### Method Detail

    - #### getIndexQuery

          public Query getIndexQuery()

      Return the wrapped query that may be costly to initialize but has a good iterator.

    - #### getRandomAccessQuery

          public Query getRandomAccessQuery()

      Return the wrapped query that may be slow at identifying all matching documents, but which is cheap to initialize and can efficiently verify that some documents match.

    - #### toString

          public String toString​(String field)

      Description copied from class: `Query`
      Prints a query to a string, with `field` assumed to be the default field and omitted.
      Specified by:
        `toString` in class `Query`

    - #### equals

          public boolean equals​(Object obj)

      Description copied from class: `Query`
      Override and implement query instance equivalence properly in a subclass. This is required so that `QueryCache` works properly.

      Typically a query will be equal to another only if it's an instance of the same class and its document-filtering properties are identical to those of the other instance. Utility methods are provided for certain repetitive code.

      Specified by:
        `equals` in class `Query`
      See Also:
        `Query.sameClassAs(Object)`, `Query.classHash()`

    - #### hashCode

          public int hashCode()

      Description copied from class: `Query`
      Override and implement query hash code properly in a subclass. This is required so that `QueryCache` works properly.
      Specified by:
        `hashCode` in class `Query`
      See Also:
        `Query.equals(Object)`

    - #### rewrite

          public Query rewrite​(IndexSearcher indexSearcher)
                        throws IOException

      Description copied from class: `Query`
      Expert: called to re-write queries into primitive queries. For example, a PrefixQuery will be rewritten into a BooleanQuery that consists of TermQuerys.

      Callers are expected to call `rewrite` multiple times if necessary, until the rewritten query is the same as the original query.

      The rewrite process may be able to make use of IndexSearcher's executor and be executed in parallel if the executor is provided.

      However, if any of the intermediary queries do not satisfy the new API, parallel rewrite is not possible for any subsequent sub-queries. To take advantage of this API, the entire query tree must override this method.

      Overrides:
        `rewrite` in class `Query`
      Throws:
        `IOException`
      See Also:
        `IndexSearcher.rewrite(Query)`

    - #### visit

          public void visit​(QueryVisitor visitor)

      Description copied from class: `Query`
      Recurse through the query tree, visiting any child queries.
      Specified by:
        `visit` in class `Query`
      Parameters:
        `visitor` - a QueryVisitor to be called by each query in the tree

    - #### createWeight

          public Weight createWeight​(IndexSearcher searcher,
                                     ScoreMode scoreMode,
                                     float boost)
                              throws IOException

      Description copied from class: `Query`
      Expert: Constructs an appropriate Weight implementation for this query.

      Only implemented by primitive queries, which re-write to themselves.

      Overrides:
        `createWeight` in class `Query`
        `scoreMode` - How the produced scorers will be consumed.
        `boost` - The boost that is propagated by the parent queries.
      Throws:
        `IOException`