org.apache.lucene.search

Class DisjunctionMaxQuery

java.lang.Object

org.apache.lucene.search.Query

org.apache.lucene.search.DisjunctionMaxQuery

All Implemented Interfaces:

java.lang.Iterable<Query>

public final 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.

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(java.util.Collection<Query> disjuncts, float tieBreakerMultiplier) Creates a new DisjunctionMaxQuery

Method Summary

Modifier and Type	Method and Description
Weight	createWeight(IndexSearcher searcher, boolean needsScores, float boost) Create the Weight used to score us
boolean	equals(java.lang.Object other) Return true iff we represent the same query as o
java.util.List<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

classHash, sameClassAs, toString

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Constructor Detail

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 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

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.List<Query> getDisjuncts()

Returns:

the disjuncts.

getTieBreakerMultiplier

public float getTieBreakerMultiplier()

Returns:

tie breaker value for multiple matches.

createWeight

public Weight createWeight(IndexSearcher searcher,
                           boolean needsScores,
                           float boost)
                    throws java.io.IOException

Create the Weight used to score us

Overrides:

createWeight in class Query

needsScores - True if document scores (Scorer.score()) are needed.

boost - The boost that is propagated by the parent queries.

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

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 other)

Return true iff we represent the same query as o

Specified by:

equals in class Query

Parameters:

other - another object

Returns:

true iff o is a DisjunctionMaxQuery with the same boost and the same subqueries, in the same order, as us

See Also:

Query.sameClassAs(Object), Query.classHash()

hashCode

public int hashCode()

Compute a hash code for hashing us

Specified by:

hashCode in class Query

Returns:

the hash code

See Also:

Query.equals(Object)