Move rescale_decimal to arrow-cast

Author: liamzwbao

arrow-cast/src/cast/decimal.rs

@@ -145,27 +145,6 @@ impl DecimalCast for i256 {
     }
 }
 
-fn cast_decimal_to_decimal_error<I, O>(
-    output_precision: u8,
-    output_scale: i8,
-) -> impl Fn(<I as ArrowPrimitiveType>::Native) -> ArrowError
-where
-    I: DecimalType,
-    O: DecimalType,
-    I::Native: DecimalCast + ArrowNativeTypeOp,
-    O::Native: DecimalCast + ArrowNativeTypeOp,
-{
-    move |x: I::Native| {
-        ArrowError::CastError(format!(
-            "Cannot cast to {}({}, {}). Overflowing on {:?}",
-            O::PREFIX,
-            output_precision,
-            output_scale,
-            x
-        ))
-    }
-}
-
 /// Construct closures to upscale decimals from `(input_precision, input_scale)` to
 /// `(output_precision, output_scale)`.
 ///
@@ -174,7 +153,7 @@ where
 /// In that case, the caller should treat this as an overflow for the output scale
 /// and handle it accordingly (e.g., return a cast error).
 #[allow(clippy::type_complexity)]
-pub fn make_upscaler<I: DecimalType, O: DecimalType>(
+fn make_upscaler<I: DecimalType, O: DecimalType>(
     input_precision: u8,
     input_scale: i8,
     output_precision: u8,
@@ -218,7 +197,7 @@ where
 /// available precision). Callers should therefore produce zero values (preserving nulls) rather
 /// than returning an error.
 #[allow(clippy::type_complexity)]
-pub fn make_downscaler<I: DecimalType, O: DecimalType>(
+fn make_downscaler<I: DecimalType, O: DecimalType>(
     input_precision: u8,
     input_scale: i8,
     output_precision: u8,
@@ -274,6 +253,76 @@ where
     Some((f, f_infallible))
 }
 
+/// Apply the rescaler function to the value.
+/// If the rescaler is infallible, use the infallible function.
+/// Otherwise, use the fallible function and validate the precision.
+fn apply_rescaler<I: DecimalType, O: DecimalType>(
+    value: I::Native,
+    output_precision: u8,
+    f: impl Fn(I::Native) -> Option<O::Native>,
+    f_infallible: Option<impl Fn(I::Native) -> O::Native>,
+) -> Option<O::Native>
+where
+    I::Native: DecimalCast,
+    O::Native: DecimalCast,
+{
+    if let Some(f_infallible) = f_infallible {
+        Some(f_infallible(value))
+    } else {
+        f(value).filter(|v| O::is_valid_decimal_precision(*v, output_precision))
+    }
+}
+
+/// Rescale a decimal from (input_precision, input_scale) to (output_precision, output_scale)
+/// and return the scaled value if it fits the output precision. Similar to the implementation in
+/// decimal.rs in arrow-cast.
+pub fn rescale_decimal<I: DecimalType, O: DecimalType>(
+    value: I::Native,
+    input_precision: u8,
+    input_scale: i8,
+    output_precision: u8,
+    output_scale: i8,
+) -> Option<O::Native>
+where
+    I::Native: DecimalCast + ArrowNativeTypeOp,
+    O::Native: DecimalCast + ArrowNativeTypeOp,
+{
+    if input_scale <= output_scale {
+        let (f, f_infallible) =
+            make_upscaler::<I, O>(input_precision, input_scale, output_precision, output_scale)?;
+        apply_rescaler::<I, O>(value, output_precision, f, f_infallible)
+    } else {
+        let Some((f, f_infallible)) =
+            make_downscaler::<I, O>(input_precision, input_scale, output_precision, output_scale)
+        else {
+            // Scale reduction exceeds supported precision; result mathematically rounds to zero
+            return Some(O::Native::ZERO);
+        };
+        apply_rescaler::<I, O>(value, output_precision, f, f_infallible)
+    }
+}
+
+fn cast_decimal_to_decimal_error<I, O>(
+    output_precision: u8,
+    output_scale: i8,
+) -> impl Fn(<I as ArrowPrimitiveType>::Native) -> ArrowError
+where
+    I: DecimalType,
+    O: DecimalType,
+    I::Native: DecimalCast + ArrowNativeTypeOp,
+    O::Native: DecimalCast + ArrowNativeTypeOp,
+{
+    move |x: I::Native| {
+        ArrowError::CastError(format!(
+            "Cannot cast to {}({}, {}). Overflowing on {:?}",
+            O::PREFIX,
+            output_precision,
+            output_scale,
+            x
+        ))
+    }
+}
+
 fn apply_decimal_cast<I: DecimalType, O: DecimalType>(
     array: &PrimitiveArray<I>,
     output_precision: u8,

arrow-cast/src/cast/mod.rs

@@ -67,7 +67,7 @@ use arrow_schema::*;
 use arrow_select::take::take;
 use num_traits::{NumCast, ToPrimitive, cast::AsPrimitive};
 
-pub use decimal::{DecimalCast, make_downscaler, make_upscaler};
+pub use decimal::{DecimalCast, rescale_decimal};
 
 /// CastOptions provides a way to override the default cast behaviors
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]

parquet-variant-compute/src/type_conversion.rs

@@ -17,8 +17,7 @@
 
 //! Module for transforming a typed arrow `Array` to `VariantArray`.
 
-use arrow::array::ArrowNativeTypeOp;
-use arrow::compute::{DecimalCast, make_downscaler, make_upscaler};
+use arrow::compute::{DecimalCast, rescale_decimal};
 use arrow::datatypes::{
     self, ArrowPrimitiveType, ArrowTimestampType, Decimal32Type, Decimal64Type, Decimal128Type,
     DecimalType,
@@ -190,55 +189,6 @@ where
     }
 }
 
-/// Rescale a decimal from (input_precision, input_scale) to (output_precision, output_scale)
-/// and return the scaled value if it fits the output precision. Similar to the implementation in
-/// decimal.rs in arrow-cast.
-pub(crate) fn rescale_decimal<I: DecimalType, O: DecimalType>(
-    value: I::Native,
-    input_precision: u8,
-    input_scale: i8,
-    output_precision: u8,
-    output_scale: i8,
-) -> Option<O::Native>
-where
-    I::Native: DecimalCast,
-    O::Native: DecimalCast,
-{
-    if input_scale <= output_scale {
-        let (f, f_infallible) =
-            make_upscaler::<I, O>(input_precision, input_scale, output_precision, output_scale)?;
-        apply_rescaler::<I, O>(value, output_precision, f, f_infallible)
-    } else {
-        let Some((f, f_infallible)) =
-            make_downscaler::<I, O>(input_precision, input_scale, output_precision, output_scale)
-        else {
-            // Scale reduction exceeds supported precision; result mathematically rounds to zero
-            return Some(O::Native::ZERO);
-        };
-        apply_rescaler::<I, O>(value, output_precision, f, f_infallible)
-    }
-}
-
-/// Apply the rescaler function to the value.
-/// If the rescaler is infallible, use the infallible function.
-/// Otherwise, use the fallible function and validate the precision.
-fn apply_rescaler<I: DecimalType, O: DecimalType>(
-    value: I::Native,
-    output_precision: u8,
-    f: impl Fn(I::Native) -> Option<O::Native>,
-    f_infallible: Option<impl Fn(I::Native) -> O::Native>,
-) -> Option<O::Native>
-where
-    I::Native: DecimalCast,
-    O::Native: DecimalCast,
-{
-    if let Some(f_infallible) = f_infallible {
-        Some(f_infallible(value))
-    } else {
-        f(value).filter(|v| O::is_valid_decimal_precision(*v, output_precision))
-    }
-}
-
 /// Convert the value at a specific index in the given array into a `Variant`.
 macro_rules! non_generic_conversion_single_value {
     ($array:expr, $cast_fn:expr, $index:expr) => {{