Move and rename DecimalType (#5120)

Oof. Moving this type from vortex-scalar to vortex-dtype so we can use
it in vortex-vector 😢

---------

Signed-off-by: Nicholas Gates <[email protected]>

Author: gatesn

Cargo.lock

@@ -6,9 +6,9 @@ use num_traits::NumCast;
 use vortex_array::arrays::ConstantArray;
 use vortex_array::compute::{CompareKernel, CompareKernelAdapter, Operator, compare};
 use vortex_array::{Array, ArrayRef, register_kernel};
-use vortex_dtype::{IntegerPType, Nullability, PType, match_each_integer_ptype};
+use vortex_dtype::{IntegerPType, Nullability, PType, ToI256, match_each_integer_ptype};
 use vortex_error::{VortexExpect, VortexResult};
-use vortex_scalar::{DecimalValue, Scalar, ScalarValue, ToI256, match_each_decimal_value};
+use vortex_scalar::{DecimalValue, Scalar, ScalarValue, match_each_decimal_value};
 
 use crate::DecimalBytePartsVTable;
 use crate::decimal_byte_parts::compute::compare::Sign::Positive;

encodings/decimal-byte-parts/src/decimal_byte_parts/compute/compare.rs

@@ -19,13 +19,12 @@ use vortex_array::vtable::{CanonicalVTable, ValidityHelper};
 use vortex_array::{Array, Canonical, ToCanonical};
 use vortex_buffer::{BitBuffer, Buffer, BufferString, ByteBuffer, buffer, buffer_mut};
 use vortex_dtype::{
-    DType, DecimalDType, IntegerPType, NativePType, Nullability, StructFields,
+    DType, DecimalDType, IntegerPType, NativeDecimalType, NativePType, Nullability, StructFields,
     match_each_integer_ptype, match_each_native_ptype,
 };
 use vortex_error::{VortexError, VortexExpect, vortex_panic};
 use vortex_scalar::{
-    DecimalScalar, ListScalar, NativeDecimalType, Scalar, StructScalar,
-    match_each_decimal_value_type,
+    DecimalScalar, ListScalar, Scalar, StructScalar, match_each_decimal_value_type,
 };
 
 use crate::{SparseArray, SparseVTable};

encodings/sparse/src/canonical.rs

@@ -10,9 +10,9 @@ use vortex_array::compute::{Operator, scalar_cmp};
 use vortex_array::validity::Validity;
 use vortex_array::{Array, ArrayRef, IntoArray, ToCanonical};
 use vortex_buffer::BitBuffer;
-use vortex_dtype::{DType, NativePType, match_each_native_ptype};
+use vortex_dtype::{DType, NativeDecimalType, NativePType, match_each_native_ptype};
 use vortex_error::{VortexExpect, VortexResult, vortex_err};
-use vortex_scalar::{NativeDecimalType, Scalar, match_each_decimal_value_type};
+use vortex_scalar::{Scalar, match_each_decimal_value_type};
 
 pub fn compare_canonical_array(
     array: &dyn Array,

fuzz/src/array/compare.rs

@@ -7,9 +7,11 @@ use vortex_array::builders::builder_with_capacity;
 use vortex_array::validity::Validity;
 use vortex_array::{Array, ArrayRef, IntoArray, ToCanonical};
 use vortex_buffer::Buffer;
-use vortex_dtype::{DType, DecimalDType, NativePType, Nullability, match_each_native_ptype};
+use vortex_dtype::{
+    DType, DecimalDType, NativeDecimalType, NativePType, Nullability, match_each_native_ptype,
+};
 use vortex_error::VortexResult;
-use vortex_scalar::{NativeDecimalType, match_each_decimal_value_type};
+use vortex_scalar::match_each_decimal_value_type;
 
 pub fn take_canonical_array_non_nullable_indices(
     array: &dyn Array,

fuzz/src/array/take.rs

@@ -3,9 +3,9 @@
 
 use num_traits::PrimInt;
 use vortex_dtype::Nullability::Nullable;
-use vortex_dtype::{DType, DecimalDType, NativePType, match_each_native_ptype};
+use vortex_dtype::{DType, DecimalDType, NativePType, i256, match_each_native_ptype};
 use vortex_error::{VortexResult, vortex_bail, vortex_err};
-use vortex_scalar::{DecimalScalar, DecimalValue, FromPrimitiveOrF16, Scalar, i256};
+use vortex_scalar::{DecimalScalar, DecimalValue, FromPrimitiveOrF16, Scalar};
 
 use crate::arrays::{ChunkedArray, ChunkedVTable};
 use crate::compute::{SumKernel, SumKernelAdapter, sum};

vortex-array/src/arrays/chunked/compute/sum.rs

@@ -2,10 +2,10 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use num_traits::{CheckedMul, ToPrimitive};
-use vortex_dtype::{DType, DecimalDType, NativePType, Nullability, match_each_native_ptype};
+use vortex_dtype::{DType, DecimalDType, NativePType, Nullability, i256, match_each_native_ptype};
 use vortex_error::{VortexExpect, VortexResult, vortex_bail, vortex_err};
 use vortex_scalar::{
-    DecimalScalar, DecimalValue, FromPrimitiveOrF16, PrimitiveScalar, Scalar, ScalarValue, i256,
+    DecimalScalar, DecimalValue, FromPrimitiveOrF16, PrimitiveScalar, Scalar, ScalarValue,
 };
 
 use crate::arrays::{ConstantArray, ConstantVTable};

vortex-array/src/arrays/constant/compute/sum.rs

@@ -3,9 +3,12 @@
 
 use itertools::Itertools;
 use vortex_buffer::{BitBufferMut, Buffer, BufferMut, ByteBuffer};
-use vortex_dtype::{DType, DecimalDType, IntegerPType, match_each_integer_ptype};
+use vortex_dtype::{
+    BigCast, DType, DecimalDType, DecimalType, IntegerPType, NativeDecimalType,
+    match_each_integer_ptype,
+};
 use vortex_error::{VortexExpect, VortexResult, vortex_ensure, vortex_panic};
-use vortex_scalar::{BigCast, DecimalValueType, NativeDecimalType, match_each_decimal_value_type};
+use vortex_scalar::match_each_decimal_value_type;
 
 use crate::ToCanonical;
 use crate::arrays::is_compatible_decimal_value_type;
@@ -51,7 +54,7 @@ use crate::vtable::ValidityHelper;
 /// ## Valid Scalar Types
 ///
 /// The underlying storage uses these native types based on precision:
-/// - `DecimalValueType::I8`, `I16`, `I32`, `I64`, `I128`, `I256`
+/// - `DecimalType::I8`, `I16`, `I32`, `I64`, `I128`, `I256`
 /// - Type selection is automatic based on the required precision
 ///
 /// # Examples
@@ -75,7 +78,7 @@ use crate::vtable::ValidityHelper;
 pub struct DecimalArray {
     pub(super) dtype: DType,
     pub(super) values: ByteBuffer,
-    pub(super) values_type: DecimalValueType,
+    pub(super) values_type: DecimalType,
     pub(super) validity: Validity,
     pub(super) stats_set: ArrayStats,
 }
@@ -139,7 +142,7 @@ impl DecimalArray {
 
         Self {
             values: buffer.into_byte_buffer(),
-            values_type: T::VALUES_TYPE,
+            values_type: T::DECIMAL_TYPE,
             dtype: DType::Decimal(decimal_dtype, validity.nullability()),
             validity,
             stats_set: Default::default(),
@@ -171,10 +174,10 @@ impl DecimalArray {
     }
 
     pub fn buffer<T: NativeDecimalType>(&self) -> Buffer<T> {
-        if self.values_type != T::VALUES_TYPE {
+        if self.values_type != T::DECIMAL_TYPE {
             vortex_panic!(
                 "Cannot extract Buffer<{:?}> for DecimalArray with values_type {:?}",
-                T::VALUES_TYPE,
+                T::DECIMAL_TYPE,
                 self.values_type,
             );
         }
@@ -190,7 +193,7 @@ impl DecimalArray {
         }
     }
 
-    pub fn values_type(&self) -> DecimalValueType {
+    pub fn values_type(&self) -> DecimalType {
         self.values_type
     }
 
@@ -276,10 +279,10 @@ where
     PatchDVT: NativeDecimalType,
     ValuesDVT: NativeDecimalType,
 {
-    if !is_compatible_decimal_value_type(ValuesDVT::VALUES_TYPE, decimal_dtype) {
+    if !is_compatible_decimal_value_type(ValuesDVT::DECIMAL_TYPE, decimal_dtype) {
         vortex_panic!(
             "patch_typed: {:?} cannot represent every value in {}.",
-            ValuesDVT::VALUES_TYPE,
+            ValuesDVT::DECIMAL_TYPE,
             decimal_dtype
         )
     }

vortex-array/src/arrays/decimal/array.rs

@@ -2,9 +2,9 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_buffer::BitBuffer;
-use vortex_dtype::Nullability;
+use vortex_dtype::{NativeDecimalType, Nullability};
 use vortex_error::{VortexResult, vortex_bail};
-use vortex_scalar::{NativeDecimalType, Scalar, match_each_decimal_value_type};
+use vortex_scalar::{Scalar, match_each_decimal_value_type};
 
 use crate::arrays::{BoolArray, DecimalArray, DecimalVTable};
 use crate::compute::{BetweenKernel, BetweenKernelAdapter, BetweenOptions, StrictComparison};
@@ -51,7 +51,7 @@ fn between_unpack<T: NativeDecimalType>(
     else {
         vortex_bail!(
             "invalid lower bound Scalar: {lower}, expected {:?}",
-            T::VALUES_TYPE
+            T::DECIMAL_TYPE
         )
     };
     let Some(upper_value) = upper
@@ -61,7 +61,7 @@ fn between_unpack<T: NativeDecimalType>(
     else {
         vortex_bail!(
             "invalid upper bound Scalar: {upper}, expected {:?}",
-            T::VALUES_TYPE
+            T::DECIMAL_TYPE
         )
     };
 

vortex-array/src/arrays/decimal/compute/between.rs

@@ -2,9 +2,10 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use itertools::Itertools;
+use vortex_dtype::NativeDecimalType;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
-use vortex_scalar::{NativeDecimalType, match_each_decimal_value_type};
+use vortex_scalar::match_each_decimal_value_type;
 
 use crate::arrays::{DecimalArray, DecimalVTable};
 use crate::compute::{IsSortedIteratorExt, IsSortedKernel, IsSortedKernelAdapter};