Multifold Improvement in Multi-Clause Boolean Query (Window Scoring Approach)

CHANGELOG.md

@@ -23,6 +23,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - Implement GRPC Search params `Highlight`and `Sort` ([#19868](https://github.com/opensearch-project/OpenSearch/pull/19868))
 - Implement GRPC ConstantScoreQuery, FuzzyQuery, MatchBoolPrefixQuery, MatchPhrasePrefix, PrefixQuery, MatchQuery ([#19854](https://github.com/opensearch-project/OpenSearch/pull/19854))
 - Add async periodic flush task support for pull-based ingestion ([#19878](https://github.com/opensearch-project/OpenSearch/pull/19878))
+- Multifold Improvement in Multi-Clause Boolean Query, Window Scoring Approach ([#19045](https://github.com/opensearch-project/OpenSearch/pull/19046))
+
 
 ### Changed
 - Faster `terms` query creation for `keyword` field with index and docValues enabled ([#19350](https://github.com/opensearch-project/OpenSearch/pull/19350))

server/src/main/java/org/opensearch/index/query/BoolQueryBuilder.java

@@ -45,6 +45,8 @@
 import org.opensearch.core.xcontent.ObjectParser;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.search.approximate.ApproximateBooleanQuery;
+import org.opensearch.search.approximate.ApproximateScoreQuery;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -335,7 +337,18 @@ protected Query doToQuery(QueryShardContext context) throws IOException {
         }
 
         Query query = Queries.applyMinimumShouldMatch(booleanQuery, minimumShouldMatch);
-        return adjustPureNegative ? fixNegativeQueryIfNeeded(query) : query;
+
+        if (adjustPureNegative) {
+            query = fixNegativeQueryIfNeeded(query);
+        }
+
+        // limit approximate query construction since several mappers (prefixQuery) expect a BooleanQuery not ApproximateBooleanQuery
+        if (query instanceof BooleanQuery boolQuery
+            && (boolQuery.getClauses(Occur.FILTER).size() == boolQuery.clauses().size() || boolQuery.clauses().size() == 1)) {
+            return new ApproximateScoreQuery(query, new ApproximateBooleanQuery(boolQuery));
+        }
+
+        return query;
     }
 
     private static void addBooleanClauses(

server/src/main/java/org/opensearch/search/approximate/ApproximateBooleanQuery.java

@@ -0,0 +1,214 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.approximate;
+
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.search.BooleanClause;
+import org.apache.lucene.search.BooleanQuery;
+import org.apache.lucene.search.ConstantScoreQuery;
+import org.apache.lucene.search.ConstantScoreWeight;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.QueryVisitor;
+import org.apache.lucene.search.ScoreMode;
+import org.apache.lucene.search.ScorerSupplier;
+import org.apache.lucene.search.Weight;
+import org.opensearch.search.internal.SearchContext;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * An approximate-able version of {@link BooleanQuery}. For single clause boolean queries,
+ * it unwraps the query into the singular clause and ensures approximation is applied.
+ */
+public class ApproximateBooleanQuery extends ApproximateQuery {
+    public final BooleanQuery boolQuery;
+    private final int size;
+    private final List<BooleanClause> clauses;
+    private boolean isTopLevel = true;  // Default to true, set to false when nested in boolean query
+
+    public ApproximateBooleanQuery(BooleanQuery boolQuery) {
+        this(boolQuery, SearchContext.DEFAULT_TRACK_TOTAL_HITS_UP_TO);
+    }
+
+    protected ApproximateBooleanQuery(BooleanQuery boolQuery, int size) {
+        this.boolQuery = boolQuery;
+        this.size = size;
+        this.clauses = boolQuery.clauses();
+    }
+
+    public BooleanQuery getBooleanQuery() {
+        return boolQuery;
+    }
+
+    public boolean isTopLevel() {
+        return this.isTopLevel;
+    }
+
+    public void setTopLevel(boolean isTopLevel) {
+        this.isTopLevel = isTopLevel;
+    }
+
+    @Override
+    public Query rewrite(IndexSearcher indexSearcher) throws IOException {
+        return super.rewrite(indexSearcher);
+    }
+
+    public static Query boolRewrite(Query query, IndexSearcher indexSearcher) {
+        if (query instanceof BooleanQuery boolQuery) {
+            return (boolQuery.clauses().size() == 1) ? boolRewrite(boolQuery.clauses().get(0).query(), indexSearcher) : query;
+        } else if (query instanceof ApproximateBooleanQuery appxBool) {
+            return (appxBool.getBooleanQuery().clauses().size() == 1)
+                ? boolRewrite(appxBool.boolQuery.clauses().get(0).query(), indexSearcher)
+                : query;
+        }
+        try {
+            return query.rewrite(indexSearcher);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    protected boolean canApproximate(SearchContext context) {
+        if (context == null) {
+            return false;
+        }
+
+        // Don't approximate if we need accurate total hits
+        if (context.trackTotalHitsUpTo() == SearchContext.TRACK_TOTAL_HITS_ACCURATE) {
+            return false;
+        }
+
+        // Don't approximate if we have aggregations
+        if (context.aggregations() != null) {
+            return false;
+        }
+
+        // Don't approximate if highlighting is enabled
+        if (context.highlight() != null) {
+            return false;
+        }
+
+        if (!isTopLevel) {
+            return false;
+        }
+
+        // For single clause boolean queries, check if the clause can be approximated
+        if (clauses.size() == 1 && clauses.get(0).occur() != BooleanClause.Occur.MUST_NOT) {
+            // If the clause is already an ApproximateScoreQuery, we can approximate + set context
+            if (clauses.get(0).query() instanceof ApproximateScoreQuery approximateScoreQuery) {
+                if (approximateScoreQuery.getApproximationQuery() instanceof ApproximateBooleanQuery nestedBool) {
+                    return nestedBool.canApproximate(context);
+                }
+                return approximateScoreQuery.getApproximationQuery().canApproximate(context);
+            }
+            return false;
+        }
+
+        boolean hasApproximate = false;
+
+        // multi clause case - we might want to consider strategies for nested cases, for now limit to just top level
+        for (BooleanClause clause : clauses) {
+            if (clause.occur() != BooleanClause.Occur.FILTER) {
+                return false;
+            } else {
+                if (clause.query() instanceof ApproximateScoreQuery appxScore) {
+                    if (appxScore.getApproximationQuery() instanceof ApproximatePointRangeQuery) {
+                        hasApproximate = true;
+                    }
+                    if (appxScore.getApproximationQuery() instanceof ApproximateBooleanQuery || clause.query() instanceof BooleanQuery) {
+                        return false;
+                    }
+                }
+            }
+        }
+
+        return hasApproximate;
+    }
+
+    @Override
+    public ConstantScoreWeight createWeight(IndexSearcher searcher, ScoreMode scoreMode, float boost) throws IOException {
+        // For single clause boolean queries, delegate to the clause's createWeight
+        if (clauses.size() == 1 && clauses.get(0).occur() != BooleanClause.Occur.MUST_NOT) {
+            Query clauseQuery = clauses.get(0).query();
+
+            // If it's a scoring query, wrap it in a ConstantScoreQuery to ensure constant scoring
+            if (!(clauseQuery instanceof ConstantScoreQuery)) {
+                clauseQuery = new ConstantScoreQuery(clauseQuery);
+            }
+
+            return (ConstantScoreWeight) clauseQuery.createWeight(searcher, scoreMode, boost);
+        }
+
+        // For multi-clause boolean queries, create a custom weight
+        return new ApproximateBooleanWeight(searcher, scoreMode, boost);
+    }
+
+    /**
+     * Custom Weight implementation for ApproximateBooleanQuery that handles multi-clause boolean queries.
+     * This is a basic implementation that behaves like a regular filter boolean query for now.
+     */
+    private class ApproximateBooleanWeight extends ConstantScoreWeight {
+        private final ScoreMode scoreMode;
+        private final IndexSearcher searcher;
+        private final float boost;
+
+        public ApproximateBooleanWeight(IndexSearcher searcher, ScoreMode scoreMode, float boost) throws IOException {
+            super(ApproximateBooleanQuery.this, boost);
+            // Create a weight for the underlying boolean query
+            this.scoreMode = scoreMode;
+            this.searcher = searcher;
+            this.boost = boost;
+        }
+
+        @Override
+        public boolean isCacheable(LeafReaderContext ctx) {
+            return false;
+        }
+
+        @Override
+        public ScorerSupplier scorerSupplier(LeafReaderContext context) throws IOException {
+            // For multi-clause boolean queries, create a custom scorer supplier
+            List<Weight> clauseWeights = new ArrayList<>(clauses.size());
+            for (BooleanClause clause : clauses) {
+                Weight weight = clause.query().createWeight(searcher, scoreMode, boost);
+                clauseWeights.add(weight);
+            }
+
+            return new ApproximateBooleanScorerSupplier(clauseWeights, scoreMode, boost, size, context);
+        }
+
+    }
+
+    @Override
+    public String toString(String s) {
+        return "ApproximateBooleanQuery(" + boolQuery.toString(s) + ")";
+    }
+
+    @Override
+    public void visit(QueryVisitor queryVisitor) {
+        boolQuery.visit(queryVisitor);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ApproximateBooleanQuery that = (ApproximateBooleanQuery) o;
+        return size == that.size && boolQuery.equals(that.boolQuery);
+    }
+
+    @Override
+    public int hashCode() {
+        return boolQuery.hashCode();
+    }
+}