org.apache.lucene.search

## Class DisjunctionMaxQuery

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

- All Implemented Interfaces:
    Cloneable, Iterable<Query>

      public final class DisjunctionMaxQuery
      extends Query
      implements Iterable<Query>

  A query that generates the union of documents produced by its subqueries, and that scores each document with the maximum score for that document as produced by any subquery, plus a tie breaking increment for any additional matching subqueries. This is useful when searching for a word in multiple fields with different boost factors (so that the fields cannot be combined equivalently into a single search field). We want the primary score to be the one associated with the highest boost, not the sum of the field scores (as BooleanQuery would give). If the query is "albino elephant" this ensures that "albino" matching one field and "elephant" matching another gets a higher score than "albino" matching both fields. To get this result, use both BooleanQuery and DisjunctionMaxQuery: for each term a DisjunctionMaxQuery searches for it in each field, while the set of these DisjunctionMaxQuery's is combined into a BooleanQuery. The tie breaker capability allows results that include the same term in multiple fields to be judged better than results that include this term in only the best of those multiple fields, without confusing this with the better case of two different terms in the multiple fields.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `protected class` | `DisjunctionMaxQuery.DisjunctionMaxWeight` Expert: the Weight for DisjunctionMaxQuery, used to normalize, score and explain these queries.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `DisjunctionMaxQuery(Collection<Query> disjuncts, float tieBreakerMultiplier)` Creates a new DisjunctionMaxQuery
    `DisjunctionMaxQuery(float tieBreakerMultiplier)` Deprecated. Use `DisjunctionMaxQuery(Collection, float)` instead

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `add(Collection<Query> disjuncts)` Deprecated. Use `DisjunctionMaxQuery(Collection, float)` instead and provide all clauses at construction time
    `void` | `add(Query query)` Deprecated. Use `DisjunctionMaxQuery(Collection, float)` instead and provide all clauses at construction time
    `Weight` | `createWeight(IndexSearcher searcher, boolean needsScores)` Create the Weight used to score us
    `boolean` | `equals(Object o)` Return true iff we represent the same query as o
    `ArrayList<Query>` | `getDisjuncts()`
    `float` | `getTieBreakerMultiplier()`
    `int` | `hashCode()` Compute a hash code for hashing us
    `Iterator<Query>` | `iterator()`
    `Query` | `rewrite(IndexReader reader)` Optimize our representation and our subqueries representations
    `String` | `toString(String field)` Prettyprint us.

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

      `clone, getBoost, setBoost, toString`

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

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

- - ### Constructor Detail

    - #### DisjunctionMaxQuery

          @Deprecated
          public DisjunctionMaxQuery(float tieBreakerMultiplier)

      Deprecated. Use `DisjunctionMaxQuery(Collection, float)` instead
      Creates a new empty DisjunctionMaxQuery. Use add() to add the subqueries.
      Parameters:
        `tieBreakerMultiplier` - the score of each non-maximum disjunct for a document is multiplied by this weight and added into the final score. If non-zero, the value should be small, on the order of 0.1, which says that 10 occurrences of word in a lower-scored field that is also in a higher scored field is just as good as a unique word in the lower scored field (i.e., one that is not in any higher scored field.

    - #### DisjunctionMaxQuery

          public DisjunctionMaxQuery(Collection<Query> disjuncts,
                             float tieBreakerMultiplier)

      Creates a new DisjunctionMaxQuery
      Parameters:
        `disjuncts` - a `Collection<Query>` of all the disjuncts to add
        `tieBreakerMultiplier` - the score of each non-maximum disjunct for a document is multiplied by this weight and added into the final score. If non-zero, the value should be small, on the order of 0.1, which says that 10 occurrences of word in a lower-scored field that is also in a higher scored field is just as good as a unique word in the lower scored field (i.e., one that is not in any higher scored field.

  - ### Method Detail

    - #### add

          @Deprecated
          public void add(Query query)

      Deprecated. Use `DisjunctionMaxQuery(Collection, float)` instead and provide all clauses at construction time
      Add a subquery to this disjunction
      Parameters:
        `query` - the disjunct added

    - #### add

          @Deprecated
          public void add(Collection<Query> disjuncts)

      Deprecated. Use `DisjunctionMaxQuery(Collection, float)` instead and provide all clauses at construction time
      Add a collection of disjuncts to this disjunction via `Iterable<Query>`
      Parameters:
        `disjuncts` - a collection of queries to add as disjuncts.

    - #### iterator

          public Iterator<Query> iterator()

      Specified by:
        `iterator` in interface `Iterable<Query>`
      Returns:
        An `Iterator<Query>` over the disjuncts

    - #### getDisjuncts

          public ArrayList<Query> getDisjuncts()

      Returns:
        the disjuncts.

    - #### getTieBreakerMultiplier

          public float getTieBreakerMultiplier()

      Returns:
        tie breaker value for multiple matches.

    - #### createWeight

          public Weight createWeight(IndexSearcher searcher,
                            boolean needsScores)
                              throws IOException

      Create the Weight used to score us
      Overrides:
        `createWeight` in class `Query`
        `needsScores` - True if document scores (`Scorer.score()`) or match frequencies (`Scorer.freq()`) are needed.
      Throws:
        `IOException`

    - #### rewrite

          public Query rewrite(IndexReader reader)
                        throws IOException

      Optimize our representation and our subqueries representations
      Overrides:
        `rewrite` in class `Query`
      Parameters:
        `reader` - the IndexReader we query
      Returns:
        an optimized copy of us (which may not be a copy if there is nothing to optimize)
      Throws:
        `IOException`

    - #### toString

          public String toString(String field)

      Prettyprint us.
      Specified by:
        `toString` in class `Query`
      Parameters:
        `field` - the field to which we are applied
      Returns:
        a string that shows what we do, of the form "(disjunct1 | disjunct2 | ... | disjunctn)^boost"

    - #### equals

          public boolean equals(Object o)

      Return true iff we represent the same query as o
      Overrides:
        `equals` in class `Query`
      Parameters:
        `o` - another object
      Returns:
        true iff o is a DisjunctionMaxQuery with the same boost and the same subqueries, in the same order, as us

    - #### hashCode

          public int hashCode()

      Compute a hash code for hashing us
      Overrides:
        `hashCode` in class `Query`
      Returns:
        the hash code

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