Skip to content

Apache Lucene open-source search software

LUCENE-10431: Deprecate MultiTermQuery.setRewriteMethod() (#722)

Alan Woodward3f994dec53a1
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt
index b5d62ed53e4..52fe6cab95f 100644
--- a/lucene/CHANGES.txt
+++ b/lucene/CHANGES.txt
@@ -98,6 +98,9 @@ API Changes
* LUCENE-10440: TaxonomyFacets and FloatTaxonomyFacets have been deprecated and are no longer
supported extension points for user-created faceting implementations. (Greg Miller)
+* LUCENE-10431: MultiTermQuery.setRewriteMethod() has been deprecated, and constructor
+ parameters for the various implementations added. (Alan Woodward)
+
New Features
---------------------
diff --git a/lucene/benchmark/src/java/org/apache/lucene/benchmark/byTask/feeds/EnwikiQueryMaker.java b/lucene/benchmark/src/java/org/apache/lucene/benchmark/byTask/feeds/EnwikiQueryMaker.java
index 9af4145e7df..e116fe9191a 100644
--- a/lucene/benchmark/src/java/org/apache/lucene/benchmark/byTask/feeds/EnwikiQueryMaker.java
+++ b/lucene/benchmark/src/java/org/apache/lucene/benchmark/byTask/feeds/EnwikiQueryMaker.java
@@ -31,6 +31,7 @@ import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.MultiTermQuery;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.WildcardQuery;
+import org.apache.lucene.util.automaton.Operations;
/**
* A QueryMaker that uses common and uncommon actual Wikipedia queries for searching the English
@@ -130,8 +131,11 @@ public class EnwikiQueryMaker extends AbstractQueryMaker {
};
private static Query[] getPrebuiltQueries(String field) {
- WildcardQuery wcq = new WildcardQuery(new Term(field, "fo*"));
- wcq.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
+ WildcardQuery wcq =
+ new WildcardQuery(
+ new Term(field, "fo*"),
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ MultiTermQuery.CONSTANT_SCORE_REWRITE);
// be wary of unanalyzed text
return new Query[] {
new SpanFirstQuery(new SpanTermQuery(new Term(field, "ford")), 5),
diff --git a/lucene/core/src/java/org/apache/lucene/search/AutomatonQuery.java b/lucene/core/src/java/org/apache/lucene/search/AutomatonQuery.java
index b3f056c5712..0428f6c4abf 100644
--- a/lucene/core/src/java/org/apache/lucene/search/AutomatonQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/AutomatonQuery.java
@@ -76,7 +76,22 @@ public class AutomatonQuery extends MultiTermQuery implements Accountable {
* UTF32ToUTF8 conversion
*/
public AutomatonQuery(final Term term, Automaton automaton, boolean isBinary) {
- super(term.field());
+ this(term, automaton, isBinary, CONSTANT_SCORE_REWRITE);
+ }
+
+ /**
+ * Create a new AutomatonQuery from an {@link Automaton}.
+ *
+ * @param term Term containing field and possibly some pattern structure. The term text is
+ * ignored.
+ * @param automaton Automaton to run, terms that are accepted are considered a match.
+ * @param isBinary if true, this automaton is already binary and will not go through the
+ * UTF32ToUTF8 conversion
+ * @param rewriteMethod the rewriteMethod to use to build the final query from the automaton
+ */
+ public AutomatonQuery(
+ final Term term, Automaton automaton, boolean isBinary, RewriteMethod rewriteMethod) {
+ super(term.field(), rewriteMethod);
this.term = term;
this.automaton = automaton;
this.automatonIsBinary = isBinary;
diff --git a/lucene/core/src/java/org/apache/lucene/search/FuzzyQuery.java b/lucene/core/src/java/org/apache/lucene/search/FuzzyQuery.java
index 8e31ba41cbe..4515c2df45d 100644
--- a/lucene/core/src/java/org/apache/lucene/search/FuzzyQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/FuzzyQuery.java
@@ -56,6 +56,11 @@ public class FuzzyQuery extends MultiTermQuery {
public static final int defaultMaxExpansions = 50;
public static final boolean defaultTranspositions = true;
+ /** Creates a default top-terms blended frequency scoring rewrite with the given max expansions */
+ public static RewriteMethod defaultRewriteMethod(int maxExpansions) {
+ return new MultiTermQuery.TopTermsBlendedFreqScoringRewrite(maxExpansions);
+ }
+
private final int maxEdits;
private final int maxExpansions;
private final boolean transpositions;
@@ -76,10 +81,16 @@ public class FuzzyQuery extends MultiTermQuery {
* maxClauseCount will be used instead.
* @param transpositions true if transpositions should be treated as a primitive edit operation.
* If this is false, comparisons will implement the classic Levenshtein algorithm.
+ * @param rewriteMethod the rewrite method to use to build the final query
*/
public FuzzyQuery(
- Term term, int maxEdits, int prefixLength, int maxExpansions, boolean transpositions) {
- super(term.field());
+ Term term,
+ int maxEdits,
+ int prefixLength,
+ int maxExpansions,
+ boolean transpositions,
+ RewriteMethod rewriteMethod) {
+ super(term.field(), rewriteMethod);
if (maxEdits < 0 || maxEdits > LevenshteinAutomata.MAXIMUM_SUPPORTED_DISTANCE) {
throw new IllegalArgumentException(
@@ -97,7 +108,22 @@ public class FuzzyQuery extends MultiTermQuery {
this.prefixLength = prefixLength;
this.transpositions = transpositions;
this.maxExpansions = maxExpansions;
- setRewriteMethod(new MultiTermQuery.TopTermsBlendedFreqScoringRewrite(maxExpansions));
+ }
+
+ /**
+ * Calls {@link #FuzzyQuery(Term, int, int, int, boolean,
+ * org.apache.lucene.search.MultiTermQuery.RewriteMethod)} FuzzyQuery(term, maxEdits,
+ * prefixLength, maxExpansions, defaultRewriteMethod(maxExpansions))
+ */
+ public FuzzyQuery(
+ Term term, int maxEdits, int prefixLength, int maxExpansions, boolean transpositions) {
+ this(
+ term,
+ maxEdits,
+ prefixLength,
+ maxExpansions,
+ transpositions,
+ defaultRewriteMethod(maxExpansions));
}
/**
diff --git a/lucene/core/src/java/org/apache/lucene/search/MultiTermQuery.java b/lucene/core/src/java/org/apache/lucene/search/MultiTermQuery.java
index 7ddeeb49325..e5bc87c84f9 100644
--- a/lucene/core/src/java/org/apache/lucene/search/MultiTermQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/MultiTermQuery.java
@@ -36,10 +36,10 @@ import org.apache.lucene.util.AttributeSource;
* #getTermsEnum(Terms,AttributeSource)} to provide a {@link FilteredTermsEnum} that iterates
* through the terms to be matched.
*
- * <p><b>NOTE</b>: if {@link #setRewriteMethod} is either {@link #CONSTANT_SCORE_BOOLEAN_REWRITE} or
+ * <p><b>NOTE</b>: if {@link RewriteMethod} is either {@link #CONSTANT_SCORE_BOOLEAN_REWRITE} or
* {@link #SCORING_BOOLEAN_REWRITE}, you may encounter a {@link IndexSearcher.TooManyClauses}
* exception during searching, which happens when the number of terms to be searched exceeds {@link
- * IndexSearcher#getMaxClauseCount()}. Setting {@link #setRewriteMethod} to {@link
+ * IndexSearcher#getMaxClauseCount()}. Setting {@link RewriteMethod} to {@link
* #CONSTANT_SCORE_REWRITE} prevents this.
*
* <p>The recommended rewrite method is {@link #CONSTANT_SCORE_REWRITE}: it doesn't spend CPU
@@ -52,7 +52,7 @@ import org.apache.lucene.util.AttributeSource;
*/
public abstract class MultiTermQuery extends Query {
protected final String field;
- protected RewriteMethod rewriteMethod = CONSTANT_SCORE_REWRITE;
+ protected RewriteMethod rewriteMethod; // TODO make this final
/** Abstract class that defines how the query is rewritten. */
public abstract static class RewriteMethod {
@@ -77,8 +77,6 @@ public abstract class MultiTermQuery extends Query {
* <p>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
* IndexSearcher.TooManyClauses} exception.
- *
- * @see #setRewriteMethod
*/
public static final RewriteMethod CONSTANT_SCORE_REWRITE =
new RewriteMethod() {
@@ -96,8 +94,6 @@ public abstract class MultiTermQuery extends Query {
*
* <p><b>NOTE</b>: This rewrite method will hit {@link IndexSearcher.TooManyClauses} if the number
* of terms exceeds {@link IndexSearcher#getMaxClauseCount}.
- *
- * @see #setRewriteMethod
*/
public static final RewriteMethod SCORING_BOOLEAN_REWRITE =
ScoringRewrite.SCORING_BOOLEAN_REWRITE;
@@ -108,8 +104,6 @@ public abstract class MultiTermQuery extends Query {
*
* <p><b>NOTE</b>: This rewrite method will hit {@link IndexSearcher.TooManyClauses} if the number
* of terms exceeds {@link IndexSearcher#getMaxClauseCount}.
- *
- * @see #setRewriteMethod
*/
public static final RewriteMethod CONSTANT_SCORE_BOOLEAN_REWRITE =
ScoringRewrite.CONSTANT_SCORE_BOOLEAN_REWRITE;
@@ -120,8 +114,6 @@ public abstract class MultiTermQuery extends Query {
*
* <p>This rewrite method only uses the top scoring terms so it will not overflow the boolean max
* clause count.
- *
- * @see #setRewriteMethod
*/
public static final class TopTermsScoringBooleanQueryRewrite
extends TopTermsRewrite<BooleanQuery.Builder> {
@@ -167,8 +159,6 @@ public abstract class MultiTermQuery extends Query {
*
* <p>This rewrite method only uses the top scoring terms so it will not overflow the boolean max
* clause count.
- *
- * @see #setRewriteMethod
*/
public static final class TopTermsBlendedFreqScoringRewrite
extends TopTermsRewrite<BlendedTermQuery.Builder> {
@@ -217,8 +207,6 @@ public abstract class MultiTermQuery extends Query {
*
* <p>This rewrite method only uses the top scoring terms so it will not overflow the boolean max
* clause count.
- *
- * @see #setRewriteMethod
*/
public static final class TopTermsBoostOnlyBooleanQueryRewrite
extends TopTermsRewrite<BooleanQuery.Builder> {
@@ -257,8 +245,9 @@ public abstract class MultiTermQuery extends Query {
}
/** Constructs a query matching terms that cannot be represented with a single Term. */
- public MultiTermQuery(final String field) {
+ public MultiTermQuery(final String field, RewriteMethod rewriteMethod) {
this.field = Objects.requireNonNull(field, "field must not be null");
+ this.rewriteMethod = Objects.requireNonNull(rewriteMethod, "rewriteMethod must not be null");
}
/** Returns the field name for this query */
@@ -294,7 +283,6 @@ public abstract class MultiTermQuery extends Query {
return rewriteMethod.rewrite(reader, this);
}
- /** @see #setRewriteMethod */
public RewriteMethod getRewriteMethod() {
return rewriteMethod;
}
@@ -302,7 +290,10 @@ public abstract class MultiTermQuery extends Query {
/**
* Sets the rewrite method to be used when executing the query. You can use one of the four core
* methods, or implement your own subclass of {@link RewriteMethod}.
+ *
+ * @deprecated set this using a constructor instead
*/
+ @Deprecated
public void setRewriteMethod(RewriteMethod method) {
rewriteMethod = method;
}
diff --git a/lucene/core/src/java/org/apache/lucene/search/PrefixQuery.java b/lucene/core/src/java/org/apache/lucene/search/PrefixQuery.java
index 0ee553f563c..dbad6ef6152 100644
--- a/lucene/core/src/java/org/apache/lucene/search/PrefixQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/PrefixQuery.java
@@ -30,7 +30,14 @@ public class PrefixQuery extends AutomatonQuery {
/** Constructs a query for terms starting with <code>prefix</code>. */
public PrefixQuery(Term prefix) {
- super(prefix, toAutomaton(prefix.bytes()), true);
+ this(prefix, CONSTANT_SCORE_REWRITE);
+ }
+
+ /**
+ * Constructs a query for terms starting with <code>prefix</code> using a defined RewriteMethod
+ */
+ public PrefixQuery(Term prefix, RewriteMethod rewriteMethod) {
+ super(prefix, toAutomaton(prefix.bytes()), true, rewriteMethod);
}
/** Build an automaton accepting all terms with the specified prefix. */
diff --git a/lucene/core/src/java/org/apache/lucene/search/RegexpQuery.java b/lucene/core/src/java/org/apache/lucene/search/RegexpQuery.java
index e786ebc8430..e6a160a5929 100644
--- a/lucene/core/src/java/org/apache/lucene/search/RegexpQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/RegexpQuery.java
@@ -17,7 +17,6 @@
package org.apache.lucene.search;
import org.apache.lucene.index.Term;
-import org.apache.lucene.util.automaton.Automaton;
import org.apache.lucene.util.automaton.AutomatonProvider;
import org.apache.lucene.util.automaton.Operations;
import org.apache.lucene.util.automaton.RegExp;
@@ -42,14 +41,9 @@ import org.apache.lucene.util.automaton.RegExp;
* @lucene.experimental
*/
public class RegexpQuery extends AutomatonQuery {
+
/** A provider that provides no named automata */
- private static AutomatonProvider defaultProvider =
- new AutomatonProvider() {
- @Override
- public Automaton getAutomaton(String name) {
- return null;
- }
- };
+ public static final AutomatonProvider DEFAULT_PROVIDER = name -> null;
/**
* Constructs a query for terms matching <code>term</code>.
@@ -69,7 +63,7 @@ public class RegexpQuery extends AutomatonQuery {
* @param flags optional RegExp features from {@link RegExp}
*/
public RegexpQuery(Term term, int flags) {
- this(term, flags, defaultProvider, Operations.DEFAULT_DETERMINIZE_WORK_LIMIT);
+ this(term, flags, DEFAULT_PROVIDER, Operations.DEFAULT_DETERMINIZE_WORK_LIMIT);
}
/**
@@ -83,7 +77,7 @@ public class RegexpQuery extends AutomatonQuery {
* otherwise know what to specify.
*/
public RegexpQuery(Term term, int flags, int determinizeWorkLimit) {
- this(term, flags, defaultProvider, determinizeWorkLimit);
+ this(term, flags, DEFAULT_PROVIDER, determinizeWorkLimit);
}
/**
@@ -100,7 +94,13 @@ public class RegexpQuery extends AutomatonQuery {
* otherwise know what to specify.
*/
public RegexpQuery(Term term, int syntax_flags, int match_flags, int determinizeWorkLimit) {
- this(term, syntax_flags, match_flags, defaultProvider, determinizeWorkLimit);
+ this(
+ term,
+ syntax_flags,
+ match_flags,
+ DEFAULT_PROVIDER,
+ determinizeWorkLimit,
+ CONSTANT_SCORE_REWRITE);
}
/**
@@ -116,7 +116,7 @@ public class RegexpQuery extends AutomatonQuery {
*/
public RegexpQuery(
Term term, int syntax_flags, AutomatonProvider provider, int determinizeWorkLimit) {
- this(term, syntax_flags, 0, provider, determinizeWorkLimit);
+ this(term, syntax_flags, 0, provider, determinizeWorkLimit, CONSTANT_SCORE_REWRITE);
}
/**
@@ -130,18 +130,22 @@ public class RegexpQuery extends AutomatonQuery {
* regexp. Set higher to allow more complex queries and lower to prevent memory exhaustion.
* Use {@link Operations#DEFAULT_DETERMINIZE_WORK_LIMIT} as a decent default if you don't
* otherwise know what to specify.
+ * @param rewriteMethod the rewrite method to use to build the final query
*/
public RegexpQuery(
Term term,
int syntax_flags,
int match_flags,
AutomatonProvider provider,
- int determinizeWorkLimit) {
+ int determinizeWorkLimit,
+ RewriteMethod rewriteMethod) {
super(
term,
Operations.determinize(
new RegExp(term.text(), syntax_flags, match_flags).toAutomaton(provider),
- determinizeWorkLimit));
+ determinizeWorkLimit),
+ false,
+ rewriteMethod);
}
/** Returns the regexp of this query wrapped in a Term. */
diff --git a/lucene/core/src/java/org/apache/lucene/search/ScoringRewrite.java b/lucene/core/src/java/org/apache/lucene/search/ScoringRewrite.java
index 5179f21ef36..d2ee23315cc 100644
--- a/lucene/core/src/java/org/apache/lucene/search/ScoringRewrite.java
+++ b/lucene/core/src/java/org/apache/lucene/search/ScoringRewrite.java
@@ -46,8 +46,6 @@ public abstract class ScoringRewrite<B> extends TermCollectingRewrite<B> {
*
* <p><b>NOTE</b>: This rewrite method will hit {@link IndexSearcher.TooManyClauses} if the number
* of terms exceeds {@link IndexSearcher#getMaxClauseCount}.
- *
- * @see MultiTermQuery#setRewriteMethod
*/
public static final ScoringRewrite<BooleanQuery.Builder> SCORING_BOOLEAN_REWRITE =
new ScoringRewrite<BooleanQuery.Builder>() {
@@ -84,8 +82,6 @@ public abstract class ScoringRewrite<B> extends TermCollectingRewrite<B> {
*
* <p><b>NOTE</b>: This rewrite method will hit {@link IndexSearcher.TooManyClauses} if the number
* of terms exceeds {@link IndexSearcher#getMaxClauseCount}.
- *
- * @see MultiTermQuery#setRewriteMethod
*/
public static final RewriteMethod CONSTANT_SCORE_BOOLEAN_REWRITE =
new RewriteMethod() {
diff --git a/lucene/core/src/java/org/apache/lucene/search/TermRangeQuery.java b/lucene/core/src/java/org/apache/lucene/search/TermRangeQuery.java
index 27d76ae1465..da5f4df5501 100644
--- a/lucene/core/src/java/org/apache/lucene/search/TermRangeQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/TermRangeQuery.java
@@ -60,10 +60,36 @@ public class TermRangeQuery extends AutomatonQuery {
BytesRef upperTerm,
boolean includeLower,
boolean includeUpper) {
+ this(field, lowerTerm, upperTerm, includeLower, includeUpper, CONSTANT_SCORE_REWRITE);
+ }
+
+ /**
+ * Constructs a query selecting all terms greater/equal than <code>lowerTerm</code> but less/equal
+ * than <code>upperTerm</code>.
+ *
+ * <p>If an endpoint is null, it is said to be "open". Either or both endpoints may be open. Open
+ * endpoints may not be exclusive (you can't select all but the first or last term without
+ * explicitly specifying the term to exclude.)
+ *
+ * @param field The field that holds both lower and upper terms.
+ * @param lowerTerm The term text at the lower end of the range
+ * @param upperTerm The term text at the upper end of the range
+ * @param includeLower If true, the <code>lowerTerm</code> is included in the range.
+ * @param includeUpper If true, the <code>upperTerm</code> is included in the range.
+ * @param rewriteMethod the rewrite method to use when building the final query
+ */
+ public TermRangeQuery(
+ String field,
+ BytesRef lowerTerm,
+ BytesRef upperTerm,
+ boolean includeLower,
+ boolean includeUpper,
+ RewriteMethod rewriteMethod) {
super(
new Term(field, lowerTerm),
toAutomaton(lowerTerm, upperTerm, includeLower, includeUpper),
- true);
+ true,
+ rewriteMethod);
this.lowerTerm = lowerTerm;
this.upperTerm = upperTerm;
this.includeLower = includeLower;
@@ -93,9 +119,21 @@ public class TermRangeQuery extends AutomatonQuery {
String upperTerm,
boolean includeLower,
boolean includeUpper) {
+ return newStringRange(
+ field, lowerTerm, upperTerm, includeLower, includeUpper, CONSTANT_SCORE_REWRITE);
+ }
+
+ /** Factory that creates a new TermRangeQuery using Strings for term text. */
+ public static TermRangeQuery newStringRange(
+ String field,
+ String lowerTerm,
+ String upperTerm,
+ boolean includeLower,
+ boolean includeUpper,
+ RewriteMethod rewriteMethod) {
BytesRef lower = lowerTerm == null ? null : new BytesRef(lowerTerm);
BytesRef upper = upperTerm == null ? null : new BytesRef(upperTerm);
- return new TermRangeQuery(field, lower, upper, includeLower, includeUpper);
+ return new TermRangeQuery(field, lower, upper, includeLower, includeUpper, rewriteMethod);
}
/** Returns the lower value of this range query */
diff --git a/lucene/core/src/java/org/apache/lucene/search/WildcardQuery.java b/lucene/core/src/java/org/apache/lucene/search/WildcardQuery.java
index 27989ca6c12..cd0bbd2f343 100644
--- a/lucene/core/src/java/org/apache/lucene/search/WildcardQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/WildcardQuery.java
@@ -59,7 +59,20 @@ public class WildcardQuery extends AutomatonQuery {
* otherwise know what to specify.
*/
public WildcardQuery(Term term, int determinizeWorkLimit) {
- super(term, toAutomaton(term, determinizeWorkLimit));
+ this(term, determinizeWorkLimit, CONSTANT_SCORE_REWRITE);
+ }
+
+ /**
+ * Constructs a query for terms matching <code>term</code>.
+ *
+ * @param determinizeWorkLimit maximum effort to spend while compiling the automaton from this
+ * wildcard. Set higher to allow more complex queries and lower to prevent memory exhaustion.
+ * Use {@link Operations#DEFAULT_DETERMINIZE_WORK_LIMIT} as a decent default if you don't
+ * otherwise know what to specify.
+ * @param rewriteMethod the rewrite method to use when building the final query
+ */
+ public WildcardQuery(Term term, int determinizeWorkLimit, RewriteMethod rewriteMethod) {
+ super(term, toAutomaton(term, determinizeWorkLimit), false, rewriteMethod);
}
/**
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQuery.java
index 548945c4f76..50cda4235d3 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQuery.java
@@ -91,16 +91,24 @@ public class TestAutomatonQuery extends LuceneTestCase {
}
private void assertAutomatonHits(int expected, Automaton automaton) throws IOException {
- AutomatonQuery query = new AutomatonQuery(newTerm("bogus"), automaton);
-
- query.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
- assertEquals(expected, automatonQueryNrHits(query));
-
- query.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
- assertEquals(expected, automatonQueryNrHits(query));
-
- query.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_BOOLEAN_REWRITE);
- assertEquals(expected, automatonQueryNrHits(query));
+ assertEquals(
+ expected,
+ automatonQueryNrHits(
+ new AutomatonQuery(
+ newTerm("bogus"), automaton, false, MultiTermQuery.SCORING_BOOLEAN_REWRITE)));
+ assertEquals(
+ expected,
+ automatonQueryNrHits(
+ new AutomatonQuery(
+ newTerm("bogus"), automaton, false, MultiTermQuery.CONSTANT_SCORE_REWRITE)));
+ assertEquals(
+ expected,
+ automatonQueryNrHits(
+ new AutomatonQuery(
+ newTerm("bogus"),
+ automaton,
+ false,
+ MultiTermQuery.CONSTANT_SCORE_BOOLEAN_REWRITE)));
}
/** Test some very simple automata. */
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQueryUnicode.java b/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQueryUnicode.java
index 951dbd872d9..cee88251d87 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQueryUnicode.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQueryUnicode.java
@@ -97,16 +97,24 @@ public class TestAutomatonQueryUnicode extends LuceneTestCase {
}
private void assertAutomatonHits(int expected, Automaton automaton) throws IOException {
- AutomatonQuery query = new AutomatonQuery(newTerm("bogus"), automaton);
-
- query.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
- assertEquals(expected, automatonQueryNrHits(query));
-
- query.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
- assertEquals(expected, automatonQueryNrHits(query));
-
- query.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_BOOLEAN_REWRITE);
- assertEquals(expected, automatonQueryNrHits(query));
+ assertEquals(
+ expected,
+ automatonQueryNrHits(
+ new AutomatonQuery(
+ newTerm("bogus"), automaton, false, MultiTermQuery.SCORING_BOOLEAN_REWRITE)));
+ assertEquals(
+ expected,
+ automatonQueryNrHits(
+ new AutomatonQuery(
+ newTerm("bogus"), automaton, false, MultiTermQuery.CONSTANT_SCORE_REWRITE)));
+ assertEquals(
+ expected,
+ automatonQueryNrHits(
+ new AutomatonQuery(
+ newTerm("bogus"),
+ automaton,
+ false,
+ MultiTermQuery.CONSTANT_SCORE_BOOLEAN_REWRITE)));
}
/**
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java
index 5d8e828b404..75ede47e763 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java
@@ -47,6 +47,7 @@ import org.apache.lucene.tests.util.LuceneTestCase;
import org.apache.lucene.tests.util.TestUtil;
import org.apache.lucene.util.IOUtils;
import org.apache.lucene.util.NamedThreadFactory;
+import org.apache.lucene.util.automaton.Operations;
public class TestBooleanQuery extends LuceneTestCase {
@@ -254,8 +255,11 @@ public class TestBooleanQuery extends LuceneTestCase {
BooleanQuery.Builder query = new BooleanQuery.Builder(); // Query: +foo -ba*
query.add(new TermQuery(new Term("field", "foo")), BooleanClause.Occur.MUST);
- WildcardQuery wildcardQuery = new WildcardQuery(new Term("field", "ba*"));
- wildcardQuery.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+ WildcardQuery wildcardQuery =
+ new WildcardQuery(
+ new Term("field", "ba*"),
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ MultiTermQuery.SCORING_BOOLEAN_REWRITE);
query.add(wildcardQuery, BooleanClause.Occur.MUST_NOT);
MultiReader multireader = new MultiReader(reader1, reader2);
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestDocValuesRewriteMethod.java b/lucene/core/src/test/org/apache/lucene/search/TestDocValuesRewriteMethod.java
index a694ed6a1a7..a87ca468195 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestDocValuesRewriteMethod.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestDocValuesRewriteMethod.java
@@ -36,6 +36,7 @@ import org.apache.lucene.tests.util.TestUtil;
import org.apache.lucene.tests.util.automaton.AutomatonTestUtil;
import org.apache.lucene.util.BytesRef;
import org.apache.lucene.util.UnicodeUtil;
+import org.apache.lucene.util.automaton.Operations;
import org.apache.lucene.util.automaton.RegExp;
/** Tests the DocValuesRewriteMethod */
@@ -114,8 +115,14 @@ public class TestDocValuesRewriteMethod extends LuceneTestCase {
/** check that the # of hits is the same as if the query is run against the inverted index */
protected void assertSame(String regexp) throws IOException {
- RegexpQuery docValues = new RegexpQuery(new Term(fieldName, regexp), RegExp.NONE);
- docValues.setRewriteMethod(new DocValuesRewriteMethod());
+ RegexpQuery docValues =
+ new RegexpQuery(
+ new Term(fieldName, regexp),
+ RegExp.NONE,
+ 0,
+ name -> null,
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ new DocValuesRewriteMethod());
RegexpQuery inverted = new RegexpQuery(new Term(fieldName, regexp), RegExp.NONE);
TopDocs invertedDocs = searcher1.search(inverted, 25);
@@ -125,17 +132,42 @@ public class TestDocValuesRewriteMethod extends LuceneTestCase {
}
public void testEquals() throws Exception {
- RegexpQuery a1 = new RegexpQuery(new Term(fieldName, "[aA]"), RegExp.NONE);
- RegexpQuery a2 = new RegexpQuery(new Term(fieldName, "[aA]"), RegExp.NONE);
- RegexpQuery b = new RegexpQuery(new Term(fieldName, "[bB]"), RegExp.NONE);
- assertEquals(a1, a2);
- assertFalse(a1.equals(b));
+ {
+ RegexpQuery a1 = new RegexpQuery(new Term(fieldName, "[aA]"), RegExp.NONE);
+ RegexpQuery a2 = new RegexpQuery(new Term(fieldName, "[aA]"), RegExp.NONE);
+ RegexpQuery b = new RegexpQuery(new Term(fieldName, "[bB]"), RegExp.NONE);
+ assertEquals(a1, a2);
+ assertFalse(a1.equals(b));
+ }
- a1.setRewriteMethod(new DocValuesRewriteMethod());
- a2.setRewriteMethod(new DocValuesRewriteMethod());
- b.setRewriteMethod(new DocValuesRewriteMethod());
- assertEquals(a1, a2);
- assertFalse(a1.equals(b));
- QueryUtils.check(a1);
+ {
+ RegexpQuery a1 =
+ new RegexpQuery(
+ new Term(fieldName, "[aA]"),
+ RegExp.NONE,
+ 0,
+ name -> null,
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ new DocValuesRewriteMethod());
+ RegexpQuery a2 =
+ new RegexpQuery(
+ new Term(fieldName, "[aA]"),
+ RegExp.NONE,
+ 0,
+ name -> null,
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ new DocValuesRewriteMethod());
+ RegexpQuery b =
+ new RegexpQuery(
+ new Term(fieldName, "[bB]"),
+ RegExp.NONE,
+ 0,
+ name -> null,
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ new DocValuesRewriteMethod());
+ assertEquals(a1, a2);
+ assertFalse(a1.equals(b));
+ QueryUtils.check(a1);
+ }
}
}
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestFieldCacheRewriteMethod.java b/lucene/core/src/test/org/apache/lucene/search/TestFieldCacheRewriteMethod.java
index ca78ac3c682..d48f9a64ad9 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestFieldCacheRewriteMethod.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestFieldCacheRewriteMethod.java
@@ -20,6 +20,7 @@ import java.io.IOException;
import org.apache.lucene.index.Term;
import org.apache.lucene.tests.search.CheckHits;
import org.apache.lucene.tests.search.QueryUtils;
+import org.apache.lucene.util.automaton.Operations;
import org.apache.lucene.util.automaton.RegExp;
/** Tests the FieldcacheRewriteMethod with random regular expressions */
@@ -28,11 +29,23 @@ public class TestFieldCacheRewriteMethod extends TestRegexpRandom2 {
/** Test fieldcache rewrite against filter rewrite */
@Override
protected void assertSame(String regexp) throws IOException {
- RegexpQuery fieldCache = new RegexpQuery(new Term(fieldName, regexp), RegExp.NONE);
- fieldCache.setRewriteMethod(new DocValuesRewriteMethod());
+ RegexpQuery fieldCache =
+ new RegexpQuery(
+ new Term(fieldName, regexp),
+ RegExp.NONE,
+ 0,
+ name -> null,
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ new DocValuesRewriteMethod());
- RegexpQuery filter = new RegexpQuery(new Term(fieldName, regexp), RegExp.NONE);
- filter.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
+ RegexpQuery filter =
+ new RegexpQuery(
+ new Term(fieldName, regexp),
+ RegExp.NONE,
+ 0,
+ name -> null,
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ MultiTermQuery.CONSTANT_SCORE_REWRITE);
TopDocs fieldCacheDocs = searcher1.search(fieldCache, 25);
TopDocs filterDocs = searcher2.search(filter, 25);
@@ -41,17 +54,43 @@ public class TestFieldCacheRewriteMethod extends TestRegexpRandom2 {
}
public void testEquals() throws Exception {
- RegexpQuery a1 = new RegexpQuery(new Term(fieldName, "[aA]"), RegExp.NONE);
- RegexpQuery a2 = new RegexpQuery(new Term(fieldName, "[aA]"), RegExp.NONE);
- RegexpQuery b = new RegexpQuery(new Term(fieldName, "[bB]"), RegExp.NONE);
- assertEquals(a1, a2);
- assertFalse(a1.equals(b));
-
- a1.setRewriteMethod(new DocValuesRewriteMethod());
- a2.setRewriteMethod(new DocValuesRewriteMethod());
- b.setRewriteMethod(new DocValuesRewriteMethod());
- assertEquals(a1, a2);
- assertFalse(a1.equals(b));
- QueryUtils.check(a1);
+ {
+ RegexpQuery a1 = new RegexpQuery(new Term(fieldName, "[aA]"), RegExp.NONE);
+ RegexpQuery a2 = new RegexpQuery(new Term(fieldName, "[aA]"), RegExp.NONE);
+ RegexpQuery b = new RegexpQuery(new Term(fieldName, "[bB]"), RegExp.NONE);
+ assertEquals(a1, a2);
+ assertFalse(a1.equals(b));
+ QueryUtils.check(a1);
+ }
+
+ {
+ RegexpQuery a1 =
+ new RegexpQuery(
+ new Term(fieldName, "[aA]"),
+ RegExp.NONE,
+ 0,
+ name -> null,
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ new DocValuesRewriteMethod());
+ RegexpQuery a2 =
+ new RegexpQuery(
+ new Term(fieldName, "[aA]"),
+ RegExp.NONE,
+ 0,
+ name -> null,
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ new DocValuesRewriteMethod());
+ RegexpQuery b =
+ new RegexpQuery(
+ new Term(fieldName, "[bB]"),
+ RegExp.NONE,
+ 0,
+ name -> null,
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ new DocValuesRewriteMethod());
+ assertEquals(a1, a2);
+ assertFalse(a1.equals(b));
+ QueryUtils.check(a1);
+ }
}
}
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestFuzzyQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestFuzzyQuery.java
index 5fe69b9d1ca..682fd94dc2a 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestFuzzyQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestFuzzyQuery.java
@@ -436,8 +436,14 @@ public class TestFuzzyQuery extends LuceneTestCase {
IndexSearcher searcher = newSearcher(reader);
writer.close();
- FuzzyQuery query = new FuzzyQuery(new Term("field", "lucene"));
- query.setRewriteMethod(new MultiTermQuery.TopTermsBoostOnlyBooleanQueryRewrite(50));
+ FuzzyQuery query =
+ new FuzzyQuery(
+ new Term("field", "lucene"),
+ FuzzyQuery.defaultMaxEdits,
+ FuzzyQuery.defaultPrefixLength,
+ FuzzyQuery.defaultMaxExpansions,
+ FuzzyQuery.defaultTranspositions,
+ new MultiTermQuery.TopTermsBoostOnlyBooleanQueryRewrite(50));
ScoreDoc[] hits = searcher.search(query, 1000).scoreDocs;
assertEquals(3, hits.length);
// normally, 'Lucenne' would be the first result as IDF will skew the score.
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestMultiTermConstantScore.java b/lucene/core/src/test/org/apache/lucene/search/TestMultiTermConstantScore.java
index fa61910ad42..0fd1c152a0b 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestMultiTermConstantScore.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestMultiTermConstantScore.java
@@ -28,6 +28,7 @@ import org.apache.lucene.tests.analysis.MockAnalyzer;
import org.apache.lucene.tests.analysis.MockTokenizer;
import org.apache.lucene.tests.index.RandomIndexWriter;
import org.apache.lucene.tests.search.QueryUtils;
+import org.apache.lucene.util.automaton.Operations;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
@@ -94,8 +95,8 @@ public class TestMultiTermConstantScore extends TestBaseRangeFilter {
/** macro for readability */
public static Query csrq(String f, String l, String h, boolean il, boolean ih) {
- TermRangeQuery query = TermRangeQuery.newStringRange(f, l, h, il, ih);
- query.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
+ TermRangeQuery query =
+ TermRangeQuery.newStringRange(f, l, h, il, ih, MultiTermQuery.CONSTANT_SCORE_REWRITE);
if (VERBOSE) {
System.out.println("TEST: query=" + query);
}
@@ -104,8 +105,7 @@ public class TestMultiTermConstantScore extends TestBaseRangeFilter {
public static Query csrq(
String f, String l, String h, boolean il, boolean ih, MultiTermQuery.RewriteMethod method) {
- TermRangeQuery query = TermRangeQuery.newStringRange(f, l, h, il, ih);
- query.setRewriteMethod(method);
+ TermRangeQuery query = TermRangeQuery.newStringRange(f, l, h, il, ih, method);
if (VERBOSE) {
System.out.println("TEST: query=" + query + " method=" + method);
}
@@ -114,16 +114,13 @@ public class TestMultiTermConstantScore extends TestBaseRangeFilter {
/** macro for readability */
public static Query cspq(Term prefix) {
- PrefixQuery query = new PrefixQuery(prefix);
- query.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
- return query;
+ return new PrefixQuery(prefix, MultiTermQuery.CONSTANT_SCORE_REWRITE);
}
/** macro for readability */
public static Query cswcq(Term wild) {
- WildcardQuery query = new WildcardQuery(wild);
- query.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
- return query;
+ return new WildcardQuery(
+ wild, Operations.DEFAULT_DETERMINIZE_WORK_LIMIT, MultiTermQuery.CONSTANT_SCORE_REWRITE);
}
@Test
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java b/lucene/core/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java
index fb36de732e1..216cc7726e5 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java
@@ -120,8 +120,7 @@ public class TestMultiTermQueryRewrites extends LuceneTestCase {
}
private void checkDuplicateTerms(MultiTermQuery.RewriteMethod method) throws Exception {
- final MultiTermQuery mtq = TermRangeQuery.newStringRange("data", "2", "7", true, true);
- mtq.setRewriteMethod(method);
+ final MultiTermQuery mtq = TermRangeQuery.newStringRange("data", "2", "7", true, true, method);
final Query q1 = searcher.rewrite(mtq);
final Query q2 = multiSearcher.rewrite(mtq);
final Query q3 = multiSearcherDupls.rewrite(mtq);
@@ -163,7 +162,7 @@ public class TestMultiTermQueryRewrites extends LuceneTestCase {
private void checkBoosts(MultiTermQuery.RewriteMethod method) throws Exception {
final MultiTermQuery mtq =
- new MultiTermQuery("data") {
+ new MultiTermQuery("data", method) {
@Override
protected TermsEnum getTermsEnum(Terms terms, AttributeSource atts) throws IOException {
return new FilteredTermsEnum(terms.iterator()) {
@@ -198,7 +197,6 @@ public class TestMultiTermQueryRewrites extends LuceneTestCase {
@Override
public void visit(QueryVisitor visitor) {}
};
- mtq.setRewriteMethod(method);
final Query q1 = searcher.rewrite(mtq);
final Query q2 = multiSearcher.rewrite(mtq);
final Query q3 = multiSearcherDupls.rewrite(mtq);
@@ -233,8 +231,7 @@ public class TestMultiTermQueryRewrites extends LuceneTestCase {
int savedMaxClauseCount = IndexSearcher.getMaxClauseCount();
IndexSearcher.setMaxClauseCount(3);
- final MultiTermQuery mtq = TermRangeQuery.newStringRange("data", "2", "7", true, true);
- mtq.setRewriteMethod(method);
+ final MultiTermQuery mtq = TermRangeQuery.newStringRange("data", "2", "7", true, true, method);
try {
IndexSearcher.TooManyClauses expected =
expectThrows(
@@ -256,8 +253,7 @@ public class TestMultiTermQueryRewrites extends LuceneTestCase {
int savedMaxClauseCount = IndexSearcher.getMaxClauseCount();
IndexSearcher.setMaxClauseCount(3);
- final MultiTermQuery mtq = TermRangeQuery.newStringRange("data", "2", "7", true, true);
- mtq.setRewriteMethod(method);
+ final MultiTermQuery mtq = TermRangeQuery.newStringRange("data", "2", "7", true, true, method);
try {
multiSearcherDupls.rewrite(mtq);
} finally {
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestPrefixRandom.java b/lucene/core/src/test/org/apache/lucene/search/TestPrefixRandom.java
index 2d0cdec8f1c..c6136bedc99 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestPrefixRandom.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestPrefixRandom.java
@@ -81,7 +81,7 @@ public class TestPrefixRandom extends LuceneTestCase {
private final BytesRef prefix;
DumbPrefixQuery(Term term) {
- super(term.field());
+ super(term.field(), CONSTANT_SCORE_REWRITE);
prefix = term.bytes();
}
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestRegexpRandom2.java b/lucene/core/src/test/org/apache/lucene/search/TestRegexpRandom2.java
index d856d245bf2..47ef5054f93 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestRegexpRandom2.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestRegexpRandom2.java
@@ -110,7 +110,7 @@ public class TestRegexpRandom2 extends LuceneTestCase {
private final Automaton automaton;
DumbRegexpQuery(Term term, int flags) {
- super(term.field());
+ super(term.field(), MultiTermQuery.CONSTANT_SCORE_REWRITE);
RegExp re = new RegExp(term.text(), flags);
automaton =
Operations.determinize(re.toAutomaton(), Operations.DEFAULT_DETERMINIZE_WORK_LIMIT);
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java
index 6cde85a5b55..8dd192e6a1e 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java
@@ -128,7 +128,10 @@ public class TestTermRangeQuery extends LuceneTestCase {
IndexReader reader = DirectoryReader.open(dir);
IndexSearcher searcher = newSearcher(reader);
- TermRangeQuery query = TermRangeQuery.newStringRange("content", "B", "J", true, true);
+ MultiTermQuery.RewriteMethod rewriteMethod =
+ new MultiTermQuery.TopTermsScoringBooleanQueryRewrite(50);
+ TermRangeQuery query =
+ TermRangeQuery.newStringRange("content", "B", "J", true, true, rewriteMethod);
checkBooleanTerms(searcher, query, "B", "C", "D", "E", "F", "G", "H", "I", "J");
final int savedClauseCount = IndexSearcher.getMaxClauseCount();
@@ -143,7 +146,6 @@ public class TestTermRangeQuery extends LuceneTestCase {
private void checkBooleanTerms(IndexSearcher searcher, TermRangeQuery query, String... terms)
throws IOException {
- query.setRewriteMethod(new MultiTermQuery.TopTermsScoringBooleanQueryRewrite(50));
final BooleanQuery bq = (BooleanQuery) searcher.rewrite(query);
final Set<String> allowedTerms = asSet(terms);
assertEquals(allowedTerms.size(), bq.clauses().size());
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java b/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java
index 83cf933aa81..4522ab8ca51 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java
@@ -28,6 +28,7 @@ import org.apache.lucene.store.Directory;
import org.apache.lucene.tests.analysis.MockAnalyzer;
import org.apache.lucene.tests.index.RandomIndexWriter;
import org.apache.lucene.tests.util.LuceneTestCase;
+import org.apache.lucene.util.automaton.Operations;
/** TestWildcard tests the '*' and '?' wildcard characters. */
public class TestWildcard extends LuceneTestCase {
@@ -66,16 +67,28 @@ public class TestWildcard extends LuceneTestCase {
MultiTermQuery wq = new WildcardQuery(new Term("field", "nowildcard"));
assertMatches(searcher, wq, 1);
- wq.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
- Query q = searcher.rewrite(wq);
+ Query q =
+ searcher.rewrite(
+ new WildcardQuery(
+ new Term("field", "nowildcard"),
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ MultiTermQuery.SCORING_BOOLEAN_REWRITE));
assertTrue(q instanceof TermQuery);
- wq.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
- q = searcher.rewrite(wq);
+ q =
+ searcher.rewrite(
+ new WildcardQuery(
+ new Term("field", "nowildcard"),
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ MultiTermQuery.CONSTANT_SCORE_REWRITE));
assertTrue(q instanceof MultiTermQueryConstantScoreWrapper);
- wq.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_BOOLEAN_REWRITE);
- q = searcher.rewrite(wq);
+ q =
+ searcher.rewrite(
+ new WildcardQuery(
+ new Term("field", "nowildcard"),
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ MultiTermQuery.CONSTANT_SCORE_BOOLEAN_REWRITE));
assertTrue(q instanceof ConstantScoreQuery);
reader.close();
indexStore.close();
@@ -87,8 +100,11 @@ public class TestWildcard extends LuceneTestCase {
IndexReader reader = DirectoryReader.open(indexStore);
IndexSearcher searcher = newSearcher(reader);
- MultiTermQuery wq = new WildcardQuery(new Term("field", ""));
- wq.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+ MultiTermQuery wq =
+ new WildcardQuery(
+ new Term("field", ""),
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ MultiTermQuery.SCORING_BOOLEAN_REWRITE);
assertMatches(searcher, wq, 0);
Query q = searcher.rewrite(wq);
assertTrue(q instanceof MatchNoDocsQuery);
diff --git a/lucene/highlighter/src/test/org/apache/lucene/search/highlight/TestHighlighter.java b/lucene/highlighter/src/test/org/apache/lucene/search/highlight/TestHighlighter.java
index 895a7044cb6..185c21764fe 100644
--- a/lucene/highlighter/src/test/org/apache/lucene/search/highlight/TestHighlighter.java
+++ b/lucene/highlighter/src/test/org/apache/lucene/search/highlight/TestHighlighter.java
@@ -92,6 +92,7 @@ import org.apache.lucene.tests.util.LuceneTestCase;
import org.apache.lucene.util.BytesRef;
import org.apache.lucene.util.automaton.Automata;
import org.apache.lucene.util.automaton.CharacterRunAutomaton;
+import org.apache.lucene.util.automaton.Operations;
import org.apache.lucene.util.automaton.RegExp;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
@@ -985,8 +986,14 @@ public class TestHighlighter extends BaseTokenStreamTestCase implements Formatte
@Override
public void run() throws Exception {
numHighlights = 0;
- FuzzyQuery fuzzyQuery = new FuzzyQuery(new Term(FIELD_NAME, "kinnedy"), 2);
- fuzzyQuery.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+ FuzzyQuery fuzzyQuery =
+ new FuzzyQuery(
+ new Term(FIELD_NAME, "kinnedy"),
+ 2,
+ FuzzyQuery.defaultPrefixLength,
+ FuzzyQuery.defaultMaxExpansions,
+ FuzzyQuery.defaultTranspositions,
+ MultiTermQuery.SCORING_BOOLEAN_REWRITE);
doSearching(fuzzyQuery);
doStandardHighlights(analyzer, searcher, hits, query, TestHighlighter.this, true);
assertTrue(
@@ -1005,8 +1012,11 @@ public class TestHighlighter extends BaseTokenStreamTestCase implements Formatte
@Override
public void run() throws Exception {
numHighlights = 0;
- WildcardQuery wildcardQuery = new WildcardQuery(new Term(FIELD_NAME, "k?nnedy"));
- wildcardQuery.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+ WildcardQuery wildcardQuery =
+ new WildcardQuery(
+ new Term(FIELD_NAME, "k?nnedy"),
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ MultiTermQuery.SCORING_BOOLEAN_REWRITE);
doSearching(wildcardQuery);
doStandardHighlights(analyzer, searcher, hits, query, TestHighlighter.this);
assertTrue(
@@ -1025,8 +1035,11 @@ public class TestHighlighter extends BaseTokenStreamTestCase implements Formatte
@Override
public void run() throws Exception {
numHighlights = 0;
- WildcardQuery wildcardQuery = new WildcardQuery(new Term(FIELD_NAME, "k*dy"));
- wildcardQuery.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+ WildcardQuery wildcardQuery =
+ new WildcardQuery(
+ new Term(FIELD_NAME, "k*dy"),
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ MultiTermQuery.SCORING_BOOLEAN_REWRITE);
doSearching(wildcardQuery);
doStandardHighlights(analyzer, searcher, hits, query, TestHighlighter.this);
assertTrue(
@@ -1050,12 +1063,14 @@ public class TestHighlighter extends BaseTokenStreamTestCase implements Formatte
// rather
// than RangeFilters
- TermRangeQuery rangeQuery =
+ query =
new TermRangeQuery(
- FIELD_NAME, new BytesRef("kannedy"), new BytesRef("kznnedy"), true, true);
- rangeQuery.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
-
- query = rangeQuery;
+ FIELD_NAME,
+ new BytesRef("kannedy"),
+ new BytesRef("kznnedy"),
+ true,
+ true,
+ MultiTermQuery.SCORING_BOOLEAN_REWRITE);
doSearching(query);
doStandardHighlights(analyzer, searcher, hits, query, TestHighlighter.this);
@@ -1072,8 +1087,11 @@ public class TestHighlighter extends BaseTokenStreamTestCase implements Formatte
numHighlights = 0;
- query = new WildcardQuery(new Term(FIELD_NAME, "ken*"));
- ((WildcardQuery) query).setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
+ query =
+ new WildcardQuery(
+ new Term(FIELD_NAME, "ken*"),
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ MultiTermQuery.CONSTANT_SCORE_REWRITE);
searcher = newSearcher(reader);
// can't rewrite ConstantScore if you want to highlight it -
// it rewrites to ConstantScoreQuery which cannot be highlighted
@@ -1288,8 +1306,9 @@ public class TestHighlighter extends BaseTokenStreamTestCase implements Formatte
numHighlights = 0;
BooleanQuery.Builder booleanQuery = new BooleanQuery.Builder();
booleanQuery.add(new TermQuery(new Term(FIELD_NAME, "john")), Occur.SHOULD);
- PrefixQuery prefixQuery = new PrefixQuery(new Term(FIELD_NAME, "kenn"));
- prefixQuery.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+ PrefixQuery prefixQuery =
+ new PrefixQuery(
+ new Term(FIELD_NAME, "kenn"), MultiTermQuery.SCORING_BOOLEAN_REWRITE);
booleanQuery.add(prefixQuery, Occur.SHOULD);
doSearching(booleanQuery.build());
diff --git a/lucene/join/src/java/org/apache/lucene/search/join/TermsQuery.java b/lucene/join/src/java/org/apache/lucene/search/join/TermsQuery.java
index 67d6336dd2f..29f02e57597 100644
--- a/lucene/join/src/java/org/apache/lucene/search/join/TermsQuery.java
+++ b/lucene/join/src/java/org/apache/lucene/search/join/TermsQuery.java
@@ -63,7 +63,7 @@ class TermsQuery extends MultiTermQuery implements Accountable {
String fromField,
Query fromQuery,
Object indexReaderContextId) {
- super(toField);
+ super(toField, CONSTANT_SCORE_REWRITE);
this.terms = terms;
ords = terms.sort();
this.fromField = fromField;
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParserBase.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParserBase.java
index 0595b86e56f..433e8243cc6 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParserBase.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParserBase.java
@@ -541,9 +541,7 @@ public abstract class QueryParserBase extends QueryBuilder
* @return new PrefixQuery instance
*/
protected Query newPrefixQuery(Term prefix) {
- PrefixQuery query = new PrefixQuery(prefix);
- query.setRewriteMethod(multiTermRewriteMethod);
- return query;
+ return new PrefixQuery(prefix, multiTermRewriteMethod);
}
/**
@@ -553,9 +551,13 @@ public abstract class QueryParserBase extends QueryBuilder
* @return new RegexpQuery instance
*/
protected Query newRegexpQuery(Term regexp) {
- RegexpQuery query = new RegexpQuery(regexp, RegExp.ALL, determinizeWorkLimit);
- query.setRewriteMethod(multiTermRewriteMethod);
- return query;
+ return new RegexpQuery(
+ regexp,
+ RegExp.ALL,
+ 0,
+ RegexpQuery.DEFAULT_PROVIDER,
+ determinizeWorkLimit,
+ multiTermRewriteMethod);
}
/**
@@ -601,11 +603,8 @@ public abstract class QueryParserBase extends QueryBuilder
end = getAnalyzer().normalize(field, part2);
}
- final TermRangeQuery query =
- new TermRangeQuery(field, start, end, startInclusive, endInclusive);
-
- query.setRewriteMethod(multiTermRewriteMethod);
- return query;
+ return new TermRangeQuery(
+ field, start, end, startInclusive, endInclusive, multiTermRewriteMethod);
}
/**
@@ -624,9 +623,7 @@ public abstract class QueryParserBase extends QueryBuilder
* @return new WildcardQuery instance
*/
protected Query newWildcardQuery(Term t) {
- WildcardQuery query = new WildcardQuery(t, determinizeWorkLimit);
- query.setRewriteMethod(multiTermRewriteMethod);
- return query;
+ return new WildcardQuery(t, determinizeWorkLimit, multiTermRewriteMethod);
}
/**
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/PrefixWildcardQueryNodeBuilder.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/PrefixWildcardQueryNodeBuilder.java
index 3f0927930cc..55f230b93d9 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/PrefixWildcardQueryNodeBuilder.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/PrefixWildcardQueryNodeBuilder.java
@@ -36,16 +36,15 @@ public class PrefixWildcardQueryNodeBuilder implements StandardQueryBuilder {
PrefixWildcardQueryNode wildcardNode = (PrefixWildcardQueryNode) queryNode;
- String text =
- wildcardNode.getText().subSequence(0, wildcardNode.getText().length() - 1).toString();
- PrefixQuery q = new PrefixQuery(new Term(wildcardNode.getFieldAsString(), text));
-
MultiTermQuery.RewriteMethod method =
(MultiTermQuery.RewriteMethod) queryNode.getTag(MultiTermRewriteMethodProcessor.TAG_ID);
- if (method != null) {
- q.setRewriteMethod(method);
+ if (method == null) {
+ method = MultiTermQuery.CONSTANT_SCORE_REWRITE;
}
- return q;
+ String text =
+ wildcardNode.getText().subSequence(0, wildcardNode.getText().length() - 1).toString();
+
+ return new PrefixQuery(new Term(wildcardNode.getFieldAsString(), text), method);
}
}
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/RegexpQueryNodeBuilder.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/RegexpQueryNodeBuilder.java
index ac64f6bad8a..a124caa2363 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/RegexpQueryNodeBuilder.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/RegexpQueryNodeBuilder.java
@@ -23,6 +23,8 @@ import org.apache.lucene.queryparser.flexible.standard.nodes.RegexpQueryNode;
import org.apache.lucene.queryparser.flexible.standard.processors.MultiTermRewriteMethodProcessor;
import org.apache.lucene.search.MultiTermQuery;
import org.apache.lucene.search.RegexpQuery;
+import org.apache.lucene.util.automaton.Operations;
+import org.apache.lucene.util.automaton.RegExp;
/** Builds a {@link RegexpQuery} object from a {@link RegexpQueryNode} object. */
public class RegexpQueryNodeBuilder implements StandardQueryBuilder {
@@ -35,16 +37,19 @@ public class RegexpQueryNodeBuilder implements StandardQueryBuilder {
public RegexpQuery build(QueryNode queryNode) throws QueryNodeException {
RegexpQueryNode regexpNode = (RegexpQueryNode) queryNode;
- // TODO: make the maxStates configurable w/ a reasonable default (QueryParserBase uses 10000)
- RegexpQuery q =
- new RegexpQuery(new Term(regexpNode.getFieldAsString(), regexpNode.textToBytesRef()));
-
MultiTermQuery.RewriteMethod method =
(MultiTermQuery.RewriteMethod) queryNode.getTag(MultiTermRewriteMethodProcessor.TAG_ID);
- if (method != null) {
- q.setRewriteMethod(method);
+ if (method == null) {
+ method = MultiTermQuery.CONSTANT_SCORE_REWRITE;
}
- return q;
+ // TODO: make the maxStates configurable w/ a reasonable default (QueryParserBase uses 10000)
+ return new RegexpQuery(
+ new Term(regexpNode.getFieldAsString(), regexpNode.textToBytesRef()),
+ RegExp.ALL,
+ 0,
+ name -> null,
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ method);
}
}
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/TermRangeQueryNodeBuilder.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/TermRangeQueryNodeBuilder.java
index 929a952bf87..05766f51de9 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/TermRangeQueryNodeBuilder.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/TermRangeQueryNodeBuilder.java
@@ -50,20 +50,18 @@ public class TermRangeQueryNodeBuilder implements StandardQueryBuilder {
upperText = null;
}
- TermRangeQuery rangeQuery =
- TermRangeQuery.newStringRange(
- field,
- lowerText,
- upperText,
- rangeNode.isLowerInclusive(),
- rangeNode.isUpperInclusive());
-
MultiTermQuery.RewriteMethod method =
(MultiTermQuery.RewriteMethod) queryNode.getTag(MultiTermRewriteMethodProcessor.TAG_ID);
- if (method != null) {
- rangeQuery.setRewriteMethod(method);
+ if (method == null) {
+ method = MultiTermQuery.CONSTANT_SCORE_REWRITE;
}
- return rangeQuery;
+ return TermRangeQuery.newStringRange(
+ field,
+ lowerText,
+ upperText,
+ rangeNode.isLowerInclusive(),
+ rangeNode.isUpperInclusive(),
+ method);
}
}
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/WildcardQueryNodeBuilder.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/WildcardQueryNodeBuilder.java
index d2b1a731352..93bee367d5c 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/WildcardQueryNodeBuilder.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/WildcardQueryNodeBuilder.java
@@ -23,6 +23,7 @@ import org.apache.lucene.queryparser.flexible.standard.nodes.WildcardQueryNode;
import org.apache.lucene.queryparser.flexible.standard.processors.MultiTermRewriteMethodProcessor;
import org.apache.lucene.search.MultiTermQuery;
import org.apache.lucene.search.WildcardQuery;
+import org.apache.lucene.util.automaton.Operations;
/** Builds a {@link WildcardQuery} object from a {@link WildcardQueryNode} object. */
public class WildcardQueryNodeBuilder implements StandardQueryBuilder {
@@ -35,16 +36,15 @@ public class WildcardQueryNodeBuilder implements StandardQueryBuilder {
public WildcardQuery build(QueryNode queryNode) throws QueryNodeException {
WildcardQueryNode wildcardNode = (WildcardQueryNode) queryNode;
- WildcardQuery q =
- new WildcardQuery(
- new Term(wildcardNode.getFieldAsString(), wildcardNode.getTextAsString()));
-
MultiTermQuery.RewriteMethod method =
(MultiTermQuery.RewriteMethod) queryNode.getTag(MultiTermRewriteMethodProcessor.TAG_ID);
- if (method != null) {
- q.setRewriteMethod(method);
+ if (method == null) {
+ method = MultiTermQuery.CONSTANT_SCORE_REWRITE;
}
- return q;
+ return new WildcardQuery(
+ new Term(wildcardNode.getFieldAsString(), wildcardNode.getTextAsString()),
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ method);
}
}
diff --git a/lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/standard/TestQPHelper.java b/lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/standard/TestQPHelper.java
index 66a8ccd0c78..a927aafbb23 100644
--- a/lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/standard/TestQPHelper.java
+++ b/lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/standard/TestQPHelper.java
@@ -77,6 +77,7 @@ import org.apache.lucene.tests.analysis.MockTokenizer;
import org.apache.lucene.tests.util.LuceneTestCase;
import org.apache.lucene.util.automaton.Automata;
import org.apache.lucene.util.automaton.CharacterRunAutomaton;
+import org.apache.lucene.util.automaton.Operations;
import org.apache.lucene.util.automaton.RegExp;
import org.junit.AfterClass;
import org.junit.BeforeClass;
@@ -1151,14 +1152,6 @@ public class TestQPHelper extends LuceneTestCase {
assertEquals(q, qp.parse("/[a-z][123]/", df));
assertEquals(q, qp.parse("/[A-Z][123]/", df));
assertEquals(new BoostQuery(q, 0.5f), qp.parse("/[A-Z][123]/^0.5", df));
- qp.setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
- q.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
- assertEquals(new BoostQuery(q, 0.5f), qp.parse("/[A-Z][123]/^0.5", df));
- assertEquals(
- MultiTermQuery.SCORING_BOOLEAN_REWRITE,
- ((RegexpQuery) (((BoostQuery) qp.parse("/[A-Z][123]/^0.5", df)).getQuery()))
- .getRewriteMethod());
- qp.setMultiTermRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
Query escaped = new RegexpQuery(new Term("field", "[a-z]\\/[123]"));
assertEquals(escaped, qp.parse("/[a-z]\\/[123]/", df));
@@ -1197,6 +1190,22 @@ public class TestQPHelper extends LuceneTestCase {
two.add(new RegexpQuery(new Term("field", "bar")), Occur.SHOULD);
assertEquals(two.build(), qp.parse("field:/foo/ field:/bar/", df));
assertEquals(two.build(), qp.parse("/foo/ /bar/", df));
+
+ qp.setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+ q =
+ new RegexpQuery(
+ new Term("field", "[a-z][123]"),
+ RegExp.ALL,
+ 0,
+ name -> null,
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+ assertEquals(new BoostQuery(q, 0.5f), qp.parse("/[A-Z][123]/^0.5", df));
+ assertEquals(
+ MultiTermQuery.SCORING_BOOLEAN_REWRITE,
+ ((RegexpQuery) (((BoostQuery) qp.parse("/[A-Z][123]/^0.5", df)).getQuery()))
+ .getRewriteMethod());
+ qp.setMultiTermRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
}
public void testStopwords() throws Exception {
diff --git a/lucene/queryparser/src/test/org/apache/lucene/queryparser/util/QueryParserTestBase.java b/lucene/queryparser/src/test/org/apache/lucene/queryparser/util/QueryParserTestBase.java
index f7f59d6930f..6a5b385d73c 100644
--- a/lucene/queryparser/src/test/org/apache/lucene/queryparser/util/QueryParserTestBase.java
+++ b/lucene/queryparser/src/test/org/apache/lucene/queryparser/util/QueryParserTestBase.java
@@ -66,6 +66,7 @@ import org.apache.lucene.tests.analysis.MockTokenizer;
import org.apache.lucene.tests.util.LuceneTestCase;
import org.apache.lucene.util.automaton.Automata;
import org.apache.lucene.util.automaton.CharacterRunAutomaton;
+import org.apache.lucene.util.automaton.Operations;
import org.apache.lucene.util.automaton.RegExp;
import org.junit.AfterClass;
import org.junit.BeforeClass;
@@ -1035,16 +1036,6 @@ public abstract class QueryParserTestBase extends LuceneTestCase {
assertEquals(q, getQuery("/[a-z][123]/", qp));
assertEquals(q, getQuery("/[A-Z][123]/", qp));
assertEquals(new BoostQuery(q, 0.5f), getQuery("/[A-Z][123]/^0.5", qp));
- qp.setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
- q.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
- assertTrue(getQuery("/[A-Z][123]/^0.5", qp) instanceof BoostQuery);
- assertTrue(((BoostQuery) getQuery("/[A-Z][123]/^0.5", qp)).getQuery() instanceof RegexpQuery);
- assertEquals(
- MultiTermQuery.SCORING_BOOLEAN_REWRITE,
- ((RegexpQuery) ((BoostQuery) getQuery("/[A-Z][123]/^0.5", qp)).getQuery())
- .getRewriteMethod());
- assertEquals(new BoostQuery(q, 0.5f), getQuery("/[A-Z][123]/^0.5", qp));
- qp.setMultiTermRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
Query escaped = new RegexpQuery(new Term("field", "[a-z]\\/[123]"));
assertEquals(escaped, getQuery("/[a-z]\\/[123]/", qp));
@@ -1080,6 +1071,23 @@ public abstract class QueryParserTestBase extends LuceneTestCase {
two.add(new RegexpQuery(new Term("field", "bar")), Occur.SHOULD);
assertEquals(two.build(), getQuery("field:/foo/ field:/bar/", qp));
assertEquals(two.build(), getQuery("/foo/ /bar/", qp));
+
+ qp.setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+ q =
+ new RegexpQuery(
+ new Term("field", "[a-z][123]"),
+ RegExp.ALL,
+ 0,
+ name -> null,
+ Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+ MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+ assertTrue(getQuery("/[A-Z][123]/^0.5", qp) instanceof BoostQuery);
+ assertTrue(((BoostQuery) getQuery("/[A-Z][123]/^0.5", qp)).getQuery() instanceof RegexpQuery);
+ assertEquals(
+ MultiTermQuery.SCORING_BOOLEAN_REWRITE,
+ ((RegexpQuery) ((BoostQuery) getQuery("/[A-Z][123]/^0.5", qp)).getQuery())
+ .getRewriteMethod());
+ assertEquals(new BoostQuery(q, 0.5f), getQuery("/[A-Z][123]/^0.5", qp));
}
public void testStopwords() throws Exception {