fix: DH-21914: ComposedFilters and Delegating filters should manage all liveness artifacts. (deephaven#7779)

Author: cpwright

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

@@ -31,7 +31,10 @@ public abstract class ComposedFilter extends WhereFilterLivenessArtifactImpl imp
         this.componentFilters = componentFilters;
 
         for (WhereFilter f : this.componentFilters) {
-            if (f instanceof LivenessArtifact && f.isRefreshing()) {
+            // We do not check for isRefreshing here (the filters are not dynamic nodes, they have a distinct
+            // isRefreshing method), because we don't actually know if a filter is going to be refreshing until we
+            // initialize it.
+            if (f instanceof LivenessArtifact) {
                 manage((LivenessArtifact) f);
             }
         }

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

@@ -28,7 +28,9 @@ public abstract class WhereFilterDelegatingBase
 
     protected WhereFilterDelegatingBase(WhereFilter filter) {
         this.filter = Objects.requireNonNull(filter);
-        if (filter instanceof LivenessArtifact && filter.isRefreshing()) {
+        if (filter instanceof LivenessArtifact) {
+            // We manage all LivenessArtifact filters; we do not know if they are refreshing at the time of
+            // construction.
             manage((LivenessArtifact) filter);
         }
     }

engine/table/src/test/java/io/deephaven/engine/table/impl/QueryTableWhereInTest.java

@@ -8,6 +8,7 @@
 import io.deephaven.chunk.ChunkType;
 import io.deephaven.engine.context.ExecutionContext;
 import io.deephaven.engine.context.QueryScope;
+import io.deephaven.engine.liveness.SingletonLivenessManager;
 import io.deephaven.engine.table.*;
 import io.deephaven.engine.table.impl.indexer.DataIndexer;
 import io.deephaven.engine.table.impl.select.*;
@@ -232,6 +233,41 @@ public void testWhereDynamicIn() {
         });
     }
 
+    @Test
+    public void testWhereInStaticSet() {
+        final Table setTable = testTable(i(2, 4, 6, 8).toTracking(), col("X", "A", "B", "C", "B"));
+        assertFalse(setTable.isRefreshing());
+
+        final QueryTable filteredTable = testRefreshingTable(i(1, 2, 3, 4, 5).toTracking(),
+                col("X", "A", "B", "C", "D", "E"));
+
+        final ControlledUpdateGraph updateGraph = ExecutionContext.getContext().getUpdateGraph().cast();
+
+        final Table result = updateGraph.exclusiveLock().computeLocked(
+                () -> filteredTable.whereIn(setTable, "X"));
+        show(result);
+        assertEquals(3, result.size());
+        assertArrayEquals(new String[] {"A", "B", "C"}, ColumnVectors.ofObject(result, "X", String.class).toArray());
+
+        updateGraph.runWithinUnitTestCycle(() -> {
+            addToTable(filteredTable, i(6), col("X", "A"));
+            filteredTable.notifyListeners(i(6), i(), i());
+        });
+        show(result);
+        assertEquals(4, result.size());
+        assertArrayEquals(new String[] {"A", "B", "C", "A"},
+                ColumnVectors.ofObject(result, "X", String.class).toArray());
+
+        final DynamicWhereFilter dynamicWhereFilter =
+                new DynamicWhereFilter((QueryTable) setTable, true, MatchPairFactory.getExpressions("X"));
+        final WhereFilter invert = WhereFilterInvertedImpl.of(dynamicWhereFilter);
+
+        final Table filteredInvert = updateGraph.exclusiveLock().computeLocked(() -> filteredTable.where(invert));
+        assertEquals(2, filteredInvert.size());
+        assertArrayEquals(new String[] {"D", "E"},
+                ColumnVectors.ofObject(filteredInvert, "X", String.class).toArray());
+    }
+
     @Test
     public void testWhereDynamicInIncremental() {
         testWhereDynamicIncrementalInternal(false, false, true, true);

engine/table/src/test/java/io/deephaven/engine/table/impl/select/TestTimeSeriesFilter.java

@@ -420,4 +420,31 @@ public void testStatic() {
         assertFalse(filtered2.isRefreshing());
         assertEquals(size, filtered2.size());
     }
+
+    public void testComposed() {
+        final long start = DateTimeUtils.epochNanos(DateTimeUtils.parseInstant("2026-03-10T09:00:00 NY"));
+
+        final TestClock testClock = new TestClock().setNanos(start + 30 * DateTimeUtils.MINUTE);
+
+        final TimeSeriesFilter timeSeriesFilter =
+                TimeSeriesFilter.newBuilder().columnName("Timestamp").period("PT5m").clock(testClock).invert(true)
+                        .build();
+
+        final Filter disjunctiveOne = DisjunctiveFilter.of(timeSeriesFilter);
+        assertTrue(disjunctiveOne instanceof TimeSeriesFilter);
+
+        final Filter disjunctiveTwo =
+                DisjunctiveFilter.of(timeSeriesFilter, WhereFilterFactory.getExpression("A in `Apple`"));
+        assertTrue(disjunctiveTwo instanceof DisjunctiveFilter);
+
+        final Filter conjunctiveOne = ConjunctiveFilter.of(timeSeriesFilter);
+        assertTrue(conjunctiveOne instanceof TimeSeriesFilter);
+
+        final Filter conjunctiveTwo =
+                ConjunctiveFilter.of(timeSeriesFilter, WhereFilterFactory.getExpression("A in `Apple`"));
+        assertTrue(conjunctiveTwo instanceof ConjunctiveFilter);
+
+        final WhereFilter inverted = WhereFilterInvertedImpl.of(timeSeriesFilter);
+        assertTrue(inverted instanceof WhereFilterInvertedImpl);
+    }
 }