Apache DataFusion SQL Query Engine
feat: support Spark-compatible abs math function part 2 - ANSI mode (#18828)
hsiang-c41bfb794c817
diff --git a/datafusion/execution/src/config.rs b/datafusion/execution/src/config.rsindex 30ba7de76a..854d239236 100644--- a/datafusion/execution/src/config.rs+++ b/datafusion/execution/src/config.rs@@ -480,6 +480,12 @@ impl SessionConfig {self.options.execution.enforce_batch_size_in_joins}+ /// Toggle SQL ANSI mode for expressions, casting, and error handling+ pub fn with_enable_ansi_mode(mut self, enable_ansi_mode: bool) -> Self {+ self.options_mut().execution.enable_ansi_mode = enable_ansi_mode;+ self+ }+/// Convert configuration options to name-value pairs with values/// converted to strings.///diff --git a/datafusion/functions/src/math/abs.rs b/datafusion/functions/src/math/abs.rsindex 081668f766..1b5aaf7745 100644--- a/datafusion/functions/src/math/abs.rs+++ b/datafusion/functions/src/math/abs.rs@@ -50,6 +50,7 @@ macro_rules! make_abs_function {}};}+#[macro_export]macro_rules! make_try_abs_function {($ARRAY_TYPE:ident) => {{|input: &ArrayRef| {@@ -62,7 +63,8 @@ macro_rules! make_try_abs_function {x))})- })?;+ })+ .and_then(|v| Ok(v.with_data_type(input.data_type().clone())))?; // maintain decimal's precision and scaleOk(Arc::new(res) as ArrayRef)}}};diff --git a/datafusion/spark/src/function/math/abs.rs b/datafusion/spark/src/function/math/abs.rsindex 101291ac5f..5edb40ae8a 100644--- a/datafusion/spark/src/function/math/abs.rs+++ b/datafusion/spark/src/function/math/abs.rs@@ -17,13 +17,15 @@use arrow::array::*;use arrow::datatypes::{DataType, Field, FieldRef};+use arrow::error::ArrowError;use datafusion_common::{DataFusionError, Result, ScalarValue, internal_err};use datafusion_expr::{ColumnarValue, ReturnFieldArgs, ScalarFunctionArgs, ScalarUDFImpl, Signature,Volatility,};use datafusion_functions::{- downcast_named_arg, make_abs_function, make_wrapping_abs_function,+ downcast_named_arg, make_abs_function, make_try_abs_function,+ make_wrapping_abs_function,};use std::any::Any;use std::sync::Arc;@@ -34,8 +36,10 @@ use std::sync::Arc;/// Returns the absolute value of input/// Returns NULL if input is NULL, returns NaN if input is NaN.///-/// TODOs:+/// Differences with DataFusion abs:/// - Spark's ANSI-compliant dialect, when off (i.e. `spark.sql.ansi.enabled=false`), taking absolute value on the minimal value of a signed integer returns the value as is. DataFusion's abs throws "DataFusion error: Arrow error: Compute error" on arithmetic overflow+///+/// TODOs:/// - Spark's abs also supports ANSI interval types: YearMonthIntervalType and DayTimeIntervalType. DataFusion's abs doesn't.///#[derive(Debug, PartialEq, Eq, Hash)]@@ -85,19 +89,39 @@ impl ScalarUDFImpl for SparkAbs {}fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {- spark_abs(&args.args)+ spark_abs(&args.args, args.config_options.execution.enable_ansi_mode)}}macro_rules! scalar_compute_op {- ($INPUT:ident, $SCALAR_TYPE:ident) => {{- let result = $INPUT.wrapping_abs();+ ($ENABLE_ANSI_MODE:expr, $INPUT:ident, $SCALAR_TYPE:ident) => {{+ let result = if $ENABLE_ANSI_MODE {+ $INPUT.checked_abs().ok_or_else(|| {+ ArrowError::ComputeError(format!(+ "{} overflow on abs({:?})",+ stringify!($SCALAR_TYPE),+ $INPUT+ ))+ })?+ } else {+ $INPUT.wrapping_abs()+ };Ok(ColumnarValue::Scalar(ScalarValue::$SCALAR_TYPE(Some(result,))))}};- ($INPUT:ident, $PRECISION:expr, $SCALE:expr, $SCALAR_TYPE:ident) => {{- let result = $INPUT.wrapping_abs();+ ($ENABLE_ANSI_MODE:expr, $INPUT:ident, $PRECISION:expr, $SCALE:expr, $SCALAR_TYPE:ident) => {{+ let result = if $ENABLE_ANSI_MODE {+ $INPUT.checked_abs().ok_or_else(|| {+ ArrowError::ComputeError(format!(+ "{} overflow on abs({:?})",+ stringify!($SCALAR_TYPE),+ $INPUT+ ))+ })?+ } else {+ $INPUT.wrapping_abs()+ };Ok(ColumnarValue::Scalar(ScalarValue::$SCALAR_TYPE(Some(result),$PRECISION,@@ -106,7 +130,10 @@ macro_rules! scalar_compute_op {}};}-pub fn spark_abs(args: &[ColumnarValue]) -> Result<ColumnarValue, DataFusionError> {+pub fn spark_abs(+ args: &[ColumnarValue],+ enable_ansi_mode: bool,+) -> Result<ColumnarValue, DataFusionError> {if args.len() != 1 {return internal_err!("abs takes exactly 1 argument, but got: {}", args.len());}@@ -119,19 +146,35 @@ pub fn spark_abs(args: &[ColumnarValue]) -> Result<ColumnarValue, DataFusionErro| DataType::UInt32| DataType::UInt64 => Ok(args[0].clone()),DataType::Int8 => {- let abs_fun = make_wrapping_abs_function!(Int8Array);+ let abs_fun = if enable_ansi_mode {+ make_try_abs_function!(Int8Array)+ } else {+ make_wrapping_abs_function!(Int8Array)+ };abs_fun(array).map(ColumnarValue::Array)}DataType::Int16 => {- let abs_fun = make_wrapping_abs_function!(Int16Array);+ let abs_fun = if enable_ansi_mode {+ make_try_abs_function!(Int16Array)+ } else {+ make_wrapping_abs_function!(Int16Array)+ };abs_fun(array).map(ColumnarValue::Array)}DataType::Int32 => {- let abs_fun = make_wrapping_abs_function!(Int32Array);+ let abs_fun = if enable_ansi_mode {+ make_try_abs_function!(Int32Array)+ } else {+ make_wrapping_abs_function!(Int32Array)+ };abs_fun(array).map(ColumnarValue::Array)}DataType::Int64 => {- let abs_fun = make_wrapping_abs_function!(Int64Array);+ let abs_fun = if enable_ansi_mode {+ make_try_abs_function!(Int64Array)+ } else {+ make_wrapping_abs_function!(Int64Array)+ };abs_fun(array).map(ColumnarValue::Array)}DataType::Float32 => {@@ -143,11 +186,19 @@ pub fn spark_abs(args: &[ColumnarValue]) -> Result<ColumnarValue, DataFusionErroabs_fun(array).map(ColumnarValue::Array)}DataType::Decimal128(_, _) => {- let abs_fun = make_wrapping_abs_function!(Decimal128Array);+ let abs_fun = if enable_ansi_mode {+ make_try_abs_function!(Decimal128Array)+ } else {+ make_wrapping_abs_function!(Decimal128Array)+ };abs_fun(array).map(ColumnarValue::Array)}DataType::Decimal256(_, _) => {- let abs_fun = make_wrapping_abs_function!(Decimal256Array);+ let abs_fun = if enable_ansi_mode {+ make_try_abs_function!(Decimal256Array)+ } else {+ make_wrapping_abs_function!(Decimal256Array)+ };abs_fun(array).map(ColumnarValue::Array)}dt => internal_err!("Not supported datatype for Spark ABS: {dt}"),@@ -159,10 +210,10 @@ pub fn spark_abs(args: &[ColumnarValue]) -> Result<ColumnarValue, DataFusionErro| ScalarValue::UInt32(_)| ScalarValue::UInt64(_) => Ok(args[0].clone()),sv if sv.is_null() => Ok(args[0].clone()),- ScalarValue::Int8(Some(v)) => scalar_compute_op!(v, Int8),- ScalarValue::Int16(Some(v)) => scalar_compute_op!(v, Int16),- ScalarValue::Int32(Some(v)) => scalar_compute_op!(v, Int32),- ScalarValue::Int64(Some(v)) => scalar_compute_op!(v, Int64),+ ScalarValue::Int8(Some(v)) => scalar_compute_op!(enable_ansi_mode, v, Int8),+ ScalarValue::Int16(Some(v)) => scalar_compute_op!(enable_ansi_mode, v, Int16),+ ScalarValue::Int32(Some(v)) => scalar_compute_op!(enable_ansi_mode, v, Int32),+ ScalarValue::Int64(Some(v)) => scalar_compute_op!(enable_ansi_mode, v, Int64),ScalarValue::Float32(Some(v)) => {Ok(ColumnarValue::Scalar(ScalarValue::Float32(Some(v.abs()))))}@@ -170,10 +221,10 @@ pub fn spark_abs(args: &[ColumnarValue]) -> Result<ColumnarValue, DataFusionErroOk(ColumnarValue::Scalar(ScalarValue::Float64(Some(v.abs()))))}ScalarValue::Decimal128(Some(v), precision, scale) => {- scalar_compute_op!(v, *precision, *scale, Decimal128)+ scalar_compute_op!(enable_ansi_mode, v, *precision, *scale, Decimal128)}ScalarValue::Decimal256(Some(v), precision, scale) => {- scalar_compute_op!(v, *precision, *scale, Decimal256)+ scalar_compute_op!(enable_ansi_mode, v, *precision, *scale, Decimal256)}dt => internal_err!("Not supported datatype for Spark ABS: {dt}"),},@@ -185,100 +236,12 @@ mod tests {use super::*;use arrow::datatypes::i256;- macro_rules! eval_legacy_mode {- ($TYPE:ident, $VAL:expr) => {{- let args = ColumnarValue::Scalar(ScalarValue::$TYPE(Some($VAL)));- match spark_abs(&[args]) {- Ok(ColumnarValue::Scalar(ScalarValue::$TYPE(Some(result)))) => {- assert_eq!(result, $VAL);- }- _ => unreachable!(),- }- }};- ($TYPE:ident, $VAL:expr, $RESULT:expr) => {{- let args = ColumnarValue::Scalar(ScalarValue::$TYPE(Some($VAL)));- match spark_abs(&[args]) {- Ok(ColumnarValue::Scalar(ScalarValue::$TYPE(Some(result)))) => {- assert_eq!(result, $RESULT);- }- _ => unreachable!(),- }- }};- ($TYPE:ident, $VAL:expr, $PRECISION:expr, $SCALE:expr) => {{- let args =- ColumnarValue::Scalar(ScalarValue::$TYPE(Some($VAL), $PRECISION, $SCALE));- match spark_abs(&[args]) {- Ok(ColumnarValue::Scalar(ScalarValue::$TYPE(- Some(result),- precision,- scale,- ))) => {- assert_eq!(result, $VAL);- assert_eq!(precision, $PRECISION);- assert_eq!(scale, $SCALE);- }- _ => unreachable!(),- }- }};- ($TYPE:ident, $VAL:expr, $PRECISION:expr, $SCALE:expr, $RESULT:expr) => {{- let args =- ColumnarValue::Scalar(ScalarValue::$TYPE(Some($VAL), $PRECISION, $SCALE));- match spark_abs(&[args]) {- Ok(ColumnarValue::Scalar(ScalarValue::$TYPE(- Some(result),- precision,- scale,- ))) => {- assert_eq!(result, $RESULT);- assert_eq!(precision, $PRECISION);- assert_eq!(scale, $SCALE);- }- _ => unreachable!(),- }- }};- }-- #[test]- fn test_abs_scalar_legacy_mode() {- // NumericType MIN- eval_legacy_mode!(UInt8, u8::MIN);- eval_legacy_mode!(UInt16, u16::MIN);- eval_legacy_mode!(UInt32, u32::MIN);- eval_legacy_mode!(UInt64, u64::MIN);- eval_legacy_mode!(Int8, i8::MIN);- eval_legacy_mode!(Int16, i16::MIN);- eval_legacy_mode!(Int32, i32::MIN);- eval_legacy_mode!(Int64, i64::MIN);- eval_legacy_mode!(Float32, f32::MIN, f32::MAX);- eval_legacy_mode!(Float64, f64::MIN, f64::MAX);- eval_legacy_mode!(Decimal128, i128::MIN, 18, 10);- eval_legacy_mode!(Decimal256, i256::MIN, 10, 2);-- // NumericType not MIN- eval_legacy_mode!(Int8, -1i8, 1i8);- eval_legacy_mode!(Int16, -1i16, 1i16);- eval_legacy_mode!(Int32, -1i32, 1i32);- eval_legacy_mode!(Int64, -1i64, 1i64);- eval_legacy_mode!(Decimal128, -1i128, 18, 10, 1i128);- eval_legacy_mode!(Decimal256, i256::from(-1i8), 10, 2, i256::from(1i8));-- // Float32, Float64- eval_legacy_mode!(Float32, f32::NEG_INFINITY, f32::INFINITY);- eval_legacy_mode!(Float32, f32::INFINITY, f32::INFINITY);- eval_legacy_mode!(Float32, 0.0f32, 0.0f32);- eval_legacy_mode!(Float32, -0.0f32, 0.0f32);- eval_legacy_mode!(Float64, f64::NEG_INFINITY, f64::INFINITY);- eval_legacy_mode!(Float64, f64::INFINITY, f64::INFINITY);- eval_legacy_mode!(Float64, 0.0f64, 0.0f64);- eval_legacy_mode!(Float64, -0.0f64, 0.0f64);- }-macro_rules! eval_array_legacy_mode {($INPUT:expr, $OUTPUT:expr, $FUNC:ident) => {{let input = $INPUT;let args = ColumnarValue::Array(Arc::new(input));let expected = $OUTPUT;- match spark_abs(&[args]) {+ match spark_abs(&[args], false) {Ok(ColumnarValue::Array(result)) => {let actual = datafusion_common::cast::$FUNC(&result).unwrap();assert_eq!(actual, &expected);@@ -367,24 +330,187 @@ mod tests {);eval_array_legacy_mode!(- Decimal128Array::from(vec![Some(i128::MIN), None])+ Decimal128Array::from(vec![Some(i128::MIN), Some(i128::MIN + 1), None]).with_precision_and_scale(38, 37).unwrap(),- Decimal128Array::from(vec![Some(i128::MIN), None])+ Decimal128Array::from(vec![Some(i128::MIN), Some(i128::MAX), None]).with_precision_and_scale(38, 37).unwrap(),as_decimal128_array);eval_array_legacy_mode!(- Decimal256Array::from(vec![Some(i256::MIN), None])- .with_precision_and_scale(5, 2)+ Decimal256Array::from(vec![+ Some(i256::MIN),+ Some(i256::MINUS_ONE),+ Some(i256::MIN + i256::from(1)),+ None+ ])+ .with_precision_and_scale(5, 2)+ .unwrap(),+ Decimal256Array::from(vec![+ Some(i256::MIN),+ Some(i256::ONE),+ Some(i256::MAX),+ None+ ])+ .with_precision_and_scale(5, 2)+ .unwrap(),+ as_decimal256_array+ );+ }++ macro_rules! eval_array_ansi_mode {+ ($INPUT:expr) => {{+ let input = $INPUT;+ let args = ColumnarValue::Array(Arc::new(input));+ match spark_abs(&[args], true) {+ Err(e) => {+ assert!(+ e.to_string().contains("overflow on abs"),+ "Error message did not match. Actual message: {e}"+ );+ }+ _ => unreachable!(),+ }+ }};+ ($INPUT:expr, $OUTPUT:expr, $FUNC:ident) => {{+ let input = $INPUT;+ let args = ColumnarValue::Array(Arc::new(input));+ let expected = $OUTPUT;+ match spark_abs(&[args], true) {+ Ok(ColumnarValue::Array(result)) => {+ let actual = datafusion_common::cast::$FUNC(&result).unwrap();+ assert_eq!(actual, &expected);+ }+ _ => unreachable!(),+ }+ }};+ }+ #[test]+ fn test_abs_array_ansi_mode() {+ eval_array_ansi_mode!(+ UInt64Array::from(vec![Some(u64::MIN), Some(u64::MAX), None]),+ UInt64Array::from(vec![Some(u64::MIN), Some(u64::MAX), None]),+ as_uint64_array+ );++ eval_array_ansi_mode!(Int8Array::from(vec![+ Some(-1),+ Some(i8::MIN),+ Some(i8::MAX),+ None+ ]));+ eval_array_ansi_mode!(Int16Array::from(vec![+ Some(-1),+ Some(i16::MIN),+ Some(i16::MAX),+ None+ ]));+ eval_array_ansi_mode!(Int32Array::from(vec![+ Some(-1),+ Some(i32::MIN),+ Some(i32::MAX),+ None+ ]));+ eval_array_ansi_mode!(Int64Array::from(vec![+ Some(-1),+ Some(i64::MIN),+ Some(i64::MAX),+ None+ ]));+ eval_array_ansi_mode!(+ Float32Array::from(vec![+ Some(-1f32),+ Some(f32::MIN),+ Some(f32::MAX),+ None,+ Some(f32::NAN),+ Some(f32::INFINITY),+ Some(f32::NEG_INFINITY),+ Some(0.0),+ Some(-0.0),+ ]),+ Float32Array::from(vec![+ Some(1f32),+ Some(f32::MAX),+ Some(f32::MAX),+ None,+ Some(f32::NAN),+ Some(f32::INFINITY),+ Some(f32::INFINITY),+ Some(0.0),+ Some(0.0),+ ]),+ as_float32_array+ );++ eval_array_ansi_mode!(+ Float64Array::from(vec![+ Some(-1f64),+ Some(f64::MIN),+ Some(f64::MAX),+ None,+ Some(f64::NAN),+ Some(f64::INFINITY),+ Some(f64::NEG_INFINITY),+ Some(0.0),+ Some(-0.0),+ ]),+ Float64Array::from(vec![+ Some(1f64),+ Some(f64::MAX),+ Some(f64::MAX),+ None,+ Some(f64::NAN),+ Some(f64::INFINITY),+ Some(f64::INFINITY),+ Some(0.0),+ Some(0.0),+ ]),+ as_float64_array+ );++ // decimal: no arithmetic overflow+ eval_array_ansi_mode!(+ Decimal128Array::from(vec![Some(-1), Some(-2), Some(i128::MIN + 1)])+ .with_precision_and_scale(38, 37).unwrap(),- Decimal256Array::from(vec![Some(i256::MIN), None])- .with_precision_and_scale(5, 2)+ Decimal128Array::from(vec![Some(1), Some(2), Some(i128::MAX)])+ .with_precision_and_scale(38, 37).unwrap(),+ as_decimal128_array+ );++ eval_array_ansi_mode!(+ Decimal256Array::from(vec![+ Some(i256::MINUS_ONE),+ Some(i256::from(-2)),+ Some(i256::MIN + i256::from(1))+ ])+ .with_precision_and_scale(18, 7)+ .unwrap(),+ Decimal256Array::from(vec![+ Some(i256::ONE),+ Some(i256::from(2)),+ Some(i256::MAX)+ ])+ .with_precision_and_scale(18, 7)+ .unwrap(),as_decimal256_array);++ // decimal: arithmetic overflow+ eval_array_ansi_mode!(+ Decimal128Array::from(vec![Some(i128::MIN), None])+ .with_precision_and_scale(38, 37)+ .unwrap()+ );+ eval_array_ansi_mode!(+ Decimal256Array::from(vec![Some(i256::MIN), None])+ .with_precision_and_scale(5, 2)+ .unwrap()+ );}#[test]diff --git a/datafusion/sqllogictest/test_files/spark/README.md b/datafusion/sqllogictest/test_files/spark/README.mdindex cffd280098..e61001c6e4 100644--- a/datafusion/sqllogictest/test_files/spark/README.md+++ b/datafusion/sqllogictest/test_files/spark/README.md@@ -39,6 +39,18 @@ When testing Spark functions:- Test cases should only contain `SELECT` statements with the function being tested- Add explicit casts to input values to ensure the correct data type is used (e.g., `0::INT`)- Explicit casting is necessary because DataFusion and Spark do not infer data types in the same way+- If the Spark built-in function under test behaves differently in ANSI SQL mode, please wrap your test cases like this example:++```sql+statement ok+set datafusion.execution.enable_ansi_mode = true;++# Functions under test+select abs((-128)::TINYINT)++statement ok+set datafusion.execution.enable_ansi_mode = false;+```### Finding Test Casesdiff --git a/datafusion/sqllogictest/test_files/spark/math/abs.slt b/datafusion/sqllogictest/test_files/spark/math/abs.sltindex 19ca902ea3..94092caab9 100644--- a/datafusion/sqllogictest/test_files/spark/math/abs.slt+++ b/datafusion/sqllogictest/test_files/spark/math/abs.slt@@ -24,71 +24,187 @@## Original Query: SELECT abs(-1);## PySpark 3.5.5 Result: {'abs(-1)': 1, 'typeof(abs(-1))': 'int', 'typeof(-1)': 'int'}-# abs: signed int and NULL+# Scalar input+## Scalar input: signed int and NULLquery IIIIRSELECT abs(-127::TINYINT), abs(-32767::SMALLINT), abs(-2147483647::INT), abs(-9223372036854775807::BIGINT), abs(NULL);----127 32767 2147483647 9223372036854775807 NULL--# See https://github.com/apache/datafusion/issues/18794 for operator precedence-# abs: signed int minimal values+## Scalar input: signed int minimal values+## See https://github.com/apache/datafusion/issues/18794 for operator precedencequery IIII-select abs((-128)::TINYINT), abs((-32768)::SMALLINT), abs((-2147483648)::INT), abs((-9223372036854775808)::BIGINT)+select abs((-128)::TINYINT), abs((-32768)::SMALLINT), abs((-2147483648)::INT), abs((-9223372036854775808)::BIGINT);-----128 -32768 -2147483648 -9223372036854775808-# abs: floats, NULL, NaN, -0, infinity, -infinity+## Scalar input: Spark ANSI mode, signed int minimal values+statement ok+set datafusion.execution.enable_ansi_mode = true;++query error DataFusion error: Arrow error: Compute error: Int8 overflow on abs\(\-128\)+select abs((-128)::TINYINT);++query error DataFusion error: Arrow error: Compute error: Int16 overflow on abs\(\-32768\)+select abs((-32768)::SMALLINT);++query error DataFusion error: Arrow error: Compute error: Int32 overflow on abs\(\-2147483648\)+select abs((-2147483648)::INT);++query error DataFusion error: Arrow error: Compute error: Int64 overflow on abs\(\-9223372036854775808\)+select abs((-9223372036854775808)::BIGINT);++statement ok+set datafusion.execution.enable_ansi_mode = false;++## Scalar input: float, NULL, NaN, -0, infinity, -infinityquery RRRRRRRRRRRR-SELECT abs(-1.0::FLOAT), abs(0.::FLOAT), abs(-0.::FLOAT), abs(-0::FLOAT), abs(NULL::FLOAT), abs('NaN'::FLOAT), abs('inf'::FLOAT), abs('+inf'::FLOAT), abs('-inf'::FLOAT), abs('infinity'::FLOAT), abs('+infinity'::FLOAT), abs('-infinity'::FLOAT)+SELECT abs(-1.0::FLOAT), abs(0.::FLOAT), abs(-0.::FLOAT), abs(-0::FLOAT), abs(NULL::FLOAT), abs('NaN'::FLOAT), abs('inf'::FLOAT), abs('+inf'::FLOAT), abs('-inf'::FLOAT), abs('infinity'::FLOAT), abs('+infinity'::FLOAT), abs('-infinity'::FLOAT);----1 0 0 0 NULL NaN Infinity Infinity Infinity Infinity Infinity Infinity-# abs: doubles, NULL, NaN, -0, infinity, -infinity+## Scalar input: double, NULL, NaN, -0, infinity, -infinityquery RRRRRRRRRRRR-SELECT abs(-1.0::DOUBLE), abs(0.::DOUBLE), abs(-0.::DOUBLE), abs(-0::DOUBLE), abs(NULL::DOUBLE), abs('NaN'::DOUBLE), abs('inf'::DOUBLE), abs('+inf'::DOUBLE), abs('-inf'::DOUBLE), abs('infinity'::DOUBLE), abs('+infinity'::DOUBLE), abs('-infinity'::DOUBLE)+SELECT abs(-1.0::DOUBLE), abs(0.::DOUBLE), abs(-0.::DOUBLE), abs(-0::DOUBLE), abs(NULL::DOUBLE), abs('NaN'::DOUBLE), abs('inf'::DOUBLE), abs('+inf'::DOUBLE), abs('-inf'::DOUBLE), abs('infinity'::DOUBLE), abs('+infinity'::DOUBLE), abs('-infinity'::DOUBLE);----1 0 0 0 NULL NaN Infinity Infinity Infinity Infinity Infinity Infinity-# abs: decimal128 and decimal256-statement ok-CREATE TABLE test_nullable_decimal(- c1 DECIMAL(10, 2), /* Decimal128 */- c2 DECIMAL(38, 10), /* Decimal128 with max precision */- c3 DECIMAL(40, 2), /* Decimal256 */- c4 DECIMAL(76, 10) /* Decimal256 with max precision */- ) AS VALUES- (0, 0, 0, 0),- (NULL, NULL, NULL, NULL);+## Scalar input: decimal128+query RRR+SELECT abs(('-99999999.99')::DECIMAL(10, 2)), abs(0::DECIMAL(10, 2)), abs(NULL::DECIMAL(10, 2));+----+99999999.99 0 NULL++query RRR+SELECT abs(('-9999999999999999999999999999.9999999999')::DECIMAL(38, 10)), abs(0::DECIMAL(38, 10)), abs(NULL::DECIMAL(38, 10));+----+9999999999999999999999999999.9999999999 0 NULL++## Scalar input: decimal256+query RRR+SELECT abs(('-99999999999999999999999999999999999999.99')::DECIMAL(40, 2)), abs(0::DECIMAL(40, 2)), abs(NULL::DECIMAL(40, 2));+----+99999999999999999999999999999999999999.99 0 NULL++query RRR+SELECT abs(('-999999999999999999999999999999999999999999999999999999999999999999.9999999999')::DECIMAL(76, 10)), abs(0::DECIMAL(76, 10)), abs(NULL::DECIMAL(76, 10));+----+999999999999999999999999999999999999999999999999999999999999999999.9999999999 0 NULL+++# Array input+## Array input: signed int, signed int minimal values and NULL+query I+SELECT abs(a) FROM (VALUES (-127::TINYINT), ((-128)::TINYINT), (NULL)) AS t(a);+----+127+-128+NULL++query I+select abs(a) FROM (VALUES (-32767::SMALLINT), ((-32768)::SMALLINT), (NULL)) AS t(a);+----+32767+-32768+NULL++query I+select abs(a) FROM (VALUES (-2147483647::INT), ((-2147483648)::INT), (NULL)) AS t(a);+----+2147483647+-2147483648+NULLquery I-INSERT into test_nullable_decimal values- (- -99999999.99,- '-9999999999999999999999999999.9999999999',- '-99999999999999999999999999999999999999.99',- '-999999999999999999999999999999999999999999999999999999999999999999.9999999999'- ),- (- 99999999.99,- '9999999999999999999999999999.9999999999',- '99999999999999999999999999999999999999.99',- '999999999999999999999999999999999999999999999999999999999999999999.9999999999'- )------2--query RRRR rowsort-SELECT abs(c1), abs(c2), abs(c3), abs(c4) FROM test_nullable_decimal------0 0 0 0-99999999.99 9999999999999999999999999999.9999999999 99999999999999999999999999999999999999.99 999999999999999999999999999999999999999999999999999999999999999999.9999999999-99999999.99 9999999999999999999999999999.9999999999 99999999999999999999999999999999999999.99 999999999999999999999999999999999999999999999999999999999999999999.9999999999-NULL NULL NULL NULL+select abs(a) FROM (VALUES (-9223372036854775807::BIGINT), ((-9223372036854775808)::BIGINT), (NULL)) AS t(a);+----+9223372036854775807+-9223372036854775808+NULL++## Array Input: Spark ANSI mode, signed int minimal values+statement ok+set datafusion.execution.enable_ansi_mode = true;++query error DataFusion error: Arrow error: Compute error: Int8Array overflow on abs\(\-128\)+SELECT abs(a) FROM (VALUES (-127::TINYINT), ((-128)::TINYINT)) AS t(a);++query error DataFusion error: Arrow error: Compute error: Int16Array overflow on abs\(\-32768\)+select abs(a) FROM (VALUES (-32767::SMALLINT), ((-32768)::SMALLINT)) AS t(a);+query error DataFusion error: Arrow error: Compute error: Int32Array overflow on abs\(\-2147483648\)+select abs(a) FROM (VALUES (-2147483647::INT), ((-2147483648)::INT)) AS t(a);++query error DataFusion error: Arrow error: Compute error: Int64Array overflow on abs\(\-9223372036854775808\)+select abs(a) FROM (VALUES (-9223372036854775807::BIGINT), ((-9223372036854775808)::BIGINT)) AS t(a);statement ok-drop table test_nullable_decimal+set datafusion.execution.enable_ansi_mode = false;++## Array input: float, NULL, NaN, -0, infinity, -infinity+query R+SELECT abs(a) FROM (VALUES (-1.0::FLOAT), (0.::FLOAT), (-0.::FLOAT), (-0::FLOAT), (NULL::FLOAT), ('NaN'::FLOAT), ('inf'::FLOAT), ('+inf'::FLOAT), ('-inf'::FLOAT), ('infinity'::FLOAT), ('+infinity'::FLOAT), ('-infinity'::FLOAT)) AS t(a);+----+1+0+0+0+NULL+NaN+Infinity+Infinity+Infinity+Infinity+Infinity+Infinity+++## Array input: double, NULL, NaN, -0, infinity, -infinity+query R+SELECT abs(a) FROM (VALUES (-1.0::DOUBLE), (0.::DOUBLE), (-0.::DOUBLE), (-0::DOUBLE), (NULL::DOUBLE), ('NaN'::DOUBLE), ('inf'::DOUBLE), ('+inf'::DOUBLE), ('-inf'::DOUBLE), ('infinity'::DOUBLE), ('+infinity'::DOUBLE), ('-infinity'::DOUBLE)) AS t(a);+----+1+0+0+0+NULL+NaN+Infinity+Infinity+Infinity+Infinity+Infinity+Infinity++## Array input: decimal128+query R+SELECT abs(a) FROM (VALUES (('-99999999.99')::DECIMAL(10, 2)), (0::DECIMAL(10, 2)), (NULL::DECIMAL(10, 2))) AS t(a);+----+99999999.99+0+NULL++query R+SELECT abs(a) FROM (VALUES (('-9999999999999999999999999999.9999999999')::DECIMAL(38, 10)), (0::DECIMAL(38, 10)), (NULL::DECIMAL(38, 10))) AS t(a);+----+9999999999999999999999999999.9999999999+0+NULL++## Array input: decimal256+query R+SELECT abs(a) FROM (VALUES (('-99999999999999999999999999999999999999.99')::DECIMAL(40, 2)), (0::DECIMAL(40, 2)), (NULL::DECIMAL(40, 2))) AS t(a);+----+99999999999999999999999999999999999999.99+0+NULL++query R+SELECT abs(a) FROM (VALUES (('-999999999999999999999999999999999999999999999999999999999999999999.9999999999')::DECIMAL(76, 10)), (0::DECIMAL(76, 10)), (NULL::DECIMAL(76, 10))) AS t(a);+----+999999999999999999999999999999999999999999999999999999999999999999.9999999999+0+NULL## Original Query: SELECT abs(INTERVAL -'1-1' YEAR TO MONTH);## PySpark 3.5.5 Result: {"abs(INTERVAL '-1-1' YEAR TO MONTH)": 13, "typeof(abs(INTERVAL '-1-1' YEAR TO MONTH))": 'interval year to month', "typeof(INTERVAL '-1-1' YEAR TO MONTH)": 'interval year to month'}