Fix regression: preserve not(not X) in BooleanFlatteningRewriter Resolve #19266 by fixing double-negation under MUST_NOT introduced by #19060 When parent is must_not and nested bool has only must_not clauses, rewrite to a positive OR:

   not(bool(must_not:[X1..Xn])) => filter(bool(should:[X1..Xn], minimum_should_match=1))
   Use FILTER (not MUST) to preserve non-scoring semantics of must_not
   Leave other flattenings unchanged; only trigger on pure must_not nested bool
   Add unit test: testDoubleNegationConvertedToPositiveMustShould

Signed-off-by: Atri Sharma <[email protected]>

Author: atris

server/src/main/java/org/opensearch/search/query/rewriters/BooleanFlatteningRewriter.java

@@ -129,11 +129,24 @@ private void flattenClauses(List<QueryBuilder> clauses, BoolQueryBuilder target,
             if (clause instanceof BoolQueryBuilder) {
                 BoolQueryBuilder nestedBool = (BoolQueryBuilder) clause;
 
-                if (canFlatten(nestedBool, clauseType)) {
-                    // Flatten the nested bool query by extracting its clauses
+                // Special handling for double negation: NOT over a bool that is ONLY NOTs
+                if (clauseType == ClauseType.MUST_NOT && canFlatten(nestedBool, ClauseType.MUST_NOT)) {
+                    // not( bool( must_not: [X1..Xn] ) )  ==>  must( bool( should: [X1..Xn], minimum_should_match: 1 ) )
+                    // This preserves the logical equivalence not(not(X)) == X and generalizes to multiple X via OR.
+                    BoolQueryBuilder orQuery = new BoolQueryBuilder();
+                    orQuery.minimumShouldMatch(1);
+                    for (QueryBuilder nestedClause : nestedBool.mustNot()) {
+                        if (nestedClause instanceof BoolQueryBuilder) {
+                            nestedClause = flattenBoolQuery((BoolQueryBuilder) nestedClause);
+                        }
+                        orQuery.should(nestedClause);
+                    }
+                    // Use FILTER to preserve scoring semantics (must_not does not contribute to score)
+                    target.filter(orQuery);
+                } else if (canFlatten(nestedBool, clauseType)) {
+                    // General flattening for same-clause-type nesting
                     List<QueryBuilder> nestedClauses = getClausesForType(nestedBool, clauseType);
                     for (QueryBuilder nestedClause : nestedClauses) {
-                        // Recursively flatten if needed
                         if (nestedClause instanceof BoolQueryBuilder) {
                             nestedClause = flattenBoolQuery((BoolQueryBuilder) nestedClause);
                         }

server/src/test/java/org/opensearch/search/query/rewriters/BooleanFlatteningRewriterTests.java

@@ -102,6 +102,27 @@ public void testMustNotClauseNoFlattening() {
         assertThat(rewrittenBool.mustNot().get(0), instanceOf(BoolQueryBuilder.class));
     }
 
+    public void testDoubleNegationConvertedToPositiveMustShould() {
+        // not( bool( must_not: [ term ] ) )  => must( bool( should: [ term ], msm=1 ) )
+        QueryBuilder inner = QueryBuilders.boolQuery().mustNot(QueryBuilders.termQuery("product", "Oranges"));
+        QueryBuilder query = QueryBuilders.boolQuery().mustNot(inner);
+
+        QueryBuilder rewritten = rewriter.rewrite(query, context);
+        assertThat(rewritten, instanceOf(BoolQueryBuilder.class));
+        BoolQueryBuilder rewrittenBool = (BoolQueryBuilder) rewritten;
+
+        // No must_not remains at top level
+        assertThat(rewrittenBool.mustNot().size(), equalTo(0));
+        // One MUST that is an OR over the inner negatives
+        assertThat(rewrittenBool.must().size(), equalTo(1));
+        assertThat(rewrittenBool.must().get(0), instanceOf(BoolQueryBuilder.class));
+
+        BoolQueryBuilder mustBool = (BoolQueryBuilder) rewrittenBool.must().get(0);
+        assertThat(mustBool.should().size(), equalTo(1));
+        assertThat(mustBool.minimumShouldMatch(), equalTo("1"));
+        assertThat(mustBool.should().get(0), instanceOf(QueryBuilders.termQuery("product", "Oranges").getClass()));
+    }
+
     @AwaitsFix(bugUrl = "https://github.com/opensearch-project/OpenSearch/issues/18906")
     public void testDeepNesting() {
         // TODO: This test expects complete flattening of deeply nested bool queries