SOLR-17319 : Combined Query Feature for Multi Query Execution

solr/core/src/java/org/apache/solr/handler/component/CombinedQueryComponent.java

@@ -153,9 +153,9 @@ public void prepare(ResponseBuilder rb) throws IOException {
 
   /**
    * Overrides the process method to handle CombinedQueryResponseBuilder instances. This method
-   * processes the responses from multiple queries in the SearchIndexer, combines them using the
-   * specified QueryAndResponseCombiner strategy, and sets the appropriate results and metadata in
-   * the CombinedQueryResponseBuilder.
+   * processes the responses from multiple queries, combines them using the specified
+   * QueryAndResponseCombiner strategy, and sets the appropriate results and metadata in the
+   * CombinedQueryResponseBuilder.
    *
    * @param rb the ResponseBuilder object to process
    * @throws IOException if an I/O error occurs during processing
@@ -167,6 +167,7 @@ public void process(ResponseBuilder rb) throws IOException {
       boolean segmentTerminatedEarly = false;
       boolean setMaxHitsTerminatedEarly = false;
       List<QueryResult> queryResults = new ArrayList<>();
+      // TODO: to be parallelized
       for (ResponseBuilder thisRb : crb.responseBuilders) {
         // Just a placeholder for future implementation for Cursors
         thisRb.setCursorMark(crb.getCursorMark());
@@ -213,7 +214,7 @@ private void prepareCombinedResponseBuilder(
     combinedQueryResult.setSegmentTerminatedEarly(segmentTerminatedEarly);
     combinedQueryResult.setMaxHitsTerminatedEarly(setMaxHitsTerminatedEarly);
     crb.setResult(combinedQueryResult);
-    if (rb.isDebug()) {
+    if (rb.isDebugQuery()) {
       String[] queryKeys = rb.req.getParams().getParams(CombinerParams.COMBINER_QUERY);
       List<Query> queries = crb.responseBuilders.stream().map(ResponseBuilder::getQuery).toList();
       NamedList<Explanation> explanations =

solr/core/src/java/org/apache/solr/handler/component/SearchHandler.java

@@ -697,6 +697,11 @@ private void processComponents(
     }
   }
 
+  /**
+   * Operations to be performed post prepare for all components.
+   *
+   * @param rb the ResponseBuilder containing the request and context, such as sort specifications.
+   */
   protected void postPrepareComponents(ResponseBuilder rb) {
     // Once all of our components have been prepared, check if this request involves a SortSpec.
     // If it does, and if our request includes a cursorMark param, then parse & init the

solr/core/src/java/org/apache/solr/search/combine/ReciprocalRankFusion.java

@@ -35,7 +35,6 @@
 import org.apache.solr.schema.IndexSchema;
 import org.apache.solr.search.DocIterator;
 import org.apache.solr.search.DocList;
-import org.apache.solr.search.DocListAndSet;
 import org.apache.solr.search.DocSet;
 import org.apache.solr.search.DocSlice;
 import org.apache.solr.search.QueryResult;
@@ -69,21 +68,24 @@ public int getK() {
   @Override
   public QueryResult combine(List<QueryResult> rankedLists, SolrParams solrParams) {
     int kVal = solrParams.getInt(CombinerParams.COMBINER_RRF_K, this.k);
-    List<DocListAndSet> docListAndSet = getDocListsAndSetFromQueryResults(rankedLists);
     QueryResult combinedResult = new QueryResult();
-    combineResults(combinedResult, docListAndSet, false, kVal);
+    combineResults(combinedResult, rankedLists, false, kVal);
     return combinedResult;
   }
 
-  private static List<DocListAndSet> getDocListsAndSetFromQueryResults(
-      List<QueryResult> rankedLists) {
-    List<DocListAndSet> docLists = new ArrayList<>(rankedLists.size());
-    for (QueryResult rankedList : rankedLists) {
-      docLists.add(rankedList.getDocListAndSet());
-    }
-    return docLists;
-  }
-
+  /**
+   * Merges per-shard ranked results using Reciprocal Rank Fusion (RRF).
+   *
+   * <p>Each shard list is assumed to be ordered by descending relevance. For a document at rank r
+   * in a shard, the contribution is {@code 1 / (k + r)} where {@code k} is read from {@link
+   * CombinerParams#COMBINER_RRF_K} or falls back to {@code this.k}. Contributions for the same
+   * document ID across shards (if found) are summed, and documents are returned sorted by the fused
+   * score (descending).
+   *
+   * @param shardDocMap per-shard ranked results;
+   * @param solrParams parameters; optional {@link CombinerParams#COMBINER_RRF_K} overrides k.
+   * @return one {@link ShardDoc} per unique document ID, ordered by fused score.
+   */
   @Override
   public List<ShardDoc> combine(Map<String, List<ShardDoc>> shardDocMap, SolrParams solrParams) {
     int kVal = solrParams.getInt(CombinerParams.COMBINER_RRF_K, this.k);
@@ -117,29 +119,29 @@ public List<ShardDoc> combine(Map<String, List<ShardDoc>> shardDocMap, SolrParam
 
   private Map<Integer, Integer[]> combineResults(
       QueryResult combinedRankedList,
-      List<DocListAndSet> rankedListAndSets,
+      List<QueryResult> queryResults,
       boolean saveRankPositionsForExplain,
       int kVal) {
     Map<Integer, Integer[]> docIdToRanks = null;
     DocSet combinedDocSet = null;
     HashMap<Integer, Float> docIdToScore = new HashMap<>();
     List<DocList> docLists = new ArrayList<>();
     long totalMatches = 0;
-    for (DocListAndSet rankedListAndSet : rankedListAndSets) {
-      DocIterator docs = rankedListAndSet.docList.iterator();
-      totalMatches = Math.max(totalMatches, rankedListAndSet.docList.matches());
+    for (QueryResult queryResult : queryResults) {
+      DocIterator docs = queryResult.getDocList().iterator();
+      totalMatches = Math.max(totalMatches, queryResult.getDocList().matches());
       int ranking = 1;
       while (docs.hasNext()) {
         int docId = docs.nextDoc();
         float rrfScore = 1f / (kVal + ranking);
         docIdToScore.compute(docId, (id, score) -> (score == null) ? rrfScore : score + rrfScore);
         ranking++;
       }
-      docLists.add(rankedListAndSet.docList);
+      docLists.add(queryResult.getDocList());
       if (combinedDocSet == null) {
-        combinedDocSet = rankedListAndSet.docSet;
-      } else if (rankedListAndSet.docSet != null) {
-        combinedDocSet = combinedDocSet.union(rankedListAndSet.docSet);
+        combinedDocSet = queryResult.getDocSet();
+      } else if (queryResult.getDocSet() != null) {
+        combinedDocSet = combinedDocSet.union(queryResult.getDocSet());
       }
     }
     List<Map.Entry<Integer, Float>> sortedByScoreDescending =
@@ -207,8 +209,7 @@ public NamedList<Explanation> getExplanations(
     NamedList<Explanation> docIdsExplanations = new SimpleOrderedMap<>();
     QueryResult combinedRankedList = new QueryResult();
     Map<Integer, Integer[]> docIdToRanks =
-        combineResults(
-            combinedRankedList, getDocListsAndSetFromQueryResults(queryResult), true, kVal);
+        combineResults(combinedRankedList, queryResult, true, kVal);
     DocList combinedDocList = combinedRankedList.getDocList();
 
     DocIterator iterator = combinedDocList.iterator();

solr/core/src/test/org/apache/solr/handler/component/CombinedQueryComponentTest.java

@@ -18,7 +18,6 @@
 
 import static org.apache.solr.common.params.CursorMarkParams.CURSOR_MARK_START;
 
-import com.carrotsearch.randomizedtesting.annotations.ThreadLeakScope;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -30,11 +29,10 @@
 import org.junit.Test;
 
 /**
- * The CombinedQueryComponentTest class is a unit test suite for the CombinedQueryComponent in Solr.
- * It verifies the functionality of the component by performing various queries and validating the
- * responses.
+ * The CombinedQueryComponentTest class is an integration test suite for the CombinedQueryComponent
+ * in Solr. It verifies the functionality of the component by performing various queries and
+ * validating the responses.
  */
-@ThreadLeakScope(ThreadLeakScope.Scope.NONE)
 public class CombinedQueryComponentTest extends SolrTestCaseJ4 {
 
   private static final int NUM_DOCS = 10;

solr/core/src/test/org/apache/solr/handler/component/DistributedCombinedQueryComponentTest.java

@@ -16,7 +16,6 @@
  */
 package org.apache.solr.handler.component;
 
-import com.carrotsearch.randomizedtesting.annotations.ThreadLeakScope;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.ArrayList;
@@ -35,7 +34,6 @@
  * functionality of the CombinedQueryComponent in a Solr distributed search environment. It focuses
  * on testing the integration of lexical and vector queries using the combiner component.
  */
-@ThreadLeakScope(ThreadLeakScope.Scope.NONE)
 public class DistributedCombinedQueryComponentTest extends BaseDistributedSearchTestCase {
 
   private static final int NUM_DOCS = 10;
@@ -205,7 +203,7 @@ public void testMultipleQueryWithSort() throws Exception {
   }
 
   /**
-   * Tests the hybrid query functionality of the system.
+   * Tests the hybrid query functionality of the system with various setting of pagination.
    *
    * @throws Exception if any unexpected error occurs during the test execution.
    */
@@ -222,15 +220,44 @@ public void testHybridQueryWithPagination() throws Exception {
                 "{\"queries\":"
                     + "{\"lexical\":{\"lucene\":{\"query\":\"id:(2^=2 OR 3^=1)\"}},"
                     + "\"vector\":{\"knn\":{ \"f\": \"vector\", \"topK\": 5, \"query\": \"[1.0, 2.0, 3.0, 4.0]\"}}},"
-                    + "\"limit\":4,\"offset\":1"
+                    + "\"fields\":[\"id\",\"score\",\"title\"],"
+                    + "\"params\":{\"combiner\":true,\"combiner.query\":[\"lexical\",\"vector\"]}}",
+                "shards",
+                getShardsString(),
+                CommonParams.QT,
+                "/search"));
+    assertFieldValues(rsp.getResults(), id, "2", "3", "4", "1", "6", "10", "8", "7", "5");
+    rsp =
+        queryServer(
+            createParams(
+                CommonParams.JSON,
+                "{\"queries\":"
+                    + "{\"lexical\":{\"lucene\":{\"query\":\"id:(2^=2 OR 3^=1)\"}},"
+                    + "\"vector\":{\"knn\":{ \"f\": \"vector\", \"topK\": 5, \"query\": \"[1.0, 2.0, 3.0, 4.0]\"}}},"
+                    + "\"limit\":4,"
+                    + "\"fields\":[\"id\",\"score\",\"title\"],"
+                    + "\"params\":{\"combiner\":true,\"combiner.query\":[\"lexical\",\"vector\"]}}",
+                "shards",
+                getShardsString(),
+                CommonParams.QT,
+                "/search"));
+    assertFieldValues(rsp.getResults(), id, "2", "3", "4", "1");
+    rsp =
+        queryServer(
+            createParams(
+                CommonParams.JSON,
+                "{\"queries\":"
+                    + "{\"lexical\":{\"lucene\":{\"query\":\"id:(2^=2 OR 3^=1)\"}},"
+                    + "\"vector\":{\"knn\":{ \"f\": \"vector\", \"topK\": 5, \"query\": \"[1.0, 2.0, 3.0, 4.0]\"}}},"
+                    + "\"limit\":4,\"offset\":3,"
                     + "\"fields\":[\"id\",\"score\",\"title\"],"
                     + "\"params\":{\"combiner\":true,\"combiner.query\":[\"lexical\",\"vector\"]}}",
                 "shards",
                 getShardsString(),
                 CommonParams.QT,
                 "/search"));
     assertEquals(4, rsp.getResults().size());
-    assertFieldValues(rsp.getResults(), id, "3", "4", "1", "6");
+    assertFieldValues(rsp.getResults(), id, "1", "6", "10", "8");
   }
 
   /**

solr/core/src/test/org/apache/solr/search/combine/ReciprocalRankFusionTest.java

@@ -19,7 +19,6 @@
 import static org.apache.solr.common.params.CombinerParams.COMBINER_RRF_K;
 import static org.apache.solr.common.params.CombinerParams.RECIPROCAL_RANK_FUSION;
 
-import com.carrotsearch.randomizedtesting.annotations.ThreadLeakScope;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -41,7 +40,6 @@
  * The ReciprocalRankFusionTest class is a unit test suite for the {@link ReciprocalRankFusion}
  * class. It verifies the correctness of the fusion algorithm and its supporting methods.
  */
-@ThreadLeakScope(ThreadLeakScope.Scope.NONE)
 public class ReciprocalRankFusionTest extends SolrTestCaseJ4 {
 
   public static ReciprocalRankFusion reciprocalRankFusion;