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]