You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@datafusion.apache.org by ag...@apache.org on 2026/05/28 23:14:25 UTC
(datafusion-comet) branch main updated: feat: support Spark expression slice (#4149)
This is an automated email from the ASF dual-hosted git repository.
andygrove pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/datafusion-comet.git
The following commit(s) were added to refs/heads/main by this push:
new da016db0e4 feat: support Spark expression slice (#4149)
da016db0e4 is described below
commit da016db0e4fd841d332d03b6040c5b739d977de4
Author: Andy Grove <ag...@apache.org>
AuthorDate: Thu May 28 17:14:20 2026 -0600
feat: support Spark expression slice (#4149)
---
native/spark-expr/src/array_funcs/array_slice.rs | 379 +++++++++++++++++++++
native/spark-expr/src/array_funcs/mod.rs | 2 +
native/spark-expr/src/comet_scalar_funcs.rs | 3 +-
.../org/apache/comet/serde/QueryPlanSerde.scala | 1 +
.../main/scala/org/apache/comet/serde/arrays.scala | 26 +-
.../sql-tests/expressions/array/slice.sql | 261 ++++++++++++++
6 files changed, 670 insertions(+), 2 deletions(-)
diff --git a/native/spark-expr/src/array_funcs/array_slice.rs b/native/spark-expr/src/array_funcs/array_slice.rs
new file mode 100644
index 0000000000..ec6ac46b03
--- /dev/null
+++ b/native/spark-expr/src/array_funcs/array_slice.rs
@@ -0,0 +1,379 @@
+// 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.
+
+// Spark-compatible slice(array, start, length).
+//
+// Differs from datafusion-spark's SparkSlice in that we correctly return an
+// empty array when a negative start position lies before the beginning of the
+// array. The upstream implementation (as of datafusion-spark 53.1.0) produces
+// the first element instead. Once the upstream is fixed, this can be removed
+// in favour of datafusion_spark::function::array::slice::SparkSlice.
+
+use arrow::array::{
+ make_array, Array, ArrayRef, AsArray, Capacities, GenericListArray, Int64Array,
+ MutableArrayData, NullBufferBuilder, OffsetSizeTrait,
+};
+use arrow::buffer::OffsetBuffer;
+use arrow::datatypes::{DataType, FieldRef};
+use datafusion::common::{cast::as_int64_array, exec_err, utils::take_function_args, Result};
+use datafusion::logical_expr::{
+ ColumnarValue, ReturnFieldArgs, ScalarFunctionArgs, ScalarUDFImpl, Signature, TypeSignature,
+ Volatility,
+};
+use std::any::Any;
+use std::sync::Arc;
+
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct SparkArraySlice {
+ signature: Signature,
+}
+
+impl Default for SparkArraySlice {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl SparkArraySlice {
+ pub fn new() -> Self {
+ Self {
+ signature: Signature::new(TypeSignature::Any(3), Volatility::Immutable),
+ }
+ }
+}
+
+impl ScalarUDFImpl for SparkArraySlice {
+ fn as_any(&self) -> &dyn Any {
+ self
+ }
+
+ fn name(&self) -> &str {
+ "spark_array_slice"
+ }
+
+ fn signature(&self) -> &Signature {
+ &self.signature
+ }
+
+ fn return_type(&self, _arg_types: &[DataType]) -> Result<DataType> {
+ datafusion::common::internal_err!("return_field_from_args should be used instead")
+ }
+
+ fn return_field_from_args(&self, args: ReturnFieldArgs) -> Result<FieldRef> {
+ Ok(Arc::clone(&args.arg_fields[0]))
+ }
+
+ fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {
+ let row_count = args.number_rows;
+ let arrays = args
+ .args
+ .iter()
+ .map(|arg| match arg {
+ ColumnarValue::Array(a) => Ok(Arc::clone(a)),
+ ColumnarValue::Scalar(s) => s.to_array_of_size(row_count),
+ })
+ .collect::<Result<Vec<_>>>()?;
+ let [array, start, length] = take_function_args(self.name(), &arrays)?;
+ let start = as_int64_array(&start)?;
+ let length = as_int64_array(&length)?;
+
+ let result = match array.data_type() {
+ DataType::List(_) => slice_list::<i32>(array.as_list::<i32>(), start, length)?,
+ DataType::LargeList(_) => slice_list::<i64>(array.as_list::<i64>(), start, length)?,
+ other => {
+ return exec_err!("{} does not support type '{other}'", self.name());
+ }
+ };
+ Ok(ColumnarValue::Array(result))
+ }
+}
+
+fn slice_list<O: OffsetSizeTrait>(
+ list_array: &GenericListArray<O>,
+ start: &Int64Array,
+ length: &Int64Array,
+) -> Result<ArrayRef> {
+ let list_field = match list_array.data_type() {
+ DataType::List(field) | DataType::LargeList(field) => field,
+ other => {
+ return exec_err!("expected List or LargeList, got {other:?}");
+ }
+ };
+
+ let values = list_array.values();
+ let original_data = values.to_data();
+ let row_count = list_array.len();
+ let mut offsets = Vec::<O>::with_capacity(row_count + 1);
+ let mut last_offset = O::zero();
+ offsets.push(last_offset);
+ let mut mutable = MutableArrayData::with_capacities(
+ vec![&original_data],
+ true,
+ Capacities::Array(original_data.len()),
+ );
+ let mut nulls = NullBufferBuilder::new(row_count);
+
+ let row_offsets = list_array.offsets();
+ let list_nulls = list_array.nulls();
+ let start_nulls = start.nulls();
+ let length_nulls = length.nulls();
+ for row in 0..row_count {
+ let is_row_null = list_nulls.is_some_and(|n| n.is_null(row))
+ || start_nulls.is_some_and(|n| n.is_null(row))
+ || length_nulls.is_some_and(|n| n.is_null(row));
+ if is_row_null {
+ offsets.push(last_offset);
+ nulls.append_null();
+ continue;
+ }
+
+ let start_value = start.value(row);
+ let length_value = length.value(row);
+
+ if start_value == 0 {
+ return exec_err!("Unexpected value for start in function slice. Expected a positive or negative number, but got 0.");
+ }
+ if length_value < 0 {
+ return exec_err!(
+ "Unexpected value for length in function slice. Expected a non-negative number, but got {length_value}."
+ );
+ }
+
+ let row_start = row_offsets[row].as_usize();
+ let row_end = row_offsets[row + 1].as_usize();
+ let arr_len = (row_end - row_start) as i64;
+
+ let zero_based_start = if start_value > 0 {
+ start_value - 1
+ } else {
+ start_value + arr_len
+ };
+
+ let copied = if zero_based_start < 0 || zero_based_start >= arr_len || length_value == 0 {
+ 0
+ } else {
+ let take = std::cmp::min(length_value, arr_len - zero_based_start) as usize;
+ let begin = row_start + zero_based_start as usize;
+ mutable.extend(0, begin, begin + take);
+ take
+ };
+
+ last_offset += O::usize_as(copied);
+ offsets.push(last_offset);
+ nulls.append_non_null();
+ }
+
+ Ok(Arc::new(GenericListArray::<O>::try_new(
+ Arc::clone(list_field),
+ OffsetBuffer::new(offsets.into()),
+ make_array(mutable.freeze()),
+ nulls.finish(),
+ )?))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use arrow::array::{Int32Array, ListArray};
+ use arrow::buffer::OffsetBuffer;
+ use arrow::datatypes::{Field, Int32Type};
+
+ fn build_list(rows: Vec<Option<Vec<Option<i32>>>>) -> Arc<ListArray> {
+ let mut offsets = vec![0i32];
+ let mut values: Vec<Option<i32>> = Vec::new();
+ let mut nulls = NullBufferBuilder::new(rows.len());
+ for row in &rows {
+ match row {
+ Some(items) => {
+ nulls.append_non_null();
+ values.extend(items.iter().copied());
+ }
+ None => nulls.append_null(),
+ }
+ offsets.push(values.len() as i32);
+ }
+ let values = Arc::new(Int32Array::from(values)) as ArrayRef;
+ let field = Arc::new(Field::new("item", DataType::Int32, true));
+ Arc::new(ListArray::new(
+ field,
+ OffsetBuffer::new(offsets.into()),
+ values,
+ nulls.finish(),
+ ))
+ }
+
+ fn run(
+ list: Arc<ListArray>,
+ start: Vec<Option<i64>>,
+ length: Vec<Option<i64>>,
+ ) -> Vec<Option<Vec<Option<i32>>>> {
+ let start = Int64Array::from(start);
+ let length = Int64Array::from(length);
+ let result = slice_list::<i32>(list.as_ref(), &start, &length).unwrap();
+ let result = result.as_list::<i32>();
+ (0..result.len())
+ .map(|i| {
+ if result.is_null(i) {
+ None
+ } else {
+ let row = result.value(i);
+ let row = row.as_primitive::<Int32Type>();
+ Some(
+ (0..row.len())
+ .map(|j| {
+ if row.is_null(j) {
+ None
+ } else {
+ Some(row.value(j))
+ }
+ })
+ .collect(),
+ )
+ }
+ })
+ .collect()
+ }
+
+ #[test]
+ fn positive_start() {
+ let list = build_list(vec![Some(vec![
+ Some(1),
+ Some(2),
+ Some(3),
+ Some(4),
+ Some(5),
+ ])]);
+ assert_eq!(
+ run(list, vec![Some(2)], vec![Some(3)]),
+ vec![Some(vec![Some(2), Some(3), Some(4)])]
+ );
+ }
+
+ #[test]
+ fn length_clamped_to_array_end() {
+ let list = build_list(vec![Some(vec![Some(1), Some(2), Some(3)])]);
+ assert_eq!(
+ run(list, vec![Some(2)], vec![Some(100)]),
+ vec![Some(vec![Some(2), Some(3)])]
+ );
+ }
+
+ #[test]
+ fn length_zero_returns_empty() {
+ let list = build_list(vec![Some(vec![Some(1), Some(2), Some(3)])]);
+ assert_eq!(
+ run(list, vec![Some(1)], vec![Some(0)]),
+ vec![Some(Vec::new())]
+ );
+ }
+
+ #[test]
+ fn start_past_end_returns_empty() {
+ let list = build_list(vec![Some(vec![Some(1), Some(2), Some(3)])]);
+ assert_eq!(
+ run(list, vec![Some(10)], vec![Some(1)]),
+ vec![Some(Vec::new())]
+ );
+ }
+
+ #[test]
+ fn negative_start_counts_from_end() {
+ let list = build_list(vec![Some(vec![
+ Some(1),
+ Some(2),
+ Some(3),
+ Some(4),
+ Some(5),
+ ])]);
+ assert_eq!(
+ run(list, vec![Some(-2)], vec![Some(2)]),
+ vec![Some(vec![Some(4), Some(5)])]
+ );
+ }
+
+ #[test]
+ fn negative_start_overflows_returns_empty() {
+ // Spark: slice([a], -2, 2) returns []. datafusion-spark returns [a] here.
+ let list = build_list(vec![Some(vec![Some(1)])]);
+ assert_eq!(
+ run(list, vec![Some(-2)], vec![Some(2)]),
+ vec![Some(Vec::new())]
+ );
+ }
+
+ #[test]
+ fn negative_start_far_below_zero_returns_empty() {
+ let list = build_list(vec![Some(vec![Some(1), Some(2), Some(3)])]);
+ assert_eq!(
+ run(list, vec![Some(-10)], vec![Some(2)]),
+ vec![Some(Vec::new())]
+ );
+ }
+
+ #[test]
+ fn negative_start_with_length_past_end() {
+ let list = build_list(vec![Some(vec![
+ Some(1),
+ Some(2),
+ Some(3),
+ Some(4),
+ Some(5),
+ ])]);
+ assert_eq!(
+ run(list, vec![Some(-2)], vec![Some(5)]),
+ vec![Some(vec![Some(4), Some(5)])]
+ );
+ }
+
+ #[test]
+ fn null_inputs_yield_null() {
+ let list = build_list(vec![None, Some(vec![Some(1)]), Some(vec![Some(1)])]);
+ assert_eq!(
+ run(
+ list,
+ vec![Some(1), None, Some(1)],
+ vec![Some(1), Some(1), None]
+ ),
+ vec![None, None, None]
+ );
+ }
+
+ #[test]
+ fn empty_array_input() {
+ let list = build_list(vec![Some(Vec::new())]);
+ assert_eq!(
+ run(list, vec![Some(1)], vec![Some(2)]),
+ vec![Some(Vec::new())]
+ );
+ }
+
+ #[test]
+ fn start_zero_errors() {
+ let list = build_list(vec![Some(vec![Some(1)])]);
+ let start = Int64Array::from(vec![Some(0)]);
+ let length = Int64Array::from(vec![Some(1)]);
+ assert!(slice_list::<i32>(list.as_ref(), &start, &length).is_err());
+ }
+
+ #[test]
+ fn negative_length_errors() {
+ let list = build_list(vec![Some(vec![Some(1)])]);
+ let start = Int64Array::from(vec![Some(1)]);
+ let length = Int64Array::from(vec![Some(-1)]);
+ assert!(slice_list::<i32>(list.as_ref(), &start, &length).is_err());
+ }
+}
diff --git a/native/spark-expr/src/array_funcs/mod.rs b/native/spark-expr/src/array_funcs/mod.rs
index 5a503eba39..057b0462ee 100644
--- a/native/spark-expr/src/array_funcs/mod.rs
+++ b/native/spark-expr/src/array_funcs/mod.rs
@@ -18,6 +18,7 @@
mod array_compact;
mod array_insert;
mod array_position;
+mod array_slice;
mod arrays_overlap;
mod arrays_zip;
mod get_array_struct_fields;
@@ -27,6 +28,7 @@ mod size;
pub use array_compact::SparkArrayCompact;
pub use array_insert::ArrayInsert;
pub use array_position::SparkArrayPositionFunc;
+pub use array_slice::SparkArraySlice;
pub use arrays_overlap::SparkArraysOverlap;
pub use arrays_zip::SparkArraysZipFunc;
pub use get_array_struct_fields::GetArrayStructFields;
diff --git a/native/spark-expr/src/comet_scalar_funcs.rs b/native/spark-expr/src/comet_scalar_funcs.rs
index 7108105dcb..784e6c6829 100644
--- a/native/spark-expr/src/comet_scalar_funcs.rs
+++ b/native/spark-expr/src/comet_scalar_funcs.rs
@@ -25,7 +25,7 @@ use crate::{
spark_ceil, spark_decimal_div, spark_decimal_integral_div, spark_floor, spark_isnan,
spark_lpad, spark_make_decimal, spark_read_side_padding, spark_round, spark_rpad,
spark_to_time, spark_unhex, spark_unscaled_value, EvalMode, SparkArrayCompact,
- SparkArrayPositionFunc, SparkArraysOverlap, SparkContains, SparkDateDiff,
+ SparkArrayPositionFunc, SparkArraySlice, SparkArraysOverlap, SparkContains, SparkDateDiff,
SparkDateFromUnixDate, SparkDateTrunc, SparkMakeDate, SparkMakeTime, SparkSecondsToTimestamp,
SparkSizeFunc,
};
@@ -212,6 +212,7 @@ fn all_scalar_functions() -> Vec<Arc<ScalarUDF>> {
vec![
Arc::new(ScalarUDF::new_from_impl(SparkArrayCompact::default())),
Arc::new(ScalarUDF::new_from_impl(SparkArrayPositionFunc::default())),
+ Arc::new(ScalarUDF::new_from_impl(SparkArraySlice::default())),
Arc::new(ScalarUDF::new_from_impl(SparkArraysOverlap::default())),
Arc::new(ScalarUDF::new_from_impl(SparkContains::default())),
Arc::new(ScalarUDF::new_from_impl(SparkDateDiff::default())),
diff --git a/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala b/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala
index b818b61b1b..7746cf8ed3 100644
--- a/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala
+++ b/spark/src/main/scala/org/apache/comet/serde/QueryPlanSerde.scala
@@ -63,6 +63,7 @@ object QueryPlanSerde extends Logging with CometExprShim with CometTypeShim {
classOf[ArrayPosition] -> CometArrayPosition,
classOf[ArrayRemove] -> CometArrayRemove,
classOf[ArrayRepeat] -> CometArrayRepeat,
+ classOf[Slice] -> CometSlice,
classOf[SortArray] -> CometSortArray,
classOf[ArraysOverlap] -> CometArraysOverlap,
classOf[ArrayUnion] -> CometArrayUnion,
diff --git a/spark/src/main/scala/org/apache/comet/serde/arrays.scala b/spark/src/main/scala/org/apache/comet/serde/arrays.scala
index f9051e50dc..33d3216857 100644
--- a/spark/src/main/scala/org/apache/comet/serde/arrays.scala
+++ b/spark/src/main/scala/org/apache/comet/serde/arrays.scala
@@ -22,7 +22,7 @@ package org.apache.comet.serde
import scala.annotation.tailrec
import scala.jdk.CollectionConverters._
-import org.apache.spark.sql.catalyst.expressions.{And, ArrayAppend, ArrayContains, ArrayExcept, ArrayFilter, ArrayInsert, ArrayIntersect, ArrayJoin, ArrayMax, ArrayMin, ArrayPosition, ArrayRemove, ArrayRepeat, ArraysOverlap, ArraysZip, ArrayUnion, Attribute, CreateArray, ElementAt, EmptyRow, Expression, Flatten, GetArrayItem, IsNotNull, Literal, Reverse, Size, SortArray}
+import org.apache.spark.sql.catalyst.expressions.{And, ArrayAppend, ArrayContains, ArrayExcept, ArrayFilter, ArrayInsert, ArrayIntersect, ArrayJoin, ArrayMax, ArrayMin, ArrayPosition, ArrayRemove, ArrayRepeat, ArraysOverlap, ArraysZip, ArrayUnion, Attribute, Cast, CreateArray, ElementAt, EmptyRow, Expression, Flatten, GetArrayItem, IsNotNull, Literal, Reverse, Size, Slice, SortArray}
import org.apache.spark.sql.catalyst.util.GenericArrayData
import org.apache.spark.sql.internal.SQLConf
import org.apache.spark.sql.types._
@@ -455,6 +455,30 @@ object CometArrayInsert extends CometExpressionSerde[ArrayInsert] {
}
}
+object CometSlice extends CometExpressionSerde[Slice] {
+ override def convert(
+ expr: Slice,
+ inputs: Seq[Attribute],
+ binding: Boolean): Option[ExprOuterClass.Expr] = {
+ val elementType = expr.x.dataType.asInstanceOf[ArrayType].elementType
+ val arrayExprProto = exprToProto(expr.x, inputs, binding)
+ val startExprProto = exprToProto(Cast(expr.start, LongType), inputs, binding)
+ val lengthExprProto = exprToProto(Cast(expr.length, LongType), inputs, binding)
+ // DataFusion list types always have nullable inner elements, so promise
+ // ArrayType(elementType, containsNull = true) here even if Spark's
+ // expr.dataType reports containsNull = false (e.g. for array(1, 2, 3)).
+ val sliceScalarExpr =
+ scalarFunctionExprToProtoWithReturnType(
+ "spark_array_slice",
+ ArrayType(elementType, containsNull = true),
+ false,
+ arrayExprProto,
+ startExprProto,
+ lengthExprProto)
+ optExprWithInfo(sliceScalarExpr, expr, expr.children: _*)
+ }
+}
+
object CometArrayUnion extends CometExpressionSerde[ArrayUnion] {
override def convert(
expr: ArrayUnion,
diff --git a/spark/src/test/resources/sql-tests/expressions/array/slice.sql b/spark/src/test/resources/sql-tests/expressions/array/slice.sql
new file mode 100644
index 0000000000..fcb2bb254b
--- /dev/null
+++ b/spark/src/test/resources/sql-tests/expressions/array/slice.sql
@@ -0,0 +1,261 @@
+-- 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.
+
+statement
+CREATE TABLE test_slice(int_arr array<int>, str_arr array<string>, start_idx int, len int) USING parquet
+
+statement
+INSERT INTO test_slice VALUES
+ (array(1, 2, 3, 4, 5), array('a', 'b', 'c', 'd', 'e'), 2, 3),
+ (array(1, 2, NULL, 4), array('a', NULL, 'c'), 1, 2),
+ (array(10, 20, 30), array('x', 'y', 'z'), -2, 2),
+ (array(), array(), 1, 1),
+ (NULL, NULL, 1, 2),
+ (array(1, 2, 3), array('a', 'b', 'c'), 4, 1),
+ (array(1, 2, 3), array('a', 'b', 'c'), -10, 2),
+ (array(1, 2, 3, 4), array('a', 'b', 'c', 'd'), -2, 100),
+ (array(7, 8, 9), array('p', 'q', 'r'), NULL, 2),
+ (array(7, 8, 9), array('p', 'q', 'r'), 1, NULL)
+
+-- all literal arguments
+query
+SELECT slice(array(1, 2, 3, 4, 5), 2, 3)
+
+query
+SELECT slice(array(1, 2, 3, 4, 5), 1, 5)
+
+query
+SELECT slice(array(1, 2, 3, 4, 5), -2, 2)
+
+query
+SELECT slice(array(1, 2, 3, 4, 5), -3, 5)
+
+-- length 0 returns empty array
+query
+SELECT slice(array(1, 2, 3, 4), 1, 0)
+
+-- length larger than remaining elements is clamped
+query
+SELECT slice(array(1, 2, 3, 4), 2, 100)
+
+-- start past end returns empty array
+query
+SELECT slice(array(1, 2, 3), 10, 1)
+
+-- empty array input
+query
+SELECT slice(array(), 1, 1)
+
+-- NULL array returns NULL
+query
+SELECT slice(cast(NULL as array<int>), 1, 2)
+
+-- NULL start returns NULL
+query
+SELECT slice(array(1, 2, 3), cast(NULL as int), 2)
+
+-- NULL length returns NULL
+query
+SELECT slice(array(1, 2, 3), 1, cast(NULL as int))
+
+-- column array + column start + column length
+query
+SELECT slice(int_arr, start_idx, len) FROM test_slice
+
+-- column array + literal start + literal length
+query
+SELECT slice(int_arr, 1, 2) FROM test_slice
+
+-- column array + column start + literal length
+query
+SELECT slice(int_arr, start_idx, 2) FROM test_slice
+
+-- column array + literal start + column length
+query
+SELECT slice(int_arr, 1, len) FROM test_slice
+
+-- string column array + column args
+query
+SELECT slice(str_arr, start_idx, len) FROM test_slice
+
+-- string column array + literal args
+query
+SELECT slice(str_arr, 1, 2) FROM test_slice
+
+-- expressions for start / length
+query
+SELECT slice(int_arr, start_idx + 1, len - 1) FROM test_slice WHERE start_idx > 0 AND len > 1
+
+-- boolean arrays
+statement
+CREATE TABLE test_slice_bool(arr array<boolean>) USING parquet
+
+statement
+INSERT INTO test_slice_bool VALUES
+ (array(true, false, true, false)),
+ (array(true)),
+ (NULL),
+ (array())
+
+query
+SELECT slice(arr, 1, 2) FROM test_slice_bool
+
+query
+SELECT slice(arr, -1, 1) FROM test_slice_bool
+
+-- tinyint arrays
+statement
+CREATE TABLE test_slice_byte(arr array<tinyint>) USING parquet
+
+statement
+INSERT INTO test_slice_byte VALUES
+ (array(cast(1 as tinyint), cast(2 as tinyint), cast(3 as tinyint))),
+ (array(cast(-128 as tinyint), cast(0 as tinyint), cast(127 as tinyint))),
+ (NULL)
+
+query
+SELECT slice(arr, 2, 2) FROM test_slice_byte
+
+-- smallint arrays
+statement
+CREATE TABLE test_slice_short(arr array<smallint>) USING parquet
+
+statement
+INSERT INTO test_slice_short VALUES
+ (array(cast(100 as smallint), cast(200 as smallint), cast(300 as smallint))),
+ (array(cast(-1 as smallint), cast(0 as smallint))),
+ (NULL)
+
+query
+SELECT slice(arr, 1, 2) FROM test_slice_short
+
+-- bigint arrays
+statement
+CREATE TABLE test_slice_long(arr array<bigint>) USING parquet
+
+statement
+INSERT INTO test_slice_long VALUES
+ (array(cast(1000000000000 as bigint), cast(2000000000000 as bigint), cast(3000000000000 as bigint))),
+ (array(cast(-1 as bigint), cast(0 as bigint), cast(1 as bigint))),
+ (NULL)
+
+query
+SELECT slice(arr, -2, 2) FROM test_slice_long
+
+-- float arrays
+statement
+CREATE TABLE test_slice_float(arr array<float>) USING parquet
+
+statement
+INSERT INTO test_slice_float VALUES
+ (array(cast(1.1 as float), cast(2.2 as float), cast(3.3 as float))),
+ (array(cast(0.0 as float), cast(-1.5 as float), cast('NaN' as float), cast('Infinity' as float))),
+ (NULL)
+
+query
+SELECT slice(arr, 1, 2) FROM test_slice_float
+
+-- double arrays
+statement
+CREATE TABLE test_slice_double(arr array<double>) USING parquet
+
+statement
+INSERT INTO test_slice_double VALUES
+ (array(1.1, 2.2, 3.3, 4.4)),
+ (array(0.0, -1.5, cast('NaN' as double), cast('Infinity' as double))),
+ (NULL)
+
+query
+SELECT slice(arr, 2, 3) FROM test_slice_double
+
+-- decimal arrays
+statement
+CREATE TABLE test_slice_decimal(arr array<decimal(10,2)>) USING parquet
+
+statement
+INSERT INTO test_slice_decimal VALUES
+ (array(cast(1.10 as decimal(10,2)), cast(2.20 as decimal(10,2)), cast(3.30 as decimal(10,2)))),
+ (array(cast(0.00 as decimal(10,2)))),
+ (NULL)
+
+query
+SELECT slice(arr, 1, 2) FROM test_slice_decimal
+
+-- date arrays
+statement
+CREATE TABLE test_slice_date(arr array<date>) USING parquet
+
+statement
+INSERT INTO test_slice_date VALUES
+ (array(date '2024-01-01', date '2024-06-15', date '2024-12-31')),
+ (array(date '2000-01-01')),
+ (NULL)
+
+query
+SELECT slice(arr, 2, 1) FROM test_slice_date
+
+-- timestamp arrays
+statement
+CREATE TABLE test_slice_ts(arr array<timestamp>) USING parquet
+
+statement
+INSERT INTO test_slice_ts VALUES
+ (array(timestamp '2024-01-01 00:00:00', timestamp '2024-06-15 12:30:00', timestamp '2024-12-31 23:59:59')),
+ (array(timestamp '2000-01-01 00:00:00')),
+ (NULL)
+
+query
+SELECT slice(arr, 1, 2) FROM test_slice_ts
+
+-- timestamp_ntz arrays
+statement
+CREATE TABLE test_slice_ts_ntz(arr array<timestamp_ntz>) USING parquet
+
+statement
+INSERT INTO test_slice_ts_ntz VALUES
+ (array(timestamp_ntz '2024-01-01 00:00:00', timestamp_ntz '2024-06-15 12:30:00', timestamp_ntz '2024-12-31 23:59:59')),
+ (array(timestamp_ntz '2000-01-01 00:00:00')),
+ (NULL)
+
+query
+SELECT slice(arr, 1, 2) FROM test_slice_ts_ntz
+
+-- nested int arrays
+statement
+CREATE TABLE test_slice_nested_int(arr array<array<int>>) USING parquet
+
+statement
+INSERT INTO test_slice_nested_int VALUES
+ (array(array(1, 2), array(3, 4), array(5, 6))),
+ (array(array(1, 2, 3))),
+ (NULL)
+
+query
+SELECT slice(arr, 1, 2) FROM test_slice_nested_int
+
+-- nested string arrays
+statement
+CREATE TABLE test_slice_nested_str(arr array<array<string>>) USING parquet
+
+statement
+INSERT INTO test_slice_nested_str VALUES
+ (array(array('a', 'b'), array('c', 'd'), array('e', 'f'))),
+ (array(array('a'))),
+ (NULL)
+
+query
+SELECT slice(arr, -2, 2) FROM test_slice_nested_str
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datafusion.apache.org
For additional commands, e-mail: commits-help@datafusion.apache.org