Removing usage of TopScoreDocCollector + TopFieldCollector deprecated methods (#create, #createSharedManager)

lucene/CHANGES.txt

@@ -244,6 +244,8 @@ Other
 
 * GITHUB#13332: Improve MissingDoclet linter to check records correctly. (Uwe Schindler)
 
+* GITHUB#13499: Remove usage of TopScoreDocCollector + TopFieldCollector deprecated methods (#create, #createSharedManager) (Jakub Slowinski)
+
 ======================== Lucene 9.12.0 =======================
 
 API Changes

lucene/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/SearchWithCollectorTask.java

@@ -20,7 +20,7 @@
 import org.apache.lucene.benchmark.byTask.feeds.QueryMaker;
 import org.apache.lucene.benchmark.byTask.utils.Config;
 import org.apache.lucene.search.Collector;
-import org.apache.lucene.search.TopScoreDocCollector;
+import org.apache.lucene.search.TopScoreDocCollectorManager;
 
 /** Does search w/ a custom collector */
 public class SearchWithCollectorTask extends SearchTask {
@@ -49,7 +49,8 @@ public boolean withCollector() {
   protected Collector createCollector() throws Exception {
     Collector collector = null;
     if (clnName.equalsIgnoreCase("topScoreDoc") == true) {
-      collector = TopScoreDocCollector.create(numHits(), Integer.MAX_VALUE);
+      collector =
+          new TopScoreDocCollectorManager(numHits(), null, Integer.MAX_VALUE, false).newCollector();
     } else if (clnName.length() > 0) {
       collector = Class.forName(clnName).asSubclass(Collector.class).getConstructor().newInstance();
 

lucene/core/src/java/org/apache/lucene/search/TopFieldCollector.java

@@ -30,8 +30,8 @@
 /**
  * A {@link Collector} that sorts by {@link SortField} using {@link FieldComparator}s.
  *
- * <p>See the {@link #create(org.apache.lucene.search.Sort, int, int)} method for instantiating a
- * TopFieldCollector.
+ * <p>See the constructor of {@link TopFieldCollectorManager} for instantiating a
+ * TopFieldCollectorManager with support for concurrency in IndexSearcher.
  *
  * @lucene.experimental
  */

lucene/core/src/test/org/apache/lucene/search/TestBooleanQueryVisitSubscorers.java

@@ -156,7 +156,7 @@ static class MyCollector extends FilterCollector {
     private final Set<Scorer> tqsSet = new HashSet<>();
 
     MyCollector() {
-      super(TopScoreDocCollector.create(10, Integer.MAX_VALUE));
+      super(new TopScoreDocCollectorManager(10, null, Integer.MAX_VALUE, false).newCollector());
     }
 
     @Override

lucene/core/src/test/org/apache/lucene/search/TestElevationComparator.java

@@ -98,7 +98,7 @@ private void runTest(boolean reversed) throws Throwable {
 
     TopDocs topDocs =
         searcher.search(
-            newq.build(), TopFieldCollector.createSharedManager(sort, 50, null, Integer.MAX_VALUE));
+            newq.build(), new TopFieldCollectorManager(sort, 50, null, Integer.MAX_VALUE, true));
     int nDocsReturned = topDocs.scoreDocs.length;
 
     assertEquals(4, nDocsReturned);

lucene/core/src/test/org/apache/lucene/search/TestNeedsScores.java

@@ -82,7 +82,7 @@ public void testConstantScoreQuery() throws Exception {
 
     TopDocs hits =
         searcher.search(
-            constantScore, TopScoreDocCollector.createSharedManager(5, null, Integer.MAX_VALUE));
+            constantScore, new TopScoreDocCollectorManager(5, null, Integer.MAX_VALUE, true));
     assertEquals(5, hits.totalHits.value);
 
     // Queries that support dynamic pruning like top-score or top-doc queries that do not compute

lucene/core/src/test/org/apache/lucene/search/TestPositiveScoresOnlyCollector.java

@@ -109,7 +109,9 @@ public void testNegativeScores() throws Exception {
     IndexReader ir = writer.getReader();
     writer.close();
     Scorer s = new SimpleScorer();
-    TopDocsCollector<ScoreDoc> tdc = TopScoreDocCollector.create(scores.length, Integer.MAX_VALUE);
+    TopDocsCollector<ScoreDoc> tdc =
+        new TopScoreDocCollectorManager(scores.length, null, Integer.MAX_VALUE, false)
+            .newCollector();
     Collector c = new PositiveScoresOnlyCollector(tdc);
     LeafCollector ac = c.getLeafCollector(ir.leaves().get(0));
     ac.setScorer(s);

lucene/core/src/test/org/apache/lucene/search/TestSearchAfter.java

@@ -231,13 +231,13 @@ void assertQuery(Query query, Sort sort) throws Exception {
     final boolean doScores;
     final CollectorManager<?, ? extends TopDocs> allManager;
     if (sort == null) {
-      allManager = TopScoreDocCollector.createSharedManager(maxDoc, null, Integer.MAX_VALUE);
+      allManager = new TopScoreDocCollectorManager(maxDoc, null, Integer.MAX_VALUE);
       doScores = false;
     } else if (sort == Sort.RELEVANCE) {
-      allManager = TopFieldCollector.createSharedManager(sort, maxDoc, null, Integer.MAX_VALUE);
+      allManager = new TopFieldCollectorManager(sort, maxDoc, null, Integer.MAX_VALUE, true);
       doScores = true;
     } else {
-      allManager = TopFieldCollector.createSharedManager(sort, maxDoc, null, Integer.MAX_VALUE);
+      allManager = new TopFieldCollectorManager(sort, maxDoc, null, Integer.MAX_VALUE, true);
       doScores = random().nextBoolean();
     }
     all = searcher.search(query, allManager);
@@ -269,20 +269,14 @@ void assertQuery(Query query, Sort sort) throws Exception {
           System.out.println("  iter lastBottom=" + lastBottom);
         }
         pagedManager =
-            TopScoreDocCollector.createSharedManager(pageSize, lastBottom, Integer.MAX_VALUE);
+            new TopScoreDocCollectorManager(pageSize, lastBottom, Integer.MAX_VALUE, true);
       } else {
         if (VERBOSE) {
           System.out.println("  iter lastBottom=" + lastBottom);
         }
-        if (sort == Sort.RELEVANCE) {
-          pagedManager =
-              TopFieldCollector.createSharedManager(
-                  sort, pageSize, (FieldDoc) lastBottom, Integer.MAX_VALUE);
-        } else {
-          pagedManager =
-              TopFieldCollector.createSharedManager(
-                  sort, pageSize, (FieldDoc) lastBottom, Integer.MAX_VALUE);
-        }
+        pagedManager =
+            new TopFieldCollectorManager(
+                sort, pageSize, (FieldDoc) lastBottom, Integer.MAX_VALUE, true);
       }
       paged = searcher.search(query, pagedManager);
       if (doScores) {

lucene/core/src/test/org/apache/lucene/search/TestSortOptimization.java

@@ -237,7 +237,7 @@ public void testSortOptimizationWithMissingValues() throws IOException {
       sortField2.setMissingValue(0L); // set a competitive missing value
       final Sort sort = new Sort(sortField1, sortField2);
       CollectorManager<TopFieldCollector, TopFieldDocs> manager =
-          TopFieldCollector.createSharedManager(sort, numHits, null, totalHitsThreshold);
+          new TopFieldCollectorManager(sort, numHits, null, totalHitsThreshold, true);
       TopDocs topDocs = searcher.search(new MatchAllDocsQuery(), manager);
       assertEquals(topDocs.scoreDocs.length, numHits);
       assertEquals(
@@ -264,7 +264,7 @@ public void testSortOptimizationWithMissingValues() throws IOException {
       sortField.setMissingValue(Long.MAX_VALUE); // set a competitive missing value
       final Sort sort = new Sort(sortField);
       CollectorManager<TopFieldCollector, TopFieldDocs> manager =
-          TopFieldCollector.createSharedManager(sort, numHits, after, totalHitsThreshold);
+          new TopFieldCollectorManager(sort, numHits, after, totalHitsThreshold, true);
       TopDocs topDocs = searcher.search(new MatchAllDocsQuery(), manager);
       assertEquals(topDocs.scoreDocs.length, numHits);
       assertNonCompetitiveHitsAreSkipped(topDocs.totalHits.value, numDocs);
@@ -279,7 +279,7 @@ public void testSortOptimizationWithMissingValues() throws IOException {
       sortField.setMissingValue(Long.MAX_VALUE); // set a competitive missing value
       final Sort sort = new Sort(sortField);
       CollectorManager<TopFieldCollector, TopFieldDocs> manager =
-          TopFieldCollector.createSharedManager(sort, numHits, after, totalHitsThreshold);
+          new TopFieldCollectorManager(sort, numHits, after, totalHitsThreshold, true);
       TopDocs topDocs = searcher.search(new MatchAllDocsQuery(), manager);
       assertEquals(topDocs.scoreDocs.length, numHits);
       assertNonCompetitiveHitsAreSkipped(topDocs.totalHits.value, numDocs);
@@ -323,7 +323,7 @@ public void testNumericDocValuesOptimizationWithMissingValues() throws IOExcepti
       sortField.setMissingValue(0L); // missing value is not competitive
       final Sort sort = new Sort(sortField);
       CollectorManager<TopFieldCollector, TopFieldDocs> manager =
-          TopFieldCollector.createSharedManager(sort, numHits, null, totalHitsThreshold);
+          new TopFieldCollectorManager(sort, numHits, null, totalHitsThreshold, true);
       topDocs1 = searcher.search(new MatchAllDocsQuery(), manager);
       assertNonCompetitiveHitsAreSkipped(topDocs1.totalHits.value, numDocs);
     }
@@ -334,7 +334,7 @@ public void testNumericDocValuesOptimizationWithMissingValues() throws IOExcepti
       final Sort sort = new Sort(sortField);
       sortField.setOptimizeSortWithPoints(false);
       CollectorManager<TopFieldCollector, TopFieldDocs> manager =
-          TopFieldCollector.createSharedManager(sort, numHits, null, totalHitsThreshold);
+          new TopFieldCollectorManager(sort, numHits, null, totalHitsThreshold, true);
       topDocs2 = searcher.search(new MatchAllDocsQuery(), manager);
       // assert that the resulting hits are the same
       assertEquals(topDocs1.scoreDocs.length, topDocs2.scoreDocs.length);
@@ -357,7 +357,7 @@ public void testNumericDocValuesOptimizationWithMissingValues() throws IOExcepti
       sortField2.setMissingValue(0L); // missing value is not competitive
       final Sort multiSorts = new Sort(new SortField[] {sortField1, sortField2});
       CollectorManager<TopFieldCollector, TopFieldDocs> manager =
-          TopFieldCollector.createSharedManager(multiSorts, numHits, null, totalHitsThreshold);
+          new TopFieldCollectorManager(multiSorts, numHits, null, totalHitsThreshold, true);
       TopDocs topDocs = searcher.search(new MatchAllDocsQuery(), manager);
       // can't optimization with NumericDocValues when there are multiple comparators
       assertEquals(topDocs.totalHits.value, numDocs);
@@ -935,7 +935,7 @@ public void testRandomLong() throws IOException {
     // test search
     int numHits = 1 + random().nextInt(100);
     CollectorManager<TopFieldCollector, TopFieldDocs> manager =
-        TopFieldCollector.createSharedManager(new Sort(sortField), numHits, null, numHits);
+        new TopFieldCollectorManager(new Sort(sortField), numHits, null, numHits, true);
     TopDocs topDocs = searcher.search(new MatchAllDocsQuery(), manager);
     for (int i = 0; i < topDocs.scoreDocs.length; i++) {
       long expectedSeqNo = seqNos.get(i);
@@ -986,12 +986,12 @@ public void testSortOptimizationOnSortedNumericField() throws IOException {
       int expectedHits = Math.min(numDocs - visitedHits, batch);
 
       CollectorManager<TopFieldCollector, TopFieldDocs> manager =
-          TopFieldCollector.createSharedManager(sort, batch, (FieldDoc) after, totalHitsThreshold);
+          new TopFieldCollectorManager(sort, batch, (FieldDoc) after, totalHitsThreshold, true);
       TopDocs topDocs = searcher.search(query, manager);
       ScoreDoc[] scoreDocs = topDocs.scoreDocs;
 
       CollectorManager<TopFieldCollector, TopFieldDocs> manager2 =
-          TopFieldCollector.createSharedManager(sort2, batch, (FieldDoc) after, totalHitsThreshold);
+          new TopFieldCollectorManager(sort2, batch, (FieldDoc) after, totalHitsThreshold, true);
       TopDocs topDocs2 = searcher.search(query, manager2);
       ScoreDoc[] scoreDocs2 = topDocs2.scoreDocs;
 
@@ -1186,7 +1186,7 @@ public void doTestStringSortOptimizationDisabled(DirectoryReader reader) throws
     final int totalHitsThreshold = 5;
 
     CollectorManager<TopFieldCollector, TopFieldDocs> manager =
-        TopFieldCollector.createSharedManager(sort, numHits, null, totalHitsThreshold);
+        new TopFieldCollectorManager(sort, numHits, null, totalHitsThreshold, true);
     IndexSearcher searcher =
         newSearcher(reader, random().nextBoolean(), random().nextBoolean(), false);
     TopDocs topDocs = searcher.search(new MatchAllDocsQuery(), manager);
@@ -1216,7 +1216,7 @@ private TopDocs assertSearchHits(DirectoryReader reader, Sort sort, int n, Field
     IndexSearcher searcher = newSearcher(reader, true, true, false);
     Query query = new MatchAllDocsQuery();
     CollectorManager<TopFieldCollector, TopFieldDocs> manager =
-        TopFieldCollector.createSharedManager(sort, n, after, n);
+        new TopFieldCollectorManager(sort, n, after, n, true);
     TopDocs topDocs = searcher.search(query, manager);
     IndexSearcher unoptimizedSearcher =
         newSearcher(new NoIndexDirectoryReader(reader), true, true, false);

lucene/core/src/test/org/apache/lucene/search/TestTopDocsMerge.java

@@ -55,7 +55,8 @@ public void search(Weight weight, Collector collector) throws IOException {
     }
 
     public TopDocs search(Weight weight, int topN) throws IOException {
-      TopScoreDocCollector collector = TopScoreDocCollector.create(topN, Integer.MAX_VALUE);
+      TopScoreDocCollector collector =
+          new TopScoreDocCollectorManager(topN, null, Integer.MAX_VALUE, false).newCollector();
       search(ctx, weight, collector);
       return collector.topDocs();
     }
@@ -346,7 +347,9 @@ void testSort(boolean useFrom) throws Exception {
         if (sort == null) {
           subHits = subSearcher.search(w, numHits);
         } else {
-          final TopFieldCollector c = TopFieldCollector.create(sort, numHits, Integer.MAX_VALUE);
+          final TopFieldCollector c =
+              new TopFieldCollectorManager(sort, numHits, null, Integer.MAX_VALUE, false)
+                  .newCollector();
           subSearcher.search(w, c);
           subHits = c.topDocs(0, numHits);
         }

lucene/facet/src/java/org/apache/lucene/facet/FacetsCollector.java

@@ -34,8 +34,9 @@
 import org.apache.lucene.search.TopDocs;
 import org.apache.lucene.search.TopDocsCollector;
 import org.apache.lucene.search.TopFieldCollector;
+import org.apache.lucene.search.TopFieldCollectorManager;
 import org.apache.lucene.search.TopFieldDocs;
-import org.apache.lucene.search.TopScoreDocCollector;
+import org.apache.lucene.search.TopScoreDocCollectorManager;
 import org.apache.lucene.search.TotalHitCountCollector;
 import org.apache.lucene.search.TotalHits;
 import org.apache.lucene.util.ArrayUtil;
@@ -253,13 +254,11 @@ private static TopDocs doSearch(
           throw new IllegalArgumentException("after must be a FieldDoc; got " + after);
         }
         hitsCollector =
-            TopFieldCollector.create(
-                sort,
-                n,
-                (FieldDoc) after,
-                Integer.MAX_VALUE); // TODO: can we disable exact hit counts
+            new TopFieldCollectorManager(sort, n, (FieldDoc) after, Integer.MAX_VALUE, false)
+                .newCollector(); // TODO: can we disable exact hit counts
       } else {
-        hitsCollector = TopScoreDocCollector.create(n, after, Integer.MAX_VALUE);
+        hitsCollector =
+            new TopScoreDocCollectorManager(n, after, Integer.MAX_VALUE, false).newCollector();
       }
       searcher.search(q, MultiCollector.wrap(hitsCollector, fc));
 

lucene/grouping/src/java/org/apache/lucene/search/grouping/BlockGroupingCollector.java

@@ -32,8 +32,8 @@
 import org.apache.lucene.search.SortField;
 import org.apache.lucene.search.TopDocs;
 import org.apache.lucene.search.TopDocsCollector;
-import org.apache.lucene.search.TopFieldCollector;
-import org.apache.lucene.search.TopScoreDocCollector;
+import org.apache.lucene.search.TopFieldCollectorManager;
+import org.apache.lucene.search.TopScoreDocCollectorManager;
 import org.apache.lucene.search.TotalHits;
 import org.apache.lucene.search.Weight;
 import org.apache.lucene.util.ArrayUtil;
@@ -294,12 +294,15 @@ public TopGroups<?> getTopGroups(
           throw new IllegalArgumentException(
               "cannot sort by relevance within group: needsScores=false");
         }
-        collector = TopScoreDocCollector.create(maxDocsPerGroup, Integer.MAX_VALUE);
+        collector =
+            new TopScoreDocCollectorManager(maxDocsPerGroup, null, Integer.MAX_VALUE, false)
+                .newCollector();
       } else {
         // Sort by fields
         collector =
-            TopFieldCollector.create(
-                withinGroupSort, maxDocsPerGroup, Integer.MAX_VALUE); // TODO: disable exact counts?
+            new TopFieldCollectorManager(
+                    withinGroupSort, maxDocsPerGroup, null, Integer.MAX_VALUE, false)
+                .newCollector(); // TODO: disable exact counts?
       }
 
       float groupMaxScore = needsScores ? Float.NEGATIVE_INFINITY : Float.NaN;

lucene/grouping/src/java/org/apache/lucene/search/grouping/TopGroupsCollector.java

@@ -31,7 +31,8 @@
 import org.apache.lucene.search.TopDocs;
 import org.apache.lucene.search.TopDocsCollector;
 import org.apache.lucene.search.TopFieldCollector;
-import org.apache.lucene.search.TopScoreDocCollector;
+import org.apache.lucene.search.TopFieldCollectorManager;
+import org.apache.lucene.search.TopScoreDocCollectorManager;
 import org.apache.lucene.util.ArrayUtil;
 
 /**
@@ -127,15 +128,17 @@ private static class TopDocsReducer<T> extends GroupReducer<T, TopDocsAndMaxScor
         supplier =
             () ->
                 new TopDocsAndMaxScoreCollector(
-                    true, TopScoreDocCollector.create(maxDocsPerGroup, Integer.MAX_VALUE), null);
+                    true,
+                    new TopScoreDocCollectorManager(maxDocsPerGroup, null, Integer.MAX_VALUE, false)
+                        .newCollector(),
+                    null);
       } else {
         supplier =
             () -> {
               TopFieldCollector topDocsCollector =
-                  TopFieldCollector.create(
-                      withinGroupSort,
-                      maxDocsPerGroup,
-                      Integer.MAX_VALUE); // TODO: disable exact counts?
+                  new TopFieldCollectorManager(
+                          withinGroupSort, maxDocsPerGroup, null, Integer.MAX_VALUE, false)
+                      .newCollector(); // TODO: disable exact counts?
               MaxScoreCollector maxScoreCollector = getMaxScores ? new MaxScoreCollector() : null;
               return new TopDocsAndMaxScoreCollector(false, topDocsCollector, maxScoreCollector);
             };

lucene/join/src/test/org/apache/lucene/search/join/TestJoinUtil.java

@@ -468,7 +468,7 @@ public void testRandomOrdinalsJoin() throws Exception {
 
       final BitSet actualResult = new FixedBitSet(indexSearcher.getIndexReader().maxDoc());
       final TopScoreDocCollector topScoreDocCollector =
-          TopScoreDocCollector.create(10, Integer.MAX_VALUE);
+          new TopScoreDocCollectorManager(10, null, Integer.MAX_VALUE, false).newCollector();
       indexSearcher.search(
           joinQuery, MultiCollector.wrap(new BitSetCollector(actualResult), topScoreDocCollector));
       assertBitSet(expectedResult, actualResult, indexSearcher);
@@ -1546,7 +1546,7 @@ private void executeRandomJoin(
         // be also testing TopDocsCollector...
         final BitSet actualResult = new FixedBitSet(indexSearcher.getIndexReader().maxDoc());
         final TopScoreDocCollector topScoreDocCollector =
-            TopScoreDocCollector.create(10, Integer.MAX_VALUE);
+            new TopScoreDocCollectorManager(10, null, Integer.MAX_VALUE, false).newCollector();
         indexSearcher.search(
             joinQuery,
             MultiCollector.wrap(new BitSetCollector(actualResult), topScoreDocCollector));