Fix Incorrect Plan Constraints Generated for Join Predicates (#3971)

Plan constraints are used to ensure that cached query plans can be
safely reused when parameter values change. These constraints validate
that a cached plan remains valid for a given set of parameter bindings
and are designed to work with constant-bound comparands where a field is
compared against a constant or parameter (e.g., `field = ?`, `field >
5`).

However, when a query contains both join predicates with non-constant
comparands (e.g., `game.score_id = score.id`) and static predicates
without constant-bound comparands (e.g., `game.score_id IS NOT NULL`),
the plan constraint generation logic could incorrectly attempt to create
constraints for the join predicate. This occurs because the static IS
NOT NULL predicate acts as a filter that allows the query to proceed,
but has no constant literals to capture in the constraint. Without
proper filtering, the planner might try to create a plan constraint for
the join predicate, which is semantically invalid since join predicates
establish correlations between fields rather than between fields and
constants.

This fixes #3973.

Author: hatyo

fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/predicates/PredicateWithValueAndRanges.java

@@ -531,6 +531,12 @@ private QueryPlanConstraint captureConstraint(@Nonnull final PredicateWithValueA
                     .stream()
                     .filter(comparison -> comparison instanceof Comparisons.ValueComparison)
                     .map(valueComparison -> ((Comparisons.ValueComparison)valueComparison).getComparandValue())
+                    // Plan constraints are only defined for constant-bound comparands (e.g., field = 5).
+                    // Non-constant comparands (such as join predicates like field1 = field2) are filtered out here.
+                    // This filtering is essential when queries combine join predicates with static predicates
+                    // like IS NOT NULL. Since neither predicate has constant literals to bind, we must avoid
+                    // incorrectly generating constraints for the join predicate, which would be semantically invalid.
+                    .filter(comparandValue -> comparandValue instanceof Value.RangeMatchableValue)
                     .map(constant -> PredicateWithValueAndRanges.ofRanges(constant, candidateRanges))
                     .collect(Collectors.toList())));
         }

fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/predicates/RangeConstraints.java

@@ -297,7 +297,7 @@ public ExplainTokensWithPrecedence explain() {
         }
 
         if (!deferredRanges.isEmpty()) {
-            resultExplainTokens.addSequence(() -> new ExplainTokens().addWhitespace()
+            resultExplainTokens.addWhitespace().addKeyword("AND").addWhitespace().addSequence(() -> new ExplainTokens().addWhitespace()
                             .addKeyword("AND").addWhitespace(),
                     () -> deferredRanges.stream().map(Comparisons.Comparison::explain)
                             .map(Precedence.AND::parenthesizeChild).iterator());

fdb-relational-core/src/test/java/com/apple/foundationdb/relational/recordlayer/query/cache/ConstraintValidityTests.java

@@ -75,7 +75,7 @@ public class ConstraintValidityTests {
 
     @RegisterExtension
     @Order(2)
-    public final SimpleDatabaseRule database = new SimpleDatabaseRule(RelationalPlanCacheTests.class, TestSchemas.score());
+    public final SimpleDatabaseRule database = new SimpleDatabaseRule(ConstraintValidityTests.class, TestSchemas.score());
 
     @RegisterExtension
     @Order(3)
@@ -94,6 +94,9 @@ public class ConstraintValidityTests {
     @Nonnull
     private static final String BitAndScore4 = "BITANDSCORE4";
 
+    @Nonnull
+    private static final String GameIdx = "GAMEIDX";
+
     @Nonnull
     private static final String Scan = "SCAN";
 
@@ -156,7 +159,9 @@ private static String inferScanType(@Nonnull final Plan<?> plan) {
         Assertions.assertInstanceOf(QueryPlan.PhysicalQueryPlan.class, plan);
         final var physicalPlan = (QueryPlan.PhysicalQueryPlan) plan;
         final var desc = physicalPlan.getRecordQueryPlan().toString(); // very ad-hoc :/
-        if (desc.contains(MaxScoreByGame10)) {
+        if (desc.contains(GameIdx)) { // not the best plan interpreter, gameIdx should be used in join queries only
+            return GameIdx;
+        } else if (desc.contains(MaxScoreByGame10)) {
             return MaxScoreByGame10;
         } else if (desc.contains(MaxScoreByGame20)) {
             return MaxScoreByGame20;
@@ -341,4 +346,13 @@ void cachingQueryWithComplexGroupByExpressionSubsumingIndexExpressionBehavesCorr
                         ppe(cons(and(and(c17Equals2, c17Equals2), and(c17Int, c8Int, c10Int, c8Equalsc15, c17IntNotNull, c8IntNotNull, c10IntNotNull)))), BitAndScore2,
                         ppe(cons(and(and(c17Equals4, c17Equals4), and(c17Int, c8Int, c10Int, c8Equalsc15, c17IntNotNull, c8IntNotNull, c10IntNotNull)))), BitAndScore4)));
     }
+
+    @Test
+    void cachingQueryWithIsNotNullFilterWorksAsExpected() throws Exception {
+        final var ticker = new FakeTicker();
+        final var cache = getCache(ticker);
+        planQuery(cache, "SELECT game.name from score, game use index (gameIdx) where game.score_id is not null and game.score_id = score.id", GameIdx);
+        cacheShouldBe(cache, Map.of("SELECT \"GAME\" . \"NAME\" from \"SCORE\" , \"GAME\" use index ( \"GAMEIDX\" ) " +
+                "where \"GAME\" . \"SCORE_ID\" is not null and \"GAME\" . \"SCORE_ID\" = \"SCORE\" . \"ID\" ", Map.of(ppe(QueryPlanConstraint.noConstraint()), GameIdx)));
+    }
 }

fdb-relational-core/src/testFixtures/java/com/apple/foundationdb/relational/utils/TestSchemas.java

@@ -88,10 +88,12 @@ public static String books() {
     @Nonnull
     private static final String SCORE_SCHEMA =
             "CREATE TABLE score(id bigint, player string, game bigint, score bigint, playDuration bigint, primary key(id))" +
+                    "CREATE TABLE game(id bigint, score_id bigint, name string, primary key(id))" +
                     "CREATE INDEX maxScoreByGame10 AS SELECT MAX(score), game + 10 FROM score GROUP BY game + 10" +
                     "CREATE INDEX maxScoreByGame20 AS SELECT MAX(score), game + 20 FROM score GROUP BY game + 20" +
                     "CREATE INDEX bitAndScore2 AS SELECT game & 2, MAX(score) FROM score GROUP BY game & 2" +
-                    "CREATE INDEX bitAndScore4 AS SELECT game & 4, MAX(score) FROM score GROUP BY game & 4";
+                    "CREATE INDEX bitAndScore4 AS SELECT game & 4, MAX(score) FROM score GROUP BY game & 4" +
+                    "CREATE INDEX gameIdx AS SELECT score_id, id, name FROM game WHERE score_id IS NOT NULL ORDER BY score_id, id, name";
 
     @Nonnull
     public static String score() {