DisjunctionMaxQuery (The Adobe AEM Quickstart and Web Application.)

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

All Implemented Interfaces:

java.lang.Cloneable, java.lang.Iterable<Query>
```
public class DisjunctionMaxQuery
extends Query
implements java.lang.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.

Constructor Summary

Constructors
Constructor and Description
`DisjunctionMaxQuery(java.util.Collection<Query> disjuncts, float tieBreakerMultiplier)` Creates a new DisjunctionMaxQuery
`DisjunctionMaxQuery(float tieBreakerMultiplier)` Creates a new empty DisjunctionMaxQuery.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`add(java.util.Collection<Query> disjuncts)` Add a collection of disjuncts to this disjunction via `Iterable<Query>`
`void`	`add(Query query)` Add a subquery to this disjunction
`DisjunctionMaxQuery`	`clone()` Create a shallow copy of us -- used in rewriting if necessary
`Weight`	`createWeight(IndexSearcher searcher)` Create the Weight used to score us
`boolean`	`equals(java.lang.Object o)` Return true iff we represent the same query as o
`void`	`extractTerms(java.util.Set<Term> terms)` Expert: adds all terms occurring in this query to the terms set.
`java.util.ArrayList<Query>`	`getDisjuncts()`
`float`	`getTieBreakerMultiplier()`
`int`	`hashCode()` Compute a hash code for hashing us
`java.util.Iterator<Query>`	`iterator()`
`Query`	`rewrite(IndexReader reader)` Optimize our representation and our subqueries representations
`java.lang.String`	`toString(java.lang.String field)` Prettyprint us.

Methods inherited from class org.apache.lucene.search.Query
getBoost, setBoost, toString

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Constructor Detail
  - DisjunctionMaxQuery
```
public DisjunctionMaxQuery(float tieBreakerMultiplier)
```
    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(java.util.Collection<Query> disjuncts,
                           float tieBreakerMultiplier)
```
    Creates a new DisjunctionMaxQuery
    
    Parameters:
    
    disjuncts - a Collection<Query> of all the disjuncts to add
    
    tieBreakerMultiplier - the weight to give to each matching non-maximum disjunct
- Method Detail
  - add
```
public void add(Query query)
```
    Add a subquery to this disjunction
    
    Parameters:
    
    query - the disjunct added
  - add
```
public void add(java.util.Collection<Query> disjuncts)
```
    Add a collection of disjuncts to this disjunction via Iterable<Query>
    
    Parameters:
    
    disjuncts - a collection of queries to add as disjuncts.
  - iterator
```
public java.util.Iterator<Query> iterator()
```
    Specified by:
    
    iterator in interface java.lang.Iterable<Query>
    
    Returns:
    
    An Iterator<Query> over the disjuncts
  - getDisjuncts
```
public java.util.ArrayList<Query> getDisjuncts()
```
    Returns:
    
    the disjuncts.
  - getTieBreakerMultiplier
```
public float getTieBreakerMultiplier()
```
    Returns:
    
    tie breaker value for multiple matches.
  - createWeight
```
public Weight createWeight(IndexSearcher searcher)
                    throws java.io.IOException
```
    Create the Weight used to score us
    
    Overrides:
    
    createWeight in class Query
    
    Throws:
    
    java.io.IOException
  - rewrite
```
public Query rewrite(IndexReader reader)
              throws java.io.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:
    
    java.io.IOException
  - clone
```
public DisjunctionMaxQuery clone()
```
    Create a shallow copy of us -- used in rewriting if necessary
    
    Overrides:
    
    clone in class Query
    
    Returns:
    
    a copy of us (but reuse, don't copy, our subqueries)
  - extractTerms
```
public void extractTerms(java.util.Set<Term> terms)
```
    Description copied from class: Query
    
    Expert: adds all terms occurring in this query to the terms set. Only works if this query is in its rewritten form.
    
    Overrides:
    
    extractTerms in class Query
  - toString
```
public java.lang.String toString(java.lang.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(java.lang.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

Class DisjunctionMaxQuery

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Constructor Detail

DisjunctionMaxQuery

DisjunctionMaxQuery

Method Detail

add

add

iterator

getDisjuncts

getTieBreakerMultiplier

createWeight

rewrite

clone

extractTerms

toString

equals

hashCode