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]

Reply via email to