Skip to content

Apache DataFusion SQL Query Engine

Refactor scalar min/max dispatch into function-based helpers (#22062)

kosiewd096558bd2ca
diff --git a/datafusion/functions-aggregate-common/src/min_max.rs b/datafusion/functions-aggregate-common/src/min_max.rs
index a9764d6ac6..2c381faccc 100644
--- a/datafusion/functions-aggregate-common/src/min_max.rs
+++ b/datafusion/functions-aggregate-common/src/min_max.rs
@@ -37,443 +37,357 @@ use datafusion_common::{
use datafusion_expr_common::accumulator::Accumulator;
use std::{cmp::Ordering, mem::size_of_val};
-// min/max of two non-string scalar values.
-macro_rules! typed_min_max {
- ($VALUE:expr, $DELTA:expr, $SCALAR:ident, $OP:ident $(, $EXTRA_ARGS:ident)*) => {{
- ScalarValue::$SCALAR(
- match ($VALUE, $DELTA) {
- (None, None) => None,
- (Some(a), None) => Some(*a),
- (None, Some(b)) => Some(*b),
- (Some(a), Some(b)) => Some((*a).$OP(*b)),
- },
- $($EXTRA_ARGS.clone()),*
- )
- }};
+macro_rules! choose_min_max {
+ (min) => {
+ std::cmp::Ordering::Greater
+ };
+ (max) => {
+ std::cmp::Ordering::Less
+ };
}
-macro_rules! typed_min_max_float {
- ($VALUE:expr, $DELTA:expr, $SCALAR:ident, $OP:ident) => {{
- ScalarValue::$SCALAR(match ($VALUE, $DELTA) {
- (None, None) => None,
- (Some(a), None) => Some(*a),
- (None, Some(b)) => Some(*b),
- (Some(a), Some(b)) => match a.total_cmp(b) {
- choose_min_max!($OP) => Some(*b),
- _ => Some(*a),
- },
- })
- }};
+macro_rules! min_max {
+ ($VALUE:expr, $DELTA:expr, $OP:ident) => {{ min_max_scalar($VALUE, $DELTA, choose_min_max!($OP)) }};
}
-// min/max of two scalar string values.
-macro_rules! typed_min_max_string {
- ($VALUE:expr, $DELTA:expr, $SCALAR:ident, $OP:ident) => {{
- ScalarValue::$SCALAR(match ($VALUE, $DELTA) {
- (None, None) => None,
- (Some(a), None) => Some(a.clone()),
- (None, Some(b)) => Some(b.clone()),
- (Some(a), Some(b)) => Some((a).$OP(b).clone()),
- })
- }};
+fn min_max_option<T: Clone + Ord>(
+ lhs: &Option<T>,
+ rhs: &Option<T>,
+ ordering: Ordering,
+) -> Option<T> {
+ match (lhs, rhs) {
+ (None, None) => None,
+ (Some(a), None) => Some(a.clone()),
+ (None, Some(b)) => Some(b.clone()),
+ (Some(a), Some(b)) if a.cmp(b) == ordering => Some(b.clone()),
+ (Some(a), Some(_)) => Some(a.clone()),
+ }
}
-// min/max of two scalar string values with a prefix argument.
-macro_rules! typed_min_max_string_arg {
- ($VALUE:expr, $DELTA:expr, $SCALAR:ident, $OP:ident, $ARG:expr) => {{
- ScalarValue::$SCALAR(
- $ARG,
- match ($VALUE, $DELTA) {
- (None, None) => None,
- (Some(a), None) => Some(a.clone()),
- (None, Some(b)) => Some(b.clone()),
- (Some(a), Some(b)) => Some((a).$OP(b).clone()),
- },
- )
- }};
+fn min_max_float_option<T: Copy>(
+ lhs: &Option<T>,
+ rhs: &Option<T>,
+ ordering: Ordering,
+ cmp: impl Fn(&T, &T) -> Ordering,
+) -> Option<T> {
+ match (lhs, rhs) {
+ (None, None) => None,
+ (Some(a), None) => Some(*a),
+ (None, Some(b)) => Some(*b),
+ (Some(a), Some(b)) if cmp(a, b) == ordering => Some(*b),
+ (Some(a), Some(_)) => Some(*a),
+ }
}
-macro_rules! choose_min_max {
- (min) => {
- std::cmp::Ordering::Greater
- };
- (max) => {
- std::cmp::Ordering::Less
- };
+fn ensure_decimal_compatibility(
+ lhs: &ScalarValue,
+ rhs: &ScalarValue,
+ lhs_type: (u8, i8),
+ rhs_type: (u8, i8),
+) -> Result<()> {
+ if lhs_type == rhs_type {
+ Ok(())
+ } else {
+ internal_err!(
+ "MIN/MAX is not expected to receive scalars of incompatible types {:?}",
+ (lhs, rhs)
+ )
+ }
}
-macro_rules! interval_min_max {
- ($OP:tt, $LHS:expr, $RHS:expr) => {{
- match $LHS.partial_cmp(&$RHS) {
- Some(choose_min_max!($OP)) => $RHS.clone(),
- Some(_) => $LHS.clone(),
- None => {
- return internal_err!(
- "Comparison error while computing interval min/max"
- );
- }
+fn min_max_generic_scalar(
+ lhs: &ScalarValue,
+ rhs: &ScalarValue,
+ ordering: Ordering,
+) -> ScalarValue {
+ if lhs.is_null() {
+ let mut rhs_copy = rhs.clone();
+ // When the new value won we want to compact it to
+ // avoid storing the entire input
+ rhs_copy.compact();
+ rhs_copy
+ } else if rhs.is_null() {
+ lhs.clone()
+ } else {
+ match lhs.partial_cmp(rhs) {
+ Some(order) if order == ordering => {
+ // When the new value won we want to compact it to
+ // avoid storing the entire input
+ let mut rhs_copy = rhs.clone();
+ rhs_copy.compact();
+ rhs_copy
+ }
+ _ => lhs.clone(),
}
- }};
+ }
}
-macro_rules! min_max_generic {
- ($VALUE:expr, $DELTA:expr, $OP:ident) => {{
- if $VALUE.is_null() {
- let mut delta_copy = $DELTA.clone();
- // When the new value won we want to compact it to
- // avoid storing the entire input
- delta_copy.compact();
- delta_copy
- } else if $DELTA.is_null() {
- $VALUE.clone()
- } else {
- match $VALUE.partial_cmp(&$DELTA) {
- Some(choose_min_max!($OP)) => {
- // When the new value won we want to compact it to
- // avoid storing the entire input
- let mut delta_copy = $DELTA.clone();
- delta_copy.compact();
- delta_copy
- }
- _ => $VALUE.clone(),
- }
- }
- }};
+fn min_max_interval_scalar(
+ lhs: &ScalarValue,
+ rhs: &ScalarValue,
+ ordering: Ordering,
+) -> Result<ScalarValue> {
+ match lhs.partial_cmp(rhs) {
+ Some(order) if order == ordering => Ok(rhs.clone()),
+ Some(_) => Ok(lhs.clone()),
+ None => internal_err!("Comparison error while computing interval min/max"),
+ }
}
-macro_rules! min_max {
- ($VALUE:expr, $DELTA:expr, $OP:ident) => {{
- match choose_min_max!($OP) {
- Ordering::Greater => Ok(min_max_scalar_impl!($VALUE, $DELTA, min)),
- Ordering::Less => Ok(min_max_scalar_impl!($VALUE, $DELTA, max)),
- Ordering::Equal => {
- unreachable!("min/max comparisons do not use equal ordering")
+fn min_max_dictionary_scalar(
+ lhs: &ScalarValue,
+ rhs: &ScalarValue,
+ ordering: Ordering,
+) -> Result<Option<ScalarValue>> {
+ match (lhs, rhs) {
+ (
+ ScalarValue::Dictionary(lhs_dict_key_type, lhs_dict_value),
+ ScalarValue::Dictionary(rhs_dict_key_type, rhs_dict_value),
+ ) => {
+ if lhs_dict_key_type != rhs_dict_key_type {
+ return internal_err!(
+ "MIN/MAX is not expected to receive dictionary scalars with different key types ({:?} vs {:?})",
+ lhs_dict_key_type,
+ rhs_dict_key_type
+ );
}
+
+ let result = min_max_scalar(
+ lhs_dict_value.as_ref(),
+ rhs_dict_value.as_ref(),
+ ordering,
+ )?;
+ Ok(Some(ScalarValue::Dictionary(
+ lhs_dict_key_type.clone(),
+ Box::new(result),
+ )))
}
- }};
+ (ScalarValue::Dictionary(_, lhs_dict_value), rhs_scalar) => {
+ min_max_scalar(lhs_dict_value.as_ref(), rhs_scalar, ordering).map(Some)
+ }
+ (lhs_scalar, ScalarValue::Dictionary(_, rhs_dict_value)) => {
+ min_max_scalar(lhs_scalar, rhs_dict_value.as_ref(), ordering).map(Some)
+ }
+ _ => Ok(None),
+ }
}
// min/max of two logically compatible scalar values.
// Dictionary scalars participate by comparing their inner logical values.
// When both inputs are dictionaries, matching key types are preserved in the
// result; differing key types remain an unexpected invariant violation.
-macro_rules! min_max_scalar_impl {
- ($VALUE:expr, $DELTA:expr, $OP:ident) => {{
- match ($VALUE, $DELTA) {
- (ScalarValue::Null, ScalarValue::Null) => ScalarValue::Null,
- (
- lhs @ ScalarValue::Decimal32(lhsv, lhsp, lhss),
- rhs @ ScalarValue::Decimal32(rhsv, rhsp, rhss)
- ) => {
- if lhsp.eq(rhsp) && lhss.eq(rhss) {
- typed_min_max!(lhsv, rhsv, Decimal32, $OP, lhsp, lhss)
- } else {
- return internal_err!(
- "MIN/MAX is not expected to receive scalars of incompatible types {:?}",
- (lhs, rhs)
- );
- }
- }
- (
- lhs @ ScalarValue::Decimal64(lhsv, lhsp, lhss),
- rhs @ ScalarValue::Decimal64(rhsv, rhsp, rhss)
- ) => {
- if lhsp.eq(rhsp) && lhss.eq(rhss) {
- typed_min_max!(lhsv, rhsv, Decimal64, $OP, lhsp, lhss)
- } else {
- return internal_err!(
- "MIN/MAX is not expected to receive scalars of incompatible types {:?}",
- (lhs, rhs)
- );
- }
- }
- (
- lhs @ ScalarValue::Decimal128(lhsv, lhsp, lhss),
- rhs @ ScalarValue::Decimal128(rhsv, rhsp, rhss)
- ) => {
- if lhsp.eq(rhsp) && lhss.eq(rhss) {
- typed_min_max!(lhsv, rhsv, Decimal128, $OP, lhsp, lhss)
- } else {
- return internal_err!(
- "MIN/MAX is not expected to receive scalars of incompatible types {:?}",
- (lhs, rhs)
- );
- }
- }
- (
- lhs @ ScalarValue::Decimal256(lhsv, lhsp, lhss),
- rhs @ ScalarValue::Decimal256(rhsv, rhsp, rhss)
- ) => {
- if lhsp.eq(rhsp) && lhss.eq(rhss) {
- typed_min_max!(lhsv, rhsv, Decimal256, $OP, lhsp, lhss)
- } else {
- return internal_err!(
- "MIN/MAX is not expected to receive scalars of incompatible types {:?}",
- (lhs, rhs)
- );
- }
- }
- (ScalarValue::Boolean(lhs), ScalarValue::Boolean(rhs)) => {
- typed_min_max!(lhs, rhs, Boolean, $OP)
- }
- (ScalarValue::Float64(lhs), ScalarValue::Float64(rhs)) => {
- typed_min_max_float!(lhs, rhs, Float64, $OP)
- }
- (ScalarValue::Float32(lhs), ScalarValue::Float32(rhs)) => {
- typed_min_max_float!(lhs, rhs, Float32, $OP)
- }
- (ScalarValue::Float16(lhs), ScalarValue::Float16(rhs)) => {
- typed_min_max_float!(lhs, rhs, Float16, $OP)
- }
- (ScalarValue::UInt64(lhs), ScalarValue::UInt64(rhs)) => {
- typed_min_max!(lhs, rhs, UInt64, $OP)
- }
- (ScalarValue::UInt32(lhs), ScalarValue::UInt32(rhs)) => {
- typed_min_max!(lhs, rhs, UInt32, $OP)
- }
- (ScalarValue::UInt16(lhs), ScalarValue::UInt16(rhs)) => {
- typed_min_max!(lhs, rhs, UInt16, $OP)
- }
- (ScalarValue::UInt8(lhs), ScalarValue::UInt8(rhs)) => {
- typed_min_max!(lhs, rhs, UInt8, $OP)
- }
- (ScalarValue::Int64(lhs), ScalarValue::Int64(rhs)) => {
- typed_min_max!(lhs, rhs, Int64, $OP)
- }
- (ScalarValue::Int32(lhs), ScalarValue::Int32(rhs)) => {
- typed_min_max!(lhs, rhs, Int32, $OP)
- }
- (ScalarValue::Int16(lhs), ScalarValue::Int16(rhs)) => {
- typed_min_max!(lhs, rhs, Int16, $OP)
- }
- (ScalarValue::Int8(lhs), ScalarValue::Int8(rhs)) => {
- typed_min_max!(lhs, rhs, Int8, $OP)
- }
- (ScalarValue::Utf8(lhs), ScalarValue::Utf8(rhs)) => {
- typed_min_max_string!(lhs, rhs, Utf8, $OP)
- }
- (ScalarValue::LargeUtf8(lhs), ScalarValue::LargeUtf8(rhs)) => {
- typed_min_max_string!(lhs, rhs, LargeUtf8, $OP)
- }
- (ScalarValue::Utf8View(lhs), ScalarValue::Utf8View(rhs)) => {
- typed_min_max_string!(lhs, rhs, Utf8View, $OP)
- }
- (ScalarValue::Binary(lhs), ScalarValue::Binary(rhs)) => {
- typed_min_max_string!(lhs, rhs, Binary, $OP)
- }
- (ScalarValue::LargeBinary(lhs), ScalarValue::LargeBinary(rhs)) => {
- typed_min_max_string!(lhs, rhs, LargeBinary, $OP)
- }
- (ScalarValue::FixedSizeBinary(lsize, lhs), ScalarValue::FixedSizeBinary(rsize, rhs)) => {
- if lsize == rsize {
- typed_min_max_string_arg!(lhs, rhs, FixedSizeBinary, $OP, *lsize)
- }
- else {
- return internal_err!(
- "MIN/MAX is not expected to receive FixedSizeBinary of incompatible sizes {:?}",
- (lsize, rsize))
- }
- }
- (ScalarValue::BinaryView(lhs), ScalarValue::BinaryView(rhs)) => {
- typed_min_max_string!(lhs, rhs, BinaryView, $OP)
- }
- (ScalarValue::TimestampSecond(lhs, l_tz), ScalarValue::TimestampSecond(rhs, _)) => {
- typed_min_max!(lhs, rhs, TimestampSecond, $OP, l_tz)
- }
- (
- ScalarValue::TimestampMillisecond(lhs, l_tz),
- ScalarValue::TimestampMillisecond(rhs, _),
- ) => {
- typed_min_max!(lhs, rhs, TimestampMillisecond, $OP, l_tz)
- }
- (
- ScalarValue::TimestampMicrosecond(lhs, l_tz),
- ScalarValue::TimestampMicrosecond(rhs, _),
- ) => {
- typed_min_max!(lhs, rhs, TimestampMicrosecond, $OP, l_tz)
- }
- (
- ScalarValue::TimestampNanosecond(lhs, l_tz),
- ScalarValue::TimestampNanosecond(rhs, _),
- ) => {
- typed_min_max!(lhs, rhs, TimestampNanosecond, $OP, l_tz)
- }
- (
- ScalarValue::Date32(lhs),
- ScalarValue::Date32(rhs),
- ) => {
- typed_min_max!(lhs, rhs, Date32, $OP)
- }
- (
- ScalarValue::Date64(lhs),
- ScalarValue::Date64(rhs),
- ) => {
- typed_min_max!(lhs, rhs, Date64, $OP)
- }
- (
- ScalarValue::Time32Second(lhs),
- ScalarValue::Time32Second(rhs),
- ) => {
- typed_min_max!(lhs, rhs, Time32Second, $OP)
- }
- (
- ScalarValue::Time32Millisecond(lhs),
- ScalarValue::Time32Millisecond(rhs),
- ) => {
- typed_min_max!(lhs, rhs, Time32Millisecond, $OP)
- }
- (
- ScalarValue::Time64Microsecond(lhs),
- ScalarValue::Time64Microsecond(rhs),
- ) => {
- typed_min_max!(lhs, rhs, Time64Microsecond, $OP)
- }
- (
- ScalarValue::Time64Nanosecond(lhs),
- ScalarValue::Time64Nanosecond(rhs),
- ) => {
- typed_min_max!(lhs, rhs, Time64Nanosecond, $OP)
- }
- (
- ScalarValue::IntervalYearMonth(lhs),
- ScalarValue::IntervalYearMonth(rhs),
- ) => {
- typed_min_max!(lhs, rhs, IntervalYearMonth, $OP)
- }
- (
- ScalarValue::IntervalMonthDayNano(lhs),
- ScalarValue::IntervalMonthDayNano(rhs),
- ) => {
- typed_min_max!(lhs, rhs, IntervalMonthDayNano, $OP)
- }
- (
- ScalarValue::IntervalDayTime(lhs),
- ScalarValue::IntervalDayTime(rhs),
- ) => {
- typed_min_max!(lhs, rhs, IntervalDayTime, $OP)
- }
- (
- ScalarValue::IntervalYearMonth(_),
- ScalarValue::IntervalMonthDayNano(_),
- ) | (
- ScalarValue::IntervalYearMonth(_),
- ScalarValue::IntervalDayTime(_),
- ) | (
- ScalarValue::IntervalMonthDayNano(_),
- ScalarValue::IntervalDayTime(_),
- ) | (
- ScalarValue::IntervalMonthDayNano(_),
- ScalarValue::IntervalYearMonth(_),
- ) | (
- ScalarValue::IntervalDayTime(_),
- ScalarValue::IntervalYearMonth(_),
- ) | (
- ScalarValue::IntervalDayTime(_),
- ScalarValue::IntervalMonthDayNano(_),
- ) => {
- interval_min_max!($OP, $VALUE, $DELTA)
- }
- (
- ScalarValue::DurationSecond(lhs),
- ScalarValue::DurationSecond(rhs),
- ) => {
- typed_min_max!(lhs, rhs, DurationSecond, $OP)
- }
- (
- ScalarValue::DurationMillisecond(lhs),
- ScalarValue::DurationMillisecond(rhs),
- ) => {
- typed_min_max!(lhs, rhs, DurationMillisecond, $OP)
- }
- (
- ScalarValue::DurationMicrosecond(lhs),
- ScalarValue::DurationMicrosecond(rhs),
- ) => {
- typed_min_max!(lhs, rhs, DurationMicrosecond, $OP)
- }
- (
- ScalarValue::DurationNanosecond(lhs),
- ScalarValue::DurationNanosecond(rhs),
- ) => {
- typed_min_max!(lhs, rhs, DurationNanosecond, $OP)
- }
-
- (
- lhs @ ScalarValue::Struct(_),
- rhs @ ScalarValue::Struct(_),
- ) => {
- min_max_generic!(lhs, rhs, $OP)
- }
-
- (
- lhs @ ScalarValue::List(_),
- rhs @ ScalarValue::List(_),
- ) => {
- min_max_generic!(lhs, rhs, $OP)
- }
-
-
- (
- lhs @ ScalarValue::LargeList(_),
- rhs @ ScalarValue::LargeList(_),
- ) => {
- min_max_generic!(lhs, rhs, $OP)
- }
-
-
- (
- lhs @ ScalarValue::FixedSizeList(_),
- rhs @ ScalarValue::FixedSizeList(_),
- ) => {
- min_max_generic!(lhs, rhs, $OP)
- }
+fn min_max_scalar(
+ lhs: &ScalarValue,
+ rhs: &ScalarValue,
+ ordering: Ordering,
+) -> Result<ScalarValue> {
+ if ordering == Ordering::Equal {
+ unreachable!("min/max comparisons do not use equal ordering");
+ }
- (
- ScalarValue::Dictionary(lhs_dict_key_type, lhs_dict_value),
- ScalarValue::Dictionary(rhs_dict_key_type, rhs_dict_value),
- ) => {
- if lhs_dict_key_type != rhs_dict_key_type {
- return internal_err!(
- "MIN/MAX is not expected to receive dictionary scalars with different key types ({:?} vs {:?})",
- lhs_dict_key_type,
- rhs_dict_key_type
- );
- }
-
- let result = min_max_scalar(
- lhs_dict_value.as_ref(),
- rhs_dict_value.as_ref(),
- choose_min_max!($OP),
- )?;
- ScalarValue::Dictionary(lhs_dict_key_type.clone(), Box::new(result))
- }
- (ScalarValue::Dictionary(_, lhs_dict_value), rhs_scalar) => {
- min_max_scalar(lhs_dict_value.as_ref(), rhs_scalar, choose_min_max!($OP))?
- }
- (lhs_scalar, ScalarValue::Dictionary(_, rhs_dict_value)) => {
- min_max_scalar(lhs_scalar, rhs_dict_value.as_ref(), choose_min_max!($OP))?
- }
+ if let Some(result) = min_max_dictionary_scalar(lhs, rhs, ordering)? {
+ return Ok(result);
+ }
- e => {
- return internal_err!(
- "MIN/MAX is not expected to receive logically incompatible scalar values {:?}",
- e
- )
- }
- }
- }};
+ min_max_scalar_same_variant(lhs, rhs, ordering)
}
-fn min_max_scalar(
+fn min_max_scalar_same_variant(
lhs: &ScalarValue,
rhs: &ScalarValue,
ordering: Ordering,
) -> Result<ScalarValue> {
- match ordering {
- Ordering::Greater => Ok(min_max_scalar_impl!(lhs, rhs, min)),
- Ordering::Less => Ok(min_max_scalar_impl!(lhs, rhs, max)),
- Ordering::Equal => unreachable!("min/max comparisons do not use equal ordering"),
- }
+ let result = match (lhs, rhs) {
+ (ScalarValue::Null, ScalarValue::Null) => ScalarValue::Null,
+ (
+ ScalarValue::Decimal32(lhsv, lhsp, lhss),
+ ScalarValue::Decimal32(rhsv, rhsp, rhss),
+ ) => {
+ ensure_decimal_compatibility(lhs, rhs, (*lhsp, *lhss), (*rhsp, *rhss))?;
+ ScalarValue::Decimal32(min_max_option(lhsv, rhsv, ordering), *lhsp, *lhss)
+ }
+ (
+ ScalarValue::Decimal64(lhsv, lhsp, lhss),
+ ScalarValue::Decimal64(rhsv, rhsp, rhss),
+ ) => {
+ ensure_decimal_compatibility(lhs, rhs, (*lhsp, *lhss), (*rhsp, *rhss))?;
+ ScalarValue::Decimal64(min_max_option(lhsv, rhsv, ordering), *lhsp, *lhss)
+ }
+ (
+ ScalarValue::Decimal128(lhsv, lhsp, lhss),
+ ScalarValue::Decimal128(rhsv, rhsp, rhss),
+ ) => {
+ ensure_decimal_compatibility(lhs, rhs, (*lhsp, *lhss), (*rhsp, *rhss))?;
+ ScalarValue::Decimal128(min_max_option(lhsv, rhsv, ordering), *lhsp, *lhss)
+ }
+ (
+ ScalarValue::Decimal256(lhsv, lhsp, lhss),
+ ScalarValue::Decimal256(rhsv, rhsp, rhss),
+ ) => {
+ ensure_decimal_compatibility(lhs, rhs, (*lhsp, *lhss), (*rhsp, *rhss))?;
+ ScalarValue::Decimal256(min_max_option(lhsv, rhsv, ordering), *lhsp, *lhss)
+ }
+ (ScalarValue::Boolean(lhs), ScalarValue::Boolean(rhs)) => {
+ ScalarValue::Boolean(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::Float64(lhs), ScalarValue::Float64(rhs)) => {
+ ScalarValue::Float64(min_max_float_option(lhs, rhs, ordering, f64::total_cmp))
+ }
+ (ScalarValue::Float32(lhs), ScalarValue::Float32(rhs)) => {
+ ScalarValue::Float32(min_max_float_option(lhs, rhs, ordering, f32::total_cmp))
+ }
+ (ScalarValue::Float16(lhs), ScalarValue::Float16(rhs)) => {
+ ScalarValue::Float16(min_max_float_option(lhs, rhs, ordering, |a, b| {
+ a.total_cmp(b)
+ }))
+ }
+ (ScalarValue::UInt64(lhs), ScalarValue::UInt64(rhs)) => {
+ ScalarValue::UInt64(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::UInt32(lhs), ScalarValue::UInt32(rhs)) => {
+ ScalarValue::UInt32(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::UInt16(lhs), ScalarValue::UInt16(rhs)) => {
+ ScalarValue::UInt16(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::UInt8(lhs), ScalarValue::UInt8(rhs)) => {
+ ScalarValue::UInt8(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::Int64(lhs), ScalarValue::Int64(rhs)) => {
+ ScalarValue::Int64(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::Int32(lhs), ScalarValue::Int32(rhs)) => {
+ ScalarValue::Int32(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::Int16(lhs), ScalarValue::Int16(rhs)) => {
+ ScalarValue::Int16(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::Int8(lhs), ScalarValue::Int8(rhs)) => {
+ ScalarValue::Int8(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::Utf8(lhs), ScalarValue::Utf8(rhs)) => {
+ ScalarValue::Utf8(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::LargeUtf8(lhs), ScalarValue::LargeUtf8(rhs)) => {
+ ScalarValue::LargeUtf8(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::Utf8View(lhs), ScalarValue::Utf8View(rhs)) => {
+ ScalarValue::Utf8View(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::Binary(lhs), ScalarValue::Binary(rhs)) => {
+ ScalarValue::Binary(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::LargeBinary(lhs), ScalarValue::LargeBinary(rhs)) => {
+ ScalarValue::LargeBinary(min_max_option(lhs, rhs, ordering))
+ }
+ (
+ ScalarValue::FixedSizeBinary(lsize, lhs),
+ ScalarValue::FixedSizeBinary(rsize, rhs),
+ ) => {
+ if lsize == rsize {
+ ScalarValue::FixedSizeBinary(*lsize, min_max_option(lhs, rhs, ordering))
+ } else {
+ return internal_err!(
+ "MIN/MAX is not expected to receive FixedSizeBinary of incompatible sizes {:?}",
+ (lsize, rsize)
+ );
+ }
+ }
+ (ScalarValue::BinaryView(lhs), ScalarValue::BinaryView(rhs)) => {
+ ScalarValue::BinaryView(min_max_option(lhs, rhs, ordering))
+ }
+ (
+ ScalarValue::TimestampSecond(lhs, l_tz),
+ ScalarValue::TimestampSecond(rhs, _),
+ ) => {
+ ScalarValue::TimestampSecond(min_max_option(lhs, rhs, ordering), l_tz.clone())
+ }
+ (
+ ScalarValue::TimestampMillisecond(lhs, l_tz),
+ ScalarValue::TimestampMillisecond(rhs, _),
+ ) => ScalarValue::TimestampMillisecond(
+ min_max_option(lhs, rhs, ordering),
+ l_tz.clone(),
+ ),
+ (
+ ScalarValue::TimestampMicrosecond(lhs, l_tz),
+ ScalarValue::TimestampMicrosecond(rhs, _),
+ ) => ScalarValue::TimestampMicrosecond(
+ min_max_option(lhs, rhs, ordering),
+ l_tz.clone(),
+ ),
+ (
+ ScalarValue::TimestampNanosecond(lhs, l_tz),
+ ScalarValue::TimestampNanosecond(rhs, _),
+ ) => ScalarValue::TimestampNanosecond(
+ min_max_option(lhs, rhs, ordering),
+ l_tz.clone(),
+ ),
+ (ScalarValue::Date32(lhs), ScalarValue::Date32(rhs)) => {
+ ScalarValue::Date32(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::Date64(lhs), ScalarValue::Date64(rhs)) => {
+ ScalarValue::Date64(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::Time32Second(lhs), ScalarValue::Time32Second(rhs)) => {
+ ScalarValue::Time32Second(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::Time32Millisecond(lhs), ScalarValue::Time32Millisecond(rhs)) => {
+ ScalarValue::Time32Millisecond(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::Time64Microsecond(lhs), ScalarValue::Time64Microsecond(rhs)) => {
+ ScalarValue::Time64Microsecond(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::Time64Nanosecond(lhs), ScalarValue::Time64Nanosecond(rhs)) => {
+ ScalarValue::Time64Nanosecond(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::IntervalYearMonth(lhs), ScalarValue::IntervalYearMonth(rhs)) => {
+ ScalarValue::IntervalYearMonth(min_max_option(lhs, rhs, ordering))
+ }
+ (
+ ScalarValue::IntervalMonthDayNano(lhs),
+ ScalarValue::IntervalMonthDayNano(rhs),
+ ) => ScalarValue::IntervalMonthDayNano(min_max_option(lhs, rhs, ordering)),
+ (ScalarValue::IntervalDayTime(lhs), ScalarValue::IntervalDayTime(rhs)) => {
+ ScalarValue::IntervalDayTime(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::IntervalYearMonth(_), ScalarValue::IntervalMonthDayNano(_))
+ | (ScalarValue::IntervalYearMonth(_), ScalarValue::IntervalDayTime(_))
+ | (ScalarValue::IntervalMonthDayNano(_), ScalarValue::IntervalDayTime(_))
+ | (ScalarValue::IntervalMonthDayNano(_), ScalarValue::IntervalYearMonth(_))
+ | (ScalarValue::IntervalDayTime(_), ScalarValue::IntervalYearMonth(_))
+ | (ScalarValue::IntervalDayTime(_), ScalarValue::IntervalMonthDayNano(_)) => {
+ return min_max_interval_scalar(lhs, rhs, ordering);
+ }
+ (ScalarValue::DurationSecond(lhs), ScalarValue::DurationSecond(rhs)) => {
+ ScalarValue::DurationSecond(min_max_option(lhs, rhs, ordering))
+ }
+ (
+ ScalarValue::DurationMillisecond(lhs),
+ ScalarValue::DurationMillisecond(rhs),
+ ) => ScalarValue::DurationMillisecond(min_max_option(lhs, rhs, ordering)),
+ (
+ ScalarValue::DurationMicrosecond(lhs),
+ ScalarValue::DurationMicrosecond(rhs),
+ ) => ScalarValue::DurationMicrosecond(min_max_option(lhs, rhs, ordering)),
+ (ScalarValue::DurationNanosecond(lhs), ScalarValue::DurationNanosecond(rhs)) => {
+ ScalarValue::DurationNanosecond(min_max_option(lhs, rhs, ordering))
+ }
+ (ScalarValue::Struct(_), ScalarValue::Struct(_))
+ | (ScalarValue::List(_), ScalarValue::List(_))
+ | (ScalarValue::LargeList(_), ScalarValue::LargeList(_))
+ | (ScalarValue::FixedSizeList(_), ScalarValue::FixedSizeList(_)) => {
+ min_max_generic_scalar(lhs, rhs, ordering)
+ }
+ _ => {
+ return internal_err!(
+ "MIN/MAX is not expected to receive logically incompatible scalar values {:?}",
+ (lhs, rhs)
+ );
+ }
+ };
+
+ Ok(result)
}
/// An accumulator to compute the maximum value
@@ -904,6 +818,118 @@ pub fn max_batch(values: &ArrayRef) -> Result<ScalarValue> {
mod tests {
use super::*;
+ #[test]
+ fn min_max_scalar_preserves_core_behaviors() -> Result<()> {
+ let cases = [
+ (
+ ScalarValue::Int32(Some(1)),
+ ScalarValue::Int32(Some(2)),
+ Ordering::Less,
+ ScalarValue::Int32(Some(2)),
+ ),
+ (
+ ScalarValue::Int32(Some(1)),
+ ScalarValue::Int32(Some(2)),
+ Ordering::Greater,
+ ScalarValue::Int32(Some(1)),
+ ),
+ (
+ ScalarValue::Utf8(Some("a".to_string())),
+ ScalarValue::Utf8(Some("b".to_string())),
+ Ordering::Less,
+ ScalarValue::Utf8(Some("b".to_string())),
+ ),
+ (
+ ScalarValue::Boolean(None),
+ ScalarValue::Boolean(Some(true)),
+ Ordering::Greater,
+ ScalarValue::Boolean(Some(true)),
+ ),
+ ];
+
+ for (lhs, rhs, ordering, expected) in cases {
+ assert_eq!(min_max_scalar(&lhs, &rhs, ordering)?, expected);
+ }
+
+ Ok(())
+ }
+
+ #[test]
+ fn min_max_scalar_float_uses_total_cmp_for_nan() -> Result<()> {
+ type F16 =
+ <arrow::datatypes::Float16Type as arrow::datatypes::ArrowPrimitiveType>::Native;
+
+ let lhs = ScalarValue::Float64(Some(f64::NAN));
+ let rhs = ScalarValue::Float64(Some(1.0));
+ assert_eq!(min_max_scalar(&lhs, &rhs, Ordering::Greater)?, rhs);
+ assert!(matches!(
+ min_max_scalar(&lhs, &rhs, Ordering::Less)?,
+ ScalarValue::Float64(Some(value)) if value.is_nan()
+ ));
+
+ let lhs = ScalarValue::Float32(Some(f32::NAN));
+ let rhs = ScalarValue::Float32(Some(1.0));
+ assert_eq!(min_max_scalar(&lhs, &rhs, Ordering::Greater)?, rhs);
+ assert!(matches!(
+ min_max_scalar(&lhs, &rhs, Ordering::Less)?,
+ ScalarValue::Float32(Some(value)) if value.is_nan()
+ ));
+
+ let lhs = ScalarValue::Float16(Some(F16::NAN));
+ let rhs = ScalarValue::Float16(Some(F16::from_f32(1.0)));
+ assert_eq!(min_max_scalar(&lhs, &rhs, Ordering::Greater)?, rhs);
+ assert!(matches!(
+ min_max_scalar(&lhs, &rhs, Ordering::Less)?,
+ ScalarValue::Float16(Some(value)) if value.is_nan()
+ ));
+ Ok(())
+ }
+
+ #[test]
+ fn min_max_decimal_mismatch_error_is_preserved() -> Result<()> {
+ let lhs = ScalarValue::Decimal128(Some(1), 10, 2);
+ let rhs = ScalarValue::Decimal128(Some(2), 11, 2);
+
+ let error = min_max_scalar(&lhs, &rhs, Ordering::Less).unwrap_err();
+ let message = error.to_string();
+
+ assert!(message.starts_with(&format!(
+ "Internal error: MIN/MAX is not expected to receive scalars of incompatible types {:?}",
+ (&lhs, &rhs)
+ )));
+ Ok(())
+ }
+
+ #[test]
+ fn min_max_fixed_size_binary_mismatch_error_is_preserved() -> Result<()> {
+ let lhs = ScalarValue::FixedSizeBinary(2, Some(vec![1, 2]));
+ let rhs = ScalarValue::FixedSizeBinary(3, Some(vec![1, 2, 3]));
+
+ let error = min_max_scalar(&lhs, &rhs, Ordering::Less).unwrap_err();
+ let message = error.to_string();
+
+ assert!(message.starts_with(
+ "Internal error: MIN/MAX is not expected to receive FixedSizeBinary of incompatible sizes (2, 3)"
+ ));
+ Ok(())
+ }
+
+ #[test]
+ fn min_max_mixed_interval_error_is_preserved() -> Result<()> {
+ let lhs = ScalarValue::IntervalYearMonth(Some(1));
+ let rhs = ScalarValue::IntervalDayTime(Some(
+ arrow::datatypes::IntervalDayTime::new(1, 0),
+ ));
+
+ let error = min_max_scalar(&lhs, &rhs, Ordering::Less).unwrap_err();
+ let message = error.to_string();
+
+ assert!(message.starts_with(
+ "Internal error: Comparison error while computing interval min/max"
+ ));
+ Ok(())
+ }
+
#[test]
fn min_max_dictionary_and_scalar_compare_by_inner_value() -> Result<()> {
let dictionary = ScalarValue::Dictionary(