Apache Lucene open-source search software
LUCENE-10431: Deprecate MultiTermQuery.setRewriteMethod() (#722)
Alan Woodward3f994dec53a1
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txtindex 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 longersupported 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.javaindex 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 textreturn 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.javaindex 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.javaindex 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.javaindex 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 TopTermsScoringBooleanQueryRewriteextends 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 TopTermsBlendedFreqScoringRewriteextends 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 TopTermsBoostOnlyBooleanQueryRewriteextends 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*/+ @Deprecatedpublic 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.javaindex 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.javaindex 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.javaindex 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.javaindex 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.javaindex 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.javaindex 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.javaindex 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.javaindex 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.javaindex 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.javaindex 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 */@Overrideprotected 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.javaindex 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.javaindex 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);}@Testdiff --git a/lucene/core/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java b/lucene/core/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.javaindex 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) {@Overrideprotected TermsEnum getTermsEnum(Terms terms, AttributeSource atts) throws IOException {return new FilteredTermsEnum(terms.iterator()) {@@ -198,7 +197,6 @@ public class TestMultiTermQueryRewrites extends LuceneTestCase {@Overridepublic 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.javaindex 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.javaindex 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.javaindex 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.javaindex 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.javaindex 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@Overridepublic 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@Overridepublic 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@Overridepublic 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 FormattenumHighlights = 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 FormattenumHighlights = 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.javaindex 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.javaindex 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 QueryBuilderend = 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.javaindex 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.javaindex 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.javaindex 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.javaindex 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.javaindex 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.javaindex 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 {