mbutrovich commented on code in PR #330:
URL: https://github.com/apache/datafusion-spark/pull/330#discussion_r4602591409
##########
crates/spark/src/function/array/array_remove.rs:
##########
@@ -0,0 +1,502 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: See the NOTICE file distributed with this work for
additional information regarding copyright ownership
+// SPDX-FileContributor: Licensed to the Apache Software Foundation (ASF)
under one or more contributor license agreements
+
+use super::array_position::{contains_map, tightest_common_type};
+use super::float_normalize::normalize_array;
+use arrow::array::{
+ Array, ArrayRef, AsArray, BooleanArray, BooleanBufferBuilder,
GenericListArray,
+ OffsetSizeTrait, Scalar, make_comparator,
+};
+use arrow::buffer::{BooleanBuffer, NullBuffer, OffsetBuffer};
+use arrow::compute::kernels::cmp::eq;
+use arrow::compute::{SortOptions, filter};
+use arrow::datatypes::{DataType, Field};
+use datafusion_common::utils::take_function_args;
+use datafusion_common::{Result, ScalarValue, exec_err, plan_err};
+use datafusion_expr::{
+ ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,
+ Volatility,
+};
+use datafusion_macros::user_doc;
+use std::sync::Arc;
+
+/// Spark-compatible `array_remove` expression.
+///
+/// <https://spark.apache.org/docs/latest/api/sql/index.html#array_remove>
+#[user_doc(
+ doc_section(label = "Array Functions"),
+ description = "Removes all elements that are equal to the element from the
array. The \
+ result is NULL when the array or the element is NULL, while the
DataFusion built-in \
+ removes the NULL elements when the element is NULL. NULL elements in
the array are \
+ always kept. Corresponding NULLs nested inside compared arrays or
structs are equal. \
Review Comment:
The DataFusion built-in [removes only the first matching
element](https://github.com/apache/datafusion/blob/cce6374e6256b3b8892ec60674578cf32bc3a32c/datafusion/functions-nested/src/remove.rs#L36),
and it already returns NULL for a NULL element. Without the Spark functions
registered, `array_remove(make_array(1, 2, 1), 1)` returns `[2, 1]` and
`array_remove(make_array(1, NULL, 3), CAST(NULL AS BIGINT))` returns `NULL`. So
the difference to document is first versus all. The comment at
[`array_remove.slt` line
46](https://github.com/apache/datafusion-spark/blob/bce98954fb97d103cacffa3bd69c842b0023c760/crates/sqllogictest/test_files/array/array_remove.slt#L46)
says the same thing as this text and needs the same fix.
```suggestion
description = "Removes all elements that are equal to the element from
the array, while \
the DataFusion built-in removes only the first one. The result is
NULL when the array \
or the element is NULL. NULL elements in the array are always kept.
Corresponding \
NULLs nested inside compared arrays or structs are equal. \
```
##########
crates/spark/src/function/array/array_remove.rs:
##########
@@ -0,0 +1,502 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: See the NOTICE file distributed with this work for
additional information regarding copyright ownership
+// SPDX-FileContributor: Licensed to the Apache Software Foundation (ASF)
under one or more contributor license agreements
+
+use super::array_position::{contains_map, tightest_common_type};
+use super::float_normalize::normalize_array;
+use arrow::array::{
+ Array, ArrayRef, AsArray, BooleanArray, BooleanBufferBuilder,
GenericListArray,
+ OffsetSizeTrait, Scalar, make_comparator,
+};
+use arrow::buffer::{BooleanBuffer, NullBuffer, OffsetBuffer};
+use arrow::compute::kernels::cmp::eq;
+use arrow::compute::{SortOptions, filter};
+use arrow::datatypes::{DataType, Field};
+use datafusion_common::utils::take_function_args;
+use datafusion_common::{Result, ScalarValue, exec_err, plan_err};
+use datafusion_expr::{
+ ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,
+ Volatility,
+};
+use datafusion_macros::user_doc;
+use std::sync::Arc;
+
+/// Spark-compatible `array_remove` expression.
+///
+/// <https://spark.apache.org/docs/latest/api/sql/index.html#array_remove>
+#[user_doc(
+ doc_section(label = "Array Functions"),
+ description = "Removes all elements that are equal to the element from the
array. The \
+ result is NULL when the array or the element is NULL, while the
DataFusion built-in \
+ removes the NULL elements when the element is NULL. NULL elements in
the array are \
+ always kept. Corresponding NULLs nested inside compared arrays or
structs are equal. \
+ For floating point values, also inside nested arrays and structs, NaN
is equal to NaN \
+ and -0.0 is equal to 0.0; the elements that are kept keep their
original values. As \
+ in Spark, the array element and the element are cast to their tightest
common type, \
+ and the result is an array of that type: numbers widen, an integer
widens to a \
+ decimal only if the decimal can hold all its values, and a date widens
to a \
+ timestamp. Other combinations are an error, for example a string and a
number, two \
+ different decimals, or structs whose field names or field types
differ, as in Spark \
+ with ANSI mode off (with ANSI mode on, Spark widens struct field
types). Map \
+ elements are also an error.",
+ syntax_example = "array_remove(array, element)",
+ sql_example = r#"```sql
+> SELECT array_remove(array(1, 2, 3, NULL, 3), 3);
+[1, 2, NULL]
+```"#,
+ argument(name = "array", description = "Array expression. NULL returns
NULL."),
+ argument(
+ name = "element",
+ description = "Element to remove. NULL returns NULL."
+ )
+)]
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct SparkArrayRemove {
+ signature: Signature,
+}
+
+impl Default for SparkArrayRemove {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl SparkArrayRemove {
+ pub fn new() -> Self {
+ Self {
+ signature: Signature::user_defined(Volatility::Immutable),
+ }
+ }
+}
+
+impl ScalarUDFImpl for SparkArrayRemove {
+ fn name(&self) -> &str {
+ "array_remove"
+ }
+
+ fn signature(&self) -> &Signature {
+ &self.signature
+ }
+
+ fn return_type(&self, arg_types: &[DataType]) -> Result<DataType> {
+ let [array, _] = take_function_args(self.name(), arg_types)?;
+ Ok(array.clone())
+ }
+
+ fn coerce_types(&self, arg_types: &[DataType]) -> Result<Vec<DataType>> {
+ let [array, element] = take_function_args(self.name(), arg_types)?;
+ coerce_array_and_element(self.name(), array, element)
+ }
+
+ fn invoke_with_args(&self, args: ScalarFunctionArgs) ->
Result<ColumnarValue> {
+ let [array, element] = take_function_args(self.name(), &args.args)?;
+ let is_scalar = matches!(
+ (array, element),
+ (ColumnarValue::Scalar(_), ColumnarValue::Scalar(_))
+ );
+ let rows = if is_scalar { 1 } else { args.number_rows };
+ let array = array.to_array(rows)?;
+ // A constant element is compared as a single value against every row.
+ let (element, constant) = match element {
+ ColumnarValue::Scalar(scalar) => (scalar.to_array()?, true),
+ ColumnarValue::Array(element) => (Arc::clone(element), false),
+ };
+
+ let result = match array.data_type() {
+ DataType::List(_) => remove::<i32>(&array, &element, constant)?,
+ DataType::LargeList(_) => remove::<i64>(&array, &element,
constant)?,
+ other => return exec_err!("array_remove does not support type
{other}"),
+ };
+
+ if is_scalar {
+ Ok(ColumnarValue::Scalar(ScalarValue::try_from_array(
+ &result, 0,
+ )?))
+ } else {
+ Ok(ColumnarValue::Array(result))
+ }
+ }
+
+ fn documentation(&self) -> Option<&Documentation> {
+ self.doc()
+ }
+}
+
+/// Removes from each row of `array` the non-null elements equal to the row's
element, which
+/// is `element[0]` for every row if `constant`, and `element[row]` otherwise.
A row is NULL
+/// when the array or the element is NULL.
+fn remove<O: OffsetSizeTrait>(
+ array: &ArrayRef,
+ element: &ArrayRef,
+ constant: bool,
+) -> Result<ArrayRef> {
+ let list = array.as_list::<O>();
+ let offsets = list.offsets();
+ // Only the values that this (possibly sliced) list refers to are looked
at.
+ let base = offsets[0].as_usize();
+ let len = offsets[offsets.len() - 1].as_usize() - base;
+ let values = list.values().slice(base, len);
+
+ // Logical nulls, so that a NULL-typed element, which has no null buffer,
is NULL.
+ let element_nulls = element.logical_nulls();
+ let row_nulls = if constant {
+ if element_nulls.as_ref().is_some_and(|n| n.is_null(0)) {
+ Some(NullBuffer::new_null(list.len()))
+ } else {
+ list.nulls().cloned()
+ }
+ } else {
+ NullBuffer::union(list.nulls(), element_nulls.as_ref())
+ };
+ let row_is_valid = |row: usize| row_nulls.as_ref().is_none_or(|n|
n.is_valid(row));
+
+ // Equality is computed on copies with canonical NaN and 0.0 at any depth,
so that it
+ // follows Spark's float equality, while the kept elements are taken from
the original
+ // values. The comparator treats NULLs nested inside the compared values
as equal.
+ let mut is_equal: Box<dyn Fn(usize, usize) -> bool> = Box::new(|_, _|
false);
+ // When every element is NULL there is nothing to compare: NULL elements
are kept and a
+ // NULL element makes every row NULL. This also covers the NULL type.
+ let any_comparison =
+ values.logical_null_count() < values.len() &&
(0..list.len()).any(row_is_valid);
+ if any_comparison {
+ let normalized = normalize_array(&values)?;
+ let needle = normalize_array(element)?;
+ is_equal = if constant && !normalized.data_type().is_nested() {
+ // Compare every value with the constant at once.
+ let equal = eq(&normalized, &Scalar::new(Arc::clone(&needle)))?;
+ let equal = equal.values().clone();
+ Box::new(move |i, _| equal.value(i))
+ } else {
+ let cmp = make_comparator(
+ normalized.as_ref(),
+ needle.as_ref(),
+ SortOptions::default(),
+ )?;
+ Box::new(move |i, row| cmp(i, if constant { 0 } else { row
}).is_eq())
+ };
+ }
+
+ let value_nulls = values.logical_nulls();
+ let mut keep = BooleanBufferBuilder::new(len);
+ let mut new_offsets = Vec::with_capacity(list.len() + 1);
+ new_offsets.push(O::usize_as(0));
+ let mut kept = 0usize;
+ for (row, w) in offsets.windows(2).enumerate() {
+ let (start, end) = (w[0].as_usize() - base, w[1].as_usize() - base);
+ if row_is_valid(row) {
+ for i in start..end {
+ let keep_it = value_nulls.as_ref().is_some_and(|n|
n.is_null(i))
+ || !is_equal(i, row);
+ keep.append(keep_it);
+ kept += usize::from(keep_it);
+ }
+ } else {
+ keep.append_n(end - start, false);
+ }
+ new_offsets.push(O::usize_as(kept));
+ }
+ let keep: BooleanBuffer = keep.finish();
+ let kept_values = if kept == len {
+ values
+ } else {
+ filter(&values, &BooleanArray::new(keep, None))?
+ };
+
+ let (DataType::List(field) | DataType::LargeList(field)) =
list.data_type() else {
+ unreachable!("remove is only called with lists");
+ };
+ Ok(Arc::new(GenericListArray::<O>::try_new(
+ Arc::clone(field),
+ OffsetBuffer::new(new_offsets.into()),
+ kept_values,
+ row_nulls,
+ )?))
+}
+
+/// Casts the array element and the element to their tightest common type, and
rejects the
+/// argument types that Spark's `ArrayRemove.checkInputDataTypes` rejects.
+///
+/// Unlike `array_position`, Spark accepts a NULL-typed common element type
here (for
+/// example `array_remove(array(), NULL)`, which returns NULL), and reports an
argument that
+/// is not an array, including an untyped NULL, as `ARRAY_FUNCTION_DIFF_TYPES`.
+fn coerce_array_and_element(
+ name: &str,
+ array: &DataType,
+ element: &DataType,
+) -> Result<Vec<DataType>> {
+ let diff_types_err = || {
+ plan_err!(
+ "[DATATYPE_MISMATCH.ARRAY_FUNCTION_DIFF_TYPES] Input to `{name}`
should have \
+ been \"ARRAY\" followed by a value with same element type, but
it's \
+ [{array}, {element}]"
+ )
+ };
Review Comment:
Spark prints its own type names in this message. For `array_remove(array(1,
2), 'a')` it reports ``Input to `array_remove` should have been "ARRAY"
followed by a value with same element type, but it's ["ARRAY<INT>",
"STRING"].`` This prints `[List(Int64, field: 'element'), Utf8]`. The
`INVALID_ORDERING_TYPE` message at lines 243-246 has the same problem: it
prints `Map("entries": non-null Struct("key": non-null Int64, "value": Int64),
unsorted)` where Spark prints `"MAP<BIGINT, BIGINT>"` and ends with a period.
Spark 4.2.0 ends both messages with ` SQLSTATE: 42K09`, as hand-built messages
on `main` do (for example
[`make_time.rs`](https://github.com/apache/datafusion-spark/blob/125600164aa825e2fe805887dfdb384d4182f2a8/crates/spark/src/function/datetime/make_time.rs#L95)).
#332 adds `spark_sql_type` to render Spark's type names, and my review of #332
proposes one shared module for it, `tightest_common_type`, and the orderability
check. Could both messages use that helper, and could
the `.slt` error cases assert the full text?
##########
crates/spark/src/function/array/array_remove.rs:
##########
@@ -0,0 +1,502 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: See the NOTICE file distributed with this work for
additional information regarding copyright ownership
+// SPDX-FileContributor: Licensed to the Apache Software Foundation (ASF)
under one or more contributor license agreements
+
+use super::array_position::{contains_map, tightest_common_type};
+use super::float_normalize::normalize_array;
+use arrow::array::{
+ Array, ArrayRef, AsArray, BooleanArray, BooleanBufferBuilder,
GenericListArray,
+ OffsetSizeTrait, Scalar, make_comparator,
+};
+use arrow::buffer::{BooleanBuffer, NullBuffer, OffsetBuffer};
+use arrow::compute::kernels::cmp::eq;
+use arrow::compute::{SortOptions, filter};
+use arrow::datatypes::{DataType, Field};
+use datafusion_common::utils::take_function_args;
+use datafusion_common::{Result, ScalarValue, exec_err, plan_err};
+use datafusion_expr::{
+ ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,
+ Volatility,
+};
+use datafusion_macros::user_doc;
+use std::sync::Arc;
+
+/// Spark-compatible `array_remove` expression.
+///
+/// <https://spark.apache.org/docs/latest/api/sql/index.html#array_remove>
+#[user_doc(
+ doc_section(label = "Array Functions"),
+ description = "Removes all elements that are equal to the element from the
array. The \
+ result is NULL when the array or the element is NULL, while the
DataFusion built-in \
+ removes the NULL elements when the element is NULL. NULL elements in
the array are \
+ always kept. Corresponding NULLs nested inside compared arrays or
structs are equal. \
+ For floating point values, also inside nested arrays and structs, NaN
is equal to NaN \
+ and -0.0 is equal to 0.0; the elements that are kept keep their
original values. As \
+ in Spark, the array element and the element are cast to their tightest
common type, \
+ and the result is an array of that type: numbers widen, an integer
widens to a \
+ decimal only if the decimal can hold all its values, and a date widens
to a \
+ timestamp. Other combinations are an error, for example a string and a
number, two \
+ different decimals, or structs whose field names or field types
differ, as in Spark \
+ with ANSI mode off (with ANSI mode on, Spark widens struct field
types). Map \
+ elements are also an error.",
+ syntax_example = "array_remove(array, element)",
+ sql_example = r#"```sql
+> SELECT array_remove(array(1, 2, 3, NULL, 3), 3);
+[1, 2, NULL]
+```"#,
+ argument(name = "array", description = "Array expression. NULL returns
NULL."),
+ argument(
+ name = "element",
+ description = "Element to remove. NULL returns NULL."
+ )
+)]
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct SparkArrayRemove {
+ signature: Signature,
+}
+
+impl Default for SparkArrayRemove {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl SparkArrayRemove {
+ pub fn new() -> Self {
+ Self {
+ signature: Signature::user_defined(Volatility::Immutable),
+ }
+ }
+}
+
+impl ScalarUDFImpl for SparkArrayRemove {
+ fn name(&self) -> &str {
+ "array_remove"
+ }
+
+ fn signature(&self) -> &Signature {
+ &self.signature
+ }
+
+ fn return_type(&self, arg_types: &[DataType]) -> Result<DataType> {
+ let [array, _] = take_function_args(self.name(), arg_types)?;
+ Ok(array.clone())
+ }
+
+ fn coerce_types(&self, arg_types: &[DataType]) -> Result<Vec<DataType>> {
+ let [array, element] = take_function_args(self.name(), arg_types)?;
+ coerce_array_and_element(self.name(), array, element)
+ }
+
+ fn invoke_with_args(&self, args: ScalarFunctionArgs) ->
Result<ColumnarValue> {
+ let [array, element] = take_function_args(self.name(), &args.args)?;
+ let is_scalar = matches!(
+ (array, element),
+ (ColumnarValue::Scalar(_), ColumnarValue::Scalar(_))
+ );
+ let rows = if is_scalar { 1 } else { args.number_rows };
+ let array = array.to_array(rows)?;
+ // A constant element is compared as a single value against every row.
+ let (element, constant) = match element {
+ ColumnarValue::Scalar(scalar) => (scalar.to_array()?, true),
+ ColumnarValue::Array(element) => (Arc::clone(element), false),
+ };
+
+ let result = match array.data_type() {
+ DataType::List(_) => remove::<i32>(&array, &element, constant)?,
+ DataType::LargeList(_) => remove::<i64>(&array, &element,
constant)?,
+ other => return exec_err!("array_remove does not support type
{other}"),
+ };
+
+ if is_scalar {
+ Ok(ColumnarValue::Scalar(ScalarValue::try_from_array(
+ &result, 0,
+ )?))
+ } else {
+ Ok(ColumnarValue::Array(result))
+ }
+ }
+
+ fn documentation(&self) -> Option<&Documentation> {
+ self.doc()
+ }
+}
+
+/// Removes from each row of `array` the non-null elements equal to the row's
element, which
+/// is `element[0]` for every row if `constant`, and `element[row]` otherwise.
A row is NULL
+/// when the array or the element is NULL.
+fn remove<O: OffsetSizeTrait>(
+ array: &ArrayRef,
+ element: &ArrayRef,
+ constant: bool,
+) -> Result<ArrayRef> {
+ let list = array.as_list::<O>();
+ let offsets = list.offsets();
+ // Only the values that this (possibly sliced) list refers to are looked
at.
+ let base = offsets[0].as_usize();
+ let len = offsets[offsets.len() - 1].as_usize() - base;
+ let values = list.values().slice(base, len);
+
+ // Logical nulls, so that a NULL-typed element, which has no null buffer,
is NULL.
+ let element_nulls = element.logical_nulls();
+ let row_nulls = if constant {
+ if element_nulls.as_ref().is_some_and(|n| n.is_null(0)) {
+ Some(NullBuffer::new_null(list.len()))
+ } else {
+ list.nulls().cloned()
+ }
+ } else {
+ NullBuffer::union(list.nulls(), element_nulls.as_ref())
+ };
+ let row_is_valid = |row: usize| row_nulls.as_ref().is_none_or(|n|
n.is_valid(row));
+
+ // Equality is computed on copies with canonical NaN and 0.0 at any depth,
so that it
+ // follows Spark's float equality, while the kept elements are taken from
the original
+ // values. The comparator treats NULLs nested inside the compared values
as equal.
+ let mut is_equal: Box<dyn Fn(usize, usize) -> bool> = Box::new(|_, _|
false);
+ // When every element is NULL there is nothing to compare: NULL elements
are kept and a
+ // NULL element makes every row NULL. This also covers the NULL type.
+ let any_comparison =
+ values.logical_null_count() < values.len() &&
(0..list.len()).any(row_is_valid);
+ if any_comparison {
+ let normalized = normalize_array(&values)?;
+ let needle = normalize_array(element)?;
+ is_equal = if constant && !normalized.data_type().is_nested() {
+ // Compare every value with the constant at once.
+ let equal = eq(&normalized, &Scalar::new(Arc::clone(&needle)))?;
+ let equal = equal.values().clone();
+ Box::new(move |i, _| equal.value(i))
+ } else {
+ let cmp = make_comparator(
+ normalized.as_ref(),
+ needle.as_ref(),
+ SortOptions::default(),
+ )?;
+ Box::new(move |i, row| cmp(i, if constant { 0 } else { row
}).is_eq())
+ };
+ }
+
+ let value_nulls = values.logical_nulls();
+ let mut keep = BooleanBufferBuilder::new(len);
+ let mut new_offsets = Vec::with_capacity(list.len() + 1);
+ new_offsets.push(O::usize_as(0));
+ let mut kept = 0usize;
+ for (row, w) in offsets.windows(2).enumerate() {
+ let (start, end) = (w[0].as_usize() - base, w[1].as_usize() - base);
+ if row_is_valid(row) {
+ for i in start..end {
+ let keep_it = value_nulls.as_ref().is_some_and(|n|
n.is_null(i))
+ || !is_equal(i, row);
+ keep.append(keep_it);
+ kept += usize::from(keep_it);
+ }
+ } else {
+ keep.append_n(end - start, false);
+ }
+ new_offsets.push(O::usize_as(kept));
+ }
+ let keep: BooleanBuffer = keep.finish();
Review Comment:
For a constant element that isn't nested, could this skip the normalized
copy and build `keep` with bitmap operations, as Comet's
[`remove_float_constant`](https://github.com/apache/datafusion-comet/blob/ba16e1a53127c90ba00fdc7058703945a8bb9f34/native/spark-expr/src/array_funcs/array_remove.rs#L119-L152)
does? Here `normalize_array` copies every value in the batch, and the loop
then makes a boxed-closure call and a `BooleanBufferBuilder::append` for each
element. Comet tests each float once against the constant (`!=`, under which
the two zeros are equal, or `is_nan` for a NaN element), ORs in the element
nulls, and takes the offsets from set-bit counts. NULL rows would still need
their bits cleared, which a pass over only those rows can do. I haven't
measured this. Could you compare the two at 8192 rows with a constant float
element? Comet's
[`float_arrays.rs`](https://github.com/apache/datafusion-comet/blob/ba16e1a53127c90ba00fdc7058703945a8bb9f34/native/spark-expr/benches/float_
arrays.rs) bench covers that case.
##########
crates/spark/src/function/array/array_position.rs:
##########
@@ -349,7 +352,7 @@ fn finer_unit(left: TimeUnit, right: TimeUnit) -> TimeUnit {
}
/// Spark cannot order maps, so it rejects them at any depth of the element
type.
-fn contains_map(data_type: &DataType) -> bool {
+pub(super) fn contains_map(data_type: &DataType) -> bool {
Review Comment:
Spark can't order `CalendarIntervalType` either.
[`OrderUtils.isOrderable`](https://github.com/apache/spark/blob/32f7299601108917fb01920a54e084595b7b3bf8/sql/api/src/main/scala/org/apache/spark/sql/catalyst/expressions/OrderUtils.scala#L26-L38)
accepts only atomic types and structs and arrays of them, and `ArrayRemove`
checks it through `TypeUtils.checkForOrderingExpr`. For
`array_remove(array(make_interval(1)), make_interval(1))`, Spark 4.2.0 raises
``[DATATYPE_MISMATCH.INVALID_ORDERING_TYPE] The `array_remove` does not support
ordering on type "INTERVAL".`` in both ANSI modes, and this PR returns `[]`.
This crate's `make_interval` returns `Interval(MonthDayNano)`. Since
`array_remove` relies on `contains_map` for its ordering check, could it also
reject `Interval(MonthDayNano)` at any depth, with a `.slt` case?
`array_position` on `main` has the same gap and would get the fix too.
--
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]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]