Apache Lucene open-source search software
GITHUB-11838 Change API to allow concurrent query rewrite (#11840)
Patrick Zhai6cde41c9fd8c
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txtindex 16e7bed965c..fda2bf447c4 100644--- a/lucene/CHANGES.txt+++ b/lucene/CHANGES.txt@@ -34,6 +34,9 @@ API Changes* GITHUB#11813: Remove Operations.isFinite: the recursive implementation could be problematicfor large automatons (WildcardQuery, PrefixQuery, RegExpQuery, etc). (taroplus, Robert Muir)+* GITHUB#11840: Query rewrite now takes an IndexSearcher instead of IndexReader to enable concurrent+ rewriting. (Patrick Zhai)+New Features---------------------diff --git a/lucene/classification/src/java/org/apache/lucene/classification/utils/NearestFuzzyQuery.java b/lucene/classification/src/java/org/apache/lucene/classification/utils/NearestFuzzyQuery.javaindex c020d7487cb..12d11e59b9d 100644--- a/lucene/classification/src/java/org/apache/lucene/classification/utils/NearestFuzzyQuery.java+++ b/lucene/classification/src/java/org/apache/lucene/classification/utils/NearestFuzzyQuery.java@@ -35,6 +35,7 @@ import org.apache.lucene.search.BooleanClause;import org.apache.lucene.search.BooleanQuery;import org.apache.lucene.search.BoostQuery;import org.apache.lucene.search.FuzzyTermsEnum;+import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.Query;import org.apache.lucene.search.QueryVisitor;import org.apache.lucene.search.TermQuery;@@ -214,7 +215,8 @@ public class NearestFuzzyQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ IndexReader reader = indexSearcher.getIndexReader();ScoreTermQueue q = new ScoreTermQueue(MAX_NUM_TERMS);// load up the list of possible termsfor (FieldVals f : fieldVals) {diff --git a/lucene/core/src/java/org/apache/lucene/document/BinaryRangeFieldRangeQuery.java b/lucene/core/src/java/org/apache/lucene/document/BinaryRangeFieldRangeQuery.javaindex f5ceb64a901..b8ebf578594 100644--- a/lucene/core/src/java/org/apache/lucene/document/BinaryRangeFieldRangeQuery.java+++ b/lucene/core/src/java/org/apache/lucene/document/BinaryRangeFieldRangeQuery.java@@ -22,7 +22,6 @@ import java.util.Arrays;import java.util.Objects;import org.apache.lucene.index.BinaryDocValues;import org.apache.lucene.index.DocValues;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.search.ConstantScoreScorer;@@ -87,8 +86,8 @@ abstract class BinaryRangeFieldRangeQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {- return super.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ return super.rewrite(indexSearcher);}private BinaryRangeDocValues getValues(LeafReader reader, String field) throws IOException {diff --git a/lucene/core/src/java/org/apache/lucene/document/DoubleRangeSlowRangeQuery.java b/lucene/core/src/java/org/apache/lucene/document/DoubleRangeSlowRangeQuery.javaindex 6406b1be81a..f0f9040d08c 100644--- a/lucene/core/src/java/org/apache/lucene/document/DoubleRangeSlowRangeQuery.java+++ b/lucene/core/src/java/org/apache/lucene/document/DoubleRangeSlowRangeQuery.java@@ -20,7 +20,7 @@ package org.apache.lucene.document;import java.io.IOException;import java.util.Arrays;import java.util.Objects;-import org.apache.lucene.index.IndexReader;+import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.Query;import org.apache.lucene.search.QueryVisitor;@@ -79,8 +79,8 @@ class DoubleRangeSlowRangeQuery extends BinaryRangeFieldRangeQuery {}@Override- public Query rewrite(IndexReader reader) throws IOException {- return super.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ return super.rewrite(indexSearcher);}private static byte[] encodeRanges(double[] min, double[] max) {diff --git a/lucene/core/src/java/org/apache/lucene/document/FeatureField.java b/lucene/core/src/java/org/apache/lucene/document/FeatureField.javaindex 27e68964459..85c3bad3519 100644--- a/lucene/core/src/java/org/apache/lucene/document/FeatureField.java+++ b/lucene/core/src/java/org/apache/lucene/document/FeatureField.java@@ -31,6 +31,7 @@ import org.apache.lucene.search.BoostQuery;import org.apache.lucene.search.DoubleValuesSource;import org.apache.lucene.search.Explanation;import org.apache.lucene.search.FieldDoc;+import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.Query;import org.apache.lucene.search.SortField;import org.apache.lucene.search.similarities.BM25Similarity;@@ -223,7 +224,7 @@ public final class FeatureField extends Field {abstract Explanation explain(String field, String feature, float w, int freq);- FeatureFunction rewrite(IndexReader reader) throws IOException {+ FeatureFunction rewrite(IndexSearcher indexSearcher) throws IOException {return this;}}@@ -340,11 +341,11 @@ public final class FeatureField extends Field {}@Override- public FeatureFunction rewrite(IndexReader reader) throws IOException {+ public FeatureFunction rewrite(IndexSearcher indexSearcher) throws IOException {if (pivot != null) {- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}- float newPivot = computePivotFeatureValue(reader, field, feature);+ float newPivot = computePivotFeatureValue(indexSearcher.getIndexReader(), field, feature);return new SaturationFunction(field, feature, newPivot);}diff --git a/lucene/core/src/java/org/apache/lucene/document/FeatureQuery.java b/lucene/core/src/java/org/apache/lucene/document/FeatureQuery.javaindex 5d8350c4d51..fcd28a3d2ec 100644--- a/lucene/core/src/java/org/apache/lucene/document/FeatureQuery.java+++ b/lucene/core/src/java/org/apache/lucene/document/FeatureQuery.java@@ -20,7 +20,6 @@ import java.io.IOException;import java.util.Objects;import org.apache.lucene.document.FeatureField.FeatureFunction;import org.apache.lucene.index.ImpactsEnum;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.PostingsEnum;import org.apache.lucene.index.Terms;@@ -50,12 +49,12 @@ final class FeatureQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {- FeatureFunction rewritten = function.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ FeatureFunction rewritten = function.rewrite(indexSearcher);if (function != rewritten) {return new FeatureQuery(fieldName, featureName, rewritten);}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/core/src/java/org/apache/lucene/document/FloatRangeSlowRangeQuery.java b/lucene/core/src/java/org/apache/lucene/document/FloatRangeSlowRangeQuery.javaindex 9c011621e06..62981f4870a 100644--- a/lucene/core/src/java/org/apache/lucene/document/FloatRangeSlowRangeQuery.java+++ b/lucene/core/src/java/org/apache/lucene/document/FloatRangeSlowRangeQuery.java@@ -20,7 +20,7 @@ package org.apache.lucene.document;import java.io.IOException;import java.util.Arrays;import java.util.Objects;-import org.apache.lucene.index.IndexReader;+import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.Query;import org.apache.lucene.search.QueryVisitor;@@ -79,8 +79,8 @@ class FloatRangeSlowRangeQuery extends BinaryRangeFieldRangeQuery {}@Override- public Query rewrite(IndexReader reader) throws IOException {- return super.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ return super.rewrite(indexSearcher);}private static byte[] encodeRanges(float[] min, float[] max) {diff --git a/lucene/core/src/java/org/apache/lucene/document/IntRangeSlowRangeQuery.java b/lucene/core/src/java/org/apache/lucene/document/IntRangeSlowRangeQuery.javaindex cd0714a5290..99d5fa212f6 100644--- a/lucene/core/src/java/org/apache/lucene/document/IntRangeSlowRangeQuery.java+++ b/lucene/core/src/java/org/apache/lucene/document/IntRangeSlowRangeQuery.java@@ -19,7 +19,7 @@ package org.apache.lucene.document;import java.io.IOException;import java.util.Arrays;import java.util.Objects;-import org.apache.lucene.index.IndexReader;+import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.Query;import org.apache.lucene.search.QueryVisitor;@@ -77,8 +77,8 @@ class IntRangeSlowRangeQuery extends BinaryRangeFieldRangeQuery {}@Override- public Query rewrite(IndexReader reader) throws IOException {- return super.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ return super.rewrite(indexSearcher);}private static byte[] encodeRanges(int[] min, int[] max) {diff --git a/lucene/core/src/java/org/apache/lucene/document/LongRangeSlowRangeQuery.java b/lucene/core/src/java/org/apache/lucene/document/LongRangeSlowRangeQuery.javaindex a4c164524fc..b86d64bef62 100644--- a/lucene/core/src/java/org/apache/lucene/document/LongRangeSlowRangeQuery.java+++ b/lucene/core/src/java/org/apache/lucene/document/LongRangeSlowRangeQuery.java@@ -20,7 +20,7 @@ package org.apache.lucene.document;import java.io.IOException;import java.util.Arrays;import java.util.Objects;-import org.apache.lucene.index.IndexReader;+import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.Query;import org.apache.lucene.search.QueryVisitor;@@ -79,8 +79,8 @@ class LongRangeSlowRangeQuery extends BinaryRangeFieldRangeQuery {}@Override- public Query rewrite(IndexReader reader) throws IOException {- return super.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ return super.rewrite(indexSearcher);}private static byte[] encodeRanges(long[] min, long[] max) {diff --git a/lucene/core/src/java/org/apache/lucene/document/SortedNumericDocValuesRangeQuery.java b/lucene/core/src/java/org/apache/lucene/document/SortedNumericDocValuesRangeQuery.javaindex 1fd5aa3bb8f..8aa01815d11 100644--- a/lucene/core/src/java/org/apache/lucene/document/SortedNumericDocValuesRangeQuery.java+++ b/lucene/core/src/java/org/apache/lucene/document/SortedNumericDocValuesRangeQuery.java@@ -19,7 +19,6 @@ package org.apache.lucene.document;import java.io.IOException;import java.util.Objects;import org.apache.lucene.index.DocValues;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.NumericDocValues;@@ -89,11 +88,11 @@ abstract class SortedNumericDocValuesRangeQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {if (lowerValue == Long.MIN_VALUE && upperValue == Long.MAX_VALUE) {return new FieldExistsQuery(field);}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}abstract SortedNumericDocValues getValues(LeafReader reader, String field) throws IOException;diff --git a/lucene/core/src/java/org/apache/lucene/document/SortedSetDocValuesRangeQuery.java b/lucene/core/src/java/org/apache/lucene/document/SortedSetDocValuesRangeQuery.javaindex 776ef988f28..cc9cbc45d0f 100644--- a/lucene/core/src/java/org/apache/lucene/document/SortedSetDocValuesRangeQuery.java+++ b/lucene/core/src/java/org/apache/lucene/document/SortedSetDocValuesRangeQuery.java@@ -19,7 +19,6 @@ package org.apache.lucene.document;import java.io.IOException;import java.util.Objects;import org.apache.lucene.index.DocValues;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.SortedDocValues;@@ -103,11 +102,11 @@ abstract class SortedSetDocValuesRangeQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {if (lowerValue == null && upperValue == null) {return new FieldExistsQuery(field);}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}abstract SortedSetDocValues getValues(LeafReader reader, String field) throws IOException;diff --git a/lucene/core/src/java/org/apache/lucene/search/BlendedTermQuery.java b/lucene/core/src/java/org/apache/lucene/search/BlendedTermQuery.javaindex e9a135f88d3..507b4911ae6 100644--- a/lucene/core/src/java/org/apache/lucene/search/BlendedTermQuery.java+++ b/lucene/core/src/java/org/apache/lucene/search/BlendedTermQuery.java@@ -19,7 +19,6 @@ package org.apache.lucene.search;import java.io.IOException;import java.util.Arrays;import java.util.List;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.IndexReaderContext;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.Term;@@ -268,11 +267,12 @@ public final class BlendedTermQuery extends Query {}@Override- public final Query rewrite(IndexReader reader) throws IOException {+ public final Query rewrite(IndexSearcher indexSearcher) throws IOException {final TermStates[] contexts = ArrayUtil.copyOfSubArray(this.contexts, 0, this.contexts.length);for (int i = 0; i < contexts.length; ++i) {- if (contexts[i] == null || contexts[i].wasBuiltFor(reader.getContext()) == false) {- contexts[i] = TermStates.build(reader.getContext(), terms[i], true);+ if (contexts[i] == null+ || contexts[i].wasBuiltFor(indexSearcher.getTopReaderContext()) == false) {+ contexts[i] = TermStates.build(indexSearcher.getTopReaderContext(), terms[i], true);}}@@ -287,7 +287,7 @@ public final class BlendedTermQuery extends Query {}for (int i = 0; i < contexts.length; ++i) {- contexts[i] = adjustFrequencies(reader.getContext(), contexts[i], df, ttf);+ contexts[i] = adjustFrequencies(indexSearcher.getTopReaderContext(), contexts[i], df, ttf);}Query[] termQueries = new Query[terms.length];diff --git a/lucene/core/src/java/org/apache/lucene/search/BooleanQuery.java b/lucene/core/src/java/org/apache/lucene/search/BooleanQuery.javaindex c7bf1b39d01..0354280eb01 100644--- a/lucene/core/src/java/org/apache/lucene/search/BooleanQuery.java+++ b/lucene/core/src/java/org/apache/lucene/search/BooleanQuery.java@@ -30,7 +30,6 @@ import java.util.Map;import java.util.Objects;import java.util.Set;import java.util.function.Predicate;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.search.BooleanClause.Occur;/**@@ -193,7 +192,7 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {// Utility method for rewriting BooleanQuery when scores are not needed.// This is called from ConstantScoreQuery#rewrite- BooleanQuery rewriteNoScoring(IndexReader reader) throws IOException {+ BooleanQuery rewriteNoScoring(IndexSearcher indexSearcher) throws IOException {boolean actuallyRewritten = false;BooleanQuery.Builder newQuery =new BooleanQuery.Builder().setMinimumNumberShouldMatch(getMinimumNumberShouldMatch());@@ -204,7 +203,7 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {for (BooleanClause clause : clauses) {Query query = clause.getQuery();- Query rewritten = new ConstantScoreQuery(query).rewrite(reader);+ Query rewritten = new ConstantScoreQuery(query).rewrite(indexSearcher);if (rewritten instanceof ConstantScoreQuery) {rewritten = ((ConstantScoreQuery) rewritten).getQuery();}@@ -238,7 +237,7 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {if (clauses.size() == 0) {return new MatchNoDocsQuery("empty BooleanQuery");}@@ -277,12 +276,12 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {Query rewritten;if (occur == Occur.FILTER || occur == Occur.MUST_NOT) {// Clauses that are not involved in scoring can get some extra simplifications- rewritten = new ConstantScoreQuery(query).rewrite(reader);+ rewritten = new ConstantScoreQuery(query).rewrite(indexSearcher);if (rewritten instanceof ConstantScoreQuery) {rewritten = ((ConstantScoreQuery) rewritten).getQuery();}} else {- rewritten = query.rewrite(reader);+ rewritten = query.rewrite(indexSearcher);}if (rewritten != query || query.getClass() == MatchNoDocsQuery.class) {// rewrite clause@@ -557,7 +556,7 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {}}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/core/src/java/org/apache/lucene/search/BoostQuery.java b/lucene/core/src/java/org/apache/lucene/search/BoostQuery.javaindex 47c0f5f6f28..37526963700 100644--- a/lucene/core/src/java/org/apache/lucene/search/BoostQuery.java+++ b/lucene/core/src/java/org/apache/lucene/search/BoostQuery.java@@ -18,7 +18,6 @@ package org.apache.lucene.search;import java.io.IOException;import java.util.Objects;-import org.apache.lucene.index.IndexReader;/*** A {@link Query} wrapper that allows to give a boost to the wrapped query. Boost values that are@@ -73,8 +72,8 @@ public final class BoostQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {- final Query rewritten = query.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ final Query rewritten = query.rewrite(indexSearcher);if (boost == 1f) {return rewritten;@@ -99,7 +98,7 @@ public final class BoostQuery extends Query {return new BoostQuery(rewritten, boost);}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/core/src/java/org/apache/lucene/search/ConstantScoreQuery.java b/lucene/core/src/java/org/apache/lucene/search/ConstantScoreQuery.javaindex c8a0b2ecc37..1984cacccbe 100644--- a/lucene/core/src/java/org/apache/lucene/search/ConstantScoreQuery.java+++ b/lucene/core/src/java/org/apache/lucene/search/ConstantScoreQuery.java@@ -18,7 +18,6 @@ package org.apache.lucene.search;import java.io.IOException;import java.util.Objects;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.util.Bits;@@ -40,8 +39,9 @@ public final class ConstantScoreQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {- Query rewritten = query.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {++ Query rewritten = query.rewrite(indexSearcher);// Do some extra simplifications that are legal since scores are not needed on the wrapped// query.@@ -50,7 +50,7 @@ public final class ConstantScoreQuery extends Query {} else if (rewritten instanceof ConstantScoreQuery) {rewritten = ((ConstantScoreQuery) rewritten).getQuery();} else if (rewritten instanceof BooleanQuery) {- rewritten = ((BooleanQuery) rewritten).rewriteNoScoring(reader);+ rewritten = ((BooleanQuery) rewritten).rewriteNoScoring(indexSearcher);}if (rewritten.getClass() == MatchNoDocsQuery.class) {@@ -70,7 +70,7 @@ public final class ConstantScoreQuery extends Query {return new ConstantScoreQuery(((BoostQuery) rewritten).getQuery());}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/core/src/java/org/apache/lucene/search/DisjunctionMaxQuery.java b/lucene/core/src/java/org/apache/lucene/search/DisjunctionMaxQuery.javaindex fdfe314da12..29772154b16 100644--- a/lucene/core/src/java/org/apache/lucene/search/DisjunctionMaxQuery.java+++ b/lucene/core/src/java/org/apache/lucene/search/DisjunctionMaxQuery.java@@ -23,7 +23,6 @@ import java.util.Collections;import java.util.Iterator;import java.util.List;import java.util.Objects;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;/**@@ -208,11 +207,10 @@ public final class DisjunctionMaxQuery extends Query implements Iterable<Query>/*** Optimize our representation and our subqueries representations*- * @param reader the IndexReader we query* @return an optimized copy of us (which may not be a copy if there is nothing to optimize)*/@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {if (disjuncts.isEmpty()) {return new MatchNoDocsQuery("empty DisjunctionMaxQuery");}@@ -232,7 +230,7 @@ public final class DisjunctionMaxQuery extends Query implements Iterable<Query>boolean actuallyRewritten = false;List<Query> rewrittenDisjuncts = new ArrayList<>();for (Query sub : disjuncts) {- Query rewrittenSub = sub.rewrite(reader);+ Query rewrittenSub = sub.rewrite(indexSearcher);actuallyRewritten |= rewrittenSub != sub;rewrittenDisjuncts.add(rewrittenSub);}@@ -241,7 +239,7 @@ public final class DisjunctionMaxQuery extends Query implements Iterable<Query>return new DisjunctionMaxQuery(rewrittenDisjuncts, tieBreakerMultiplier);}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/core/src/java/org/apache/lucene/search/DocValuesRewriteMethod.java b/lucene/core/src/java/org/apache/lucene/search/DocValuesRewriteMethod.javaindex e0e9efc7822..d450205f330 100644--- a/lucene/core/src/java/org/apache/lucene/search/DocValuesRewriteMethod.java+++ b/lucene/core/src/java/org/apache/lucene/search/DocValuesRewriteMethod.java@@ -18,7 +18,6 @@ package org.apache.lucene.search;import java.io.IOException;import org.apache.lucene.index.DocValues;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.SortedDocValues;import org.apache.lucene.index.SortedSetDocValues;@@ -36,7 +35,7 @@ import org.apache.lucene.util.LongBitSet;public final class DocValuesRewriteMethod extends MultiTermQuery.RewriteMethod {@Override- public Query rewrite(IndexReader reader, MultiTermQuery query) {+ public Query rewrite(IndexSearcher indexSearcher, MultiTermQuery query) {return new ConstantScoreQuery(new MultiTermQueryDocValuesWrapper(query));}diff --git a/lucene/core/src/java/org/apache/lucene/search/DoubleValuesSource.java b/lucene/core/src/java/org/apache/lucene/search/DoubleValuesSource.javaindex 303dc516af8..f27b791dd95 100644--- a/lucene/core/src/java/org/apache/lucene/search/DoubleValuesSource.java+++ b/lucene/core/src/java/org/apache/lucene/search/DoubleValuesSource.java@@ -22,7 +22,6 @@ import java.util.Objects;import java.util.function.DoubleToLongFunction;import java.util.function.LongToDoubleFunction;import org.apache.lucene.index.DocValues;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.NumericDocValues;import org.apache.lucene.search.comparators.DoubleComparator;@@ -85,7 +84,7 @@ public abstract class DoubleValuesSource implements SegmentCacheable {** <p>Queries that use DoubleValuesSource objects should call rewrite() during {@link* Query#createWeight(IndexSearcher, ScoreMode, float)} rather than during {@link- * Query#rewrite(IndexReader)} to avoid IndexReader reference leakage.+ * Query#rewrite(IndexSearcher)} to avoid IndexReader reference leakage.** <p>For the same reason, implementations that cache references to the IndexSearcher should* return a new object from this method.diff --git a/lucene/core/src/java/org/apache/lucene/search/FieldExistsQuery.java b/lucene/core/src/java/org/apache/lucene/search/FieldExistsQuery.javaindex 1e5dd09d183..fa4ec75965c 100644--- a/lucene/core/src/java/org/apache/lucene/search/FieldExistsQuery.java+++ b/lucene/core/src/java/org/apache/lucene/search/FieldExistsQuery.java@@ -107,7 +107,8 @@ public class FieldExistsQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ IndexReader reader = indexSearcher.getIndexReader();boolean allReadersRewritable = true;for (LeafReaderContext context : reader.leaves()) {@@ -155,7 +156,7 @@ public class FieldExistsQuery extends Query {if (allReadersRewritable) {return new MatchAllDocsQuery();}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/core/src/java/org/apache/lucene/search/IndexOrDocValuesQuery.java b/lucene/core/src/java/org/apache/lucene/search/IndexOrDocValuesQuery.javaindex 9ba52eb674f..599608f0d84 100644--- a/lucene/core/src/java/org/apache/lucene/search/IndexOrDocValuesQuery.java+++ b/lucene/core/src/java/org/apache/lucene/search/IndexOrDocValuesQuery.java@@ -19,7 +19,6 @@ package org.apache.lucene.search;import java.io.IOException;import org.apache.lucene.document.LongPoint;import org.apache.lucene.document.SortedNumericDocValuesField;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;/**@@ -101,9 +100,9 @@ public final class IndexOrDocValuesQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {- Query indexRewrite = indexQuery.rewrite(reader);- Query dvRewrite = dvQuery.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ Query indexRewrite = indexQuery.rewrite(indexSearcher);+ Query dvRewrite = dvQuery.rewrite(indexSearcher);if (indexRewrite.getClass() == MatchAllDocsQuery.class|| dvRewrite.getClass() == MatchAllDocsQuery.class) {return new MatchAllDocsQuery();diff --git a/lucene/core/src/java/org/apache/lucene/search/IndexSearcher.java b/lucene/core/src/java/org/apache/lucene/search/IndexSearcher.javaindex e04b2566d9b..6d16e76365f 100644--- a/lucene/core/src/java/org/apache/lucene/search/IndexSearcher.java+++ b/lucene/core/src/java/org/apache/lucene/search/IndexSearcher.java@@ -764,9 +764,9 @@ public class IndexSearcher {*/public Query rewrite(Query original) throws IOException {Query query = original;- for (Query rewrittenQuery = query.rewrite(reader);+ for (Query rewrittenQuery = query.rewrite(this);rewrittenQuery != query;- rewrittenQuery = query.rewrite(reader)) {+ rewrittenQuery = query.rewrite(this)) {query = rewrittenQuery;}query.visit(getNumClausesCheckVisitor());diff --git a/lucene/core/src/java/org/apache/lucene/search/KnnVectorQuery.java b/lucene/core/src/java/org/apache/lucene/search/KnnVectorQuery.javaindex 78e4f961a45..9f809045476 100644--- a/lucene/core/src/java/org/apache/lucene/search/KnnVectorQuery.java+++ b/lucene/core/src/java/org/apache/lucene/search/KnnVectorQuery.java@@ -86,12 +86,12 @@ public class KnnVectorQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ IndexReader reader = indexSearcher.getIndexReader();TopDocs[] perLeafResults = new TopDocs[reader.leaves().size()];Weight filterWeight = null;if (filter != null) {- IndexSearcher indexSearcher = new IndexSearcher(reader);BooleanQuery booleanQuery =new BooleanQuery.Builder().add(filter, BooleanClause.Occur.FILTER)diff --git a/lucene/core/src/java/org/apache/lucene/search/MultiPhraseQuery.java b/lucene/core/src/java/org/apache/lucene/search/MultiPhraseQuery.javaindex 1bf34569c39..27819235f64 100644--- a/lucene/core/src/java/org/apache/lucene/search/MultiPhraseQuery.java+++ b/lucene/core/src/java/org/apache/lucene/search/MultiPhraseQuery.java@@ -24,7 +24,6 @@ import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.Objects;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.IndexReaderContext;import org.apache.lucene.index.LeafReader;import org.apache.lucene.index.LeafReaderContext;@@ -185,7 +184,7 @@ public class MultiPhraseQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {if (termArrays.length == 0) {return new MatchNoDocsQuery("empty MultiPhraseQuery");} else if (termArrays.length == 1) { // optimize one-term case@@ -196,7 +195,7 @@ public class MultiPhraseQuery extends Query {}return builder.build();} else {- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}}diff --git a/lucene/core/src/java/org/apache/lucene/search/MultiTermQuery.java b/lucene/core/src/java/org/apache/lucene/search/MultiTermQuery.javaindex 363a508aca4..282af18ae85 100644--- a/lucene/core/src/java/org/apache/lucene/search/MultiTermQuery.java+++ b/lucene/core/src/java/org/apache/lucene/search/MultiTermQuery.java@@ -18,9 +18,8 @@ package org.apache.lucene.search;import java.io.IOException;import java.util.Objects;-import org.apache.lucene.index.FilteredTermsEnum; // javadocs-import org.apache.lucene.index.IndexReader;-import org.apache.lucene.index.SingleTermsEnum; // javadocs+import org.apache.lucene.index.FilteredTermsEnum;+import org.apache.lucene.index.SingleTermsEnum;import org.apache.lucene.index.Term;import org.apache.lucene.index.TermStates;import org.apache.lucene.index.Terms;@@ -56,7 +55,8 @@ public abstract class MultiTermQuery extends Query {/** Abstract class that defines how the query is rewritten. */public abstract static class RewriteMethod {- public abstract Query rewrite(IndexReader reader, MultiTermQuery query) throws IOException;+ public abstract Query rewrite(IndexSearcher indexSearcher, MultiTermQuery query)+ throws IOException;/*** Returns the {@link MultiTermQuery}s {@link TermsEnum}*@@ -81,7 +81,7 @@ public abstract class MultiTermQuery extends Query {public static final RewriteMethod CONSTANT_SCORE_REWRITE =new RewriteMethod() {@Override- public Query rewrite(IndexReader reader, MultiTermQuery query) {+ public Query rewrite(IndexSearcher indexSearcher, MultiTermQuery query) {return new MultiTermQueryConstantScoreWrapper<>(query);}};@@ -279,8 +279,8 @@ public abstract class MultiTermQuery extends Query {* AttributeSource)}. For example, to rewrite to a single term, return a {@link SingleTermsEnum}*/@Override- public final Query rewrite(IndexReader reader) throws IOException {- return rewriteMethod.rewrite(reader, this);+ public final Query rewrite(IndexSearcher indexSearcher) throws IOException {+ return rewriteMethod.rewrite(indexSearcher, this);}/**diff --git a/lucene/core/src/java/org/apache/lucene/search/NGramPhraseQuery.java b/lucene/core/src/java/org/apache/lucene/search/NGramPhraseQuery.javaindex 41b0decba7c..e5023bf032d 100644--- a/lucene/core/src/java/org/apache/lucene/search/NGramPhraseQuery.java+++ b/lucene/core/src/java/org/apache/lucene/search/NGramPhraseQuery.java@@ -18,14 +18,13 @@ package org.apache.lucene.search;import java.io.IOException;import java.util.Objects;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.Term;/*** This is a {@link PhraseQuery} which is optimized for n-gram phrase query. For example, when you* query "ABCD" on a 2-gram field, you may want to use NGramPhraseQuery rather than {@link- * PhraseQuery}, because NGramPhraseQuery will {@link #rewrite(IndexReader)} the query to "AB/0- * CD/2", while {@link PhraseQuery} will query "AB/0 BC/1 CD/2" (where term/position).+ * PhraseQuery}, because NGramPhraseQuery will {@link Query#rewrite(IndexSearcher)} the query to+ * "AB/0 CD/2", while {@link PhraseQuery} will query "AB/0 BC/1 CD/2" (where term/position).*/public class NGramPhraseQuery extends Query {@@ -44,7 +43,7 @@ public class NGramPhraseQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {final Term[] terms = phraseQuery.getTerms();final int[] positions = phraseQuery.getPositions();@@ -63,7 +62,7 @@ public class NGramPhraseQuery extends Query {}if (isOptimizable == false) {- return phraseQuery.rewrite(reader);+ return phraseQuery.rewrite(indexSearcher);}PhraseQuery.Builder builder = new PhraseQuery.Builder();diff --git a/lucene/core/src/java/org/apache/lucene/search/NamedMatches.java b/lucene/core/src/java/org/apache/lucene/search/NamedMatches.javaindex 9a24f9433ba..d0ec5c3a212 100644--- a/lucene/core/src/java/org/apache/lucene/search/NamedMatches.java+++ b/lucene/core/src/java/org/apache/lucene/search/NamedMatches.java@@ -25,7 +25,6 @@ import java.util.Iterator;import java.util.LinkedList;import java.util.List;import java.util.Objects;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;/**@@ -113,8 +112,8 @@ public class NamedMatches implements Matches {}@Override- public Query rewrite(IndexReader reader) throws IOException {- Query rewritten = in.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ Query rewritten = in.rewrite(indexSearcher);if (rewritten != in) {return new NamedQuery(name, rewritten);}diff --git a/lucene/core/src/java/org/apache/lucene/search/PhraseQuery.java b/lucene/core/src/java/org/apache/lucene/search/PhraseQuery.javaindex 93a2ace6453..64386165136 100644--- a/lucene/core/src/java/org/apache/lucene/search/PhraseQuery.java+++ b/lucene/core/src/java/org/apache/lucene/search/PhraseQuery.java@@ -24,7 +24,6 @@ import java.util.Objects;import org.apache.lucene.codecs.lucene90.Lucene90PostingsFormat;import org.apache.lucene.codecs.lucene90.Lucene90PostingsReader;import org.apache.lucene.index.ImpactsEnum;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.IndexReaderContext;import org.apache.lucene.index.LeafReader;import org.apache.lucene.index.LeafReaderContext;@@ -284,7 +283,7 @@ public class PhraseQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {if (terms.length == 0) {return new MatchNoDocsQuery("empty PhraseQuery");} else if (terms.length == 1) {@@ -296,7 +295,7 @@ public class PhraseQuery extends Query {}return new PhraseQuery(slop, terms, newPositions);} else {- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}}diff --git a/lucene/core/src/java/org/apache/lucene/search/Query.java b/lucene/core/src/java/org/apache/lucene/search/Query.javaindex 4f04728395d..9cb7a11fd0f 100644--- a/lucene/core/src/java/org/apache/lucene/search/Query.java+++ b/lucene/core/src/java/org/apache/lucene/search/Query.java@@ -17,7 +17,6 @@package org.apache.lucene.search;import java.io.IOException;-import org.apache.lucene.index.IndexReader;/*** The abstract base class for queries.@@ -77,9 +76,12 @@ public abstract class Query {* <p>Callers are expected to call <code>rewrite</code> multiple times if necessary, until the* rewritten query is the same as the original query.*+ * <p>The rewrite process may be able to make use of IndexSearcher's executor and be executed in+ * parallel if the executor is provided.+ ** @see IndexSearcher#rewrite(Query)*/- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {return this;}diff --git a/lucene/core/src/java/org/apache/lucene/search/ScoringRewrite.java b/lucene/core/src/java/org/apache/lucene/search/ScoringRewrite.javaindex d2ee23315cc..08ed0b1fb62 100644--- a/lucene/core/src/java/org/apache/lucene/search/ScoringRewrite.java+++ b/lucene/core/src/java/org/apache/lucene/search/ScoringRewrite.java@@ -86,8 +86,8 @@ public abstract class ScoringRewrite<B> extends TermCollectingRewrite<B> {public static final RewriteMethod CONSTANT_SCORE_BOOLEAN_REWRITE =new RewriteMethod() {@Override- public Query rewrite(IndexReader reader, MultiTermQuery query) throws IOException {- final Query bq = SCORING_BOOLEAN_REWRITE.rewrite(reader, query);+ public Query rewrite(IndexSearcher indexSearcher, MultiTermQuery query) throws IOException {+ final Query bq = SCORING_BOOLEAN_REWRITE.rewrite(indexSearcher, query);// strip the scores offreturn new ConstantScoreQuery(bq);}@@ -100,8 +100,9 @@ public abstract class ScoringRewrite<B> extends TermCollectingRewrite<B> {protected abstract void checkMaxClauseCount(int count) throws IOException;@Override- public final Query rewrite(final IndexReader reader, final MultiTermQuery query)+ public final Query rewrite(IndexSearcher indexSearcher, final MultiTermQuery query)throws IOException {+ IndexReader reader = indexSearcher.getIndexReader();final B builder = getTopLevelBuilder();final ParallelArraysTermCollector col = new ParallelArraysTermCollector();collectTerms(reader, query, col);diff --git a/lucene/core/src/java/org/apache/lucene/search/SynonymQuery.java b/lucene/core/src/java/org/apache/lucene/search/SynonymQuery.javaindex 2aefe3f7860..0b68dc35681 100644--- a/lucene/core/src/java/org/apache/lucene/search/SynonymQuery.java+++ b/lucene/core/src/java/org/apache/lucene/search/SynonymQuery.java@@ -29,7 +29,6 @@ import org.apache.lucene.index.Impact;import org.apache.lucene.index.Impacts;import org.apache.lucene.index.ImpactsEnum;import org.apache.lucene.index.ImpactsSource;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.PostingsEnum;import org.apache.lucene.index.SlowImpactsEnum;@@ -143,7 +142,7 @@ public final class SynonymQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {// optimize zero and non-boosted single term casesif (terms.length == 0) {return new BooleanQuery.Builder().build();diff --git a/lucene/core/src/java/org/apache/lucene/search/TermInSetQuery.java b/lucene/core/src/java/org/apache/lucene/search/TermInSetQuery.javaindex 14ced9fd778..ef254c894ec 100644--- a/lucene/core/src/java/org/apache/lucene/search/TermInSetQuery.java+++ b/lucene/core/src/java/org/apache/lucene/search/TermInSetQuery.java@@ -24,7 +24,6 @@ import java.util.Collections;import java.util.List;import java.util.Objects;import java.util.SortedSet;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.PostingsEnum;@@ -113,7 +112,7 @@ public class TermInSetQuery extends Query implements Accountable {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {final int threshold =Math.min(BOOLEAN_REWRITE_TERM_COUNT_THRESHOLD, IndexSearcher.getMaxClauseCount());if (termData.size() <= threshold) {@@ -124,7 +123,7 @@ public class TermInSetQuery extends Query implements Accountable {}return new ConstantScoreQuery(bq.build());}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/core/src/java/org/apache/lucene/search/TopTermsRewrite.java b/lucene/core/src/java/org/apache/lucene/search/TopTermsRewrite.javaindex 067867ca734..fe95a2fb3e3 100644--- a/lucene/core/src/java/org/apache/lucene/search/TopTermsRewrite.java+++ b/lucene/core/src/java/org/apache/lucene/search/TopTermsRewrite.java@@ -21,7 +21,6 @@ import java.util.Comparator;import java.util.HashMap;import java.util.Map;import java.util.PriorityQueue;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.Term;import org.apache.lucene.index.TermState;import org.apache.lucene.index.TermStates;@@ -61,12 +60,12 @@ public abstract class TopTermsRewrite<B> extends TermCollectingRewrite<B> {protected abstract int getMaxSize();@Override- public final Query rewrite(final IndexReader reader, final MultiTermQuery query)+ public final Query rewrite(IndexSearcher indexSearcher, final MultiTermQuery query)throws IOException {final int maxSize = Math.min(size, getMaxSize());final PriorityQueue<ScoreTerm> stQueue = new PriorityQueue<>();collectTerms(- reader,+ indexSearcher.getIndexReader(),query,new TermCollector() {private final MaxNonCompetitiveBoostAttribute maxBoostAtt =diff --git a/lucene/core/src/java/org/apache/lucene/search/package-info.java b/lucene/core/src/java/org/apache/lucene/search/package-info.javaindex 4f606597d0a..65392b13a9e 100644--- a/lucene/core/src/java/org/apache/lucene/search/package-info.java+++ b/lucene/core/src/java/org/apache/lucene/search/package-info.java@@ -357,11 +357,11 @@* each Query implementation must provide an implementation of Weight. See the subsection on* <a href="#weightClass">The Weight Interface</a> below for details on implementing the* Weight interface.- * <li>{@link org.apache.lucene.search.Query#rewrite(org.apache.lucene.index.IndexReader)- * rewrite(IndexReader reader)} — Rewrites queries into primitive queries. Primitive- * queries are: {@link org.apache.lucene.search.TermQuery TermQuery}, {@link- * org.apache.lucene.search.BooleanQuery BooleanQuery}, <span >and other queries that- * implement {@link org.apache.lucene.search.Query#createWeight(IndexSearcher,ScoreMode,float)+ * <li>{@link org.apache.lucene.search.Query#rewrite(IndexSearcher) rewrite(IndexReader reader)}+ * — Rewrites queries into primitive queries. Primitive queries are: {@link+ * org.apache.lucene.search.TermQuery TermQuery}, {@link org.apache.lucene.search.BooleanQuery+ * BooleanQuery}, <span >and other queries that implement {@link+ * org.apache.lucene.search.Query#createWeight(IndexSearcher,ScoreMode,float)* createWeight(IndexSearcher searcher,ScoreMode scoreMode, float boost)}</span>* </ol>*diff --git a/lucene/core/src/test/org/apache/lucene/search/TestBooleanRewrites.java b/lucene/core/src/test/org/apache/lucene/search/TestBooleanRewrites.javaindex f0bf8ff96ff..4f2e3a829b8 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestBooleanRewrites.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestBooleanRewrites.java@@ -82,7 +82,7 @@ public class TestBooleanRewrites extends LuceneTestCase {query1.add(new TermQuery(new Term("field", "a")), Occur.FILTER);// Single clauses rewrite to a term query- final Query rewritten1 = query1.build().rewrite(reader);+ final Query rewritten1 = query1.build().rewrite(searcher);assertTrue(rewritten1 instanceof BoostQuery);assertEquals(0f, ((BoostQuery) rewritten1).getBoost(), 0f);diff --git a/lucene/core/src/test/org/apache/lucene/search/TestFieldExistsQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestFieldExistsQuery.javaindex 1f2ab372a1e..f22ef5a2c8e 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestFieldExistsQuery.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestFieldExistsQuery.java@@ -60,7 +60,8 @@ public class TestFieldExistsQuery extends LuceneTestCase {final IndexReader reader = iw.getReader();iw.close();- assertTrue((new FieldExistsQuery("f")).rewrite(reader) instanceof MatchAllDocsQuery);+ assertTrue(+ (new FieldExistsQuery("f")).rewrite(newSearcher(reader)) instanceof MatchAllDocsQuery);reader.close();dir.close();}@@ -79,7 +80,8 @@ public class TestFieldExistsQuery extends LuceneTestCase {final IndexReader reader = iw.getReader();iw.close();- assertTrue(new FieldExistsQuery("dim").rewrite(reader) instanceof MatchAllDocsQuery);+ assertTrue(+ new FieldExistsQuery("dim").rewrite(newSearcher(reader)) instanceof MatchAllDocsQuery);reader.close();dir.close();}@@ -103,9 +105,10 @@ public class TestFieldExistsQuery extends LuceneTestCase {iw.commit();final IndexReader reader = iw.getReader();iw.close();+ final IndexSearcher searcher = newSearcher(reader);- assertFalse((new FieldExistsQuery("dim")).rewrite(reader) instanceof MatchAllDocsQuery);- assertFalse((new FieldExistsQuery("f")).rewrite(reader) instanceof MatchAllDocsQuery);+ assertFalse((new FieldExistsQuery("dim")).rewrite(searcher) instanceof MatchAllDocsQuery);+ assertFalse((new FieldExistsQuery("f")).rewrite(searcher) instanceof MatchAllDocsQuery);reader.close();dir.close();}@@ -124,10 +127,11 @@ public class TestFieldExistsQuery extends LuceneTestCase {iw.commit();final IndexReader reader = iw.getReader();iw.close();+ final IndexSearcher searcher = newSearcher(reader);- assertFalse((new FieldExistsQuery("dv1")).rewrite(reader) instanceof MatchAllDocsQuery);- assertFalse((new FieldExistsQuery("dv2")).rewrite(reader) instanceof MatchAllDocsQuery);- assertFalse((new FieldExistsQuery("dv3")).rewrite(reader) instanceof MatchAllDocsQuery);+ assertFalse((new FieldExistsQuery("dv1")).rewrite(searcher) instanceof MatchAllDocsQuery);+ assertFalse((new FieldExistsQuery("dv2")).rewrite(searcher) instanceof MatchAllDocsQuery);+ assertFalse((new FieldExistsQuery("dv3")).rewrite(searcher) instanceof MatchAllDocsQuery);reader.close();dir.close();}diff --git a/lucene/core/src/test/org/apache/lucene/search/TestKnnVectorQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestKnnVectorQuery.javaindex e2dcb785144..56e5bbf63ef 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestKnnVectorQuery.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestKnnVectorQuery.java@@ -202,7 +202,7 @@ public class TestKnnVectorQuery extends LuceneTestCase {getIndexStore("field", new float[] {0, 1}, new float[] {1, 2}, new float[] {0, 0});IndexReader reader = DirectoryReader.open(indexStore)) {KnnVectorQuery query = new KnnVectorQuery("field", new float[] {2, 3}, 3);- Query dasq = query.rewrite(reader);+ Query dasq = query.rewrite(newSearcher(reader));IndexSearcher leafSearcher = newSearcher(reader.leaves().get(0).reader());expectThrows(IllegalStateException.class,@@ -222,7 +222,7 @@ public class TestKnnVectorQuery extends LuceneTestCase {try (IndexReader reader = DirectoryReader.open(d)) {IndexSearcher searcher = new IndexSearcher(reader);KnnVectorQuery query = new KnnVectorQuery("field", new float[] {2, 3}, 3);- Query dasq = query.rewrite(reader);+ Query dasq = query.rewrite(searcher);Scorer scorer =dasq.createWeight(searcher, ScoreMode.COMPLETE, 1).scorer(reader.leaves().get(0));// before advancing the iterator@@ -249,7 +249,7 @@ public class TestKnnVectorQuery extends LuceneTestCase {IndexReader reader = DirectoryReader.open(d)) {IndexSearcher searcher = new IndexSearcher(reader);KnnVectorQuery query = new KnnVectorQuery("field", new float[] {2, 3}, 3);- Query rewritten = query.rewrite(reader);+ Query rewritten = query.rewrite(searcher);Weight weight = searcher.createWeight(rewritten, ScoreMode.COMPLETE, 1);Scorer scorer = weight.scorer(reader.leaves().get(0));@@ -291,7 +291,7 @@ public class TestKnnVectorQuery extends LuceneTestCase {IndexSearcher searcher = new IndexSearcher(reader);KnnVectorQuery query =new KnnVectorQuery("field", VectorUtil.l2normalize(new float[] {2, 3}), 3);- Query rewritten = query.rewrite(reader);+ Query rewritten = query.rewrite(searcher);Weight weight = searcher.createWeight(rewritten, ScoreMode.COMPLETE, 1);Scorer scorer = weight.scorer(reader.leaves().get(0));@@ -345,7 +345,7 @@ public class TestKnnVectorQuery extends LuceneTestCase {assertEquals(1, reader.leaves().size());IndexSearcher searcher = new IndexSearcher(reader);KnnVectorQuery query = new KnnVectorQuery("field", new float[] {2, 3}, 3);- Query rewritten = query.rewrite(reader);+ Query rewritten = query.rewrite(searcher);Weight weight = searcher.createWeight(rewritten, ScoreMode.COMPLETE, 1);Scorer scorer = weight.scorer(reader.leaves().get(0));@@ -400,7 +400,7 @@ public class TestKnnVectorQuery extends LuceneTestCase {assertEquals(1, reader.leaves().size());IndexSearcher searcher = new IndexSearcher(reader);KnnVectorQuery query = new KnnVectorQuery("field", new float[] {1, 0}, 2);- Query rewritten = query.rewrite(reader);+ Query rewritten = query.rewrite(searcher);Weight weight = searcher.createWeight(rewritten, ScoreMode.COMPLETE, 1);Scorer scorer = weight.scorer(reader.leaves().get(0));diff --git a/lucene/core/src/test/org/apache/lucene/search/TestMatchNoDocsQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestMatchNoDocsQuery.javaindex e1facc81e61..02cc9a9f2c0 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestMatchNoDocsQuery.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestMatchNoDocsQuery.java@@ -87,7 +87,7 @@ public class TestMatchNoDocsQuery extends LuceneTestCase {assertEquals(query.toString(), "key:one MatchNoDocsQuery(\"field not found\")");assertEquals(searcher.count(query), 1);hits = searcher.search(query, 1000).scoreDocs;- Query rewrite = query.rewrite(ir);+ Query rewrite = query.rewrite(searcher);assertEquals(1, hits.length);assertEquals(rewrite.toString(), "key:one");diff --git a/lucene/core/src/test/org/apache/lucene/search/TestMatchesIterator.java b/lucene/core/src/test/org/apache/lucene/search/TestMatchesIterator.javaindex b62d1ec69f1..33acb57c8a5 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestMatchesIterator.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestMatchesIterator.java@@ -499,7 +499,7 @@ public class TestMatchesIterator extends MatchesTestBase {SeekCountingLeafReader reader = new SeekCountingLeafReader(getOnlyLeafReader(this.reader));this.searcher = new IndexSearcher(reader);Query query = new PrefixQuery(new Term(FIELD_WITH_OFFSETS, "w"));- Weight w = searcher.createWeight(query.rewrite(reader), ScoreMode.COMPLETE, 1);+ Weight w = searcher.createWeight(query.rewrite(searcher), ScoreMode.COMPLETE, 1);// docs 0-3 match several different terms here, but we only seek to the first term and// then short-cut return; other terms are ignored until we try and iterate over matchesdiff --git a/lucene/core/src/test/org/apache/lucene/search/TestNGramPhraseQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestNGramPhraseQuery.javaindex f42a576ce54..905b43b93ed 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestNGramPhraseQuery.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestNGramPhraseQuery.java@@ -29,6 +29,7 @@ public class TestNGramPhraseQuery extends LuceneTestCase {private static IndexReader reader;private static Directory directory;+ private static IndexSearcher searcher;@BeforeClasspublic static void beforeClass() throws Exception {@@ -36,6 +37,7 @@ public class TestNGramPhraseQuery extends LuceneTestCase {RandomIndexWriter writer = new RandomIndexWriter(random(), directory);writer.close();reader = DirectoryReader.open(directory);+ searcher = new IndexSearcher(reader);}@AfterClass@@ -50,8 +52,8 @@ public class TestNGramPhraseQuery extends LuceneTestCase {// bi-gram test ABC => AB/BC => AB/BCNGramPhraseQuery pq1 = new NGramPhraseQuery(2, new PhraseQuery("f", "AB", "BC"));- Query q = pq1.rewrite(reader);- assertSame(q.rewrite(reader), q);+ Query q = pq1.rewrite(searcher);+ assertSame(q.rewrite(searcher), q);PhraseQuery rewritten1 = (PhraseQuery) q;assertArrayEquals(new Term[] {new Term("f", "AB"), new Term("f", "BC")}, rewritten1.getTerms());assertArrayEquals(new int[] {0, 1}, rewritten1.getPositions());@@ -59,7 +61,7 @@ public class TestNGramPhraseQuery extends LuceneTestCase {// bi-gram test ABCD => AB/BC/CD => AB//CDNGramPhraseQuery pq2 = new NGramPhraseQuery(2, new PhraseQuery("f", "AB", "BC", "CD"));- q = pq2.rewrite(reader);+ q = pq2.rewrite(searcher);assertTrue(q instanceof PhraseQuery);assertNotSame(pq2, q);PhraseQuery rewritten2 = (PhraseQuery) q;@@ -70,7 +72,7 @@ public class TestNGramPhraseQuery extends LuceneTestCase {NGramPhraseQuery pq3 =new NGramPhraseQuery(3, new PhraseQuery("f", "ABC", "BCD", "CDE", "DEF", "EFG", "FGH"));- q = pq3.rewrite(reader);+ q = pq3.rewrite(searcher);assertTrue(q instanceof PhraseQuery);assertNotSame(pq3, q);PhraseQuery rewritten3 = (PhraseQuery) q;diff --git a/lucene/core/src/test/org/apache/lucene/search/TestNeedsScores.java b/lucene/core/src/test/org/apache/lucene/search/TestNeedsScores.javaindex aa2f3c89212..03b58571086 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestNeedsScores.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestNeedsScores.java@@ -139,10 +139,10 @@ public class TestNeedsScores extends LuceneTestCase {}@Override- public Query rewrite(IndexReader reader) throws IOException {- Query in2 = in.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ Query in2 = in.rewrite(indexSearcher);if (in2 == in) {- return super.rewrite(reader);+ return super.rewrite(indexSearcher);} else {return new AssertNeedsScores(in2, value);}diff --git a/lucene/core/src/test/org/apache/lucene/search/TestPhraseQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestPhraseQuery.javaindex da93b3a1951..f721f5e4fe2 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestPhraseQuery.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestPhraseQuery.java@@ -567,7 +567,7 @@ public class TestPhraseQuery extends LuceneTestCase {/* test that a single term is rewritten to a term query */public void testRewrite() throws IOException {PhraseQuery pq = new PhraseQuery("foo", "bar");- Query rewritten = pq.rewrite(searcher.getIndexReader());+ Query rewritten = pq.rewrite(searcher);assertTrue(rewritten instanceof TermQuery);}diff --git a/lucene/core/src/test/org/apache/lucene/search/TestWANDScorer.java b/lucene/core/src/test/org/apache/lucene/search/TestWANDScorer.javaindex 8a31e34cc39..188b7db34bc 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestWANDScorer.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestWANDScorer.java@@ -949,12 +949,12 @@ public class TestWANDScorer extends LuceneTestCase {}@Override- public Query rewrite(IndexReader reader) throws IOException {- Query rewritten = query.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ Query rewritten = query.rewrite(indexSearcher);if (rewritten != query) {return new MaxScoreWrapperQuery(rewritten, maxRange, maxScore);}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/facet/src/java/org/apache/lucene/facet/DrillDownQuery.java b/lucene/facet/src/java/org/apache/lucene/facet/DrillDownQuery.javaindex a4d47aa8c12..9fe4b15b907 100644--- a/lucene/facet/src/java/org/apache/lucene/facet/DrillDownQuery.java+++ b/lucene/facet/src/java/org/apache/lucene/facet/DrillDownQuery.java@@ -24,11 +24,11 @@ import java.util.List;import java.util.Map;import java.util.Objects;import java.util.Set;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.Term;import org.apache.lucene.search.BooleanClause.Occur;import org.apache.lucene.search.BooleanQuery;import org.apache.lucene.search.BoostQuery;+import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.MatchAllDocsQuery;import org.apache.lucene.search.Query;import org.apache.lucene.search.QueryVisitor;@@ -100,8 +100,8 @@ public final class DrillDownQuery extends Query {/*** Creates a new {@code DrillDownQuery} over the given base query. Can be {@code null}, in which- * case the result {@link Query} from {@link #rewrite(IndexReader)} will be a pure browsing query,- * filtering on the added categories only.+ * case the result {@link Query} from {@link Query#rewrite(IndexSearcher)} will be a pure browsing+ * query, filtering on the added categories only.*/public DrillDownQuery(FacetsConfig config, Query baseQuery) {this.baseQuery = baseQuery;@@ -156,7 +156,7 @@ public final class DrillDownQuery extends Query {}@Override- public Query rewrite(IndexReader r) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {BooleanQuery rewritten = getBooleanQuery();if (rewritten.clauses().isEmpty()) {return new MatchAllDocsQuery();diff --git a/lucene/facet/src/java/org/apache/lucene/facet/DrillSidewaysQuery.java b/lucene/facet/src/java/org/apache/lucene/facet/DrillSidewaysQuery.javaindex 81643019ad9..88850df057c 100644--- a/lucene/facet/src/java/org/apache/lucene/facet/DrillSidewaysQuery.java+++ b/lucene/facet/src/java/org/apache/lucene/facet/DrillSidewaysQuery.java@@ -24,7 +24,6 @@ import java.util.Comparator;import java.util.List;import java.util.Objects;import org.apache.lucene.facet.DrillSidewaysScorer.DocsAndCost;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.search.BulkScorer;import org.apache.lucene.search.ConstantScoreScorer;@@ -80,8 +79,8 @@ class DrillSidewaysQuery extends Query {}/**- * Needed for {@link #rewrite(IndexReader)}. Ensures the same "managed" lists get used since- * {@link DrillSideways} accesses references to these through the original {@code+ * Needed for {@link Query#rewrite(IndexSearcher)}. Ensures the same "managed" lists get used+ * since {@link DrillSideways} accesses references to these through the original {@code* DrillSidewaysQuery}.*/private DrillSidewaysQuery(@@ -107,17 +106,17 @@ class DrillSidewaysQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {Query newQuery = baseQuery;while (true) {- Query rewrittenQuery = newQuery.rewrite(reader);+ Query rewrittenQuery = newQuery.rewrite(indexSearcher);if (rewrittenQuery == newQuery) {break;}newQuery = rewrittenQuery;}if (newQuery == baseQuery) {- return super.rewrite(reader);+ return super.rewrite(indexSearcher);} else {return new DrillSidewaysQuery(newQuery,diff --git a/lucene/facet/src/java/org/apache/lucene/facet/range/DoubleRange.java b/lucene/facet/src/java/org/apache/lucene/facet/range/DoubleRange.javaindex bf188a9d80f..3824baca4d3 100644--- a/lucene/facet/src/java/org/apache/lucene/facet/range/DoubleRange.java+++ b/lucene/facet/src/java/org/apache/lucene/facet/range/DoubleRange.java@@ -20,7 +20,6 @@ import java.io.IOException;import java.util.Objects;import org.apache.lucene.facet.MultiDoubleValues;import org.apache.lucene.facet.MultiDoubleValuesSource;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.search.ConstantScoreScorer;import org.apache.lucene.search.ConstantScoreWeight;@@ -154,14 +153,14 @@ public final class DoubleRange extends Range {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {if (fastMatchQuery != null) {- final Query fastMatchRewritten = fastMatchQuery.rewrite(reader);+ final Query fastMatchRewritten = fastMatchQuery.rewrite(indexSearcher);if (fastMatchRewritten != fastMatchQuery) {return new ValueSourceQuery(range, fastMatchRewritten, valueSource);}}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Override@@ -252,14 +251,14 @@ public final class DoubleRange extends Range {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {if (fastMatchQuery != null) {- final Query fastMatchRewritten = fastMatchQuery.rewrite(reader);+ final Query fastMatchRewritten = fastMatchQuery.rewrite(indexSearcher);if (fastMatchRewritten != fastMatchQuery) {return new MultiValueSourceQuery(range, fastMatchRewritten, valueSource);}}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/facet/src/java/org/apache/lucene/facet/range/LongRange.java b/lucene/facet/src/java/org/apache/lucene/facet/range/LongRange.javaindex 63e99190437..6796780d010 100644--- a/lucene/facet/src/java/org/apache/lucene/facet/range/LongRange.java+++ b/lucene/facet/src/java/org/apache/lucene/facet/range/LongRange.java@@ -20,7 +20,6 @@ import java.io.IOException;import java.util.Objects;import org.apache.lucene.facet.MultiLongValues;import org.apache.lucene.facet.MultiLongValuesSource;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.search.ConstantScoreScorer;import org.apache.lucene.search.ConstantScoreWeight;@@ -141,14 +140,14 @@ public final class LongRange extends Range {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {if (fastMatchQuery != null) {- final Query fastMatchRewritten = fastMatchQuery.rewrite(reader);+ final Query fastMatchRewritten = fastMatchQuery.rewrite(indexSearcher);if (fastMatchRewritten != fastMatchQuery) {return new ValueSourceQuery(range, fastMatchRewritten, valueSource);}}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Override@@ -239,14 +238,14 @@ public final class LongRange extends Range {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {if (fastMatchQuery != null) {- final Query fastMatchRewritten = fastMatchQuery.rewrite(reader);+ final Query fastMatchRewritten = fastMatchQuery.rewrite(indexSearcher);if (fastMatchRewritten != fastMatchQuery) {return new MultiValueSourceQuery(range, fastMatchRewritten, valuesSource);}}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/facet/src/test/org/apache/lucene/facet/TestDrillDownQuery.java b/lucene/facet/src/test/org/apache/lucene/facet/TestDrillDownQuery.javaindex fdac9935eee..d606009d79f 100644--- a/lucene/facet/src/test/org/apache/lucene/facet/TestDrillDownQuery.java+++ b/lucene/facet/src/test/org/apache/lucene/facet/TestDrillDownQuery.java@@ -255,7 +255,8 @@ public class TestDrillDownQuery extends FacetTestCase {public void testNoDrillDown() throws Exception {Query base = new MatchAllDocsQuery();DrillDownQuery q = new DrillDownQuery(config, base);- Query rewrite = q.rewrite(reader).rewrite(reader);+ IndexSearcher searcher = newSearcher(reader);+ Query rewrite = q.rewrite(searcher).rewrite(searcher);assertEquals(base, rewrite);}diff --git a/lucene/facet/src/test/org/apache/lucene/facet/TestDrillSideways.java b/lucene/facet/src/test/org/apache/lucene/facet/TestDrillSideways.javaindex 36382041a5c..b479b752c4d 100644--- a/lucene/facet/src/test/org/apache/lucene/facet/TestDrillSideways.java+++ b/lucene/facet/src/test/org/apache/lucene/facet/TestDrillSideways.java@@ -747,7 +747,7 @@ public class TestDrillSideways extends FacetTestCase {Query baseQuery =new TermQuery(new Term("content", "foo")) {@Override- public Query rewrite(IndexReader reader) {+ public Query rewrite(IndexSearcher indexSearcher) {// return a new instance, forcing the DrillDownQuery to also rewrite itself, exposing// the bug in LUCENE-9988:return new TermQuery(getTerm());diff --git a/lucene/facet/src/test/org/apache/lucene/facet/range/TestRangeFacetCounts.java b/lucene/facet/src/test/org/apache/lucene/facet/range/TestRangeFacetCounts.javaindex 9e83cba98c5..91790fefbe5 100644--- a/lucene/facet/src/test/org/apache/lucene/facet/range/TestRangeFacetCounts.java+++ b/lucene/facet/src/test/org/apache/lucene/facet/range/TestRangeFacetCounts.java@@ -1558,12 +1558,12 @@ public class TestRangeFacetCounts extends FacetTestCase {}@Override- public Query rewrite(IndexReader reader) throws IOException {- final Query inRewritten = in.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ final Query inRewritten = in.rewrite(indexSearcher);if (in != inRewritten) {return new UsedQuery(inRewritten, used);}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.java b/lucene/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.javaindex 3108a11ba85..b0c7d9c6ab4 100644--- a/lucene/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.java+++ b/lucene/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.java@@ -245,9 +245,11 @@ public class WeightedSpanTermExtractor {final IndexReader reader = getLeafContext().reader();Query rewritten;if (query instanceof MultiTermQuery) {- rewritten = MultiTermQuery.SCORING_BOOLEAN_REWRITE.rewrite(reader, (MultiTermQuery) query);+ rewritten =+ MultiTermQuery.SCORING_BOOLEAN_REWRITE.rewrite(+ new IndexSearcher(reader), (MultiTermQuery) query);} else {- rewritten = origQuery.rewrite(reader);+ rewritten = origQuery.rewrite(new IndexSearcher(reader));}if (rewritten != origQuery) {// only rewrite once and then flatten again - the rewritten query could have a specialdiff --git a/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/UnifiedHighlighter.java b/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/UnifiedHighlighter.javaindex 79894cf5bcb..efb6e939bd0 100644--- a/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/UnifiedHighlighter.java+++ b/lucene/highlighter/src/java/org/apache/lucene/search/uhighlight/UnifiedHighlighter.java@@ -1249,11 +1249,11 @@ public class UnifiedHighlighter {/*** When highlighting phrases accurately, we need to know which {@link SpanQuery}'s need to have- * {@link Query#rewrite(IndexReader)} called on them. It helps performance to avoid it if it's not- * needed. This method will be invoked on all SpanQuery instances recursively. If you have custom- * SpanQuery queries then override this to check instanceof and provide a definitive answer. If- * the query isn't your custom one, simply return null to have the default rules apply, which- * govern the ones included in Lucene.+ * {@link Query#rewrite(IndexSearcher)} called on them. It helps performance to avoid it if it's+ * not needed. This method will be invoked on all SpanQuery instances recursively. If you have+ * custom SpanQuery queries then override this to check instanceof and provide a definitive+ * answer. If the query isn't your custom one, simply return null to have the default rules apply,+ * which govern the ones included in Lucene.*/protected Boolean requiresRewrite(SpanQuery spanQuery) {return null;diff --git a/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/FieldQuery.java b/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/FieldQuery.javaindex ff5a11c47d6..d89b34d8abd 100644--- a/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/FieldQuery.java+++ b/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/FieldQuery.java@@ -33,6 +33,7 @@ import org.apache.lucene.search.BooleanQuery;import org.apache.lucene.search.BoostQuery;import org.apache.lucene.search.ConstantScoreQuery;import org.apache.lucene.search.DisjunctionMaxQuery;+import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.MultiTermQuery;import org.apache.lucene.search.PhraseQuery;import org.apache.lucene.search.Query;@@ -65,8 +66,14 @@ public class FieldQuery {throws IOException {this.fieldMatch = fieldMatch;Set<Query> flatQueries = new LinkedHashSet<>();- flatten(query, reader, flatQueries, 1f);- saveTerms(flatQueries, reader);+ IndexSearcher searcher;+ if (reader == null) {+ searcher = null;+ } else {+ searcher = new IndexSearcher(reader);+ }+ flatten(query, searcher, flatQueries, 1f);+ saveTerms(flatQueries, searcher);Collection<Query> expandQueries = expand(flatQueries);for (Query flatQuery : expandQueries) {@@ -96,7 +103,7 @@ public class FieldQuery {}protected void flatten(- Query sourceQuery, IndexReader reader, Collection<Query> flatQueries, float boost)+ Query sourceQuery, IndexSearcher searcher, Collection<Query> flatQueries, float boost)throws IOException {while (sourceQuery instanceof BoostQuery) {BoostQuery bq = (BoostQuery) sourceQuery;@@ -107,13 +114,13 @@ public class FieldQuery {BooleanQuery bq = (BooleanQuery) sourceQuery;for (BooleanClause clause : bq) {if (!clause.isProhibited()) {- flatten(clause.getQuery(), reader, flatQueries, boost);+ flatten(clause.getQuery(), searcher, flatQueries, boost);}}} else if (sourceQuery instanceof DisjunctionMaxQuery) {DisjunctionMaxQuery dmq = (DisjunctionMaxQuery) sourceQuery;for (Query query : dmq) {- flatten(query, reader, flatQueries, boost);+ flatten(query, searcher, flatQueries, boost);}} else if (sourceQuery instanceof TermQuery) {if (boost != 1f) {@@ -123,7 +130,7 @@ public class FieldQuery {} else if (sourceQuery instanceof SynonymQuery) {SynonymQuery synQuery = (SynonymQuery) sourceQuery;for (Term term : synQuery.getTerms()) {- flatten(new TermQuery(term), reader, flatQueries, boost);+ flatten(new TermQuery(term), searcher, flatQueries, boost);}} else if (sourceQuery instanceof PhraseQuery) {PhraseQuery pq = (PhraseQuery) sourceQuery;@@ -135,28 +142,28 @@ public class FieldQuery {} else if (sourceQuery instanceof ConstantScoreQuery) {final Query q = ((ConstantScoreQuery) sourceQuery).getQuery();if (q != null) {- flatten(q, reader, flatQueries, boost);+ flatten(q, searcher, flatQueries, boost);}} else if (sourceQuery instanceof FunctionScoreQuery) {final Query q = ((FunctionScoreQuery) sourceQuery).getWrappedQuery();if (q != null) {- flatten(q, reader, flatQueries, boost);+ flatten(q, searcher, flatQueries, boost);}- } else if (reader != null) {+ } else if (searcher != null) {Query query = sourceQuery;Query rewritten;if (sourceQuery instanceof MultiTermQuery) {rewritten =new MultiTermQuery.TopTermsScoringBooleanQueryRewrite(MAX_MTQ_TERMS)- .rewrite(reader, (MultiTermQuery) query);+ .rewrite(searcher, (MultiTermQuery) query);} else {- rewritten = query.rewrite(reader);+ rewritten = query.rewrite(searcher);}if (rewritten != query) {// only rewrite once and then flatten again - the rewritten query could have a speacial// treatment// if this method is overwritten in a subclass.- flatten(rewritten, reader, flatQueries, boost);+ flatten(rewritten, searcher, flatQueries, boost);}// if the query is already rewritten we discard it}@@ -311,7 +318,7 @@ public class FieldQuery {* - fieldMatch==false* termSetMap=Map<null,Set<"john","lennon">>*/- void saveTerms(Collection<Query> flatQueries, IndexReader reader) throws IOException {+ void saveTerms(Collection<Query> flatQueries, IndexSearcher searcher) throws IOException {for (Query query : flatQueries) {while (query instanceof BoostQuery) {query = ((BoostQuery) query).getQuery();@@ -320,8 +327,8 @@ public class FieldQuery {if (query instanceof TermQuery) termSet.add(((TermQuery) query).getTerm().text());else if (query instanceof PhraseQuery) {for (Term term : ((PhraseQuery) query).getTerms()) termSet.add(term.text());- } else if (query instanceof MultiTermQuery && reader != null) {- BooleanQuery mtqTerms = (BooleanQuery) query.rewrite(reader);+ } else if (query instanceof MultiTermQuery && searcher != null) {+ BooleanQuery mtqTerms = (BooleanQuery) query.rewrite(searcher);for (BooleanClause clause : mtqTerms) {termSet.add(((TermQuery) clause.getQuery()).getTerm().text());}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 185c21764fe..4779562ced2 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@@ -259,7 +259,7 @@ public class TestHighlighter extends BaseTokenStreamTestCase implements Formattenew Query() {@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {CommonTermsQuery query = new CommonTermsQuery(Occur.MUST, Occur.SHOULD, 3);query.add(new Term(FIELD_NAME, "this")); // stop-wordquery.add(new Term(FIELD_NAME, "long"));@@ -2209,7 +2209,7 @@ public class TestHighlighter extends BaseTokenStreamTestCase implements Formattesearcher = newSearcher(reader);// for any multi-term queries to work (prefix, wildcard, range,fuzzy etc)// you must use a rewritten query!- query = unReWrittenQuery.rewrite(reader);+ query = unReWrittenQuery.rewrite(searcher);if (VERBOSE) System.out.println("Searching for: " + query.toString(FIELD_NAME));hits = searcher.search(query, 1000);}diff --git a/lucene/highlighter/src/test/org/apache/lucene/search/highlight/custom/TestHighlightCustomQuery.java b/lucene/highlighter/src/test/org/apache/lucene/search/highlight/custom/TestHighlightCustomQuery.javaindex 97e0baf6e91..37235bdb611 100644--- a/lucene/highlighter/src/test/org/apache/lucene/search/highlight/custom/TestHighlightCustomQuery.java+++ b/lucene/highlighter/src/test/org/apache/lucene/search/highlight/custom/TestHighlightCustomQuery.java@@ -21,9 +21,9 @@ import java.util.Collections;import java.util.Map;import java.util.Objects;import org.apache.lucene.analysis.TokenStream;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.Term;import org.apache.lucene.search.BoostQuery;+import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.Query;import org.apache.lucene.search.QueryVisitor;import org.apache.lucene.search.TermQuery;@@ -167,7 +167,7 @@ public class TestHighlightCustomQuery extends LuceneTestCase {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {return new TermQuery(term);}diff --git a/lucene/highlighter/src/test/org/apache/lucene/search/uhighlight/TestUnifiedHighlighter.java b/lucene/highlighter/src/test/org/apache/lucene/search/uhighlight/TestUnifiedHighlighter.javaindex 6bad8ddbe5e..95feb416570 100644--- a/lucene/highlighter/src/test/org/apache/lucene/search/uhighlight/TestUnifiedHighlighter.java+++ b/lucene/highlighter/src/test/org/apache/lucene/search/uhighlight/TestUnifiedHighlighter.java@@ -1619,7 +1619,7 @@ public class TestUnifiedHighlighter extends LuceneTestCase {}@Override- public Query rewrite(IndexReader reader) {+ public Query rewrite(IndexSearcher indexSearcher) {return this;}diff --git a/lucene/highlighter/src/test/org/apache/lucene/search/uhighlight/TestUnifiedHighlighterMTQ.java b/lucene/highlighter/src/test/org/apache/lucene/search/uhighlight/TestUnifiedHighlighterMTQ.javaindex 4f7bd056ca1..4aabf26d45b 100644--- a/lucene/highlighter/src/test/org/apache/lucene/search/uhighlight/TestUnifiedHighlighterMTQ.java+++ b/lucene/highlighter/src/test/org/apache/lucene/search/uhighlight/TestUnifiedHighlighterMTQ.java@@ -1111,8 +1111,8 @@ public class TestUnifiedHighlighterMTQ extends LuceneTestCase {}@Override- public Query rewrite(IndexReader reader) throws IOException {- Query newOriginalQuery = originalQuery.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ Query newOriginalQuery = originalQuery.rewrite(indexSearcher);if (newOriginalQuery != originalQuery) {return new MyWrapperSpanQuery((SpanQuery) newOriginalQuery);}diff --git a/lucene/highlighter/src/test/org/apache/lucene/search/uhighlight/TestUnifiedHighlighterStrictPhrases.java b/lucene/highlighter/src/test/org/apache/lucene/search/uhighlight/TestUnifiedHighlighterStrictPhrases.javaindex 8116ece1c1c..9f189a215b8 100644--- a/lucene/highlighter/src/test/org/apache/lucene/search/uhighlight/TestUnifiedHighlighterStrictPhrases.java+++ b/lucene/highlighter/src/test/org/apache/lucene/search/uhighlight/TestUnifiedHighlighterStrictPhrases.java@@ -658,8 +658,8 @@ public class TestUnifiedHighlighterStrictPhrases extends LuceneTestCase {}@Override- public Query rewrite(IndexReader reader) throws IOException {- Query newWrapped = wrapped.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ Query newWrapped = wrapped.rewrite(indexSearcher);if (newWrapped != wrapped) {return new MyQuery(newWrapped);}diff --git a/lucene/highlighter/src/test/org/apache/lucene/search/vectorhighlight/AbstractTestCase.java b/lucene/highlighter/src/test/org/apache/lucene/search/vectorhighlight/AbstractTestCase.javaindex 8542a45aab7..9a2f8a9e4fa 100644--- a/lucene/highlighter/src/test/org/apache/lucene/search/vectorhighlight/AbstractTestCase.java+++ b/lucene/highlighter/src/test/org/apache/lucene/search/vectorhighlight/AbstractTestCase.java@@ -21,7 +21,9 @@ import java.util.ArrayList;import java.util.Arrays;import java.util.Collection;import java.util.List;-import org.apache.lucene.analysis.*;+import org.apache.lucene.analysis.Analyzer;+import org.apache.lucene.analysis.TokenStream;+import org.apache.lucene.analysis.Tokenizer;import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;import org.apache.lucene.analysis.tokenattributes.TermToBytesRefAttribute;@@ -37,6 +39,7 @@ import org.apache.lucene.index.IndexWriterConfig.OpenMode;import org.apache.lucene.index.Term;import org.apache.lucene.search.BoostQuery;import org.apache.lucene.search.DisjunctionMaxQuery;+import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.PhraseQuery;import org.apache.lucene.search.Query;import org.apache.lucene.search.TermQuery;@@ -56,6 +59,7 @@ public abstract class AbstractTestCase extends LuceneTestCase {protected Analyzer analyzerB;protected Analyzer analyzerK;protected IndexReader reader;+ protected IndexSearcher searcher;protected static final String[] shortMVValues = {"", "", "a b c", "", // empty data in multi valued field@@ -343,6 +347,7 @@ public abstract class AbstractTestCase extends LuceneTestCase {writer.close();if (reader != null) reader.close();reader = DirectoryReader.open(dir);+ searcher = newSearcher(reader);}// make 1 doc with multi valued & not analyzed field@@ -363,6 +368,7 @@ public abstract class AbstractTestCase extends LuceneTestCase {writer.close();if (reader != null) reader.close();reader = DirectoryReader.open(dir);+ searcher = newSearcher(reader);}protected void makeIndexShortMV() throws Exception {diff --git a/lucene/highlighter/src/test/org/apache/lucene/search/vectorhighlight/TestFieldQuery.java b/lucene/highlighter/src/test/org/apache/lucene/search/vectorhighlight/TestFieldQuery.javaindex 42fec6dba55..6538c0d2985 100644--- a/lucene/highlighter/src/test/org/apache/lucene/search/vectorhighlight/TestFieldQuery.java+++ b/lucene/highlighter/src/test/org/apache/lucene/search/vectorhighlight/TestFieldQuery.java@@ -63,7 +63,7 @@ public class TestFieldQuery extends AbstractTestCase {FieldQuery fq = new FieldQuery(booleanQuery, true, true);Set<Query> flatQueries = new HashSet<>();- fq.flatten(booleanQuery, reader, flatQueries, 1f);+ fq.flatten(booleanQuery, searcher, flatQueries, 1f);assertCollectionQueries(flatQueries, tq(boost, "A"), tq(boost, "B"), tq(boost, "C"));}@@ -73,7 +73,7 @@ public class TestFieldQuery extends AbstractTestCase {query = new BoostQuery(query, boost);FieldQuery fq = new FieldQuery(query, true, true);Set<Query> flatQueries = new HashSet<>();- fq.flatten(query, reader, flatQueries, 1f);+ fq.flatten(query, searcher, flatQueries, 1f);assertCollectionQueries(flatQueries, tq(boost, "A"), tq(boost, "B"), pqF(boost, "C", "D"));}@@ -87,7 +87,7 @@ public class TestFieldQuery extends AbstractTestCase {FieldQuery fq = new FieldQuery(booleanQuery, true, true);Set<Query> flatQueries = new HashSet<>();- fq.flatten(booleanQuery, reader, flatQueries, 1f);+ fq.flatten(booleanQuery, searcher, flatQueries, 1f);assertCollectionQueries(flatQueries, tq(boost, "A"), pqF(boost, "B", "C"));}@@ -99,7 +99,7 @@ public class TestFieldQuery extends AbstractTestCase {FieldQuery fq = new FieldQuery(query.build(), true, true);Set<Query> flatQueries = new HashSet<>();- fq.flatten(query.build(), reader, flatQueries, 1f);+ fq.flatten(query.build(), searcher, flatQueries, 1f);assertCollectionQueries(flatQueries, tq("AA"), pqF("BC", "CD"), pqF("EF", "FG", "GH"));}@@ -107,7 +107,7 @@ public class TestFieldQuery extends AbstractTestCase {Query query = pqF("A");FieldQuery fq = new FieldQuery(query, true, true);Set<Query> flatQueries = new HashSet<>();- fq.flatten(query, reader, flatQueries, 1f);+ fq.flatten(query, searcher, flatQueries, 1f);assertCollectionQueries(flatQueries, tq("A"));}@@ -950,7 +950,7 @@ public class TestFieldQuery extends AbstractTestCase {query = new BoostQuery(query, boost);FieldQuery fq = new FieldQuery(query, true, true);Set<Query> flatQueries = new HashSet<>();- fq.flatten(query, reader, flatQueries, 1f);+ fq.flatten(query, searcher, flatQueries, 1f);assertCollectionQueries(flatQueries, tq(boost, "A"));}}diff --git a/lucene/join/src/java/org/apache/lucene/search/join/ParentChildrenBlockJoinQuery.java b/lucene/join/src/java/org/apache/lucene/search/join/ParentChildrenBlockJoinQuery.javaindex 9ba6daee284..64f5e5ba116 100644--- a/lucene/join/src/java/org/apache/lucene/search/join/ParentChildrenBlockJoinQuery.java+++ b/lucene/join/src/java/org/apache/lucene/search/join/ParentChildrenBlockJoinQuery.java@@ -18,7 +18,6 @@package org.apache.lucene.search.join;import java.io.IOException;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.ReaderUtil;import org.apache.lucene.search.DocIdSetIterator;@@ -88,12 +87,12 @@ public class ParentChildrenBlockJoinQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {- final Query childRewrite = childQuery.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ final Query childRewrite = childQuery.rewrite(indexSearcher);if (childRewrite != childQuery) {return new ParentChildrenBlockJoinQuery(parentFilter, childRewrite, parentDocId);} else {- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}}diff --git a/lucene/join/src/java/org/apache/lucene/search/join/ToChildBlockJoinQuery.java b/lucene/join/src/java/org/apache/lucene/search/join/ToChildBlockJoinQuery.javaindex 42c41efcefa..3f2a9e76c54 100644--- a/lucene/join/src/java/org/apache/lucene/search/join/ToChildBlockJoinQuery.java+++ b/lucene/join/src/java/org/apache/lucene/search/join/ToChildBlockJoinQuery.java@@ -20,7 +20,6 @@ import java.io.IOException;import java.util.Collection;import java.util.Collections;import java.util.Locale;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.search.DocIdSetIterator;import org.apache.lucene.search.Explanation;@@ -305,12 +304,12 @@ public class ToChildBlockJoinQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {- final Query parentRewrite = parentQuery.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ final Query parentRewrite = parentQuery.rewrite(indexSearcher);if (parentRewrite != parentQuery) {return new ToChildBlockJoinQuery(parentRewrite, parentsFilter);} else {- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}}diff --git a/lucene/join/src/java/org/apache/lucene/search/join/ToParentBlockJoinQuery.java b/lucene/join/src/java/org/apache/lucene/search/join/ToParentBlockJoinQuery.javaindex 5640c9e4a7c..1e4fe34a365 100644--- a/lucene/join/src/java/org/apache/lucene/search/join/ToParentBlockJoinQuery.java+++ b/lucene/join/src/java/org/apache/lucene/search/join/ToParentBlockJoinQuery.java@@ -22,7 +22,6 @@ import java.io.IOException;import java.util.Collection;import java.util.Collections;import java.util.Locale;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.IndexWriter;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.search.ConstantScoreQuery;@@ -425,12 +424,12 @@ public class ToParentBlockJoinQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {- final Query childRewrite = childQuery.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ final Query childRewrite = childQuery.rewrite(indexSearcher);if (childRewrite != childQuery) {return new ToParentBlockJoinQuery(childRewrite, parentsFilter, scoreMode);} else {- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}}diff --git a/lucene/luke/src/java/org/apache/lucene/luke/models/search/SearchImpl.java b/lucene/luke/src/java/org/apache/lucene/luke/models/search/SearchImpl.javaindex c4b96297d18..3aa4385fbc0 100644--- a/lucene/luke/src/java/org/apache/lucene/luke/models/search/SearchImpl.java+++ b/lucene/luke/src/java/org/apache/lucene/luke/models/search/SearchImpl.java@@ -152,7 +152,7 @@ public final class SearchImpl extends LukeModel implements Search {if (rewrite) {try {- query = query.rewrite(reader);+ query = query.rewrite(searcher);} catch (IOException e) {throw new LukeException(String.format(Locale.ENGLISH, "Failed to rewrite query: %s", query.toString()), e);diff --git a/lucene/misc/src/test/org/apache/lucene/misc/search/TestDiversifiedTopDocsCollector.java b/lucene/misc/src/test/org/apache/lucene/misc/search/TestDiversifiedTopDocsCollector.javaindex 6e8d9671a51..f189699c20b 100644--- a/lucene/misc/src/test/org/apache/lucene/misc/search/TestDiversifiedTopDocsCollector.java+++ b/lucene/misc/src/test/org/apache/lucene/misc/search/TestDiversifiedTopDocsCollector.java@@ -499,12 +499,12 @@ public class TestDiversifiedTopDocsCollector extends LuceneTestCase {}@Override- public Query rewrite(IndexReader reader) throws IOException {- Query rewritten = query.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ Query rewritten = query.rewrite(indexSearcher);if (rewritten != query) {return new DocValueScoreQuery(rewritten, scoreField);}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/monitor/src/java/org/apache/lucene/monitor/ForceNoBulkScoringQuery.java b/lucene/monitor/src/java/org/apache/lucene/monitor/ForceNoBulkScoringQuery.javaindex 2af23b4a561..a97d1054c4c 100644--- a/lucene/monitor/src/java/org/apache/lucene/monitor/ForceNoBulkScoringQuery.java+++ b/lucene/monitor/src/java/org/apache/lucene/monitor/ForceNoBulkScoringQuery.java@@ -19,7 +19,6 @@ package org.apache.lucene.monitor;import java.io.IOException;import java.util.Objects;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.search.*;import org.apache.lucene.search.Matches;@@ -34,10 +33,10 @@ class ForceNoBulkScoringQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {- Query rewritten = inner.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ Query rewritten = inner.rewrite(indexSearcher);if (rewritten != inner) return new ForceNoBulkScoringQuery(rewritten);- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/monitor/src/test/org/apache/lucene/monitor/MonitorTestBase.java b/lucene/monitor/src/test/org/apache/lucene/monitor/MonitorTestBase.javaindex 65017e73247..548c417aafe 100644--- a/lucene/monitor/src/test/org/apache/lucene/monitor/MonitorTestBase.java+++ b/lucene/monitor/src/test/org/apache/lucene/monitor/MonitorTestBase.java@@ -22,9 +22,9 @@ import java.util.HashMap;import java.util.Map;import org.apache.lucene.analysis.Analyzer;import org.apache.lucene.analysis.standard.StandardAnalyzer;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.queryparser.classic.ParseException;import org.apache.lucene.queryparser.classic.QueryParser;+import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.Query;import org.apache.lucene.search.QueryVisitor;import org.apache.lucene.tests.util.LuceneTestCase;@@ -65,7 +65,7 @@ public abstract class MonitorTestBase extends LuceneTestCase {public static class ThrowOnRewriteQuery extends Query {@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {throw new IOException("Error rewriting");}diff --git a/lucene/monitor/src/test/org/apache/lucene/monitor/TestForceNoBulkScoringQuery.java b/lucene/monitor/src/test/org/apache/lucene/monitor/TestForceNoBulkScoringQuery.javaindex 28f96c760b3..4f5011ba17e 100644--- a/lucene/monitor/src/test/org/apache/lucene/monitor/TestForceNoBulkScoringQuery.java+++ b/lucene/monitor/src/test/org/apache/lucene/monitor/TestForceNoBulkScoringQuery.java@@ -67,7 +67,7 @@ public class TestForceNoBulkScoringQuery extends LuceneTestCase {assertEquals(q.getWrappedQuery(), pq);- Query rewritten = q.rewrite(reader);+ Query rewritten = q.rewrite(newSearcher(reader));assertTrue(rewritten instanceof ForceNoBulkScoringQuery);Query inner = ((ForceNoBulkScoringQuery) rewritten).getWrappedQuery();diff --git a/lucene/queries/src/java/org/apache/lucene/queries/CommonTermsQuery.java b/lucene/queries/src/java/org/apache/lucene/queries/CommonTermsQuery.javaindex 46a7f45069a..b6ff82dce38 100644--- a/lucene/queries/src/java/org/apache/lucene/queries/CommonTermsQuery.java+++ b/lucene/queries/src/java/org/apache/lucene/queries/CommonTermsQuery.java@@ -30,6 +30,7 @@ import org.apache.lucene.index.TermsEnum;import org.apache.lucene.search.BooleanClause.Occur;import org.apache.lucene.search.BooleanQuery;import org.apache.lucene.search.BoostQuery;+import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.MatchNoDocsQuery;import org.apache.lucene.search.Query;import org.apache.lucene.search.QueryVisitor;@@ -101,7 +102,8 @@ public class CommonTermsQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ IndexReader reader = indexSearcher.getIndexReader();if (this.terms.isEmpty()) {return new MatchNoDocsQuery("CommonTermsQuery with no terms");} else if (this.terms.size() == 1) {diff --git a/lucene/queries/src/java/org/apache/lucene/queries/function/FunctionScoreQuery.java b/lucene/queries/src/java/org/apache/lucene/queries/function/FunctionScoreQuery.javaindex f5f03d20291..449188091bd 100644--- a/lucene/queries/src/java/org/apache/lucene/queries/function/FunctionScoreQuery.java+++ b/lucene/queries/src/java/org/apache/lucene/queries/function/FunctionScoreQuery.java@@ -19,7 +19,6 @@ package org.apache.lucene.queries.function;import java.io.IOException;import java.util.Objects;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.search.BooleanClause;import org.apache.lucene.search.DoubleValues;@@ -122,8 +121,8 @@ public final class FunctionScoreQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {- Query rewritten = in.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ Query rewritten = in.rewrite(indexSearcher);if (rewritten == in) {return this;}diff --git a/lucene/queries/src/java/org/apache/lucene/queries/mlt/MoreLikeThisQuery.java b/lucene/queries/src/java/org/apache/lucene/queries/mlt/MoreLikeThisQuery.javaindex 7ba1bb00b5e..159d30c8e54 100644--- a/lucene/queries/src/java/org/apache/lucene/queries/mlt/MoreLikeThisQuery.java+++ b/lucene/queries/src/java/org/apache/lucene/queries/mlt/MoreLikeThisQuery.java@@ -22,9 +22,9 @@ import java.util.Arrays;import java.util.Objects;import java.util.Set;import org.apache.lucene.analysis.Analyzer;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.search.BooleanClause;import org.apache.lucene.search.BooleanQuery;+import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.Query;import org.apache.lucene.search.QueryVisitor;@@ -57,8 +57,8 @@ public class MoreLikeThisQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {- MoreLikeThis mlt = new MoreLikeThis(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ MoreLikeThis mlt = new MoreLikeThis(indexSearcher.getIndexReader());mlt.setFieldNames(moreLikeFields);mlt.setAnalyzer(analyzer);diff --git a/lucene/queries/src/java/org/apache/lucene/queries/payloads/PayloadScoreQuery.java b/lucene/queries/src/java/org/apache/lucene/queries/payloads/PayloadScoreQuery.javaindex a782901f932..d4dd52b4620 100644--- a/lucene/queries/src/java/org/apache/lucene/queries/payloads/PayloadScoreQuery.java+++ b/lucene/queries/src/java/org/apache/lucene/queries/payloads/PayloadScoreQuery.java@@ -19,7 +19,6 @@ package org.apache.lucene.queries.payloads;import java.io.IOException;import java.util.Map;import java.util.Objects;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.PostingsEnum;import org.apache.lucene.index.Term;@@ -83,12 +82,12 @@ public class PayloadScoreQuery extends SpanQuery {}@Override- public Query rewrite(IndexReader reader) throws IOException {- Query matchRewritten = wrappedQuery.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ Query matchRewritten = wrappedQuery.rewrite(indexSearcher);if (wrappedQuery != matchRewritten && matchRewritten instanceof SpanQuery) {return new PayloadScoreQuery((SpanQuery) matchRewritten, function, decoder, includeSpanScore);}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/queries/src/java/org/apache/lucene/queries/payloads/SpanPayloadCheckQuery.java b/lucene/queries/src/java/org/apache/lucene/queries/payloads/SpanPayloadCheckQuery.javaindex 1d3c13ed9cd..ef04a8dccd0 100644--- a/lucene/queries/src/java/org/apache/lucene/queries/payloads/SpanPayloadCheckQuery.java+++ b/lucene/queries/src/java/org/apache/lucene/queries/payloads/SpanPayloadCheckQuery.java@@ -20,7 +20,6 @@ import java.io.IOException;import java.util.List;import java.util.Map;import java.util.Objects;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.PostingsEnum;import org.apache.lucene.index.Term;@@ -116,13 +115,13 @@ public class SpanPayloadCheckQuery extends SpanQuery {}@Override- public Query rewrite(IndexReader reader) throws IOException {- Query matchRewritten = match.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ Query matchRewritten = match.rewrite(indexSearcher);if (match != matchRewritten && matchRewritten instanceof SpanQuery) {return new SpanPayloadCheckQuery((SpanQuery) matchRewritten, payloadToMatch, payloadType, operation);}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/queries/src/java/org/apache/lucene/queries/spans/FieldMaskingSpanQuery.java b/lucene/queries/src/java/org/apache/lucene/queries/spans/FieldMaskingSpanQuery.javaindex 500f9aad456..038a2e3742d 100644--- a/lucene/queries/src/java/org/apache/lucene/queries/spans/FieldMaskingSpanQuery.java+++ b/lucene/queries/src/java/org/apache/lucene/queries/spans/FieldMaskingSpanQuery.java@@ -18,7 +18,6 @@ package org.apache.lucene.queries.spans;import java.io.IOException;import java.util.Objects;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.search.BooleanClause;import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.Query;@@ -93,13 +92,13 @@ public final class FieldMaskingSpanQuery extends SpanQuery {}@Override- public Query rewrite(IndexReader reader) throws IOException {- SpanQuery rewritten = (SpanQuery) maskedQuery.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ SpanQuery rewritten = (SpanQuery) maskedQuery.rewrite(indexSearcher);if (rewritten != maskedQuery) {return new FieldMaskingSpanQuery(rewritten, field);}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanContainQuery.java b/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanContainQuery.javaindex 680ceea0f78..99412f96406 100644--- a/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanContainQuery.java+++ b/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanContainQuery.java@@ -20,7 +20,6 @@ import java.io.IOException;import java.util.ArrayList;import java.util.Map;import java.util.Objects;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.Term;import org.apache.lucene.index.TermStates;@@ -109,9 +108,9 @@ abstract class SpanContainQuery extends SpanQuery implements Cloneable {}@Override- public Query rewrite(IndexReader reader) throws IOException {- SpanQuery rewrittenBig = (SpanQuery) big.rewrite(reader);- SpanQuery rewrittenLittle = (SpanQuery) little.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ SpanQuery rewrittenBig = (SpanQuery) big.rewrite(indexSearcher);+ SpanQuery rewrittenLittle = (SpanQuery) little.rewrite(indexSearcher);if (big != rewrittenBig || little != rewrittenLittle) {try {SpanContainQuery clone = (SpanContainQuery) super.clone();@@ -122,7 +121,7 @@ abstract class SpanContainQuery extends SpanQuery implements Cloneable {throw new AssertionError(e);}}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanMultiTermQueryWrapper.java b/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanMultiTermQueryWrapper.javaindex aa36368270e..82b105bbcd0 100644--- a/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanMultiTermQueryWrapper.java+++ b/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanMultiTermQueryWrapper.java@@ -20,7 +20,6 @@ import java.io.IOException;import java.util.ArrayList;import java.util.List;import java.util.Objects;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.Term;import org.apache.lucene.index.TermStates;import org.apache.lucene.search.BooleanClause.Occur;@@ -117,8 +116,8 @@ public class SpanMultiTermQueryWrapper<Q extends MultiTermQuery> extends SpanQue}@Override- public Query rewrite(IndexReader reader) throws IOException {- return rewriteMethod.rewrite(reader, query);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ return rewriteMethod.rewrite(indexSearcher, query);}@Override@@ -141,7 +140,8 @@ public class SpanMultiTermQueryWrapper<Q extends MultiTermQuery> extends SpanQue/** Abstract class that defines how the query is rewritten. */public abstract static class SpanRewriteMethod extends MultiTermQuery.RewriteMethod {@Override- public abstract SpanQuery rewrite(IndexReader reader, MultiTermQuery query) throws IOException;+ public abstract SpanQuery rewrite(IndexSearcher indexSearcher, MultiTermQuery query)+ throws IOException;}/**@@ -182,8 +182,9 @@ public class SpanMultiTermQueryWrapper<Q extends MultiTermQuery> extends SpanQue};@Override- public SpanQuery rewrite(IndexReader reader, MultiTermQuery query) throws IOException {- return (SpanQuery) delegate.rewrite(reader, query);+ public SpanQuery rewrite(IndexSearcher indexSearcher, MultiTermQuery query)+ throws IOException {+ return (SpanQuery) delegate.rewrite(indexSearcher, query);}};@@ -233,8 +234,8 @@ public class SpanMultiTermQueryWrapper<Q extends MultiTermQuery> extends SpanQue}@Override- public SpanQuery rewrite(IndexReader reader, MultiTermQuery query) throws IOException {- return (SpanQuery) delegate.rewrite(reader, query);+ public SpanQuery rewrite(IndexSearcher indexSearcher, MultiTermQuery query) throws IOException {+ return (SpanQuery) delegate.rewrite(indexSearcher, query);}@Overridediff --git a/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanNearQuery.java b/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanNearQuery.javaindex b3f9f8e357b..00318e4bae6 100644--- a/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanNearQuery.java+++ b/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanNearQuery.java@@ -23,7 +23,6 @@ import java.util.LinkedList;import java.util.List;import java.util.Map;import java.util.Objects;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.Term;import org.apache.lucene.index.TermStates;@@ -242,12 +241,12 @@ public class SpanNearQuery extends SpanQuery implements Cloneable {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {boolean actuallyRewritten = false;List<SpanQuery> rewrittenClauses = new ArrayList<>();for (int i = 0; i < clauses.size(); i++) {SpanQuery c = clauses.get(i);- SpanQuery query = (SpanQuery) c.rewrite(reader);+ SpanQuery query = (SpanQuery) c.rewrite(indexSearcher);actuallyRewritten |= query != c;rewrittenClauses.add(query);}@@ -260,7 +259,7 @@ public class SpanNearQuery extends SpanQuery implements Cloneable {throw new AssertionError(e);}}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanNotQuery.java b/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanNotQuery.javaindex fc2f334a4ba..aded21f5f7c 100644--- a/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanNotQuery.java+++ b/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanNotQuery.java@@ -19,7 +19,6 @@ package org.apache.lucene.queries.spans;import java.io.IOException;import java.util.Map;import java.util.Objects;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.Term;import org.apache.lucene.index.TermStates;@@ -224,13 +223,13 @@ public final class SpanNotQuery extends SpanQuery {}@Override- public Query rewrite(IndexReader reader) throws IOException {- SpanQuery rewrittenInclude = (SpanQuery) include.rewrite(reader);- SpanQuery rewrittenExclude = (SpanQuery) exclude.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ SpanQuery rewrittenInclude = (SpanQuery) include.rewrite(indexSearcher);+ SpanQuery rewrittenExclude = (SpanQuery) exclude.rewrite(indexSearcher);if (rewrittenInclude != include || rewrittenExclude != exclude) {return new SpanNotQuery(rewrittenInclude, rewrittenExclude, pre, post);}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanOrQuery.java b/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanOrQuery.javaindex 2b8e1856774..46b14aef92d 100644--- a/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanOrQuery.java+++ b/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanOrQuery.java@@ -21,7 +21,6 @@ import java.util.ArrayList;import java.util.Iterator;import java.util.List;import java.util.Map;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.Term;import org.apache.lucene.index.TermStates;@@ -67,19 +66,19 @@ public final class SpanOrQuery extends SpanQuery {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {SpanOrQuery rewritten = new SpanOrQuery();boolean actuallyRewritten = false;for (int i = 0; i < clauses.size(); i++) {SpanQuery c = clauses.get(i);- SpanQuery query = (SpanQuery) c.rewrite(reader);+ SpanQuery query = (SpanQuery) c.rewrite(indexSearcher);actuallyRewritten |= query != c;rewritten.addClause(query);}if (actuallyRewritten) {return rewritten;}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanPositionCheckQuery.java b/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanPositionCheckQuery.javaindex 0227a13f3ab..a83969f3fb5 100644--- a/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanPositionCheckQuery.java+++ b/lucene/queries/src/java/org/apache/lucene/queries/spans/SpanPositionCheckQuery.java@@ -19,7 +19,6 @@ package org.apache.lucene.queries.spans;import java.io.IOException;import java.util.Map;import java.util.Objects;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.Term;import org.apache.lucene.index.TermStates;@@ -113,8 +112,8 @@ public abstract class SpanPositionCheckQuery extends SpanQuery implements Clonea}@Override- public Query rewrite(IndexReader reader) throws IOException {- SpanQuery rewritten = (SpanQuery) match.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ SpanQuery rewritten = (SpanQuery) match.rewrite(indexSearcher);if (rewritten != match) {try {SpanPositionCheckQuery clone = (SpanPositionCheckQuery) this.clone();@@ -125,7 +124,7 @@ public abstract class SpanPositionCheckQuery extends SpanQuery implements Clonea}}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/queries/src/test/org/apache/lucene/queries/function/TestValueSources.java b/lucene/queries/src/test/org/apache/lucene/queries/function/TestValueSources.javaindex 93bed6fe9f5..48a84c105f2 100644--- a/lucene/queries/src/test/org/apache/lucene/queries/function/TestValueSources.java+++ b/lucene/queries/src/test/org/apache/lucene/queries/function/TestValueSources.java@@ -781,8 +781,8 @@ public class TestValueSources extends LuceneTestCase {}@Override- public Query rewrite(IndexReader reader) throws IOException {- var rewrite = in.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ var rewrite = in.rewrite(indexSearcher);return rewrite == in ? this : new AssertScoreComputedOnceQuery(rewrite);}diff --git a/lucene/queries/src/test/org/apache/lucene/queries/spans/AssertingSpanQuery.java b/lucene/queries/src/test/org/apache/lucene/queries/spans/AssertingSpanQuery.javaindex f22a70a0302..8eab12aa7d1 100644--- a/lucene/queries/src/test/org/apache/lucene/queries/spans/AssertingSpanQuery.java+++ b/lucene/queries/src/test/org/apache/lucene/queries/spans/AssertingSpanQuery.java@@ -18,7 +18,6 @@ package org.apache.lucene.queries.spans;import java.io.IOException;import java.util.Objects;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.Query;import org.apache.lucene.search.QueryVisitor;@@ -50,10 +49,10 @@ public class AssertingSpanQuery extends SpanQuery {}@Override- public Query rewrite(IndexReader reader) throws IOException {- Query q = in.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ Query q = in.rewrite(indexSearcher);if (q == in) {- return super.rewrite(reader);+ return super.rewrite(indexSearcher);} else if (q instanceof SpanQuery) {return new AssertingSpanQuery((SpanQuery) q);} else {diff --git a/lucene/queries/src/test/org/apache/lucene/queries/spans/TestFieldMaskingSpanQuery.java b/lucene/queries/src/test/org/apache/lucene/queries/spans/TestFieldMaskingSpanQuery.javaindex 567bfdf711e..9c98a002582 100644--- a/lucene/queries/src/test/org/apache/lucene/queries/spans/TestFieldMaskingSpanQuery.java+++ b/lucene/queries/src/test/org/apache/lucene/queries/spans/TestFieldMaskingSpanQuery.java@@ -164,7 +164,7 @@ public class TestFieldMaskingSpanQuery extends LuceneTestCase {new FieldMaskingSpanQuery(new SpanTermQuery(new Term("last", "sally")) {@Override- public Query rewrite(IndexReader reader) {+ public Query rewrite(IndexSearcher indexSearcher) {return new SpanOrQuery(new SpanTermQuery(new Term("first", "sally")),new SpanTermQuery(new Term("first", "james")));diff --git a/lucene/queries/src/test/org/apache/lucene/queries/spans/TestSpanMultiTermQueryWrapper.java b/lucene/queries/src/test/org/apache/lucene/queries/spans/TestSpanMultiTermQueryWrapper.javaindex 252818079c7..f0dbaebac90 100644--- a/lucene/queries/src/test/org/apache/lucene/queries/spans/TestSpanMultiTermQueryWrapper.java+++ b/lucene/queries/src/test/org/apache/lucene/queries/spans/TestSpanMultiTermQueryWrapper.java@@ -232,7 +232,8 @@ public class TestSpanMultiTermQueryWrapper extends LuceneTestCase {wrapper.setRewriteMethod(new SpanMultiTermQueryWrapper.SpanRewriteMethod() {@Override- public SpanQuery rewrite(IndexReader reader, MultiTermQuery query) throws IOException {+ public SpanQuery rewrite(IndexSearcher indexSearcher, MultiTermQuery query)+ throws IOException {return null;}});diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/complexPhrase/ComplexPhraseQueryParser.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/complexPhrase/ComplexPhraseQueryParser.javaindex 4dad705b876..339e60a14bd 100644--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/complexPhrase/ComplexPhraseQueryParser.java+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/complexPhrase/ComplexPhraseQueryParser.java@@ -22,7 +22,6 @@ import java.util.Iterator;import java.util.List;import java.util.Objects;import org.apache.lucene.analysis.Analyzer;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.Term;import org.apache.lucene.queries.spans.SpanNearQuery;import org.apache.lucene.queries.spans.SpanNotQuery;@@ -256,7 +255,7 @@ public class ComplexPhraseQueryParser extends QueryParser {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {final Query contents = this.contents[0];// ArrayList spanClauses = new ArrayList();if (contents instanceof TermQuery@@ -284,7 +283,7 @@ public class ComplexPhraseQueryParser extends QueryParser {// HashSet bclauseterms=new HashSet();Query qc = clause.getQuery();// Rewrite this clause e.g one* becomes (one OR onerous)- qc = new IndexSearcher(reader).rewrite(qc);+ qc = indexSearcher.rewrite(qc);if (clause.getOccur().equals(BooleanClause.Occur.MUST_NOT)) {numNegatives++;}diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/DistanceRewriteQuery.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/DistanceRewriteQuery.javaindex d739bc022e6..7186aa3cf24 100644--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/DistanceRewriteQuery.java+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/DistanceRewriteQuery.java@@ -17,7 +17,7 @@package org.apache.lucene.queryparser.surround.query;import java.io.IOException;-import org.apache.lucene.index.IndexReader;+import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.Query;import org.apache.lucene.search.QueryVisitor;@@ -28,8 +28,8 @@ class DistanceRewriteQuery extends RewriteQuery<DistanceQuery> {}@Override- public Query rewrite(IndexReader reader) throws IOException {- return srndQuery.getSpanNearQuery(reader, fieldName, qf);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ return srndQuery.getSpanNearQuery(indexSearcher.getIndexReader(), fieldName, qf);}@Overridediff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/RewriteQuery.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/RewriteQuery.javaindex 69005e6dd00..533cf72ce02 100644--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/RewriteQuery.java+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/RewriteQuery.java@@ -18,7 +18,7 @@ package org.apache.lucene.queryparser.surround.query;import java.io.IOException;import java.util.Objects;-import org.apache.lucene.index.IndexReader;+import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.Query;abstract class RewriteQuery<SQ extends SrndQuery> extends Query {@@ -33,7 +33,7 @@ abstract class RewriteQuery<SQ extends SrndQuery> extends Query {}@Override- public abstract Query rewrite(IndexReader reader) throws IOException;+ public abstract Query rewrite(IndexSearcher indexSearcher) throws IOException;@Overridepublic String toString(String field) {diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/SimpleTermRewriteQuery.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/SimpleTermRewriteQuery.javaindex 22f1118beb4..4371e5f224f 100644--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/SimpleTermRewriteQuery.java+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/surround/query/SimpleTermRewriteQuery.java@@ -19,9 +19,9 @@ package org.apache.lucene.queryparser.surround.query;import java.io.IOException;import java.util.ArrayList;import java.util.List;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.Term;import org.apache.lucene.search.BooleanClause;+import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.MatchNoDocsQuery;import org.apache.lucene.search.Query;import org.apache.lucene.search.QueryVisitor;@@ -33,10 +33,10 @@ class SimpleTermRewriteQuery extends RewriteQuery<SimpleTerm> {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {final List<Query> luceneSubQueries = new ArrayList<>();srndQuery.visitMatchingTerms(- reader,+ indexSearcher.getIndexReader(),fieldName,new SimpleTerm.MatchingTermVisitor() {@Overridediff --git a/lucene/queryparser/src/test/org/apache/lucene/queryparser/xml/TestCoreParser.java b/lucene/queryparser/src/test/org/apache/lucene/queryparser/xml/TestCoreParser.javaindex debf6e404bc..95ee8cdfd60 100644--- a/lucene/queryparser/src/test/org/apache/lucene/queryparser/xml/TestCoreParser.java+++ b/lucene/queryparser/src/test/org/apache/lucene/queryparser/xml/TestCoreParser.java@@ -315,7 +315,7 @@ public class TestCoreParser extends LuceneTestCase {}protected Query rewrite(Query q) throws IOException {- return q.rewrite(reader());+ return q.rewrite(searcher());}protected void dumpResults(String qType, Query q, int numDocs) throws IOException {diff --git a/lucene/sandbox/src/java/org/apache/lucene/sandbox/queries/FuzzyLikeThisQuery.java b/lucene/sandbox/src/java/org/apache/lucene/sandbox/queries/FuzzyLikeThisQuery.javaindex 6193d27a99f..ab4cbb05fc9 100644--- a/lucene/sandbox/src/java/org/apache/lucene/sandbox/queries/FuzzyLikeThisQuery.java+++ b/lucene/sandbox/src/java/org/apache/lucene/sandbox/queries/FuzzyLikeThisQuery.java@@ -38,6 +38,7 @@ import org.apache.lucene.search.BoostAttribute;import org.apache.lucene.search.BoostQuery;import org.apache.lucene.search.ConstantScoreQuery;import org.apache.lucene.search.FuzzyTermsEnum;+import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.Query;import org.apache.lucene.search.QueryVisitor;import org.apache.lucene.search.TermQuery;@@ -282,7 +283,8 @@ public class FuzzyLikeThisQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ IndexReader reader = indexSearcher.getIndexReader();ScoreTermQueue q = new ScoreTermQueue(maxNumTerms);// load up the list of possible termsfor (FieldVals f : fieldVals) {diff --git a/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/CombinedFieldQuery.java b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/CombinedFieldQuery.javaindex 88a905d8f77..be59acae655 100644--- a/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/CombinedFieldQuery.java+++ b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/CombinedFieldQuery.java@@ -253,7 +253,7 @@ public final class CombinedFieldQuery extends Query implements Accountable {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {if (terms.length == 0 || fieldAndWeights.isEmpty()) {return new BooleanQuery.Builder().build();}diff --git a/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/CoveringQuery.java b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/CoveringQuery.javaindex 69e5bd69f83..5a493a00c1a 100644--- a/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/CoveringQuery.java+++ b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/CoveringQuery.java@@ -22,7 +22,6 @@ import java.util.Collection;import java.util.List;import java.util.Objects;import java.util.stream.Collectors;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.search.BooleanClause;import org.apache.lucene.search.BooleanQuery;@@ -125,7 +124,7 @@ public final class CoveringQuery extends Query implements Accountable {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {if (minimumNumberMatch instanceof LongValuesSource.ConstantLongValuesSource) {final long constantMin =((LongValuesSource.ConstantLongValuesSource) minimumNumberMatch).getValue();@@ -136,7 +135,7 @@ public final class CoveringQuery extends Query implements Accountable {BooleanQuery.Builder builder =new BooleanQuery.Builder().setMinimumNumberShouldMatch((int) Math.max(constantMin, 1));for (Query query : queries) {- Query r = query.rewrite(reader);+ Query r = query.rewrite(indexSearcher);builder.add(r, BooleanClause.Occur.SHOULD);}return builder.build();@@ -144,14 +143,14 @@ public final class CoveringQuery extends Query implements Accountable {Multiset<Query> rewritten = new Multiset<>();boolean actuallyRewritten = false;for (Query query : queries) {- Query r = query.rewrite(reader);+ Query r = query.rewrite(indexSearcher);rewritten.add(r);actuallyRewritten |= query != r;}if (actuallyRewritten) {return new CoveringQuery(rewritten, minimumNumberMatch);}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/IndexSortSortedNumericDocValuesRangeQuery.java b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/IndexSortSortedNumericDocValuesRangeQuery.javaindex a3baa9d48bd..723803e6d08 100644--- a/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/IndexSortSortedNumericDocValuesRangeQuery.java+++ b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/IndexSortSortedNumericDocValuesRangeQuery.java@@ -22,7 +22,6 @@ import java.util.function.Predicate;import org.apache.lucene.document.IntPoint;import org.apache.lucene.document.LongPoint;import org.apache.lucene.index.DocValues;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.NumericDocValues;@@ -148,12 +147,12 @@ public class IndexSortSortedNumericDocValuesRangeQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {if (lowerValue == Long.MIN_VALUE && upperValue == Long.MAX_VALUE) {return new FieldExistsQuery(field);}- Query rewrittenFallback = fallbackQuery.rewrite(reader);+ Query rewrittenFallback = fallbackQuery.rewrite(indexSearcher);if (rewrittenFallback.getClass() == MatchAllDocsQuery.class) {return new MatchAllDocsQuery();}diff --git a/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/MultiRangeQuery.java b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/MultiRangeQuery.javaindex 19b885dfed5..837de213d22 100644--- a/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/MultiRangeQuery.java+++ b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/MultiRangeQuery.java@@ -23,7 +23,6 @@ import java.util.Arrays;import java.util.Comparator;import java.util.List;import java.util.Objects;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.PointValues;@@ -169,7 +168,7 @@ public abstract class MultiRangeQuery extends Query implements Cloneable {* #mergeOverlappingRanges}*/@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {if (numDims != 1) {return this;}diff --git a/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/PhraseWildcardQuery.java b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/PhraseWildcardQuery.javaindex c4fc7189fe1..bbe8a4970eb 100644--- a/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/PhraseWildcardQuery.java+++ b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/PhraseWildcardQuery.java@@ -113,14 +113,14 @@ public class PhraseWildcardQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {if (phraseTerms.isEmpty()) {return NO_MATCH_QUERY;}if (phraseTerms.size() == 1) {return phraseTerms.get(0).getQuery();}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/TermAutomatonQuery.java b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/TermAutomatonQuery.javaindex 42aad127841..0fbdaf4ac8a 100644--- a/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/TermAutomatonQuery.java+++ b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/TermAutomatonQuery.java@@ -23,7 +23,6 @@ import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.IndexReaderContext;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.PostingsEnum;@@ -449,7 +448,7 @@ public class TermAutomatonQuery extends Query implements Accountable {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {if (Operations.isEmpty(det)) {return new MatchNoDocsQuery();}diff --git a/lucene/sandbox/src/test/org/apache/lucene/sandbox/queries/TestFuzzyLikeThisQuery.java b/lucene/sandbox/src/test/org/apache/lucene/sandbox/queries/TestFuzzyLikeThisQuery.javaindex 740241188d1..42b4a7ff4f4 100644--- a/lucene/sandbox/src/test/org/apache/lucene/sandbox/queries/TestFuzzyLikeThisQuery.java+++ b/lucene/sandbox/src/test/org/apache/lucene/sandbox/queries/TestFuzzyLikeThisQuery.java@@ -81,7 +81,7 @@ public class TestFuzzyLikeThisQuery extends LuceneTestCase {public void testClosestEditDistanceMatchComesFirst() throws Throwable {FuzzyLikeThisQuery flt = new FuzzyLikeThisQuery(10, analyzer);flt.addTerms("smith", "name", 2, 1);- Query q = flt.rewrite(searcher.getIndexReader());+ Query q = flt.rewrite(searcher);HashSet<Term> queryTerms = new HashSet<>();q.visit(QueryVisitor.termCollector(queryTerms));assertTrue("Should have variant smythe", queryTerms.contains(new Term("name", "smythe")));@@ -98,7 +98,7 @@ public class TestFuzzyLikeThisQuery extends LuceneTestCase {public void testMultiWord() throws Throwable {FuzzyLikeThisQuery flt = new FuzzyLikeThisQuery(10, analyzer);flt.addTerms("jonathin smoth", "name", 2, 1);- Query q = flt.rewrite(searcher.getIndexReader());+ Query q = flt.rewrite(searcher);HashSet<Term> queryTerms = new HashSet<>();q.visit(QueryVisitor.termCollector(queryTerms));assertTrue("Should have variant jonathan", queryTerms.contains(new Term("name", "jonathan")));@@ -116,7 +116,7 @@ public class TestFuzzyLikeThisQuery extends LuceneTestCase {flt.addTerms("jonathin smoth", "name", 2, 1);flt.addTerms("jonathin smoth", "this field does not exist", 2, 1);// don't fail here just because the field doesn't exits- Query q = flt.rewrite(searcher.getIndexReader());+ Query q = flt.rewrite(searcher);HashSet<Term> queryTerms = new HashSet<>();q.visit(QueryVisitor.termCollector(queryTerms));assertTrue("Should have variant jonathan", queryTerms.contains(new Term("name", "jonathan")));@@ -132,7 +132,7 @@ public class TestFuzzyLikeThisQuery extends LuceneTestCase {public void testNoMatchFirstWordBug() throws Throwable {FuzzyLikeThisQuery flt = new FuzzyLikeThisQuery(10, analyzer);flt.addTerms("fernando smith", "name", 2, 1);- Query q = flt.rewrite(searcher.getIndexReader());+ Query q = flt.rewrite(searcher);HashSet<Term> queryTerms = new HashSet<>();q.visit(QueryVisitor.termCollector(queryTerms));assertTrue("Should have variant smith", queryTerms.contains(new Term("name", "smith")));diff --git a/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestCoveringQuery.java b/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestCoveringQuery.javaindex 98d174f806c..3edc18b16a0 100644--- a/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestCoveringQuery.java+++ b/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestCoveringQuery.java@@ -80,7 +80,8 @@ public class TestCoveringQuery extends LuceneTestCase {LongValuesSource vs = LongValuesSource.fromIntField("field");assertEquals(new CoveringQuery(Collections.singleton(tq), vs),- new CoveringQuery(Collections.singleton(pq), vs).rewrite(new MultiReader()));+ new CoveringQuery(Collections.singleton(pq), vs)+ .rewrite(new IndexSearcher(new MultiReader())));}public void testToString() {diff --git a/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestIndexSortSortedNumericDocValuesRangeQuery.java b/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestIndexSortSortedNumericDocValuesRangeQuery.javaindex fc0e3b098af..b8aa0b5a65d 100644--- a/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestIndexSortSortedNumericDocValuesRangeQuery.java+++ b/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestIndexSortSortedNumericDocValuesRangeQuery.java@@ -372,7 +372,7 @@ public class TestIndexSortSortedNumericDocValuesRangeQuery extends LuceneTestCasIndexReader reader = writer.getReader();Query query = createQuery("field", Long.MIN_VALUE, Long.MAX_VALUE);- Query rewrittenQuery = query.rewrite(reader);+ Query rewrittenQuery = query.rewrite(newSearcher(reader));assertEquals(new FieldExistsQuery("field"), rewrittenQuery);writer.close();@@ -390,7 +390,7 @@ public class TestIndexSortSortedNumericDocValuesRangeQuery extends LuceneTestCasQuery fallbackQuery = new BooleanQuery.Builder().build();Query query = new IndexSortSortedNumericDocValuesRangeQuery("field", 1, 42, fallbackQuery);- Query rewrittenQuery = query.rewrite(reader);+ Query rewrittenQuery = query.rewrite(newSearcher(reader));assertNotEquals(query, rewrittenQuery);assertThat(rewrittenQuery, instanceOf(IndexSortSortedNumericDocValuesRangeQuery.class));diff --git a/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestMultiRangeQueries.java b/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestMultiRangeQueries.javaindex 03b92418199..1b170b88cd3 100644--- a/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestMultiRangeQueries.java+++ b/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestMultiRangeQueries.java@@ -806,7 +806,7 @@ public class TestMultiRangeQueries extends LuceneTestCase {builder2.add(LongPoint.newRangeQuery("point", lower, upper), BooleanClause.Occur.SHOULD);}- MultiRangeQuery multiRangeQuery = (MultiRangeQuery) builder1.build().rewrite(reader);+ MultiRangeQuery multiRangeQuery = (MultiRangeQuery) builder1.build().rewrite(searcher);BooleanQuery booleanQuery = builder2.build();int count = searcher.search(multiRangeQuery, DummyTotalHitCountCollector.createManager());int booleanCount = searcher.search(booleanQuery, DummyTotalHitCountCollector.createManager());@@ -839,7 +839,7 @@ public class TestMultiRangeQueries extends LuceneTestCase {builder2.add(LongPoint.newRangeQuery("point", lower, upper), BooleanClause.Occur.SHOULD);}- MultiRangeQuery multiRangeQuery = (MultiRangeQuery) builder1.build().rewrite(reader);+ MultiRangeQuery multiRangeQuery = (MultiRangeQuery) builder1.build().rewrite(searcher);BooleanQuery booleanQuery = builder2.build();int count =multiRangeQuerydiff --git a/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestTermAutomatonQuery.java b/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestTermAutomatonQuery.javaindex 431fb3eb3e3..d3d02b70894 100644--- a/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestTermAutomatonQuery.java+++ b/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestTermAutomatonQuery.java@@ -785,7 +785,7 @@ public class TestTermAutomatonQuery extends LuceneTestCase {w.addDocument(doc);IndexReader r = w.getReader();- assertTrue(q.rewrite(r) instanceof MatchNoDocsQuery);+ assertTrue(q.rewrite(newSearcher(r)) instanceof MatchNoDocsQuery);IOUtils.close(w, r, dir);}@@ -804,7 +804,7 @@ public class TestTermAutomatonQuery extends LuceneTestCase {w.addDocument(doc);IndexReader r = w.getReader();- Query rewrite = q.rewrite(r);+ Query rewrite = q.rewrite(newSearcher(r));assertTrue(rewrite instanceof TermQuery);assertEquals(new Term("field", "foo"), ((TermQuery) rewrite).getTerm());IOUtils.close(w, r, dir);@@ -827,7 +827,7 @@ public class TestTermAutomatonQuery extends LuceneTestCase {w.addDocument(doc);IndexReader r = w.getReader();- Query rewrite = q.rewrite(r);+ Query rewrite = q.rewrite(newSearcher(r));assertTrue(rewrite instanceof PhraseQuery);Term[] terms = ((PhraseQuery) rewrite).getTerms();assertEquals(new Term("field", "foo"), terms[0]);@@ -859,7 +859,7 @@ public class TestTermAutomatonQuery extends LuceneTestCase {w.addDocument(doc);IndexReader r = w.getReader();- Query rewrite = q.rewrite(r);+ Query rewrite = q.rewrite(newSearcher(r));assertTrue(rewrite instanceof PhraseQuery);Term[] terms = ((PhraseQuery) rewrite).getTerms();assertEquals(new Term("field", "foo"), terms[0]);@@ -888,7 +888,7 @@ public class TestTermAutomatonQuery extends LuceneTestCase {w.addDocument(doc);IndexReader r = w.getReader();- Query rewrite = q.rewrite(r);+ Query rewrite = q.rewrite(newSearcher(r));assertTrue(rewrite instanceof MultiPhraseQuery);Term[][] terms = ((MultiPhraseQuery) rewrite).getTermArrays();assertEquals(1, terms.length);@@ -923,7 +923,7 @@ public class TestTermAutomatonQuery extends LuceneTestCase {w.addDocument(doc);IndexReader r = w.getReader();- Query rewrite = q.rewrite(r);+ Query rewrite = q.rewrite(newSearcher(r));assertTrue(rewrite instanceof MultiPhraseQuery);Term[][] terms = ((MultiPhraseQuery) rewrite).getTermArrays();assertEquals(2, terms.length);diff --git a/lucene/spatial-extras/src/java/org/apache/lucene/spatial/composite/CompositeVerifyQuery.java b/lucene/spatial-extras/src/java/org/apache/lucene/spatial/composite/CompositeVerifyQuery.javaindex 354a0196229..6483e425394 100644--- a/lucene/spatial-extras/src/java/org/apache/lucene/spatial/composite/CompositeVerifyQuery.java+++ b/lucene/spatial-extras/src/java/org/apache/lucene/spatial/composite/CompositeVerifyQuery.java@@ -17,7 +17,6 @@package org.apache.lucene.spatial.composite;import java.io.IOException;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.search.ConstantScoreScorer;import org.apache.lucene.search.ConstantScoreWeight;@@ -47,12 +46,12 @@ public class CompositeVerifyQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {- final Query rewritten = indexQuery.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ final Query rewritten = indexQuery.rewrite(indexSearcher);if (rewritten != indexQuery) {return new CompositeVerifyQuery(rewritten, predicateValueSource);}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/spatial-extras/src/java/org/apache/lucene/spatial/vector/PointVectorStrategy.java b/lucene/spatial-extras/src/java/org/apache/lucene/spatial/vector/PointVectorStrategy.javaindex 77055d15ae2..0442b1c7ec0 100644--- a/lucene/spatial-extras/src/java/org/apache/lucene/spatial/vector/PointVectorStrategy.java+++ b/lucene/spatial-extras/src/java/org/apache/lucene/spatial/vector/PointVectorStrategy.java@@ -24,7 +24,6 @@ import org.apache.lucene.document.Field;import org.apache.lucene.document.FieldType;import org.apache.lucene.document.StoredField;import org.apache.lucene.index.DocValuesType;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.search.BooleanClause;import org.apache.lucene.search.BooleanQuery;@@ -253,8 +252,8 @@ public class PointVectorStrategy extends SpatialStrategy {}@Override- public Query rewrite(IndexReader reader) throws IOException {- Query rewritten = inner.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ Query rewritten = inner.rewrite(indexSearcher);if (rewritten == inner) return this;return new DistanceRangeQuery(rewritten, distanceSource, limit);}diff --git a/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionQuery.java b/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionQuery.javaindex 577c1a88656..8db16c194a7 100644--- a/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionQuery.java+++ b/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionQuery.java@@ -20,11 +20,11 @@ import static org.apache.lucene.analysis.miscellaneous.ConcatenateGraphFilter.SEimport static org.apache.lucene.search.suggest.document.CompletionAnalyzer.HOLE_CHARACTER;import java.io.IOException;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.Term;import org.apache.lucene.index.Terms;+import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.Query;import org.apache.lucene.search.suggest.BitsProducer;@@ -83,11 +83,11 @@ public abstract class CompletionQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {byte type = 0;boolean first = true;Terms terms;- for (LeafReaderContext context : reader.leaves()) {+ for (LeafReaderContext context : indexSearcher.getLeafContexts()) {LeafReader leafReader = context.reader();try {if ((terms = leafReader.terms(getField())) == null) {@@ -124,7 +124,7 @@ public abstract class CompletionQuery extends Query {}}}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/SuggestIndexSearcher.java b/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/SuggestIndexSearcher.javaindex b4b97dbde29..e46e73bb1aa 100644--- a/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/SuggestIndexSearcher.java+++ b/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/SuggestIndexSearcher.java@@ -62,7 +62,7 @@ public class SuggestIndexSearcher extends IndexSearcher {public void suggest(CompletionQuery query, TopSuggestDocsCollector collector) throws IOException {// TODO use IndexSearcher.rewrite instead// have to implement equals() and hashCode() in CompletionQuerys and co- query = (CompletionQuery) query.rewrite(getIndexReader());+ query = (CompletionQuery) query.rewrite(this);Weight weight = query.createWeight(this, collector.scoreMode(), 1f);for (LeafReaderContext context : getIndexReader().leaves()) {BulkScorer scorer = weight.bulkScorer(context);diff --git a/lucene/test-framework/src/java/org/apache/lucene/tests/search/AssertingQuery.java b/lucene/test-framework/src/java/org/apache/lucene/tests/search/AssertingQuery.javaindex 0947ff908bb..d4fcb653aba 100644--- a/lucene/test-framework/src/java/org/apache/lucene/tests/search/AssertingQuery.java+++ b/lucene/test-framework/src/java/org/apache/lucene/tests/search/AssertingQuery.java@@ -18,7 +18,6 @@ package org.apache.lucene.tests.search;import java.io.IOException;import java.util.Random;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.Query;import org.apache.lucene.search.QueryVisitor;@@ -74,10 +73,10 @@ public final class AssertingQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {- final Query rewritten = in.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ final Query rewritten = in.rewrite(indexSearcher);if (rewritten == in) {- return super.rewrite(reader);+ return super.rewrite(indexSearcher);} else {return wrap(new Random(random.nextLong()), rewritten);}diff --git a/lucene/test-framework/src/java/org/apache/lucene/tests/search/BlockScoreQueryWrapper.java b/lucene/test-framework/src/java/org/apache/lucene/tests/search/BlockScoreQueryWrapper.javaindex ebb5c4bd132..5745aef757b 100644--- a/lucene/test-framework/src/java/org/apache/lucene/tests/search/BlockScoreQueryWrapper.java+++ b/lucene/test-framework/src/java/org/apache/lucene/tests/search/BlockScoreQueryWrapper.java@@ -19,7 +19,6 @@ package org.apache.lucene.tests.search;import java.io.IOException;import java.util.Arrays;import java.util.Objects;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.search.DocIdSetIterator;import org.apache.lucene.search.Explanation;@@ -69,12 +68,12 @@ public final class BlockScoreQueryWrapper extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {- final Query rewritten = query.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ final Query rewritten = query.rewrite(indexSearcher);if (rewritten != query) {return new BlockScoreQueryWrapper(rewritten, blockLength);}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Overridediff --git a/lucene/test-framework/src/java/org/apache/lucene/tests/search/RandomApproximationQuery.java b/lucene/test-framework/src/java/org/apache/lucene/tests/search/RandomApproximationQuery.javaindex 78dc60732fb..d58baae6936 100644--- a/lucene/test-framework/src/java/org/apache/lucene/tests/search/RandomApproximationQuery.java+++ b/lucene/test-framework/src/java/org/apache/lucene/tests/search/RandomApproximationQuery.java@@ -19,7 +19,6 @@ package org.apache.lucene.tests.search;import com.carrotsearch.randomizedtesting.generators.RandomNumbers;import java.io.IOException;import java.util.Random;-import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.search.DocIdSetIterator;import org.apache.lucene.search.FilterWeight;@@ -43,12 +42,12 @@ public class RandomApproximationQuery extends Query {}@Override- public Query rewrite(IndexReader reader) throws IOException {- final Query rewritten = query.rewrite(reader);+ public Query rewrite(IndexSearcher indexSearcher) throws IOException {+ final Query rewritten = query.rewrite(indexSearcher);if (rewritten != query) {return new RandomApproximationQuery(rewritten, random);}- return super.rewrite(reader);+ return super.rewrite(indexSearcher);}@Override