Minscore is made sure it works at the lower level

Author: mridula-s109

server/src/main/java/org/elasticsearch/search/retriever/rankdoc/RankDocsQuery.java

@@ -274,12 +274,12 @@ public RankDocsQuery(
         this.minScore = minScore;
     }
 
-    private RankDocsQuery(RankDoc[] docs, Query topQuery, Query tailQuery, boolean onlyRankDocs) {
+    private RankDocsQuery(RankDoc[] docs, Query topQuery, Query tailQuery, boolean onlyRankDocs, float minScore) {
         this.docs = docs;
         this.topQuery = topQuery;
         this.tailQuery = tailQuery;
         this.onlyRankDocs = onlyRankDocs;
-        this.minScore = DEFAULT_MIN_SCORE;
+        this.minScore = minScore;
     }
 
     private static int binarySearch(RankDoc[] docs, int fromIndex, int toIndex, int key) {
@@ -312,7 +312,11 @@ public RankDoc[] rankDocs() {
     @Override
     public Query rewrite(IndexSearcher searcher) throws IOException {
         if (tailQuery == null) {
-            return topQuery;
+            var topRewrite = topQuery.rewrite(searcher);
+            if (topRewrite != topQuery) {
+                return new RankDocsQuery(this.docs, topRewrite, null, this.onlyRankDocs, this.minScore);
+            }
+            return this;
         }
         boolean hasChanged = false;
         var topRewrite = topQuery.rewrite(searcher);
@@ -323,22 +327,33 @@ public Query rewrite(IndexSearcher searcher) throws IOException {
         if (tailRewrite != tailQuery) {
             hasChanged = true;
         }
-        return hasChanged ? new RankDocsQuery(docs, topRewrite, tailRewrite, onlyRankDocs) : this;
+        return hasChanged ? new RankDocsQuery(this.docs, topRewrite, tailRewrite, this.onlyRankDocs, this.minScore) : this;
     }
 
     @Override
     public Weight createWeight(IndexSearcher searcher, ScoreMode scoreMode, float boost) throws IOException {
-        if (tailQuery == null) {
-            throw new IllegalArgumentException("[tailQuery] should not be null; maybe missing a rewrite?");
+        Query combinedQuery;
+        if (onlyRankDocs) {
+            combinedQuery = topQuery; 
+        } else {
+            if (tailQuery == null) {
+                 combinedQuery = topQuery;
+            } else {
+                var combined = new BooleanQuery.Builder().add(topQuery, BooleanClause.Occur.SHOULD)
+                    .add(tailQuery, BooleanClause.Occur.FILTER)
+                    .build();
+                combinedQuery = combined;
+            }
         }
-        var combined = new BooleanQuery.Builder().add(topQuery, onlyRankDocs ? BooleanClause.Occur.MUST : BooleanClause.Occur.SHOULD)
-            .add(tailQuery, BooleanClause.Occur.FILTER)
-            .build();
+
         var topWeight = topQuery.createWeight(searcher, scoreMode, boost);
-        var combinedWeight = searcher.rewrite(combined).createWeight(searcher, scoreMode, boost);
+        var combinedWeight = searcher.rewrite(combinedQuery).createWeight(searcher, scoreMode, boost);
         return new Weight(this) {
             @Override
             public int count(LeafReaderContext context) throws IOException {
+                if (onlyRankDocs) {
+                    return topWeight.count(context);
+                }
                 return combinedWeight.count(context);
             }
 
@@ -359,22 +374,23 @@ public Matches matches(LeafReaderContext context, int doc) throws IOException {
 
             @Override
             public ScorerSupplier scorerSupplier(LeafReaderContext context) throws IOException {
-                ScorerSupplier supplier = combinedWeight.scorerSupplier(context);
-                if (minScore != DEFAULT_MIN_SCORE) {
+                ScorerSupplier baseSupplier = onlyRankDocs ? topWeight.scorerSupplier(context) : combinedWeight.scorerSupplier(context);
+
+                if (minScore != DEFAULT_MIN_SCORE && baseSupplier != null) {
                     return new ScorerSupplier() {
                         @Override
                         public Scorer get(long leadCost) throws IOException {
-                            Scorer scorer = supplier.get(leadCost);
-                            return new MinScoreScorer(scorer, minScore);
+                            Scorer scorer = baseSupplier.get(leadCost);
+                            return scorer == null ? null : new MinScoreScorer(scorer, minScore);
                         }
 
                         @Override
                         public long cost() {
-                            return supplier.cost();
+                            return baseSupplier.cost();
                         }
                     };
                 }
-                return supplier;
+                return baseSupplier;
             }
         };
     }

server/src/test/java/org/elasticsearch/index/query/RankDocsQueryBuilderTests.java

@@ -19,6 +19,7 @@
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.ScoreDoc;
+import org.apache.lucene.search.TopDocs;
 import org.apache.lucene.search.TopScoreDocCollectorManager;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.tests.index.RandomIndexWriter;
@@ -278,4 +279,62 @@ public void testMinScoreSerializationAndParsing() throws IOException {
 
         assertArrayEquals(rankDocs, parsedBuilder.rankDocs());
     }
+
+    public void testRankDocsQueryMinScoreFiltering() throws IOException {
+        try (Directory directory = newDirectory()) {
+            try (RandomIndexWriter iw = new RandomIndexWriter(random(), directory)) {
+                Document doc0 = new Document();
+                iw.addDocument(doc0);
+                Document doc1 = new Document();
+                iw.addDocument(doc1);
+                Document doc2 = new Document();
+                iw.addDocument(doc2);
+                Document doc3 = new Document();
+                iw.addDocument(doc3);
+            }
+
+            float minScore = 1.5f;
+            RankDoc[] rankDocs = new RankDoc[] {
+                new RankDoc(0, 2.0f, 0),
+                new RankDoc(1, 1.0f, 0),
+                new RankDoc(2, 1.6f, 0)
+            };
+            Arrays.sort(rankDocs);
+            for (int i = 0; i < rankDocs.length; i++) {
+                rankDocs[i].rank = i;
+            }
+            RankDocsQueryBuilder builder = new RankDocsQueryBuilder(rankDocs, null, true, minScore);
+
+            try (IndexReader reader = DirectoryReader.open(directory)) {
+                SearchExecutionContext context = createSearchExecutionContext(newSearcher(reader));
+                Query query = builder.doToQuery(context);
+                assertTrue("Query should be RankDocsQuery", query instanceof RankDocsQuery);
+
+                IndexSearcher searcher = newSearcher(reader);
+                TopDocs topDocs = searcher.search(query, 10);
+
+                long expectedTotalHits = 2; 
+                long expectedFilteredHits = 2;
+                assertEquals("Total hits should match filtered count", expectedTotalHits, topDocs.totalHits.value());
+                assertEquals("Number of score docs should match filtered count", expectedFilteredHits, topDocs.scoreDocs.length);
+
+                boolean foundDoc0 = false;
+                boolean foundDoc2 = false;
+                for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
+                    assertTrue("Score should be >= minScore", scoreDoc.score >= minScore);
+                    if (scoreDoc.doc == 0) {
+                        assertEquals("Doc 0 score mismatch", 2.0f, scoreDoc.score, 0f);
+                        foundDoc0 = true;
+                    } else if (scoreDoc.doc == 2) {
+                        assertEquals("Doc 2 score mismatch", 1.6f, scoreDoc.score, 0f);
+                        foundDoc2 = true;
+                    } else {
+                        fail("Unexpected document ID returned: " + scoreDoc.doc);
+                    }
+                }
+                assertTrue("Document 0 should have been found", foundDoc0);
+                assertTrue("Document 2 should have been found", foundDoc2);
+            }
+        }
+    }
 }