feat: DH-21493: pushdown support for sorted regions

engine/table/src/main/java/io/deephaven/engine/table/impl/BasePushdownFilterContext.java

@@ -66,6 +66,16 @@ interface UnifiedChunkFilter extends SafeCloseable {
      */
     List<ColumnSource<?>> columnSources();
 
+    /**
+     * Whether this filter is a range filter.
+     */
+    boolean isRangeFilter();
+
+    /**
+     * Whether this filter is a match filter.
+     */
+    boolean isMatchFilter();
+
     /**
      * Whether this filter supports direct chunk filtering, i.e., it can be applied to a chunk of data rather than a
      * table. This includes any filter that implements {@link ExposesChunkFilter} or {@link ConditionFilter} with

engine/table/src/main/java/io/deephaven/engine/table/impl/BasePushdownFilterContextImpl.java

@@ -60,19 +60,21 @@ public BasePushdownFilterContextImpl(
                     "filter must be stateless, but does not permit parallelization: " + filter);
         }
 
-        this.filter = filter;
         this.columnSources = columnSources;
-
         executedFilterCost = 0;
+        // Extract the effective filter and use it for populating the context.
+        final WhereFilter effectiveFilter = WhereFilterDelegating.maybeUnwrapFilter(filter);
+        this.filter = effectiveFilter;
 
-        isRangeFilter = filter instanceof RangeFilter
-                && ((RangeFilter) filter).getRealFilter() instanceof AbstractRangeFilter;
-        isMatchFilter = filter instanceof MatchFilter &&
-                ((MatchFilter) filter).getFailoverFilterIfCached() == null;
+        isRangeFilter = effectiveFilter instanceof RangeFilter
+                && ((RangeFilter) effectiveFilter).getRealFilter() instanceof AbstractRangeFilter;
+        isMatchFilter = effectiveFilter instanceof MatchFilter &&
+                ((MatchFilter) effectiveFilter).getFailoverFilterIfCached() == null;
 
-        final Optional<ChunkFilter> chunkFilter = ExposesChunkFilter.chunkFilter(filter);
+        final Optional<ChunkFilter> chunkFilter = ExposesChunkFilter.chunkFilter(effectiveFilter);
         supportsChunkFiltering = chunkFilter.isPresent()
-                || (filter instanceof ConditionFilter && ((ConditionFilter) filter).getNumInputsUsed() == 1);
+                || (effectiveFilter instanceof ConditionFilter
+                        && ((ConditionFilter) effectiveFilter).getNumInputsUsed() == 1);
 
         conditionalFilterInitTable = null; // lazily initialized
         filterNullBehavior = null; // lazily initialized
@@ -104,6 +106,16 @@ public final List<ColumnSource<?>> columnSources() {
         return columnSources;
     }
 
+    @Override
+    public final boolean isRangeFilter() {
+        return isRangeFilter;
+    }
+
+    @Override
+    public final boolean isMatchFilter() {
+        return isMatchFilter;
+    }
+
     /**
      * Whether this filter supports direct chunk filtering, i.e., it can be applied to a chunk of data rather than a
      * table. This includes any filter that implements {@link ExposesChunkFilter} or {@link ConditionFilter} with

engine/table/src/main/java/io/deephaven/engine/table/impl/QueryTable.java

@@ -290,6 +290,13 @@ public interface MemoizableOperation<T extends DynamicNode & NotificationStepRec
             Configuration.getInstance().getBooleanWithDefault("QueryTable.disableWherePushdownParquetDictionary",
                     false);
 
+    /**
+     * Disable the usage of sorted column regions during push-down filtering.
+     */
+    public static boolean DISABLE_WHERE_PUSHDOWN_SORTED_COLUMN_LOCATION =
+            Configuration.getInstance().getBooleanWithDefault("QueryTable.disableWherePushdownSortedColumn",
+                    false);
+
     /**
      * You can choose to enable or disable the column parallel select and update.
      */

engine/table/src/main/java/io/deephaven/engine/table/impl/select/WhereFilterDelegating.java

@@ -0,0 +1,30 @@
+//
+// Copyright (c) 2016-2026 Deephaven Data Labs and Patent Pending
+//
+package io.deephaven.engine.table.impl.select;
+
+public interface WhereFilterDelegating {
+
+    /**
+     * Returns the filter to which this filter delegates.
+     */
+    WhereFilter getWrappedFilter();
+
+    /**
+     * Returns the wrapped filter if and only if the wrapped filter is functionally identical to this filter. Filters
+     * that perform a transformation (e.g. {@code not}) on their wrapped filter should return themselves.
+     */
+    WhereFilter maybeUnwrapFilter();
+
+    /**
+     * If the provided filter is an instance of {@code WhereFilterDelegating}, returns the effective wrapped filter of
+     * that filter. Otherwise, returns the filter itself wrapped in an Optional.
+     */
+    static WhereFilter maybeUnwrapFilter(WhereFilter filter) {
+        if (filter instanceof WhereFilterDelegating) {
+            return ((WhereFilterDelegating) filter).maybeUnwrapFilter();
+        }
+        // This filter is not a delegating filter, so return it directly.
+        return filter;
+    }
+}

engine/table/src/main/java/io/deephaven/engine/table/impl/select/WhereFilterDelegatingBase.java

@@ -22,7 +22,7 @@
 
 public abstract class WhereFilterDelegatingBase
         extends WhereFilterLivenessArtifactImpl
-        implements DependencyStreamProvider {
+        implements WhereFilterDelegating, DependencyStreamProvider {
 
     protected final WhereFilter filter;
 
@@ -45,6 +45,7 @@ public Stream<NotificationQueue.Dependency> getDependencyStream() {
         return Stream.empty();
     }
 
+    @Override
     public WhereFilter getWrappedFilter() {
         return filter;
     }

engine/table/src/main/java/io/deephaven/engine/table/impl/select/WhereFilterInvertedImpl.java

@@ -23,6 +23,12 @@ private WhereFilterInvertedImpl(WhereFilter filter) {
         super(filter);
     }
 
+    @Override
+    public WhereFilter maybeUnwrapFilter() {
+        // This filter inverts the results of the wrapped filter so we can't unwrap.
+        return this;
+    }
+
     @NotNull
     @Override
     public WritableRowSet filter(
@@ -47,11 +53,6 @@ public String toString() {
         return "not(" + filter + ")";
     }
 
-    @VisibleForTesting
-    WhereFilter filter() {
-        return filter;
-    }
-
     @Override
     public final <T> T walk(Visitor<T> visitor) {
         return visitor.visit(this);

engine/table/src/main/java/io/deephaven/engine/table/impl/select/WhereFilterSerialImpl.java

@@ -21,6 +21,15 @@ private WhereFilterSerialImpl(WhereFilter filter) {
         super(filter);
     }
 
+    @Override
+    public WhereFilter maybeUnwrapFilter() {
+        if (filter instanceof WhereFilterDelegating) {
+            // Delegate to the wrapped filter to find the effective wrapped filter.
+            return ((WhereFilterDelegating) filter).maybeUnwrapFilter();
+        }
+        return filter;
+    }
+
     /**
      * Always returns {@code false} to indicate that parallelization is not permitted.
      *

engine/table/src/main/java/io/deephaven/engine/table/impl/select/WhereFilterWithDeclaredBarriersImpl.java

@@ -30,6 +30,15 @@ private WhereFilterWithDeclaredBarriersImpl(
         this.declaredBarriers = declaredBarriers;
     }
 
+    @Override
+    public WhereFilter maybeUnwrapFilter() {
+        if (filter instanceof WhereFilterDelegating) {
+            // Delegate to the wrapped filter to find the effective wrapped filter.
+            return ((WhereFilterDelegating) filter).maybeUnwrapFilter();
+        }
+        return filter;
+    }
+
     public Object[] declaredBarriers() {
         return declaredBarriers;
     }

engine/table/src/main/java/io/deephaven/engine/table/impl/select/WhereFilterWithRespectedBarriersImpl.java

@@ -31,6 +31,15 @@ private WhereFilterWithRespectedBarriersImpl(
         this.respectedBarriers = respectedBarriers;
     }
 
+    @Override
+    public WhereFilter maybeUnwrapFilter() {
+        if (filter instanceof WhereFilterDelegating) {
+            // Delegate to the wrapped filter to find the effective wrapped filter.
+            return ((WhereFilterDelegating) filter).maybeUnwrapFilter();
+        }
+        return filter;
+    }
+
     public Object[] respectedBarriers() {
         return respectedBarriers;
     }