parking the progress in a commit

Author: mridula-s109

server/src/main/java/org/elasticsearch/search/retriever/RankDocsRetrieverBuilder.java

@@ -124,19 +124,31 @@ public void extractToSearchSourceBuilder(SearchSourceBuilder searchSourceBuilder
                     false
                 );
             }
+            // Set top-level minScore only when not in onlyRankDocs mode
+            if (effectiveMinScore != RankDocsQueryBuilder.DEFAULT_MIN_SCORE) {
+                 searchSourceBuilder.minScore(effectiveMinScore);
+            }
         } else {
-            // Pass minScore down to RankDocsQueryBuilder
-            rankQuery = new RankDocsQueryBuilder(rankDocResults, null, false, effectiveMinScore);
+            // Pass minScore down to RankDocsQueryBuilder and set onlyRankDocs = true to ensure pre-computed scores are used.
+            // Filter the results upfront if minScore is set
+            RankDoc[] finalRankDocs;
+            if (effectiveMinScore != RankDocsQueryBuilder.DEFAULT_MIN_SCORE) {
+                finalRankDocs = Arrays.stream(rankDocResults)
+                    .filter(doc -> doc.score >= effectiveMinScore)
+                    .toArray(RankDoc[]::new);
+            } else {
+                finalRankDocs = rankDocResults;
+            }
+            // Now pass the potentially filtered array and the original minScore
+            rankQuery = new RankDocsQueryBuilder(finalRankDocs, null, true, effectiveMinScore);
+            // Do NOT set top-level minScore here, filtering is done above, and RankDocsQuery handles score propagation.
         }
         rankQuery.queryName(retrieverName());
         // ignore prefilters of this level, they were already propagated to children
         searchSourceBuilder.query(rankQuery);
         if (searchSourceBuilder.size() < 0) {
             searchSourceBuilder.size(rankWindowSize);
         }
-        if (sourceHasMinScore()) {
-            searchSourceBuilder.minScore(effectiveMinScore);
-        }
         if (searchSourceBuilder.size() + searchSourceBuilder.from() > rankDocResults.length) {
             searchSourceBuilder.size(Math.max(0, rankDocResults.length - searchSourceBuilder.from()));
         }

x-pack/plugin/rank-rrf/src/internalClusterTest/java/org/elasticsearch/xpack/rank/linear/LinearRetrieverIT.java

@@ -924,7 +924,7 @@ public void testLinearWithMinScore() {
             assertThat(resp.getHits().getAt(2).getId(), equalTo("doc_1"));
             assertThat((double) resp.getHits().getAt(2).getScore(), closeTo(10.0f, 0.1f));
             assertThat(resp.getHits().getAt(3).getId(), equalTo("doc_3"));
-            assertThat((double) resp.getHits().getAt(3).getScore(), closeTo(0.0f, 0.1f));
+            assertThat((double) resp.getHits().getAt(3).getScore(), closeTo(10.0f, 0.1f));
         });
     }
 
@@ -994,12 +994,9 @@ public void testLinearWithMinScoreAndNormalization() {
             System.out.println("------------------");
 
             // Calculated scores >= 1.5f should only be doc_2(2.0)
-            // Observed behavior consistently shows 2 hits: doc_2(2.0) and one other doc (doc_1 or doc_3) with score 0.0
-            assertThat(resp.getHits().getHits().length, equalTo(2));
+            assertThat(resp.getHits().getHits().length, equalTo(1));
             assertThat(resp.getHits().getAt(0).getId(), equalTo("doc_2"));
             assertThat((double) resp.getHits().getAt(0).getScore(), closeTo(2.0f, 0.01f));
-            // Assert the second hit has score 0.0, but don't assert its ID due to inconsistency
-            assertThat((double) resp.getHits().getAt(1).getScore(), closeTo(0.0f, 0.01f));
         });
     }
 

x-pack/plugin/rank-rrf/src/main/java/org/elasticsearch/xpack/rank/linear/LinearRetrieverBuilder.java

@@ -188,10 +188,16 @@ protected RankDoc[] combineInnerRetrieverResults(List<ScoreDoc[]> rankResults, b
         // sort the results based on the final score, tiebreaker based on smaller doc id
         LinearRankDoc[] sortedResults = docsToRankResults.values().toArray(LinearRankDoc[]::new);
         Arrays.sort(sortedResults);
+
+        // Filter results based on minScore
+        LinearRankDoc[] filteredResults = Arrays.stream(sortedResults)
+                                                .filter(doc -> doc.score >= this.minScore)
+                                                .toArray(LinearRankDoc[]::new);
+
         // trim the results if needed, otherwise each shard will always return `rank_window_size` results.
-        LinearRankDoc[] topResults = new LinearRankDoc[Math.min(rankWindowSize, sortedResults.length)];
+        LinearRankDoc[] topResults = new LinearRankDoc[Math.min(rankWindowSize, filteredResults.length)];
         for (int rank = 0; rank < topResults.length; ++rank) {
-            topResults[rank] = sortedResults[rank];
+            topResults[rank] = filteredResults[rank];
             topResults[rank].rank = rank + 1;
         }
         return topResults;