[backport] GITHUB-11838 Add api to allow concurrent query rewrite

.gitignore

@@ -65,4 +65,4 @@ websites/apidocs/api/**/*.manifest
 svn-*/
 
 # vscode files
-.vscode/
+.vscode/*

src/Lucene.Net.Facet/DrillDownQuery.cs

@@ -1,5 +1,6 @@
 // Lucene version compatibility level 4.8.1
 using Lucene.Net.Diagnostics;
+using Lucene.Net.Search;
 using Lucene.Net.Support;
 using System;
 using System.Collections;
@@ -141,7 +142,7 @@ public DrillDownQuery(FacetsConfig config)
         /// <summary>
         /// Creates a new <see cref="DrillDownQuery"/> over the given base query. Can be
         /// <c>null</c>, in which case the result <see cref="Query"/> from
-        /// <see cref="Rewrite(IndexReader)"/> will be a pure browsing query, filtering on
+        /// <see cref="Rewrite(IndexSearcher)"/> will be a pure browsing query, filtering on
         /// the added categories only. 
         /// </summary>
         public DrillDownQuery(FacetsConfig config, Query baseQuery)
@@ -297,7 +298,7 @@ public override bool Equals(object obj)
             return query.Equals(other.query) && base.Equals(other);
         }
 
-        public override Query Rewrite(IndexReader r)
+        public override Query Rewrite(IndexSearcher indexSearcher)
         {
             if (query.Clauses.Count == 0)
             {

src/Lucene.Net.Facet/DrillSidewaysQuery.cs

@@ -62,12 +62,12 @@ public override string ToString(string field)
             return nameof(DrillSidewaysQuery);
         }
 
-        public override Query Rewrite(IndexReader reader)
+        public override Query Rewrite(IndexSearcher indexSearcher)
         {
             Query newQuery = baseQuery;
             while (true)
             {
-                Query rewrittenQuery = newQuery.Rewrite(reader);
+                Query rewrittenQuery = newQuery.Rewrite(indexSearcher);
                 if (rewrittenQuery == newQuery)
                 {
                     break;

src/Lucene.Net.Highlighter/Highlight/QueryTermExtractor.cs

@@ -28,7 +28,7 @@ namespace Lucene.Net.Search.Highlight
     /// <summary> 
     /// Utility class used to extract the terms used in a query, plus any weights.
     /// This class will not find terms for <see cref="MultiTermQuery"/>, RangeQuery and <see cref="PrefixQuery"/> classes
-    /// so the caller must pass a rewritten query (see <see cref="Query.Rewrite(IndexReader)"/>) to obtain a list of 
+    /// so the caller must pass a rewritten query (see <see cref="Query.Rewrite(IndexSearcher)"/>) to obtain a list of 
     /// expanded terms.
     /// </summary>
     public static class QueryTermExtractor

src/Lucene.Net.Highlighter/Highlight/QueryTermScorer.cs

@@ -43,7 +43,7 @@ public class QueryTermScorer : IScorer
         private ICharTermAttribute termAtt;
 
         /// <param name="query">
-        /// a Lucene query (ideally rewritten using <see cref="Query.Rewrite(IndexReader)"/> before
+        /// a Lucene query (ideally rewritten using <see cref="Query.Rewrite(IndexSearcher)"/> before
         /// being passed to this class and the searcher)
         /// </param>
         public QueryTermScorer(Query query)
@@ -52,7 +52,7 @@ public QueryTermScorer(Query query)
         }
 
         /// <param name="query">
-        /// a Lucene query (ideally rewritten using <see cref="Query.Rewrite(IndexReader)"/> before
+        /// a Lucene query (ideally rewritten using <see cref="Query.Rewrite(IndexSearcher)"/> before
         /// being passed to this class and the searcher)
         /// </param>
         /// <param name="fieldName">the Field name which is used to match Query terms</param>
@@ -62,7 +62,7 @@ public QueryTermScorer(Query query, string fieldName)
         }
 
         /// <param name="query">
-        /// a Lucene query (ideally rewritten using <see cref="Query.Rewrite(IndexReader)"/> before
+        /// a Lucene query (ideally rewritten using <see cref="Query.Rewrite(IndexSearcher)"/> before
         /// being passed to this class and the searcher)
         /// </param>
         /// <param name="reader">

src/Lucene.Net.Highlighter/Highlight/WeightedSpanTermExtractor.cs

@@ -219,7 +219,7 @@ protected virtual void Extract(Query query, IDictionary<string, WeightedSpanTerm
                     origQuery = copy;
                 }
                 IndexReader reader = GetLeafContext().Reader;
-                Query rewritten = origQuery.Rewrite(reader);
+                Query rewritten = origQuery.Rewrite(new IndexSearcher(reader));
                 if (rewritten != origQuery)
                 {
                     // only rewrite once and then flatten again - the rewritten query could have a speacial treatment
@@ -272,7 +272,7 @@ protected virtual void ExtractWeightedSpanTerms(IDictionary<string, WeightedSpan
             {
                 foreach (string field in fieldNames)
                 {
-                    SpanQuery rewrittenQuery = (SpanQuery)spanQuery.Rewrite(GetLeafContext().Reader);
+                    SpanQuery rewrittenQuery = (SpanQuery)spanQuery.Rewrite(new IndexSearcher(GetLeafContext().Reader));
                     queries[field] = rewrittenQuery;
                     rewrittenQuery.ExtractTerms(nonWeightedTerms);
                 }

src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs

@@ -881,9 +881,10 @@ public override long GetCost()
 
         private static Query Rewrite(Query original)
         {
+            var indexSearcher = new IndexSearcher(EMPTY_INDEXREADER);
             Query query = original;
-            for (Query rewrittenQuery = query.Rewrite(EMPTY_INDEXREADER); rewrittenQuery != query;
-                rewrittenQuery = query.Rewrite(EMPTY_INDEXREADER))
+            for (Query rewrittenQuery = query.Rewrite(indexSearcher); rewrittenQuery != query;
+                rewrittenQuery = query.Rewrite(indexSearcher))
             {
                 query = rewrittenQuery;
             }

src/Lucene.Net.Highlighter/VectorHighlight/FieldQuery.cs

@@ -50,8 +50,16 @@ internal FieldQuery(Query query, IndexReader reader, bool phraseHighlight, bool
             this.fieldMatch = fieldMatch;
             // LUCENENET NOTE: LinkedHashSet cares about insertion order
             ISet<Query> flatQueries = new JCG.LinkedHashSet<Query>();
-            Flatten(query, reader, flatQueries);
-            SaveTerms(flatQueries, reader);
+
+            IndexSearcher searcher;
+            if (reader == null) {
+                searcher = null;
+            } else {
+                searcher = new IndexSearcher(reader);
+            }
+
+            Flatten(query, searcher, flatQueries);
+            SaveTerms(flatQueries, searcher);
             ICollection<Query> expandQueries = Expand(flatQueries);
 
             foreach (Query flatQuery in expandQueries)
@@ -81,23 +89,23 @@ internal FieldQuery(Query query, bool phraseHighlight, bool fieldMatch)
         {
         }
 
-        internal void Flatten(Query sourceQuery, IndexReader reader, ICollection<Query> flatQueries)
+        internal void Flatten(Query sourceQuery, IndexSearcher indexSearcher, ICollection<Query> flatQueries)
         {
             if (sourceQuery is BooleanQuery bq)
             {
                 foreach (BooleanClause clause in bq)
                 {
                     if (!clause.IsProhibited)
                     {
-                        Flatten(ApplyParentBoost(clause.Query, bq), reader, flatQueries);
+                        Flatten(ApplyParentBoost(clause.Query, bq), indexSearcher, flatQueries);
                     }
                 }
             }
             else if (sourceQuery is DisjunctionMaxQuery dmq)
             {
                 foreach (Query query in dmq)
                 {
-                    Flatten(ApplyParentBoost(query, dmq), reader, flatQueries);
+                    Flatten(ApplyParentBoost(query, dmq), indexSearcher, flatQueries);
                 }
             }
             else if (sourceQuery is TermQuery)
@@ -126,18 +134,18 @@ internal void Flatten(Query sourceQuery, IndexReader reader, ICollection<Query>
                 Query q = constantScoreQuery.Query;
                 if (q != null)
                 {
-                    Flatten(ApplyParentBoost(q, sourceQuery), reader, flatQueries);
+                    Flatten(ApplyParentBoost(q, sourceQuery), indexSearcher, flatQueries);
                 }
             }
             else if (sourceQuery is FilteredQuery filteredQuery)
             {
                 Query q = filteredQuery.Query;
                 if (q != null)
                 {
-                    Flatten(ApplyParentBoost(q, sourceQuery), reader, flatQueries);
+                    Flatten(ApplyParentBoost(q, sourceQuery), indexSearcher, flatQueries);
                 }
             }
-            else if (reader != null)
+            else if (indexSearcher != null)
             {
                 Query query = sourceQuery;
                 if (sourceQuery is MultiTermQuery)
@@ -146,12 +154,12 @@ internal void Flatten(Query sourceQuery, IndexReader reader, ICollection<Query>
                     copy.MultiTermRewriteMethod = new MultiTermQuery.TopTermsScoringBooleanQueryRewrite(MAX_MTQ_TERMS);
                     query = copy;
                 }
-                Query rewritten = query.Rewrite(reader);
+                Query rewritten = query.Rewrite(indexSearcher);
                 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);
+                    Flatten(rewritten, indexSearcher, flatQueries);
 
                 }
                 // if the query is already rewritten we discard it
@@ -348,7 +356,7 @@ private string GetKey(Query query)
         ///          termSetMap=IDictionary&lt;null,ISet&lt;"john","lennon"&gt;&gt;
         /// </code>
         /// </summary>
-        internal void SaveTerms(ICollection<Query> flatQueries, IndexReader reader)
+        internal void SaveTerms(ICollection<Query> flatQueries, IndexSearcher indexSearcher)
         {
             foreach (Query query in flatQueries)
             {
@@ -360,9 +368,9 @@ internal void SaveTerms(ICollection<Query> flatQueries, IndexReader reader)
                     foreach (Term term in phraseQuery.GetTerms())
                         termSet.Add(term.Text);
                 }
-                else if (query is MultiTermQuery && reader != null)
+                else if (query is MultiTermQuery && indexSearcher != null)
                 {
-                    BooleanQuery mtqTerms = (BooleanQuery)query.Rewrite(reader);
+                    BooleanQuery mtqTerms = (BooleanQuery)query.Rewrite(indexSearcher);
                     foreach (BooleanClause clause in mtqTerms.GetClauses())
                     {
                         termSet.Add(((TermQuery)clause.Query).Term.Text);

src/Lucene.Net.Join/Support/ToChildBlockJoinQuery.cs

@@ -337,9 +337,9 @@ public override void ExtractTerms(ISet<Term> terms)
             _parentQuery.ExtractTerms(terms);
         }
 
-        public override Query Rewrite(IndexReader reader)
+        public override Query Rewrite(IndexSearcher indexSearcher)
         {
-            Query parentRewrite = _parentQuery.Rewrite(reader);
+            Query parentRewrite = _parentQuery.Rewrite(indexSearcher);
             if (parentRewrite != _parentQuery)
             {
                 Query rewritten = new ToChildBlockJoinQuery(_parentQuery, parentRewrite, _parentsFilter, _doScores);

src/Lucene.Net.Join/Support/ToParentBlockJoinQuery.cs

@@ -454,9 +454,9 @@ public override void ExtractTerms(ISet<Term> terms)
             _childQuery.ExtractTerms(terms);
         }
 
-        public override Query Rewrite(IndexReader reader)
+        public override Query Rewrite(IndexSearcher indexSearcher)
         {
-            Query childRewrite = _childQuery.Rewrite(reader);
+            Query childRewrite = _childQuery.Rewrite(indexSearcher);
             if (childRewrite != _childQuery)
             {
                 Query rewritten = new ToParentBlockJoinQuery(_origChildQuery, childRewrite, _parentsFilter, _scoreMode);

src/Lucene.Net.Join/TermsIncludingScoreQuery.cs

@@ -69,9 +69,9 @@ public override void ExtractTerms(ISet<Term> terms)
             _originalQuery.ExtractTerms(terms);
         }
 
-        public override Query Rewrite(IndexReader reader)
+        public override Query Rewrite(IndexSearcher indexSearcher)
         {
-            Query originalQueryRewrite = _originalQuery.Rewrite(reader);
+            Query originalQueryRewrite = _originalQuery.Rewrite(indexSearcher);
             if (originalQueryRewrite != _originalQuery)
             {
                 Query rewritten = new TermsIncludingScoreQuery(_field, _multipleValuesPerDocument, _terms, _scores,

src/Lucene.Net.Join/ToChildBlockJoinQuery.cs

@@ -335,9 +335,9 @@ public override void ExtractTerms(ISet<Term> terms)
             _parentQuery.ExtractTerms(terms);
         }
 
-        public override Query Rewrite(IndexReader reader)
+        public override Query Rewrite(IndexSearcher indexSearcher)
         {
-            Query parentRewrite = _parentQuery.Rewrite(reader);
+            Query parentRewrite = _parentQuery.Rewrite(indexSearcher);
             if (parentRewrite != _parentQuery)
             {
                 Query rewritten = new ToChildBlockJoinQuery(_parentQuery, parentRewrite, _parentsFilter, _doScores);

src/Lucene.Net.Join/ToParentBlockJoinQuery.cs

@@ -452,9 +452,9 @@ public override void ExtractTerms(ISet<Term> terms)
             _childQuery.ExtractTerms(terms);
         }
 
-        public override Query Rewrite(IndexReader reader)
+        public override Query Rewrite(IndexSearcher indexSearcher)
         {
-            Query childRewrite = _childQuery.Rewrite(reader);
+            Query childRewrite = _childQuery.Rewrite(indexSearcher);
             if (childRewrite != _childQuery)
             {
                 Query rewritten = new ToParentBlockJoinQuery(_origChildQuery, childRewrite, _parentsFilter, _scoreMode);

src/Lucene.Net.Queries/BoostingQuery.cs

@@ -52,7 +52,7 @@ public BoostingQuery(Query match, Query context, float boost)
             this.context.Boost = 0.0f; // ignore context-only matches
         }
 
-        public override Query Rewrite(IndexReader reader)
+        public override Query Rewrite(IndexSearcher indexSearcher)
         {
             return new BooleanQueryAnonymousClass(this)
             {

src/Lucene.Net.Queries/CommonTermsQuery.cs

@@ -150,8 +150,9 @@ public virtual void Add(Term term)
             this.m_terms.Add(term);
         }
 
-        public override Query Rewrite(IndexReader reader)
+        public override Query Rewrite(IndexSearcher indexSearcher)
         {
+            IndexReader reader = indexSearcher.IndexReader;
             if (this.m_terms.Count == 0)
             {
                 return new BooleanQuery();

src/Lucene.Net.Queries/CustomScoreQuery.cs

@@ -80,13 +80,13 @@ public CustomScoreQuery(Query subQuery, params FunctionQuery[] scoringQueries)
         }
 
         /// <summary>
-        /// <seealso cref="Query.Rewrite(IndexReader)"/>
+        /// <seealso cref="Query.Rewrite(IndexSearcher)"/>
         /// </summary>
-        public override Query Rewrite(IndexReader reader)
+        public override Query Rewrite(IndexSearcher indexSearcher)
         {
             CustomScoreQuery clone = null;
 
-            Query sq = subQuery.Rewrite(reader);
+            Query sq = subQuery.Rewrite(indexSearcher);
             if (sq != subQuery)
             {
                 clone = (CustomScoreQuery)Clone();
@@ -95,7 +95,7 @@ public override Query Rewrite(IndexReader reader)
 
             for (int i = 0; i < scoringQueries.Length; i++)
             {
-                Query v = scoringQueries[i].Rewrite(reader);
+                Query v = scoringQueries[i].Rewrite(indexSearcher);
                 if (v != scoringQueries[i])
                 {
                     if (clone is null)

src/Lucene.Net.Queries/Function/BoostedQuery.cs

@@ -47,9 +47,9 @@ public BoostedQuery(Query subQuery, ValueSource boostVal)
 
         public virtual ValueSource ValueSource => boostVal;
 
-        public override Query Rewrite(IndexReader reader)
+        public override Query Rewrite(IndexSearcher indexSearcher)
         {
-            var newQ = q.Rewrite(reader);
+            var newQ = q.Rewrite(indexSearcher);
             if (Equals(newQ, q))
             {
                 return this;

src/Lucene.Net.Queries/Function/FunctionQuery.cs

@@ -44,7 +44,7 @@ public FunctionQuery(ValueSource func)
         /// <returns> The associated <see cref="Function.ValueSource"/> </returns>
         public virtual ValueSource ValueSource => func;
 
-        public override Query Rewrite(IndexReader reader)
+        public override Query Rewrite(IndexSearcher indexSearcher)
         {
             return this;
         }

src/Lucene.Net.Queries/Mlt/MoreLikeThisQuery.cs

@@ -57,8 +57,10 @@ public MoreLikeThisQuery(string likeText, string[] moreLikeFields, Analyzer anal
             this.fieldName = fieldName;
         }
 
-        public override Query Rewrite(IndexReader reader)
+        public override Query Rewrite(IndexSearcher indexSearcher)
         {
+            IndexReader reader = indexSearcher.IndexReader;
+
             var mlt = new MoreLikeThis(reader)
             {
                 FieldNames = moreLikeFields,

src/Lucene.Net.QueryParser/ComplexPhrase/ComplexPhraseQueryParser.cs

@@ -253,7 +253,7 @@ protected internal void ParsePhraseElements(ComplexPhraseQueryParser qp)
                 }
             }
 
-            public override Query Rewrite(IndexReader reader)
+            public override Query Rewrite(IndexSearcher indexSearcher)
             {
                 // ArrayList spanClauses = new ArrayList();
                 if (contents is TermQuery)
@@ -264,7 +264,7 @@ public override Query Rewrite(IndexReader reader)
                 // clauses can be complex
                 // Booleans e.g. nots and ors etc
                 int numNegatives = 0;
-                if (!(contents is BooleanQuery))
+                if (contents is not BooleanQuery)
                 {
                     throw new ArgumentException("Unknown query type \""
                         + contents.GetType().Name
@@ -280,7 +280,7 @@ public override Query Rewrite(IndexReader reader)
                     // HashSet bclauseterms=new HashSet();
                     Query qc = bclauses[i].Query;
                     // Rewrite this clause e.g one* becomes (one OR onerous)
-                    qc = qc.Rewrite(reader);
+                    qc = qc.Rewrite(indexSearcher);
                     if (bclauses[i].Occur.Equals(Occur.MUST_NOT))
                     {
                         numNegatives++;