[core] Fix unsupported predicate returning empty results in applyPartitionFilter

buildPartitionPredicate returned null for both "unsupported predicate type"
and "invalid partition spec", but applyPartitionFilter treated all nulls as
"no matches". This caused BucketsTable/FilesTable/FileKeyRangesTable to
return empty results for unsupported predicates like isNotNull.

Introduce PushdownResult to distinguish three states: unsupported (skip
pushdown), no-match (return empty), and success (apply predicate).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: sundapeng

paimon-core/src/main/java/org/apache/paimon/table/system/PartitionsTable.java

@@ -456,14 +456,14 @@ private List<Partition> listPartitionEntries(@Nullable LeafPredicate partitionPr
                 List<String> partitionKeys = fileStoreTable.partitionKeys();
                 RowType partitionType = fileStoreTable.schema().logicalPartitionType();
                 String defaultPartitionName = fileStoreTable.coreOptions().partitionDefaultName();
-                Predicate partPred =
+                PartitionPredicateHelper.PushdownResult pushdownResult =
                         PartitionPredicateHelper.buildPartitionPredicate(
                                 partitionPredicate,
                                 partitionKeys,
                                 partitionType,
                                 defaultPartitionName);
-                if (partPred != null) {
-                    scan.withPartitionFilter(partPred);
+                if (pushdownResult.predicate() != null) {
+                    scan.withPartitionFilter(pushdownResult.predicate());
                 }
             }
 

paimon-core/src/main/java/org/apache/paimon/utils/PartitionPredicateHelper.java

@@ -40,15 +40,45 @@
  */
 public class PartitionPredicateHelper {
 
+    /** Result of attempting to build a partition predicate for pushdown. */
+    public static class PushdownResult {
+        private static final PushdownResult UNSUPPORTED = new PushdownResult(null, false);
+
+        @Nullable private final Predicate predicate;
+        private final boolean supported;
+
+        private PushdownResult(@Nullable Predicate predicate, boolean supported) {
+            this.predicate = predicate;
+            this.supported = supported;
+        }
+
+        static PushdownResult unsupported() {
+            return UNSUPPORTED;
+        }
+
+        static PushdownResult noMatch() {
+            return new PushdownResult(null, true);
+        }
+
+        static PushdownResult of(Predicate predicate) {
+            return new PushdownResult(predicate, true);
+        }
+
+        public boolean isSupported() {
+            return supported;
+        }
+
+        @Nullable
+        public Predicate predicate() {
+            return predicate;
+        }
+    }
+
     /**
      * Build a partition-typed predicate from a string-based leaf predicate on the "partition"
-     * column. Only Equal and In predicates are supported for pushdown.
-     *
-     * @return the predicate on partition fields, or {@code null} if the predicate cannot be pushed
-     *     down (unsupported predicate type or invalid partition spec)
+     * column.
      */
-    @Nullable
-    public static Predicate buildPartitionPredicate(
+    public static PushdownResult buildPartitionPredicate(
             LeafPredicate partitionPredicate,
             List<String> partitionKeys,
             RowType partitionType,
@@ -58,7 +88,7 @@ public static Predicate buildPartitionPredicate(
                     parsePartitionSpec(
                             partitionPredicate.literals().get(0).toString(), partitionKeys);
             if (partSpec == null) {
-                return null;
+                return PushdownResult.noMatch();
             }
             PredicateBuilder partBuilder = new PredicateBuilder(partitionType);
             List<Predicate> predicates = new ArrayList<>();
@@ -71,7 +101,7 @@ public static Predicate buildPartitionPredicate(
                     predicates.add(partBuilder.equal(i, value));
                 }
             }
-            return PredicateBuilder.and(predicates);
+            return PushdownResult.of(PredicateBuilder.and(predicates));
         } else if (partitionPredicate.function() instanceof In) {
             List<Predicate> orPredicates = new ArrayList<>();
             PredicateBuilder partBuilder = new PredicateBuilder(partitionType);
@@ -94,16 +124,16 @@ public static Predicate buildPartitionPredicate(
                 }
                 orPredicates.add(PredicateBuilder.and(andPredicates));
             }
-            return orPredicates.isEmpty() ? null : PredicateBuilder.or(orPredicates);
+            return orPredicates.isEmpty()
+                    ? PushdownResult.noMatch()
+                    : PushdownResult.of(PredicateBuilder.or(orPredicates));
         }
-        // Range predicates (>, >=, <, <=) can be pushed down for simple value formats
-        // used by BucketsTable, FilesTable, FileKeyRangesTable.
         if (partitionPredicate.function() instanceof LeafBinaryFunction) {
             LinkedHashMap<String, String> partSpec =
                     parsePartitionSpec(
                             partitionPredicate.literals().get(0).toString(), partitionKeys);
             if (partSpec == null) {
-                return null;
+                return PushdownResult.noMatch();
             }
             PredicateBuilder partBuilder = new PredicateBuilder(partitionType);
             List<Predicate> predicates = new ArrayList<>();
@@ -122,9 +152,9 @@ public static Predicate buildPartitionPredicate(
                                     Collections.singletonList(value)));
                 }
             }
-            return PredicateBuilder.and(predicates);
+            return PushdownResult.of(PredicateBuilder.and(predicates));
         }
-        return null;
+        return PushdownResult.unsupported();
     }
 
     public static boolean applyPartitionFilter(
@@ -137,13 +167,16 @@ public static boolean applyPartitionFilter(
             return true;
         }
 
-        Predicate predicate =
+        PushdownResult result =
                 buildPartitionPredicate(
                         partitionPredicate, partitionKeys, partitionType, defaultPartitionName);
-        if (predicate == null) {
+        if (!result.isSupported()) {
+            return true;
+        }
+        if (result.predicate() == null) {
             return false;
         }
-        snapshotReader.withPartitionFilter(predicate);
+        snapshotReader.withPartitionFilter(result.predicate());
         return true;
     }
 

paimon-core/src/test/java/org/apache/paimon/table/system/BucketsTableTest.java

@@ -148,6 +148,15 @@ public void testBucketsTableWithCombinedFilter() throws Exception {
         assertThat(readWithFilter(bucketsTable, filter, new int[] {0, 1, 2, 4})).isEmpty();
     }
 
+    @Test
+    public void testBucketsTableUnsupportedPredicateFallsBackToFullScan() throws Exception {
+        PredicateBuilder builder = new PredicateBuilder(BucketsTable.TABLE_TYPE);
+
+        // isNotNull cannot be pushed down as partition filter — must fall back to full scan
+        Predicate filter = builder.isNotNull(0);
+        assertThat(readWithFilter(bucketsTable, filter, new int[] {0, 1, 2, 4})).hasSize(2);
+    }
+
     private List<InternalRow> readWithFilter(Table table, Predicate filter, int[] projection)
             throws Exception {
         ReadBuilder readBuilder = table.newReadBuilder().withFilter(filter);