JackieTien97 commented on code in PR #18889:
URL: https://github.com/apache/iotdb/pull/18889#discussion_r4357924383


##########
iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/schema/source/DeviceAttributeUpdater.java:
##########
@@ -145,9 +160,24 @@ private TsBlock getFilterTsBlock() {
     final List<Column> filterResultColumns =
         new ArrayList<>(Arrays.asList(curBlock.getValueColumns()));
 
-    // Get result of calculated common sub expressions
-    commonTransformerList.forEach(
-        columnTransformer -> 
filterResultColumns.add(columnTransformer.getColumn()));
+    if (!commonTransformerList.isEmpty()) {
+      boolean[] selection = new boolean[deviceSchemaBatch.size()];
+      for (int i = 0; i < selection.length; i++) {
+        selection[i] = satisfy(curFilterColumn, i);
+      }
+      // CASE may clear a common expression. Recompute only rows whose filter 
guard passed.
+      for (ColumnTransformer transformer : commonTransformerList) {
+        if (transformer.canEvaluateWithSelection()) {
+          transformer.tryEvaluateWithSelection(selection);
+        } else {
+          // Stateful transformers must be re-evaluated over every row: a 
masked evaluation
+          // would read the masked rows as nulls and corrupt their running 
state. The snapshot
+          // taken at the input boundary makes the full re-evaluation 
idempotent.
+          transformer.tryEvaluate();

Review Comment:
   **This fallback breaks the CASE guard as soon as one device in the batch 
matches.**
   
   Default config, so all devices are in one batch:
   ```sql
   CREATE TABLE g3 (id STRING TAG, src STRING ATTRIBUTE, a STRING ATTRIBUTE, v 
DOUBLE FIELD);
   INSERT INTO g3(time, id, src, a, v) VALUES (1,'d0','1','seed',1), 
(2,'d1','5','seed',1), (3,'d2','n/a','seed',1);
   UPDATE g3 SET a = CAST(diff(CAST(src AS DOUBLE), src = 'x') AS STRING)
   WHERE CASE WHEN src = 'n/a' THEN false ELSE diff(CAST(src AS DOUBLE), src = 
'x') > 0 END;
   ```
   This PR: `305 … SemanticException: Cannot cast n/a to DOUBLE type`, nothing 
updated (master: NPE). Expected: d1.a = '4.0'; the filter itself evaluates fine 
and matches d1. `testGuardedCommonDiffWithoutMatchingDevices` only covers a 
batch with no match (the early return) and a batch without 'n/a'. With 
1000-device batches, a guarded device plus a match in the same batch is the 
normal case.
   
   When nothing throws, the full recompute still disagrees with what the WHERE 
saw:
   ```sql
   -- d0 '1', d1 '3', d2 '6'
   SHOW DEVICES FROM g5 WHERE CASE WHEN src = '3' THEN false ELSE diff(CAST(src 
AS DOUBLE), src = 'x') IS NULL END;  -- d0, d2
   UPDATE g5 SET a = coalesce(CAST(diff(CAST(src AS DOUBLE), src = 'x') AS 
STRING), 'NULL') WHERE <same>;
   -- d0 = 'NULL', d2 = '3.0': d2 was selected because the diff IS NULL
   ```
   And the set of updated devices depends on batch boundaries, because the full 
recompute replaces DIFF's carried state while the no-match early return keeps 
the masked one:
   ```sql
   -- d0 '10', d1 '20', d2 '0', d3 '5'
   UPDATE u SET a = CAST(diff(CAST(src AS DOUBLE), src = 'x') AS STRING)
   WHERE CASE WHEN src = '0' THEN false ELSE diff(CAST(src AS DOUBLE), src = 
'x') > 0 END;
   -- max_tsblock_line_number = 1000: only d1 updated ('10.0')
   -- max_tsblock_line_number = 3, batches [d0,d1,d2] | [d3]: d1 = '10.0' and 
d3 = '5.0'
   ```
   I don't see a recompute strategy that is right for a stateful common: a 
masked recompute changes its values, a full one runs the guarded rows. Keeping 
the column the filter produced is the consistent option, but that's the 
deferred redesign. Until then, could we add a test with a guarded row and a 
match in one batch, and drop the claim that the stateful case is handled?



##########
iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/unary/scalar/DiffColumnTransformer.java:
##########
@@ -34,11 +34,28 @@ public class DiffColumnTransformer extends 
BinaryColumnTransformer {
   // indicate whether lastValue is null
   private boolean lastValueIsNull = true;
 
+  // Re-evaluation in the same block must start from the state before this 
input.
+  private double lastValueBeforeCurrentInput;
+  private boolean lastValueIsNullBeforeCurrentInput = true;
+
   public DiffColumnTransformer(
       Type returnType, ColumnTransformer leftTransformer, ColumnTransformer 
rightTransformer) {
     super(returnType, leftTransformer, rightTransformer);
   }
 
+  @Override
+  protected void resetForNewInput() {

Review Comment:
   **The state carried into the next block is whatever the last evaluation 
left, so a masked CASE pass that runs after the full one still corrupts the 
next block.**
   
   The snapshot makes re-evaluation within a block start from the same state, 
but the state handed to the next block comes from whichever evaluation ran 
last. If the plain `diff` is evaluated before a CASE that masks it, the masked 
pass wins: masked rows are read as null with a null flag, which sets 
`lastValueIsNull`.
   ```sql
   -- max_tsblock_line_number = 3; x = 1..7, f = true, FLUSH after rows 3, 6, 7 
-> blocks [1,2,3] | [4,5,6] | [7]
   SELECT time, diff(x, f) AS d, CASE WHEN x = 7 THEN diff(x, f) ELSE 100.0 END 
AS a FROM fv4;
   -- d = null,1,1,null,1,1,null ; a(7) = null
   SELECT time, CASE WHEN x = 7 THEN diff(x, f) ELSE 100.0 END AS a, diff(x, f) 
AS d FROM fv4;
   -- d = null,1,1,1,1,1,1      ; a(7) = 1.0
   ```
   Same at the default config: on 30,000 rows, `SELECT diff(x, ignore_null) AS 
d, CASE WHEN x > 0 THEN x ELSE diff(x, ignore_null) END AS a` returns d = null 
at the first row of every later block (rows 7282, 10001, 15001, 22282, 25001); 
the swapped order is correct. Filters too: on blocks x = [1,3,4] | [10,11], 
`WHERE diff(x, f) IS NOT NULL` returns 3, 4, 10, 11, but `WHERE diff(x, f) IS 
NOT NULL OR CASE WHEN x > 5 THEN diff(x, f) > 0 ELSE false END` returns 3, 4, 
11 — the extra OR term drops x = 10.
   
   Master behaves the same, so these aren't regressions, but it's the 
"preserving the previous block's contribution" case in the description, and the 
ITs only cover the CASE-first order. One option: record the end state of the 
unmasked evaluation and have the masked path restore it after its pass, so the 
next block starts from the full evaluation when there was one, and from the 
masked state only when the DIFF is used solely inside a CASE (master's 
behavior). That should fix the projection and OR cases above, though not the 
UPDATE batch dependence, which comes from the fallback.



##########
iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/ColumnTransformer.java:
##########
@@ -47,6 +54,30 @@ public void tryEvaluate() {
     }
   }
 
+  /** Reuses a cached result, or recomputes only selected rows when it is 
missing. */
+  public void tryEvaluateWithSelection(boolean[] selection) {
+    if (!columnCache.hasCached()) {
+      evaluateWithSelection(selection);
+    }
+  }
+
+  /**
+   * Whether evaluating with a row-selection mask yields the same values at 
the selected rows
+   * (unselected rows are nulled by design) and the same cross-block running 
state as a full
+   * evaluation, for this node and its whole subtree. Stateful transformers 
override this to return
+   * {@code false} so that callers re-evaluate them over every row.
+   */
+  public boolean canEvaluateWithSelection() {

Review Comment:
   Nit: this is a plan property, but `DeviceAttributeUpdater` asks it for every 
common on every batch, and the recursion has no visited set — on the shared DAG 
from `testProjectionCollectsSharedDagOnlyOnce` it visits the input 4096 times, 
allocating a lambda and a `boolean[]` per visit. Computing it once in the 
constructor (next to `projectCacheTransformers`) avoids that.
   
   Also, the Javadoc says stateful transformers return false "so that callers 
re-evaluate them over every row", but only the schema updater asks; CASE, AND 
and OR still mask binary DIFF without consulting it.



##########
integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/IoTDBCaseWhenThenTableIT.java:
##########
@@ -695,4 +695,224 @@ public void testThenWithBinarySameConstant() {
     String[] retArray = new String[] {"0,", "11,", "22,", "33,"};
     tableResultSetEqualTest(sql, expectedHeader, retArray, DATABASE);
   }
+
+  @Test
+  public void testCaseWhenReusesAggregationAcrossBlocks() {
+    prepareTableData(
+        new String[] {
+          "USE " + DATABASE,
+          "CREATE TABLE case_aggregation_cache (dev STRING TAG, c DOUBLE 
FIELD, q INT32 FIELD)",
+          "INSERT INTO case_aggregation_cache(time, dev, c, q) VALUES "
+              + "(0, 'd0', 1.0, 0), (0, 'd1', 1.0, 0), (3600000, 'd1', 1.0, 0)"
+        });
+
+    // The non-pushdown predicate and the different device/window shapes make 
the aggregation
+    // produce multiple blocks. CASE clears the shared aggregate before the 
next output uses it.
+    String suffix = " FROM case_aggregation_cache WHERE q % 2 < 1 GROUP BY 
dev, date_bin(1h, time)";
+    for (String projection :
+        new String[] {
+          "CASE WHEN sum(c) > 0 THEN 1.0 END AS case_result, CAST(sum(c) AS 
DOUBLE) AS total",
+          "CASE WHEN sum(c) > 0 THEN 1.0 END AS case_result, sum(c) + 0 AS 
total",
+          "CASE WHEN sum(c) > 0 THEN CAST(sum(c) AS DOUBLE) / CAST(sum(c) AS 
DOUBLE) END "
+              + "AS case_result, CAST(sum(c) AS DOUBLE) AS total"
+        }) {
+      tableResultSetEqualTest(
+          "SELECT " + projection + suffix,
+          new String[] {"case_result", "total"},
+          new String[] {"1.0,1.0,", "1.0,1.0,", "1.0,1.0,"},
+          DATABASE);
+    }
+  }
+
+  @Test
+  public void testReusingCasePreservesPendingSiblingColumn() {
+    prepareTableData(
+        new String[] {
+          "USE " + DATABASE,
+          "CREATE TABLE case_sibling_cache (dev STRING TAG, x DOUBLE FIELD)",
+          "INSERT INTO case_sibling_cache(time, dev, x) VALUES "
+              + "(0, 'd0', -3.0), (1, 'd0', 0.0), (2, 'd0', 2.0)"
+        });
+
+    String sharedCase = "CASE WHEN x > 0 THEN 1.0 ELSE 0.0 END";
+    tableResultSetEqualTest(
+        "SELECT "
+            + sharedCase
+            + " AS a, x + CASE WHEN ("
+            + sharedCase
+            + ") > 0 THEN 2.0 ELSE 3.0 END AS b FROM case_sibling_cache ORDER 
BY time",
+        new String[] {"a", "b"},
+        new String[] {"0.0,0.0,", "0.0,3.0,", "1.0,4.0,"},
+        DATABASE);
+  }
+
+  @Test
+  public void testSharedDiffAcrossCaseFilterAndProjection() {
+    prepareTableData(
+        new String[] {
+          "USE " + DATABASE,
+          "CREATE TABLE case_shared_diff (dev STRING TAG, x DOUBLE FIELD)",
+          "INSERT INTO case_shared_diff(time, dev, x) VALUES "
+              + "(1, 'd0', 1.0), (2, 'd0', 3.0), (3, 'd0', 6.0)",
+          "FLUSH",
+          "INSERT INTO case_shared_diff(time, dev, x) VALUES (4, 'd0', 10.0), 
(5, 'd0', 11.0)",
+          "FLUSH"
+        });
+    tableResultSetEqualTest(
+        "SELECT time, diff(x) AS d FROM case_shared_diff "
+            + "WHERE CASE WHEN diff(x) > 1.0 THEN 1.0 ELSE 0.0 END > 0.0",
+        new String[] {"time", "d"},
+        new String[] {
+          "1970-01-01T00:00:00.002Z,2.0,",
+          "1970-01-01T00:00:00.003Z,3.0,",
+          "1970-01-01T00:00:00.004Z,4.0,"
+        },
+        DATABASE);
+    tableResultSetEqualTest(
+        "SELECT diff(x) AS d FROM case_shared_diff "
+            + "WHERE CASE WHEN diff(x) > 1.0 THEN true ELSE true END",
+        new String[] {"d"},
+        new String[] {"null,", "2.0,", "3.0,", "4.0,", "1.0,"},
+        DATABASE);
+    tableResultSetEqualTest(
+        "SELECT CASE WHEN x > 5 THEN diff(x) ELSE 100.0 END AS a, "
+            + "CASE WHEN x > 5 THEN 200.0 ELSE diff(x) END AS b, diff(x) AS d "
+            + "FROM case_shared_diff",
+        new String[] {"a", "b", "d"},
+        new String[] {
+          "100.0,null,null,", "100.0,2.0,2.0,", "3.0,200.0,3.0,", 
"4.0,200.0,4.0,", "1.0,200.0,1.0,"
+        },
+        DATABASE);
+  }
+
+  @Test
+  public void testDynamicIgnoreNullDiffAcrossCaseFilterAndProjection() {
+    prepareTableData(
+        new String[] {
+          "USE " + DATABASE,
+          "CREATE TABLE case_dynamic_diff "
+              + "(dev STRING TAG, x DOUBLE FIELD, ignore_null BOOLEAN FIELD)",
+          "INSERT INTO case_dynamic_diff(time, dev, x, ignore_null) VALUES "
+              + "(1, 'd0', 1.0, true), (2, 'd0', 3.0, false), (3, 'd0', null, 
true), "
+              + "(4, 'd0', 10.0, null), (5, 'd0', null, false)",
+          "FLUSH",
+          "INSERT INTO case_dynamic_diff(time, dev, x, ignore_null) VALUES "
+              + "(6, 'd0', 20.0, true), (7, 'd0', 25.0, false), "
+              + "(8, 'd0', null, true), (9, 'd0', 30.0, true)",
+          "FLUSH"
+        });
+    String diff = "diff(x, ignore_null)";
+    tableResultSetEqualTest(
+        "SELECT " + diff + " AS d FROM case_dynamic_diff ORDER BY time",
+        new String[] {"d"},
+        new String[] {"null,", "2.0,", "null,", "7.0,", "null,", "null,", 
"5.0,", "null,", "5.0,"},
+        DATABASE);
+    tableResultSetEqualTest(
+        "SELECT CASE WHEN x > 5 THEN "
+            + diff
+            + " ELSE 100.0 END AS a, CASE WHEN x > 5 THEN 200.0 ELSE "
+            + diff
+            + " END AS b, "
+            + diff
+            + " AS d FROM case_dynamic_diff ORDER BY time",
+        new String[] {"a", "b", "d"},
+        new String[] {
+          "100.0,null,null,",
+          "100.0,2.0,2.0,",
+          "100.0,null,null,",
+          "null,200.0,7.0,",
+          "100.0,null,null,",
+          "null,200.0,null,",
+          "5.0,200.0,5.0,",
+          "100.0,null,null,",
+          "null,200.0,5.0,"
+        },
+        DATABASE);
+    // The expected values preserve master's masked WHEN evaluation of the 
binary diff: a full

Review Comment:
   These expectations (here, L858 and L903) assert values the comments say a 
full evaluation wouldn't produce. The inconsistency also shows directly, on 
master and this PR, with f = false in every row: `CASE WHEN x > 0 THEN x ELSE 
diff(x, false) END` gives 1, -3, 3, -7, but `CASE WHEN x > 0 THEN x ELSE 
diff(x, f) END` gives 1, null, 3, null. In one statement, WHERE and SELECT can 
disagree: over x = 1, 3, 6, `SELECT diff(x, f) AS d … WHERE CASE WHEN x = 3 
THEN false ELSE diff(x, f) IS NULL END` returns the x = 6 row with d = 3.0.
   
   Freezing these as expected output will make a later fix look like a 
regression. Could these cases assert only the well-defined rows, or be marked 
as current behavior with an issue link?



##########
iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/schema/source/DeviceAttributeUpdater.java:
##########
@@ -145,9 +160,24 @@ private TsBlock getFilterTsBlock() {
     final List<Column> filterResultColumns =
         new ArrayList<>(Arrays.asList(curBlock.getValueColumns()));
 
-    // Get result of calculated common sub expressions
-    commonTransformerList.forEach(
-        columnTransformer -> 
filterResultColumns.add(columnTransformer.getColumn()));
+    if (!commonTransformerList.isEmpty()) {
+      boolean[] selection = new boolean[deviceSchemaBatch.size()];

Review Comment:
   Nit: this re-runs `satisfy(curFilterColumn, i)` for every row, but 
`prepareBatchResult` already put exactly those rows in `indexes`. Building the 
mask from `indexes` avoids two copies of the predicate, and it could be built 
lazily, only when a common isn't cached.



##########
iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java:
##########
@@ -131,6 +131,13 @@ protected void doTransform(
     }
   }
 
+  @Override
+  public boolean canEvaluateWithSelection() {

Review Comment:
   Nit: the only caller can't reach this. Table-model scalar UDFs can't be used 
in UPDATE at all: building the updater fails on both builds 
(`IllegalArgumentException: IoTDBLocalFactory must not be null for UDF 
execution` in `SchemaRegionMemoryImpl.constructDevicePredicateUpdater`), and 
`MappableUDFColumnTransformer` is tree-model only. Fine as a safe default, but 
nothing tests it.



##########
integration-test/src/test/java/org/apache/iotdb/relational/it/schema/IoTDBCaseDeviceCacheIT.java:
##########
@@ -0,0 +1,232 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.iotdb.relational.it.schema;
+
+import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.framework.IoTDBTestRunner;
+import org.apache.iotdb.itbase.category.TableClusterIT;
+import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
+import org.apache.iotdb.itbase.env.BaseEnv;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+
+import static org.apache.iotdb.db.it.utils.TestUtils.assertResultSetEqual;
+import static org.apache.iotdb.db.it.utils.TestUtils.prepareTableData;
+
+@RunWith(IoTDBTestRunner.class)
+@Category({TableLocalStandaloneIT.class, TableClusterIT.class})
+public class IoTDBCaseDeviceCacheIT {
+  private static final String DATABASE = "case_device_cache";
+  private static final String CASE_RESULT = "CASE WHEN src = 'match' THEN 
'match' ELSE 'other' END";
+
+  @BeforeClass
+  public static void setUp() throws Exception {
+    // CUSTOM fixes the region count; PROACTIVE treats the default count as a 
minimum.
+    // Keep devices in one schema region to exercise mixed-row and repeated 
batches.
+    EnvFactory.getEnv()
+        .getConfig()
+        .getCommonConfig()
+        .setSchemaRegionGroupExtensionPolicy("CUSTOM")
+        .setDefaultSchemaRegionGroupNumPerDatabase(1);
+    
EnvFactory.getEnv().getConfig().getCommonConfig().setMaxTsBlockLineNumber(2);
+    EnvFactory.getEnv().initClusterEnvironment();
+    prepareTableData(new String[] {"CREATE DATABASE " + DATABASE});
+  }
+
+  @AfterClass
+  public static void tearDown() throws Exception {
+    EnvFactory.getEnv().cleanClusterEnvironment();
+  }
+
+  @Test
+  public void testDevicePredicatesAcrossBatches() throws Exception {
+    try (Connection connection = 
EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+        Statement statement = connection.createStatement()) {
+      createTable(statement, "predicate_cache");
+      for (String predicate : new String[] {CASE_RESULT + " = src"}) {

Review Comment:
   Nit: one-element loop. Also, only the `CASE … = src` order is covered; the 
other order still fails on both builds (`SHOW DEVICES FROM cc WHERE src = CASE 
WHEN src = 'match' THEN 'match' ELSE 'other' END` → `301: … "leftColumn" is 
null`, same for `COUNT DEVICES`). Fine if in-block sibling clearing is out of 
scope, but a comment or issue link would make that explicit.



##########
iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/schema/source/DeviceAttributeUpdater.java:
##########
@@ -145,9 +160,24 @@ private TsBlock getFilterTsBlock() {
     final List<Column> filterResultColumns =
         new ArrayList<>(Arrays.asList(curBlock.getValueColumns()));
 
-    // Get result of calculated common sub expressions
-    commonTransformerList.forEach(
-        columnTransformer -> 
filterResultColumns.add(columnTransformer.getColumn()));
+    if (!commonTransformerList.isEmpty()) {
+      boolean[] selection = new boolean[deviceSchemaBatch.size()];
+      for (int i = 0; i < selection.length; i++) {
+        selection[i] = satisfy(curFilterColumn, i);
+      }
+      // CASE may clear a common expression. Recompute only rows whose filter 
guard passed.
+      for (ColumnTransformer transformer : commonTransformerList) {
+        if (transformer.canEvaluateWithSelection()) {
+          transformer.tryEvaluateWithSelection(selection);

Review Comment:
   **New on this PR: a masked recompute here can feed the stateful fallback, so 
SET silently writes NULL.**
   
   ```sql
   -- w1: d0 '1', d1 '9', d2 '5' (one batch)
   UPDATE w1 SET a = CAST(CAST(src AS DOUBLE) AS STRING),
                 b = CAST(diff(CAST(src AS DOUBLE), src = 'x') AS STRING)
   WHERE CASE WHEN src = 'n/a' THEN false ELSE diff(CAST(src AS DOUBLE), src = 
'x') > 0 END;
   -- this PR: d1 a = '9.0', b = null   (master: NPE)
   -- with the two SET items swapped: d1 b = '8.0' (correct)
   ```
   `commonTransformerList` is `[CAST(src AS DOUBLE), diff(...)]`. The CAST is 
recomputed here with the filter mask (`[null, 9, null]`); its refcount is 2 
(SET `a` plus DIFF's child), so the column stays cached after `getColumn()`. 
The DIFF then takes the `tryEvaluate()` fallback, but 
`BinaryColumnTransformer.evaluate()` calls `leftTransformer.tryEvaluate()`, 
which reuses the masked CAST column, and the masked nulls (with flag `false`) 
reset the DIFF. So the fallback isn't a full evaluation, the result depends on 
the order of the SET items, and unlike the exception above nothing reports it.



##########
iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/schema/source/DevicePredicateHandler.java:
##########
@@ -59,14 +61,36 @@ public abstract class DevicePredicateHandler implements 
AutoCloseable {
   protected TsBlock curBlock;
   protected Column curFilterColumn;
 
+  // Retain the original constructor descriptor for precompiled subclasses 
without common roots.

Review Comment:
   Nit: which precompiled subclasses is this for? The in-tree callers 
(`DevicePredicateFilter`, `DeviceBlackListConstructor`) could pass 
`Collections.emptyList()`. If it's for out-of-tree code, note that the new 
abstract `ColumnTransformer.forEachChild` (L180) breaks precompiled 
`ColumnTransformer` subclasses the same way. Same for `DeviceUpdater` L42.



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]

Reply via email to