diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/DynamicWhereFilter.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/DynamicWhereFilter.java
index 9c7b466dc99..53527caf51c 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/DynamicWhereFilter.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/DynamicWhereFilter.java
@@ -537,21 +537,15 @@ private WritableRowSet filterLinear(final RowSet selection, final boolean filter
         // @formatter:off
         try (final ColumnSource.GetContext keyGetContext = sourceKeySource.makeGetContext(maxChunkSize);
              final RowSequence.Iterator selectionIterator = selection.getRowSequenceIterator();
-             final WritableBooleanChunk<Values> matches = WritableBooleanChunk.makeWritableChunk(maxChunkSize)) {
+             final WritableLongChunk<OrderedRowKeys> matchingKeys = WritableLongChunk.makeWritableChunk(maxChunkSize)) {
             // @formatter:on
 
             while (selectionIterator.hasMore()) {
                 final RowSequence selectionChunk = selectionIterator.getNextRowSequenceWithLength(maxChunkSize);
                 final LongChunk<OrderedRowKeys> selectionRowKeyChunk = selectionChunk.asRowKeyChunk();
                 final Chunk<Values> keyChunk = Chunk.downcast(sourceKeySource.getChunk(keyGetContext, selectionChunk));
-                setKernel.matchValues(keyChunk, matches, filterInclusion);
-
-                final int thisChunkSize = keyChunk.size();
-                for (int ii = 0; ii < thisChunkSize; ++ii) {
-                    if (matches.get(ii)) {
-                        filteredRowSetBuilder.appendKey(selectionRowKeyChunk.get(ii));
-                    }
-                }
+                setKernel.matchValues(keyChunk, selectionRowKeyChunk, matchingKeys, filterInclusion);
+                filteredRowSetBuilder.appendOrderedRowKeysChunk(matchingKeys);
             }
         }
 
diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ByteSetInclusionKernel.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ByteSetInclusionKernel.java
index 81f3deebd05..bc5be688cfb 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ByteSetInclusionKernel.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ByteSetInclusionKernel.java
@@ -8,10 +8,9 @@
 package io.deephaven.engine.table.impl.select.setinclusion;
 
 import gnu.trove.iterator.TByteIterator;
-import io.deephaven.chunk.ByteChunk;
-import io.deephaven.chunk.Chunk;
-import io.deephaven.chunk.WritableBooleanChunk;
+import io.deephaven.chunk.*;
 import io.deephaven.chunk.attributes.Values;
+import io.deephaven.engine.rowset.chunkattributes.OrderedRowKeys;
 import io.deephaven.util.type.TypeUtils;
 import gnu.trove.set.TByteSet;
 import gnu.trove.set.hash.TByteHashSet;
@@ -24,24 +23,24 @@ public class ByteSetInclusionKernel implements SetInclusionKernel {
     private final TByteSet liveValues;
     private final boolean inclusion;
 
-    ByteSetInclusionKernel(Collection<Object> liveValues, boolean inclusion) {
+    ByteSetInclusionKernel(@NotNull final Collection<Object> liveValues, final boolean inclusion) {
         this.liveValues = new TByteHashSet(liveValues.size());
         liveValues.forEach(x -> this.liveValues.add(TypeUtils.unbox((Byte) x)));
         this.inclusion = inclusion;
     }
 
-    ByteSetInclusionKernel(boolean inclusion) {
+    ByteSetInclusionKernel(final boolean inclusion) {
         this.liveValues = new TByteHashSet();
         this.inclusion = inclusion;
     }
 
     @Override
-    public boolean add(Object key) {
+    public boolean add(@NotNull final Object key) {
         return liveValues.add(TypeUtils.unbox((Byte) key));
     }
 
     @Override
-    public boolean remove(Object key) {
+    public boolean remove(@NotNull final Object key) {
         return liveValues.remove(TypeUtils.unbox((Byte) key));
     }
 
@@ -75,22 +74,49 @@ public java.util.Iterator<Object> iterator() {
     }
 
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches) {
-        matchValues(values.asByteChunk(), matches, inclusion);
+    public void matchValues(
+            @NotNull final Chunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        matchValues(values, keys, results, inclusion);
     }
 
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches, boolean inclusionOverride) {
-        matchValues(values.asByteChunk(), matches, inclusionOverride);
+    public void matchValues(
+            @NotNull final Chunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results,
+            final boolean inclusionOverride) {
+        if (inclusionOverride) {
+            matchValues(values.asByteChunk(), keys, results);
+        } else {
+            matchValuesInvert(values.asByteChunk(), keys, results);
+        }
     }
 
     private void matchValues(
-            ByteChunk<Values> values,
-            WritableBooleanChunk<?> matches,
-            boolean inclusionToUse) {
+            @NotNull final ByteChunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        results.setSize(0);
+        for (int ii = 0; ii < values.size(); ++ii) {
+            final byte checkValue = values.get(ii);
+            if (liveValues.contains(checkValue)) {
+                results.add(keys.get(ii));
+            }
+        }
+    }
+
+    private void matchValuesInvert(
+            @NotNull final ByteChunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        results.setSize(0);
         for (int ii = 0; ii < values.size(); ++ii) {
-            matches.set(ii, liveValues.contains(values.get(ii)) == inclusionToUse);
+            final byte checkValue = values.get(ii);
+            if (!liveValues.contains(checkValue)) {
+                results.add(keys.get(ii));
+            }
         }
-        matches.setSize(values.size());
     }
 }
diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/CharSetInclusionKernel.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/CharSetInclusionKernel.java
index 179fd8a32b0..2cbc836a9b7 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/CharSetInclusionKernel.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/CharSetInclusionKernel.java
@@ -4,10 +4,9 @@
 package io.deephaven.engine.table.impl.select.setinclusion;
 
 import gnu.trove.iterator.TCharIterator;
-import io.deephaven.chunk.CharChunk;
-import io.deephaven.chunk.Chunk;
-import io.deephaven.chunk.WritableBooleanChunk;
+import io.deephaven.chunk.*;
 import io.deephaven.chunk.attributes.Values;
+import io.deephaven.engine.rowset.chunkattributes.OrderedRowKeys;
 import io.deephaven.util.type.TypeUtils;
 import gnu.trove.set.TCharSet;
 import gnu.trove.set.hash.TCharHashSet;
@@ -20,24 +19,24 @@ public class CharSetInclusionKernel implements SetInclusionKernel {
     private final TCharSet liveValues;
     private final boolean inclusion;
 
-    CharSetInclusionKernel(Collection<Object> liveValues, boolean inclusion) {
+    CharSetInclusionKernel(@NotNull final Collection<Object> liveValues, final boolean inclusion) {
         this.liveValues = new TCharHashSet(liveValues.size());
         liveValues.forEach(x -> this.liveValues.add(TypeUtils.unbox((Character) x)));
         this.inclusion = inclusion;
     }
 
-    CharSetInclusionKernel(boolean inclusion) {
+    CharSetInclusionKernel(final boolean inclusion) {
         this.liveValues = new TCharHashSet();
         this.inclusion = inclusion;
     }
 
     @Override
-    public boolean add(Object key) {
+    public boolean add(@NotNull final Object key) {
         return liveValues.add(TypeUtils.unbox((Character) key));
     }
 
     @Override
-    public boolean remove(Object key) {
+    public boolean remove(@NotNull final Object key) {
         return liveValues.remove(TypeUtils.unbox((Character) key));
     }
 
@@ -71,22 +70,49 @@ public java.util.Iterator<Object> iterator() {
     }
 
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches) {
-        matchValues(values.asCharChunk(), matches, inclusion);
+    public void matchValues(
+            @NotNull final Chunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        matchValues(values, keys, results, inclusion);
     }
 
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches, boolean inclusionOverride) {
-        matchValues(values.asCharChunk(), matches, inclusionOverride);
+    public void matchValues(
+            @NotNull final Chunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results,
+            final boolean inclusionOverride) {
+        if (inclusionOverride) {
+            matchValues(values.asCharChunk(), keys, results);
+        } else {
+            matchValuesInvert(values.asCharChunk(), keys, results);
+        }
     }
 
     private void matchValues(
-            CharChunk<Values> values,
-            WritableBooleanChunk<?> matches,
-            boolean inclusionToUse) {
+            @NotNull final CharChunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        results.setSize(0);
+        for (int ii = 0; ii < values.size(); ++ii) {
+            final char checkValue = values.get(ii);
+            if (liveValues.contains(checkValue)) {
+                results.add(keys.get(ii));
+            }
+        }
+    }
+
+    private void matchValuesInvert(
+            @NotNull final CharChunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        results.setSize(0);
         for (int ii = 0; ii < values.size(); ++ii) {
-            matches.set(ii, liveValues.contains(values.get(ii)) == inclusionToUse);
+            final char checkValue = values.get(ii);
+            if (!liveValues.contains(checkValue)) {
+                results.add(keys.get(ii));
+            }
         }
-        matches.setSize(values.size());
     }
 }
diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/DoubleSetInclusionKernel.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/DoubleSetInclusionKernel.java
index 19ee26801a3..b473998041a 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/DoubleSetInclusionKernel.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/DoubleSetInclusionKernel.java
@@ -8,10 +8,9 @@
 package io.deephaven.engine.table.impl.select.setinclusion;
 
 import gnu.trove.iterator.TDoubleIterator;
-import io.deephaven.chunk.DoubleChunk;
-import io.deephaven.chunk.Chunk;
-import io.deephaven.chunk.WritableBooleanChunk;
+import io.deephaven.chunk.*;
 import io.deephaven.chunk.attributes.Values;
+import io.deephaven.engine.rowset.chunkattributes.OrderedRowKeys;
 import io.deephaven.util.type.TypeUtils;
 import gnu.trove.set.TDoubleSet;
 import gnu.trove.set.hash.TDoubleHashSet;
@@ -24,24 +23,24 @@ public class DoubleSetInclusionKernel implements SetInclusionKernel {
     private final TDoubleSet liveValues;
     private final boolean inclusion;
 
-    DoubleSetInclusionKernel(Collection<Object> liveValues, boolean inclusion) {
+    DoubleSetInclusionKernel(@NotNull final Collection<Object> liveValues, final boolean inclusion) {
         this.liveValues = new TDoubleHashSet(liveValues.size());
         liveValues.forEach(x -> this.liveValues.add(TypeUtils.unbox((Double) x)));
         this.inclusion = inclusion;
     }
 
-    DoubleSetInclusionKernel(boolean inclusion) {
+    DoubleSetInclusionKernel(final boolean inclusion) {
         this.liveValues = new TDoubleHashSet();
         this.inclusion = inclusion;
     }
 
     @Override
-    public boolean add(Object key) {
+    public boolean add(@NotNull final Object key) {
         return liveValues.add(TypeUtils.unbox((Double) key));
     }
 
     @Override
-    public boolean remove(Object key) {
+    public boolean remove(@NotNull final Object key) {
         return liveValues.remove(TypeUtils.unbox((Double) key));
     }
 
@@ -75,22 +74,49 @@ public java.util.Iterator<Object> iterator() {
     }
 
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches) {
-        matchValues(values.asDoubleChunk(), matches, inclusion);
+    public void matchValues(
+            @NotNull final Chunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        matchValues(values, keys, results, inclusion);
     }
 
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches, boolean inclusionOverride) {
-        matchValues(values.asDoubleChunk(), matches, inclusionOverride);
+    public void matchValues(
+            @NotNull final Chunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results,
+            final boolean inclusionOverride) {
+        if (inclusionOverride) {
+            matchValues(values.asDoubleChunk(), keys, results);
+        } else {
+            matchValuesInvert(values.asDoubleChunk(), keys, results);
+        }
     }
 
     private void matchValues(
-            DoubleChunk<Values> values,
-            WritableBooleanChunk<?> matches,
-            boolean inclusionToUse) {
+            @NotNull final DoubleChunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        results.setSize(0);
+        for (int ii = 0; ii < values.size(); ++ii) {
+            final double checkValue = values.get(ii);
+            if (liveValues.contains(checkValue)) {
+                results.add(keys.get(ii));
+            }
+        }
+    }
+
+    private void matchValuesInvert(
+            @NotNull final DoubleChunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        results.setSize(0);
         for (int ii = 0; ii < values.size(); ++ii) {
-            matches.set(ii, liveValues.contains(values.get(ii)) == inclusionToUse);
+            final double checkValue = values.get(ii);
+            if (!liveValues.contains(checkValue)) {
+                results.add(keys.get(ii));
+            }
         }
-        matches.setSize(values.size());
     }
 }
diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/FloatSetInclusionKernel.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/FloatSetInclusionKernel.java
index d22400b1d9b..84b86f1635b 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/FloatSetInclusionKernel.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/FloatSetInclusionKernel.java
@@ -8,10 +8,9 @@
 package io.deephaven.engine.table.impl.select.setinclusion;
 
 import gnu.trove.iterator.TFloatIterator;
-import io.deephaven.chunk.FloatChunk;
-import io.deephaven.chunk.Chunk;
-import io.deephaven.chunk.WritableBooleanChunk;
+import io.deephaven.chunk.*;
 import io.deephaven.chunk.attributes.Values;
+import io.deephaven.engine.rowset.chunkattributes.OrderedRowKeys;
 import io.deephaven.util.type.TypeUtils;
 import gnu.trove.set.TFloatSet;
 import gnu.trove.set.hash.TFloatHashSet;
@@ -24,24 +23,24 @@ public class FloatSetInclusionKernel implements SetInclusionKernel {
     private final TFloatSet liveValues;
     private final boolean inclusion;
 
-    FloatSetInclusionKernel(Collection<Object> liveValues, boolean inclusion) {
+    FloatSetInclusionKernel(@NotNull final Collection<Object> liveValues, final boolean inclusion) {
         this.liveValues = new TFloatHashSet(liveValues.size());
         liveValues.forEach(x -> this.liveValues.add(TypeUtils.unbox((Float) x)));
         this.inclusion = inclusion;
     }
 
-    FloatSetInclusionKernel(boolean inclusion) {
+    FloatSetInclusionKernel(final boolean inclusion) {
         this.liveValues = new TFloatHashSet();
         this.inclusion = inclusion;
     }
 
     @Override
-    public boolean add(Object key) {
+    public boolean add(@NotNull final Object key) {
         return liveValues.add(TypeUtils.unbox((Float) key));
     }
 
     @Override
-    public boolean remove(Object key) {
+    public boolean remove(@NotNull final Object key) {
         return liveValues.remove(TypeUtils.unbox((Float) key));
     }
 
@@ -75,22 +74,49 @@ public java.util.Iterator<Object> iterator() {
     }
 
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches) {
-        matchValues(values.asFloatChunk(), matches, inclusion);
+    public void matchValues(
+            @NotNull final Chunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        matchValues(values, keys, results, inclusion);
     }
 
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches, boolean inclusionOverride) {
-        matchValues(values.asFloatChunk(), matches, inclusionOverride);
+    public void matchValues(
+            @NotNull final Chunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results,
+            final boolean inclusionOverride) {
+        if (inclusionOverride) {
+            matchValues(values.asFloatChunk(), keys, results);
+        } else {
+            matchValuesInvert(values.asFloatChunk(), keys, results);
+        }
     }
 
     private void matchValues(
-            FloatChunk<Values> values,
-            WritableBooleanChunk<?> matches,
-            boolean inclusionToUse) {
+            @NotNull final FloatChunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        results.setSize(0);
+        for (int ii = 0; ii < values.size(); ++ii) {
+            final float checkValue = values.get(ii);
+            if (liveValues.contains(checkValue)) {
+                results.add(keys.get(ii));
+            }
+        }
+    }
+
+    private void matchValuesInvert(
+            @NotNull final FloatChunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        results.setSize(0);
         for (int ii = 0; ii < values.size(); ++ii) {
-            matches.set(ii, liveValues.contains(values.get(ii)) == inclusionToUse);
+            final float checkValue = values.get(ii);
+            if (!liveValues.contains(checkValue)) {
+                results.add(keys.get(ii));
+            }
         }
-        matches.setSize(values.size());
     }
 }
diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/IntSetInclusionKernel.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/IntSetInclusionKernel.java
index ae8d152b0d6..fecbea438ac 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/IntSetInclusionKernel.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/IntSetInclusionKernel.java
@@ -8,10 +8,9 @@
 package io.deephaven.engine.table.impl.select.setinclusion;
 
 import gnu.trove.iterator.TIntIterator;
-import io.deephaven.chunk.IntChunk;
-import io.deephaven.chunk.Chunk;
-import io.deephaven.chunk.WritableBooleanChunk;
+import io.deephaven.chunk.*;
 import io.deephaven.chunk.attributes.Values;
+import io.deephaven.engine.rowset.chunkattributes.OrderedRowKeys;
 import io.deephaven.util.type.TypeUtils;
 import gnu.trove.set.TIntSet;
 import gnu.trove.set.hash.TIntHashSet;
@@ -24,24 +23,24 @@ public class IntSetInclusionKernel implements SetInclusionKernel {
     private final TIntSet liveValues;
     private final boolean inclusion;
 
-    IntSetInclusionKernel(Collection<Object> liveValues, boolean inclusion) {
+    IntSetInclusionKernel(@NotNull final Collection<Object> liveValues, final boolean inclusion) {
         this.liveValues = new TIntHashSet(liveValues.size());
         liveValues.forEach(x -> this.liveValues.add(TypeUtils.unbox((Integer) x)));
         this.inclusion = inclusion;
     }
 
-    IntSetInclusionKernel(boolean inclusion) {
+    IntSetInclusionKernel(final boolean inclusion) {
         this.liveValues = new TIntHashSet();
         this.inclusion = inclusion;
     }
 
     @Override
-    public boolean add(Object key) {
+    public boolean add(@NotNull final Object key) {
         return liveValues.add(TypeUtils.unbox((Integer) key));
     }
 
     @Override
-    public boolean remove(Object key) {
+    public boolean remove(@NotNull final Object key) {
         return liveValues.remove(TypeUtils.unbox((Integer) key));
     }
 
@@ -75,22 +74,49 @@ public java.util.Iterator<Object> iterator() {
     }
 
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches) {
-        matchValues(values.asIntChunk(), matches, inclusion);
+    public void matchValues(
+            @NotNull final Chunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        matchValues(values, keys, results, inclusion);
     }
 
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches, boolean inclusionOverride) {
-        matchValues(values.asIntChunk(), matches, inclusionOverride);
+    public void matchValues(
+            @NotNull final Chunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results,
+            final boolean inclusionOverride) {
+        if (inclusionOverride) {
+            matchValues(values.asIntChunk(), keys, results);
+        } else {
+            matchValuesInvert(values.asIntChunk(), keys, results);
+        }
     }
 
     private void matchValues(
-            IntChunk<Values> values,
-            WritableBooleanChunk<?> matches,
-            boolean inclusionToUse) {
+            @NotNull final IntChunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        results.setSize(0);
+        for (int ii = 0; ii < values.size(); ++ii) {
+            final int checkValue = values.get(ii);
+            if (liveValues.contains(checkValue)) {
+                results.add(keys.get(ii));
+            }
+        }
+    }
+
+    private void matchValuesInvert(
+            @NotNull final IntChunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        results.setSize(0);
         for (int ii = 0; ii < values.size(); ++ii) {
-            matches.set(ii, liveValues.contains(values.get(ii)) == inclusionToUse);
+            final int checkValue = values.get(ii);
+            if (!liveValues.contains(checkValue)) {
+                results.add(keys.get(ii));
+            }
         }
-        matches.setSize(values.size());
     }
 }
diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/LongSetInclusionKernel.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/LongSetInclusionKernel.java
index 94342e30b00..94a9c06cfbc 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/LongSetInclusionKernel.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/LongSetInclusionKernel.java
@@ -8,10 +8,9 @@
 package io.deephaven.engine.table.impl.select.setinclusion;
 
 import gnu.trove.iterator.TLongIterator;
-import io.deephaven.chunk.LongChunk;
-import io.deephaven.chunk.Chunk;
-import io.deephaven.chunk.WritableBooleanChunk;
+import io.deephaven.chunk.*;
 import io.deephaven.chunk.attributes.Values;
+import io.deephaven.engine.rowset.chunkattributes.OrderedRowKeys;
 import io.deephaven.util.type.TypeUtils;
 import gnu.trove.set.TLongSet;
 import gnu.trove.set.hash.TLongHashSet;
@@ -24,24 +23,24 @@ public class LongSetInclusionKernel implements SetInclusionKernel {
     private final TLongSet liveValues;
     private final boolean inclusion;
 
-    LongSetInclusionKernel(Collection<Object> liveValues, boolean inclusion) {
+    LongSetInclusionKernel(@NotNull final Collection<Object> liveValues, final boolean inclusion) {
         this.liveValues = new TLongHashSet(liveValues.size());
         liveValues.forEach(x -> this.liveValues.add(TypeUtils.unbox((Long) x)));
         this.inclusion = inclusion;
     }
 
-    LongSetInclusionKernel(boolean inclusion) {
+    LongSetInclusionKernel(final boolean inclusion) {
         this.liveValues = new TLongHashSet();
         this.inclusion = inclusion;
     }
 
     @Override
-    public boolean add(Object key) {
+    public boolean add(@NotNull final Object key) {
         return liveValues.add(TypeUtils.unbox((Long) key));
     }
 
     @Override
-    public boolean remove(Object key) {
+    public boolean remove(@NotNull final Object key) {
         return liveValues.remove(TypeUtils.unbox((Long) key));
     }
 
@@ -75,22 +74,49 @@ public java.util.Iterator<Object> iterator() {
     }
 
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches) {
-        matchValues(values.asLongChunk(), matches, inclusion);
+    public void matchValues(
+            @NotNull final Chunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        matchValues(values, keys, results, inclusion);
     }
 
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches, boolean inclusionOverride) {
-        matchValues(values.asLongChunk(), matches, inclusionOverride);
+    public void matchValues(
+            @NotNull final Chunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results,
+            final boolean inclusionOverride) {
+        if (inclusionOverride) {
+            matchValues(values.asLongChunk(), keys, results);
+        } else {
+            matchValuesInvert(values.asLongChunk(), keys, results);
+        }
     }
 
     private void matchValues(
-            LongChunk<Values> values,
-            WritableBooleanChunk<?> matches,
-            boolean inclusionToUse) {
+            @NotNull final LongChunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        results.setSize(0);
+        for (int ii = 0; ii < values.size(); ++ii) {
+            final long checkValue = values.get(ii);
+            if (liveValues.contains(checkValue)) {
+                results.add(keys.get(ii));
+            }
+        }
+    }
+
+    private void matchValuesInvert(
+            @NotNull final LongChunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        results.setSize(0);
         for (int ii = 0; ii < values.size(); ++ii) {
-            matches.set(ii, liveValues.contains(values.get(ii)) == inclusionToUse);
+            final long checkValue = values.get(ii);
+            if (!liveValues.contains(checkValue)) {
+                results.add(keys.get(ii));
+            }
         }
-        matches.setSize(values.size());
     }
 }
diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ObjectSetInclusionKernel.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ObjectSetInclusionKernel.java
index 5c3744ce7f8..d84f21d45bb 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ObjectSetInclusionKernel.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ObjectSetInclusionKernel.java
@@ -3,10 +3,10 @@
 //
 package io.deephaven.engine.table.impl.select.setinclusion;
 
-import io.deephaven.chunk.Chunk;
-import io.deephaven.chunk.ObjectChunk;
-import io.deephaven.chunk.WritableBooleanChunk;
+import io.deephaven.chunk.*;
 import io.deephaven.chunk.attributes.Values;
+import io.deephaven.engine.rowset.chunkattributes.OrderedRowKeys;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.Collection;
 import java.util.HashSet;
@@ -17,23 +17,23 @@ public class ObjectSetInclusionKernel implements SetInclusionKernel {
     private final Collection<Object> liveValues;
     private final boolean inclusion;
 
-    public ObjectSetInclusionKernel(Collection<Object> liveValues, boolean inclusion) {
+    public ObjectSetInclusionKernel(@NotNull final Collection<Object> liveValues, final boolean inclusion) {
         this.liveValues = new HashSet<>(liveValues);
         this.inclusion = inclusion;
     }
 
-    ObjectSetInclusionKernel(boolean inclusion) {
+    ObjectSetInclusionKernel(final boolean inclusion) {
         this.liveValues = new HashSet<>();
         this.inclusion = inclusion;
     }
 
     @Override
-    public boolean add(Object key) {
+    public boolean add(@NotNull final Object key) {
         return liveValues.add(key);
     }
 
     @Override
-    public boolean remove(Object key) {
+    public boolean remove(@NotNull final Object key) {
         return liveValues.remove(key);
     }
 
@@ -48,22 +48,49 @@ public Iterator<Object> iterator() {
     }
 
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches) {
-        matchValues(values.asObjectChunk(), matches, inclusion);
+    public void matchValues(
+            @NotNull final Chunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        matchValues(values, keys, results, inclusion);
     }
 
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches, boolean inclusionOverride) {
-        matchValues(values.asObjectChunk(), matches, inclusionOverride);
+    public void matchValues(
+            @NotNull final Chunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results,
+            final boolean inclusionOverride) {
+        if (inclusionOverride) {
+            matchValues(values.asObjectChunk(), keys, results);
+        } else {
+            matchValuesInvert(values.asObjectChunk(), keys, results);
+        }
     }
 
     private void matchValues(
-            ObjectChunk<?, Values> values,
-            WritableBooleanChunk<?> matches,
-            boolean inclusionToUse) {
+            @NotNull final ObjectChunk<?, Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        results.setSize(0);
+        for (int ii = 0; ii < values.size(); ++ii) {
+            final Object checkValue = values.get(ii);
+            if (liveValues.contains(checkValue)) {
+                results.add(keys.get(ii));
+            }
+        }
+    }
+
+    private void matchValuesInvert(
+            @NotNull final ObjectChunk<?, Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        results.setSize(0);
         for (int ii = 0; ii < values.size(); ++ii) {
-            matches.set(ii, liveValues.contains(values.get(ii)) == inclusionToUse);
+            final Object checkValue = values.get(ii);
+            if (!liveValues.contains(checkValue)) {
+                results.add(keys.get(ii));
+            }
         }
-        matches.setSize(values.size());
     }
 }
diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/SetInclusionKernel.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/SetInclusionKernel.java
index e87b877c207..e92a87a0588 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/SetInclusionKernel.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/SetInclusionKernel.java
@@ -3,19 +3,22 @@
 //
 package io.deephaven.engine.table.impl.select.setinclusion;
 
-import io.deephaven.chunk.Chunk;
-import io.deephaven.chunk.ChunkType;
-import io.deephaven.chunk.WritableBooleanChunk;
+import io.deephaven.chunk.*;
 import io.deephaven.chunk.attributes.Values;
+import io.deephaven.engine.rowset.chunkattributes.OrderedRowKeys;
 
 import java.util.Collection;
 import java.util.Iterator;
 
 public interface SetInclusionKernel {
 
-    void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches);
+    void matchValues(Chunk<Values> values, LongChunk<OrderedRowKeys> keys, WritableLongChunk<OrderedRowKeys> results);
 
-    void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches, boolean inclusionOverride);
+    void matchValues(
+            Chunk<Values> values,
+            LongChunk<OrderedRowKeys> keys,
+            WritableLongChunk<OrderedRowKeys> results,
+            boolean inclusionOverride);
 
     boolean add(Object key);
 
diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ShortSetInclusionKernel.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ShortSetInclusionKernel.java
index a51675e685c..663a8efb190 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ShortSetInclusionKernel.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ShortSetInclusionKernel.java
@@ -8,10 +8,9 @@
 package io.deephaven.engine.table.impl.select.setinclusion;
 
 import gnu.trove.iterator.TShortIterator;
-import io.deephaven.chunk.ShortChunk;
-import io.deephaven.chunk.Chunk;
-import io.deephaven.chunk.WritableBooleanChunk;
+import io.deephaven.chunk.*;
 import io.deephaven.chunk.attributes.Values;
+import io.deephaven.engine.rowset.chunkattributes.OrderedRowKeys;
 import io.deephaven.util.type.TypeUtils;
 import gnu.trove.set.TShortSet;
 import gnu.trove.set.hash.TShortHashSet;
@@ -24,24 +23,24 @@ public class ShortSetInclusionKernel implements SetInclusionKernel {
     private final TShortSet liveValues;
     private final boolean inclusion;
 
-    ShortSetInclusionKernel(Collection<Object> liveValues, boolean inclusion) {
+    ShortSetInclusionKernel(@NotNull final Collection<Object> liveValues, final boolean inclusion) {
         this.liveValues = new TShortHashSet(liveValues.size());
         liveValues.forEach(x -> this.liveValues.add(TypeUtils.unbox((Short) x)));
         this.inclusion = inclusion;
     }
 
-    ShortSetInclusionKernel(boolean inclusion) {
+    ShortSetInclusionKernel(final boolean inclusion) {
         this.liveValues = new TShortHashSet();
         this.inclusion = inclusion;
     }
 
     @Override
-    public boolean add(Object key) {
+    public boolean add(@NotNull final Object key) {
         return liveValues.add(TypeUtils.unbox((Short) key));
     }
 
     @Override
-    public boolean remove(Object key) {
+    public boolean remove(@NotNull final Object key) {
         return liveValues.remove(TypeUtils.unbox((Short) key));
     }
 
@@ -75,22 +74,49 @@ public java.util.Iterator<Object> iterator() {
     }
 
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches) {
-        matchValues(values.asShortChunk(), matches, inclusion);
+    public void matchValues(
+            @NotNull final Chunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        matchValues(values, keys, results, inclusion);
     }
 
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches, boolean inclusionOverride) {
-        matchValues(values.asShortChunk(), matches, inclusionOverride);
+    public void matchValues(
+            @NotNull final Chunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results,
+            final boolean inclusionOverride) {
+        if (inclusionOverride) {
+            matchValues(values.asShortChunk(), keys, results);
+        } else {
+            matchValuesInvert(values.asShortChunk(), keys, results);
+        }
     }
 
     private void matchValues(
-            ShortChunk<Values> values,
-            WritableBooleanChunk<?> matches,
-            boolean inclusionToUse) {
+            @NotNull final ShortChunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        results.setSize(0);
+        for (int ii = 0; ii < values.size(); ++ii) {
+            final short checkValue = values.get(ii);
+            if (liveValues.contains(checkValue)) {
+                results.add(keys.get(ii));
+            }
+        }
+    }
+
+    private void matchValuesInvert(
+            @NotNull final ShortChunk<Values> values,
+            @NotNull final LongChunk<OrderedRowKeys> keys,
+            @NotNull WritableLongChunk<OrderedRowKeys> results) {
+        results.setSize(0);
         for (int ii = 0; ii < values.size(); ++ii) {
-            matches.set(ii, liveValues.contains(values.get(ii)) == inclusionToUse);
+            final short checkValue = values.get(ii);
+            if (!liveValues.contains(checkValue)) {
+                results.add(keys.get(ii));
+            }
         }
-        matches.setSize(values.size());
     }
 }