true
- * Default is false.
+ * points are not relevant then use this to change
+ * the rewrite method.
*/
- public void setConstantScoreRewrite(boolean v) {
- constantScoreRewrite = v;
+ public void setMultiTermRewriteMethod(MultiTermQuery.RewriteMethod method) {
+ multiTermRewriteMethod = method;
}
/**
- * @see #setConstantScoreRewrite(boolean)
+ * @see #setMultiTermRewriteMethod
*/
- public boolean getConstantScoreRewrite() {
- return constantScoreRewrite;
+ public MultiTermQuery.RewriteMethod getMultiTermRewriteMethod() {
+ return multiTermRewriteMethod;
}
/**
@@ -858,7 +867,7 @@
*/
protected Query newPrefixQuery(Term prefix){
PrefixQuery query = new PrefixQuery(prefix);
- query.setConstantScoreRewrite(constantScoreRewrite);
+ query.setRewriteMethod(multiTermRewriteMethod);
return query;
}
@@ -884,7 +893,7 @@
*/
protected Query newRangeQuery(String field, String part1, String part2, boolean inclusive) {
final TermRangeQuery query = new TermRangeQuery(field, part1, part2, inclusive, inclusive, rangeCollator);
- query.setConstantScoreRewrite(constantScoreRewrite);
+ query.setRewriteMethod(multiTermRewriteMethod);
return query;
}
@@ -903,7 +912,7 @@
*/
protected Query newWildcardQuery(Term t) {
WildcardQuery query = new WildcardQuery(t);
- query.setConstantScoreRewrite(constantScoreRewrite);
+ query.setRewriteMethod(multiTermRewriteMethod);
return query;
}
Index: src/java/org/apache/lucene/queryParser/QueryParser.jj
===================================================================
--- src/java/org/apache/lucene/queryParser/QueryParser.jj (revision 795767)
+++ src/java/org/apache/lucene/queryParser/QueryParser.jj (working copy)
@@ -49,6 +49,7 @@
import org.apache.lucene.search.BooleanClause;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.FuzzyQuery;
+import org.apache.lucene.search.MultiTermQuery;
import org.apache.lucene.search.MatchAllDocsQuery;
import org.apache.lucene.search.MultiPhraseQuery;
import org.apache.lucene.search.PhraseQuery;
@@ -142,7 +143,7 @@
private Operator operator = OR_OPERATOR;
boolean lowercaseExpandedTerms = true;
- boolean constantScoreRewrite= true;
+ MultiTermQuery.RewriteMethod multiTermRewriteMethod = MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT;
boolean allowLeadingWildcard = false;
boolean enablePositionIncrements = false;
@@ -355,40 +356,48 @@
}
/**
- * @deprecated Please use {@link #setConstantScoreRewrite} instead.
+ * @deprecated Please use {@link #setMultiTermRewriteMethod} instead.
*/
public void setUseOldRangeQuery(boolean useOldRangeQuery) {
- constantScoreRewrite = !useOldRangeQuery;
+ if (useOldRangeQuery) {
+ setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE);
+ } else {
+ setMultiTermRewriteMethod(MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT);
+ }
}
/**
- * @deprecated Please use {@link #getConstantScoreRewrite} instead.
+ * @deprecated Please use {@link #getMultiTermRewriteMethod} instead.
*/
public boolean getUseOldRangeQuery() {
- return !constantScoreRewrite;
+ if (getMultiTermRewriteMethod() == MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE) {
+ return true;
+ } else {
+ return false;
+ }
}
/**
- * By default QueryParser uses constant-score rewriting
+ * By default QueryParser uses {@link MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}
* when creating a PrefixQuery, WildcardQuery or RangeQuery. This implementation is generally preferable because it
* a) Runs faster b) Does not have the scarcity of terms unduly influence score
* c) avoids any "TooManyBooleanClauses" exception.
* However, if your application really needs to use the
* old-fashioned BooleanQuery expansion rewriting and the above
- * points are not relevant then set this option to true
- * Default is false.
+ * points are not relevant then use this to change
+ * the rewrite method.
*/
- public void setConstantScoreRewrite(boolean v) {
- constantScoreRewrite = v;
+ public void setMultiTermRewriteMethod(MultiTermQuery.RewriteMethod method) {
+ multiTermRewriteMethod = method;
}
/**
- * @see #setConstantScoreRewrite(boolean)
+ * @see #setMultiTermRewriteMethod
*/
- public boolean getConstantScoreRewrite() {
- return constantScoreRewrite;
+ public MultiTermQuery.RewriteMethod getMultiTermRewriteMethod() {
+ return multiTermRewriteMethod;
}
/**
@@ -882,7 +891,7 @@
*/
protected Query newPrefixQuery(Term prefix){
PrefixQuery query = new PrefixQuery(prefix);
- query.setConstantScoreRewrite(constantScoreRewrite);
+ query.setRewriteMethod(multiTermRewriteMethod);
return query;
}
@@ -908,7 +917,7 @@
*/
protected Query newRangeQuery(String field, String part1, String part2, boolean inclusive) {
final TermRangeQuery query = new TermRangeQuery(field, part1, part2, inclusive, inclusive, rangeCollator);
- query.setConstantScoreRewrite(constantScoreRewrite);
+ query.setRewriteMethod(multiTermRewriteMethod);
return query;
}
@@ -927,7 +936,7 @@
*/
protected Query newWildcardQuery(Term t) {
WildcardQuery query = new WildcardQuery(t);
- query.setConstantScoreRewrite(constantScoreRewrite);
+ query.setRewriteMethod(multiTermRewriteMethod);
return query;
}
Index: src/java/org/apache/lucene/queryParser/CharStream.java
===================================================================
--- src/java/org/apache/lucene/queryParser/CharStream.java (revision 795767)
+++ src/java/org/apache/lucene/queryParser/CharStream.java (working copy)
@@ -109,4 +109,4 @@
void Done();
}
-/* JavaCC - OriginalChecksum=32a89423891f765dde472f7ef0e3ef7b (do not edit this line) */
+/* JavaCC - OriginalChecksum=a83909a2403f969f94d18375f9f143e4 (do not edit this line) */
Index: src/java/org/apache/lucene/queryParser/ParseException.java
===================================================================
--- src/java/org/apache/lucene/queryParser/ParseException.java (revision 795767)
+++ src/java/org/apache/lucene/queryParser/ParseException.java (working copy)
@@ -195,4 +195,4 @@
}
}
-/* JavaCC - OriginalChecksum=c7631a240f7446940695eac31d9483ca (do not edit this line) */
+/* JavaCC - OriginalChecksum=c63b396885c4ff44d7aa48d3feae60cd (do not edit this line) */
Index: src/java/org/apache/lucene/queryParser/ComplexPhraseQueryParser.java
===================================================================
--- src/java/org/apache/lucene/queryParser/ComplexPhraseQueryParser.java (revision 795767)
+++ src/java/org/apache/lucene/queryParser/ComplexPhraseQueryParser.java (working copy)
@@ -29,6 +29,7 @@
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.TermQuery;
+import org.apache.lucene.search.MultiTermQuery;
import org.apache.lucene.search.TermRangeQuery;
import org.apache.lucene.search.spans.SpanNearQuery;
import org.apache.lucene.search.spans.SpanNotQuery;
@@ -77,9 +78,9 @@
public Query parse(String query) throws ParseException {
if (isPass2ResolvingPhrases) {
- boolean oldConstantScoreRewriteSetting = getConstantScoreRewrite();
+ MultiTermQuery.RewriteMethod oldMethod = getMultiTermRewriteMethod();
try {
- // Temporarily set constantScoreRewrite to false so that Parser will
+ // Temporarily force BooleanQuery rewrite so that Parser will
// generate visible
// collection of terms which we can convert into SpanQueries.
// ConstantScoreRewrite mode produces an
@@ -88,10 +89,10 @@
// QueryParser is not guaranteed threadsafe anyway so this temporary
// state change should not
// present an issue
- setConstantScoreRewrite(false);
+ setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE);
return super.parse(query);
} finally {
- setConstantScoreRewrite(oldConstantScoreRewriteSetting);
+ setMultiTermRewriteMethod(oldMethod);
}
}
@@ -165,7 +166,7 @@
// that can be turned into SpanOr clause
TermRangeQuery rangeQuery = new TermRangeQuery(field, part1, part2, inclusive, inclusive,
getRangeCollator());
- rangeQuery.setConstantScoreRewrite(false);;
+ rangeQuery.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE);
return rangeQuery;
}
return super.newRangeQuery(field, part1, part2, inclusive);
Index: src/java/org/apache/lucene/queryParser/QueryParserTokenManager.java
===================================================================
--- src/java/org/apache/lucene/queryParser/QueryParserTokenManager.java (revision 795767)
+++ src/java/org/apache/lucene/queryParser/QueryParserTokenManager.java (working copy)
@@ -23,6 +23,7 @@
import org.apache.lucene.search.BooleanClause;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.FuzzyQuery;
+import org.apache.lucene.search.MultiTermQuery;
import org.apache.lucene.search.MatchAllDocsQuery;
import org.apache.lucene.search.MultiPhraseQuery;
import org.apache.lucene.search.PhraseQuery;
Index: src/java/org/apache/lucene/search/MultiTermQuery.java
===================================================================
--- src/java/org/apache/lucene/search/MultiTermQuery.java (revision 795767)
+++ src/java/org/apache/lucene/search/MultiTermQuery.java (working copy)
@@ -18,6 +18,10 @@
*/
import java.io.IOException;
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
@@ -34,24 +38,288 @@
* FilteredTermEnum} that iterates through the terms to be
* matched.
*
- * NOTE: if {@link #setConstantScoreRewrite} is - * false, you may encounter a {@link - * BooleanQuery.TooManyClauses} exception during searching, - * which happens when the number of terms to be searched - * exceeds {@link BooleanQuery#getMaxClauseCount()}. - * Setting {@link #setConstantScoreRewrite} to false + *
NOTE: if {@link #setRewriteMethod} is either + * {@link #CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE} or {@link + * #SCORING_BOOLEAN_QUERY_REWRITE}, you may encounter a + * {@link BooleanQuery.TooManyClauses} exception during + * searching, which happens when the number of terms to be + * searched exceeds {@link + * BooleanQuery#getMaxClauseCount()}. Setting {@link + * #setRewriteMethod} to {@link #CONSTANT_SCORE_FILTER_REWRITE} * prevents this. * - * Note that {@link QueryParser} by default produces - * MultiTermQueries with {@link #setConstantScoreRewrite} - * true. + *
The recommended rewrite method is {@link + * #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}: it doesn't spend CPU + * computing unhelpful scores, and it tries to pick the most + * performant rewrite method given the query. + * + * Note that {@link QueryParser} produces + * MultiTermQueries using {@link + * #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} by default. */ public abstract class MultiTermQuery extends Query { /* @deprecated move to sub class */ protected Term term; - protected boolean constantScoreRewrite = false; + protected RewriteMethod rewriteMethod = SCORING_BOOLEAN_QUERY_REWRITE; transient int numberOfTerms = 0; + // nocommit + private static boolean first=true; + + /** Abstract class that defines how the query is rewritten. */ + public static abstract class RewriteMethod implements Serializable { + public abstract Query rewrite(IndexReader reader, MultiTermQuery query) throws IOException; + } + + private static final class ConstantScoreFilterRewrite extends RewriteMethod implements Serializable { + public Query rewrite(IndexReader reader, MultiTermQuery query) { + Query result = new ConstantScoreQuery(new MultiTermQueryWrapperFilter(query)); + result.setBoost(query.getBoost()); + return result; + } + + // Make sure we are still a singleton even after deserializing + protected Object readResolve() { + return CONSTANT_SCORE_FILTER_REWRITE; + } + } + + /** A rewrite method that first creates a private Filter, + * by visiting each term in sequence and marking all docs + * for that term. Matching documents are assigned a + * constant score equal to the query's boost. + * + *
This method is faster than the BooleanQuery + * rewrite methods when the number of matched terms or + * matched documents is non-trivial. Also, it will never + * hit an errant {@link BooleanQuery.TooManyClauses} + * exception. + * + * @see #setRewriteMethod */ + public final static RewriteMethod CONSTANT_SCORE_FILTER_REWRITE = new ConstantScoreFilterRewrite(); + + private static class ScoringBooleanQueryRewrite extends RewriteMethod implements Serializable { + public Query rewrite(IndexReader reader, MultiTermQuery query) throws IOException { + + FilteredTermEnum enumerator = query.getEnum(reader); + BooleanQuery result = new BooleanQuery(true); + int count = 0; + try { + do { + Term t = enumerator.term(); + if (t != null) { + count++; + TermQuery tq = new TermQuery(t); // found a match + tq.setBoost(query.getBoost() * enumerator.difference()); // set the boost + result.add(tq, BooleanClause.Occur.SHOULD); // add to query + } + } while (enumerator.next()); + if (first) { + System.out.println("bq terms=" + count); + first = false; + } + } finally { + enumerator.close(); + } + query.incTotalNumberOfTerms(count); + return result; + } + + // Make sure we are still a singleton even after deserializing + protected Object readResolve() { + return SCORING_BOOLEAN_QUERY_REWRITE; + } + } + + /** A rewrite method that first translates each term into + * {@link BooleanClause.Occur#SHOULD} clause in a + * BooleanQuery, and keeps the scores as computed by the + * query. Note that typically such scores are + * meaningless to the user, and require non-trivial CPU + * to compute, so it's almost always better to use {@link + * #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} instead. + * + *
NOTE: This rewrite method will hit {@link + * BooleanQuery.TooManyClauses} if the number of terms + * exceeds {@link BooleanQuery#getMaxClauseCount}. + * + * @see #setRewriteMethod */ + public final static RewriteMethod SCORING_BOOLEAN_QUERY_REWRITE = new ScoringBooleanQueryRewrite(); + + private static class ConstantScoreBooleanQueryRewrite extends ScoringBooleanQueryRewrite implements Serializable { + public Query rewrite(IndexReader reader, MultiTermQuery query) throws IOException { + // strip the scores off + Query result = new ConstantScoreQuery(new QueryWrapperFilter(super.rewrite(reader, query))); + result.setBoost(query.getBoost()); + return result; + } + + // Make sure we are still a singleton even after deserializing + protected Object readResolve() { + return CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE; + } + } + + /** Like {@link #SCORING_BOOLEAN_QUERY_REWRITE} except + * scores are not computed. Instead, each matching + * document receives a constant score equal to the + * query's boost. + * + *
NOTE: This rewrite method will hit {@link
+ * BooleanQuery.TooManyClauses} if the number of terms
+ * exceeds {@link BooleanQuery#getMaxClauseCount}.
+ *
+ * @see #setRewriteMethod */
+ public final static RewriteMethod CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE = new ConstantScoreBooleanQueryRewrite();
+
+
+ /** A rewrite method that tries to pick the best
+ * constant-score rewrite method based on term and
+ * document counts from the query. If both the number of
+ * terms and documents is small enough, then {@link
+ * #CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE} is used.
+ * Otherwise, {@link #CONSTANT_SCORE_FILTER_REWRITE} is
+ * used.
+ */
+ public static class ConstantScoreAutoRewrite extends RewriteMethod implements Serializable {
+
+ public static int DEFAULT_TERM_COUNT_CUTOFF = 10000;
+ public static int DEFAULT_DOC_COUNT_PERCENT = 1;
+
+ private int termCountCutoff = DEFAULT_TERM_COUNT_CUTOFF;
+ private double docCountPercent = DEFAULT_DOC_COUNT_PERCENT;
+
+ /** If the number of terms in this query is equal to or
+ * larger than this setting then {@link
+ * #CONSTANT_SCORE_FILTER_REWRITE} is used. */
+ public void setTermCountCutoff(int count) {
+ termCountCutoff = count;
+ }
+
+ /** @see #setTermCountCutoff */
+ public int getTermCountCutoff() {
+ return termCountCutoff;
+ }
+
+ /** If the number of documents to be visited in the
+ * postings exceeds this specified percentage of the
+ * maxDoc() for the index, then {@link
+ * #CONSTANT_SCORE_FILTER_REWRITE} is used.
+ * @param percent 0.0 to 100.0 */
+ public void setDocCountPercent(double percent) {
+ docCountPercent = percent;
+ }
+
+ /** @see #setDocCountPercent */
+ public double getDocCountPercent() {
+ return docCountPercent;
+ }
+
+ public Query rewrite(IndexReader reader, MultiTermQuery query) throws IOException {
+ // Get the enum and start visiting terms. If we
+ // exhaust the enum before hitting either of the
+ // cutoffs, we use ConstantBooleanQueryRewrite; else,
+ // ConstantFilterRewrite:
+ final Collection pendingTerms = new ArrayList();
+ final int docCountCutoff = (int) ((docCountPercent / 100.) * reader.maxDoc());
+ final int termCountLimit = Math.min(BooleanQuery.getMaxClauseCount(), termCountCutoff);
+ int docVisitCount = 0;
+
+ FilteredTermEnum enumerator = query.getEnum(reader);
+ try {
+ while(true) {
+ Term t = enumerator.term();
+ if (t != null) {
+ pendingTerms.add(t);
+ // Loading the TermInfo from the terms dict here
+ // should not be costly, because 1) the
+ // query/filter will load the TermInfo when it
+ // runs, and 2) the terms dict has a cache:
+ docVisitCount += reader.docFreq(t);
+ }
+
+ if (pendingTerms.size() >= termCountLimit || docVisitCount >= docCountCutoff) {
+ // Too many terms -- make a filter.
+ if (first) {
+ System.out.println("auto terms=" + pendingTerms.size() + " docs=" + docVisitCount);
+ first = false;
+ }
+ Query result = new ConstantScoreQuery(new MultiTermQueryWrapperFilter(query));
+ result.setBoost(query.getBoost());
+ return result;
+ } else if (!enumerator.next()) {
+ if (first) {
+ System.out.println("auto terms=" + pendingTerms.size() + " docs=" + docVisitCount);
+ first = false;
+ }
+ // Enumeration is done, and we hit a small
+ // enough number of terms & docs -- just make a
+ // BooleanQuery, now
+ Iterator it = pendingTerms.iterator();
+ BooleanQuery bq = new BooleanQuery(true);
+ while(it.hasNext()) {
+ TermQuery tq = new TermQuery((Term) it.next());
+ bq.add(tq, BooleanClause.Occur.SHOULD);
+ }
+ // Strip scores
+ Query result = new ConstantScoreQuery(new QueryWrapperFilter(bq));
+ result.setBoost(query.getBoost());
+ return result;
+ }
+ }
+ } finally {
+ enumerator.close();
+ }
+ }
+
+ public int hashCode() {
+ final int prime = 1279;
+ return (int) (prime * termCountCutoff + Double.doubleToLongBits(docCountPercent));
+ }
+
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null)
+ return false;
+ if (getClass() != obj.getClass())
+ return false;
+
+ ConstantScoreAutoRewrite other = (ConstantScoreAutoRewrite) obj;
+ if (other.termCountCutoff != termCountCutoff) {
+ return false;
+ }
+
+ if (Double.doubleToLongBits(other.docCountPercent) != Double.doubleToLongBits(docCountPercent)) {
+ return false;
+ }
+
+ return true;
+ }
+ }
+
+ /** Read-only default instance of {@link
+ * ConstantScoreAutoRewrite}, with {@link
+ * ConstantScoreAutoRewrite#setTermCountCutoff} set to
+ * {@link
+ * ConstantScoreAutoRewrite#DEFAULT_TERM_COUNT_CUTOFF}
+ * and {@link
+ * ConstantScoreAutoRewrite#setDocCountPercent} set to
+ * {@link
+ * ConstantScoreAutoRewrite#DEFAULT_DOC_COUNT_PERCENT}.
+ * Note that you cannot alter the configuration of this
+ * instance; you'll need to create a private instance
+ * instead. */
+ public final static RewriteMethod CONSTANT_SCORE_AUTO_REWRITE_DEFAULT = new ConstantScoreAutoRewrite() {
+ public void setTermCountCutoff(int count) {
+ throw new UnsupportedOperationException("Please create a private instance");
+ }
+
+ public void setDocCountPercent(double percent) {
+ throw new UnsupportedOperationException("Please create a private instance");
+ }
+ };
+
/** Constructs a query for terms matching term. */
public MultiTermQuery(Term term) {
this.term = term;
@@ -105,33 +373,12 @@
numberOfTerms = 0;
}
- protected Filter getFilter() {
- return new MultiTermQueryWrapperFilter(this);
+ protected void incTotalNumberOfTerms(int inc) {
+ numberOfTerms += inc;
}
public Query rewrite(IndexReader reader) throws IOException {
- if (!constantScoreRewrite) {
- FilteredTermEnum enumerator = getEnum(reader);
- BooleanQuery query = new BooleanQuery(true);
- try {
- do {
- Term t = enumerator.term();
- if (t != null) {
- numberOfTerms++;
- TermQuery tq = new TermQuery(t); // found a match
- tq.setBoost(getBoost() * enumerator.difference()); // set the boost
- query.add(tq, BooleanClause.Occur.SHOULD); // add to query
- }
- } while (enumerator.next());
- } finally {
- enumerator.close();
- }
- return query;
- } else {
- Query query = new ConstantScoreQuery(getFilter());
- query.setBoost(getBoost());
- return query;
- }
+ return rewriteMethod.rewrite(reader, this);
}
@@ -155,34 +402,18 @@
}
/**
- * @see #setConstantScoreRewrite
+ * @see #setRewriteMethod
*/
- public boolean getConstantScoreRewrite() {
- return constantScoreRewrite;
+ public RewriteMethod getRewriteMethod() {
+ return rewriteMethod;
}
/**
- * This method determines what method is used during searching:
- *
false
- * (the default), the query is rewritten to {@link
- * BooleanQuery} with one clause for each term in the
- * range. If the the number of terms in the range
- * exceeds {@link BooleanQuery#getMaxClauseCount()}, a
- * {@link BooleanQuery.TooManyClauses} exception will be
- * thrown during searching. This mode may also give
- * worse performance when the number of terms is large,
- * and/or the number of matching documents is large.
- *
- * true,
- * the query is first rewritten to a filter. Matching
- * documents will identical scores, equal to this
- * query's boost.
- * MultiTermQueryWrapperFilter.
* This class also provides the functionality behind
- * {@link MultiTermQuery#getFilter}, this is why it is not abstract.
+ * {@link MultiTermQuery#CONSTANT_SCORE_FILTER_REWRITE};
+ * this is why it is not abstract.
*/
public class MultiTermQueryWrapperFilter extends Filter {
@@ -96,6 +97,8 @@
abstract class TermGenerator {
public void generate(IndexReader reader, TermEnum enumerator) throws IOException {
+ final int[] docs = new int[32];
+ final int[] freqs = new int[32];
TermDocs termDocs = reader.termDocs();
try {
do {
@@ -104,8 +107,15 @@
break;
query.numberOfTerms++;
termDocs.seek(term);
- while (termDocs.next()) {
- handleDoc(termDocs.doc());
+ while (true) {
+ final int count = termDocs.read(docs, freqs);
+ if (count != 0) {
+ for(int i=0;iThis query uses {@linkplain
+ * MultiTermQuery#SCORING_BOOLEAN_QUERY_REWRITE}. If you
+ * want to change this, use the new {@link TermRangeQuery}
+ * instead.
*
* @deprecated Use {@link TermRangeQuery} for term ranges or
* {@link NumericRangeQuery} for numeric ranges instead.
@@ -93,7 +94,7 @@
inclusive, inclusive,
collator
);
- delegate.setConstantScoreRewrite(false);
+ delegate.setRewriteMethod(TermRangeQuery.SCORING_BOOLEAN_QUERY_REWRITE);
}
public void setBoost(float b) {
Index: src/java/org/apache/lucene/search/PrefixQuery.java
===================================================================
--- src/java/org/apache/lucene/search/PrefixQuery.java (revision 795767)
+++ src/java/org/apache/lucene/search/PrefixQuery.java (working copy)
@@ -24,7 +24,15 @@
import org.apache.lucene.util.ToStringUtils;
/** A Query that matches documents containing terms with a specified prefix. A PrefixQuery
- * is built by QueryParser for input like app*. */
+ * is built by QueryParser for input like app*.
+ *
+ *
NOTE: Currently this query uses {@link + * MultiTermQuery#SCORING_BOOLEAN_QUERY_REWRITE}, which + * assigns not-very-useful scores to the resulting hits. In + * 3.0 this default will change to {@link + * MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}; you + * can use {@link MultiTermQuery#setRewriteMethod} to change + * it. */ public class PrefixQuery extends MultiTermQuery { private Term prefix; Index: src/java/org/apache/lucene/search/ConstantScoreRangeQuery.java =================================================================== --- src/java/org/apache/lucene/search/ConstantScoreRangeQuery.java (revision 795767) +++ src/java/org/apache/lucene/search/ConstantScoreRangeQuery.java (working copy) @@ -29,9 +29,8 @@ * supplied range according to {@link String#compareTo(String)}. It is not intended * for numerical ranges, use {@link NumericRangeQuery} instead. * - *
This query is in - * {@linkplain MultiTermQuery#setConstantScoreRewrite(boolean) constant score rewrite mode}. - * If you want to change this, use the new {@link TermRangeQuery} instead. + *
This query is hardwired to {@link MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}. + * If you want to change this, use {@link TermRangeQuery} instead. * * @deprecated Use {@link TermRangeQuery} for term ranges or * {@link NumericRangeQuery} for numeric ranges instead. @@ -44,14 +43,14 @@ public ConstantScoreRangeQuery(String fieldName, String lowerVal, String upperVal, boolean includeLower, boolean includeUpper) { super(fieldName, lowerVal, upperVal, includeLower, includeUpper); - this.constantScoreRewrite = true; + rewriteMethod = CONSTANT_SCORE_AUTO_REWRITE_DEFAULT; } public ConstantScoreRangeQuery(String fieldName, String lowerVal, String upperVal, boolean includeLower, boolean includeUpper, Collator collator) { super(fieldName, lowerVal, upperVal, includeLower, includeUpper, collator); - this.constantScoreRewrite = true; + rewriteMethod = CONSTANT_SCORE_AUTO_REWRITE_DEFAULT; } public String getLowerVal() { @@ -63,8 +62,9 @@ } /** Changes of mode are not supported by this class (fixed to constant score rewrite mode) */ - public void setConstantScoreRewrite(boolean constantScoreRewrite) { - if (!constantScoreRewrite) - throw new UnsupportedOperationException("Use TermRangeQuery instead to enable boolean query rewrite."); + public void setRewriteMethod(RewriteMethod method) { + if (method != CONSTANT_SCORE_FILTER_REWRITE) { + throw new UnsupportedOperationException("Use TermRangeQuery instead to change the rewrite method."); + } } } Index: src/java/org/apache/lucene/search/NumericRangeQuery.java =================================================================== --- src/java/org/apache/lucene/search/NumericRangeQuery.java (revision 795767) +++ src/java/org/apache/lucene/search/NumericRangeQuery.java (working copy) @@ -123,12 +123,12 @@ * *
Comparisions of the different types of RangeQueries on an index with about 500,000 docs showed * that {@link TermRangeQuery} in boolean rewrite mode (with raised {@link BooleanQuery} clause count) - * took about 30-40 secs to complete, {@link TermRangeQuery} in constant score rewrite mode took 5 secs + * took about 30-40 secs to complete, {@link TermRangeQuery} in filter rewrite mode took 5 secs * and executing this class took <100ms to complete (on an Opteron64 machine, Java 1.5, 8 bit * precision step). This query type was developed for a geographic portal, where the performance for * e.g. bounding boxes or exact date/time stamps is important.
* - *The query defaults to {@linkplain #setConstantScoreRewrite constant score rewrite mode}. + *
The query defaults to {@linkplain MultiTermQuery#CONSTANT_SCORE_FILTER_REWRITE} * With precision steps of ≤4, this query can be run in conventional {@link BooleanQuery} * rewrite mode without changing the max clause count. * @@ -152,7 +152,7 @@ this.max = max; this.minInclusive = minInclusive; this.maxInclusive = maxInclusive; - setConstantScoreRewrite(true); + setRewriteMethod(CONSTANT_SCORE_FILTER_REWRITE); } /** Index: src/java/org/apache/lucene/search/TermRangeQuery.java =================================================================== --- src/java/org/apache/lucene/search/TermRangeQuery.java (revision 795767) +++ src/java/org/apache/lucene/search/TermRangeQuery.java (working copy) @@ -20,7 +20,6 @@ import java.io.IOException; import java.text.Collator; -import org.apache.lucene.index.Term; import org.apache.lucene.index.IndexReader; import org.apache.lucene.util.ToStringUtils; @@ -31,9 +30,9 @@ * supplied range according to {@link String#compareTo(String)}. It is not intended * for numerical ranges, use {@link NumericRangeQuery} instead. * - *
This query is in constant score mode per default. - * See {@link MultiTermQuery#setConstantScoreRewrite} for the tradeoffs between - * enabling and disabling constantScoreRewrite mode. + *
This query uses the {@link
+ * MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}
+ * rewrite method.
* @since 2.9
*/
@@ -110,7 +109,7 @@
this.includeLower = includeLower;
this.includeUpper = includeUpper;
this.collator = collator;
- this.constantScoreRewrite = true;
+ rewriteMethod = CONSTANT_SCORE_AUTO_REWRITE_DEFAULT;
}
/** Returns the field name for this query */
Index: src/java/org/apache/lucene/search/WildcardQuery.java
===================================================================
--- src/java/org/apache/lucene/search/WildcardQuery.java (revision 795767)
+++ src/java/org/apache/lucene/search/WildcardQuery.java (working copy)
@@ -30,8 +30,14 @@
* a Wildcard term should not start with one of the wildcards * or
* ?.
*
- * @see WildcardTermEnum
- */
+ *
NOTE: Currently this query uses {@link + * MultiTermQuery#SCORING_BOOLEAN_QUERY_REWRITE}, which + * assigns not-very-useful scores to the resulting hits. In + * 3.0 this default will change to {@link + * MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}; you can use {@link + * MultiTermQuery#setRewriteMethod} to change it. + * + * @see WildcardTermEnum */ public class WildcardQuery extends MultiTermQuery { private boolean termContainsWildcard; protected Term term; Index: contrib/highlighter/src/test/org/apache/lucene/search/highlight/HighlighterTest.java =================================================================== --- contrib/highlighter/src/test/org/apache/lucene/search/highlight/HighlighterTest.java (revision 795767) +++ contrib/highlighter/src/test/org/apache/lucene/search/highlight/HighlighterTest.java (working copy) @@ -53,6 +53,7 @@ import org.apache.lucene.queryParser.ParseException; import org.apache.lucene.queryParser.QueryParser; import org.apache.lucene.search.BooleanQuery; +import org.apache.lucene.search.MultiTermQuery; import org.apache.lucene.search.ConstantScoreRangeQuery; import org.apache.lucene.search.FilteredQuery; import org.apache.lucene.search.Hits; @@ -548,7 +549,7 @@ numHighlights = 0; query = new WildcardQuery(new Term(FIELD_NAME, "ken*")); - ((WildcardQuery)query).setConstantScoreRewrite(true); + ((WildcardQuery)query).setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE); searcher = new IndexSearcher(ramDir); // can't rewrite ConstantScore if you want to highlight it - // it rewrites to ConstantScoreQuery which cannot be highlighted @@ -1186,7 +1187,7 @@ searchers[1] = new IndexSearcher(ramDir2); MultiSearcher multiSearcher = new MultiSearcher(searchers); QueryParser parser = new QueryParser(FIELD_NAME, new StandardAnalyzer()); - parser.setConstantScoreRewrite(false); + parser.setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE); query = parser.parse("multi*"); System.out.println("Searching for: " + query.toString(FIELD_NAME)); // at this point the multisearcher calls combine(query[]) @@ -1487,7 +1488,7 @@ public void doSearching(String queryString) throws Exception { QueryParser parser = new QueryParser(FIELD_NAME, new StandardAnalyzer()); - parser.setConstantScoreRewrite(false); + parser.setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE); query = parser.parse(queryString); doSearching(query); } Index: contrib/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.java =================================================================== --- contrib/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.java (revision 795767) +++ contrib/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.java (working copy) @@ -28,14 +28,11 @@ import org.apache.lucene.analysis.CachingTokenFilter; import org.apache.lucene.analysis.TokenStream; -import org.apache.lucene.index.FilterIndexReader; import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.Term; -import org.apache.lucene.index.TermEnum; import org.apache.lucene.index.memory.MemoryIndex; import org.apache.lucene.search.BooleanClause; import org.apache.lucene.search.BooleanQuery; -import org.apache.lucene.search.ConstantScoreRangeQuery; import org.apache.lucene.search.DisjunctionMaxQuery; import org.apache.lucene.search.FilteredQuery; import org.apache.lucene.search.FuzzyQuery; @@ -139,9 +136,9 @@ terms.putAll(disjunctTerms); } else if (query instanceof MultiTermQuery && (highlightCnstScrRngQuery || expandMultiTermQuery)) { MultiTermQuery mtq = ((MultiTermQuery)query); - if(mtq.getConstantScoreRewrite()) { + if(mtq.getRewriteMethod() == MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE) { mtq = copyMultiTermQuery(mtq); - mtq.setConstantScoreRewrite(false); + mtq.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE); query = mtq; } String field;