fix[array]: invalid arbitrary decimal scalar value

Signed-off-by: Joe Isaacs <[email protected]>

Author: joseph-isaacs

vortex-array/src/builders/decimal.rs

@@ -284,8 +284,6 @@ impl Default for DecimalBuffer {
 #[cfg(test)]
 mod tests {
     use vortex_dtype::DecimalDType;
-    
-    
 
     use crate::arrays::DecimalArray;
     use crate::assert_arrays_eq;

vortex-dtype/src/decimal/precision.rs

@@ -122,3 +122,18 @@ impl<D: NativeDecimalType> TryFrom<&DecimalDType> for PrecisionScale<D> {
         PrecisionScale::try_new(value.precision, value.scale)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::PrecisionScale;
+
+    #[test]
+    fn max_precision() {
+        let prec = PrecisionScale::<i8>::new(2, 1);
+        assert!(prec.is_valid(8));
+        assert!(prec.is_valid(99));
+        assert!(prec.is_valid(-9));
+        assert!(prec.is_valid(0));
+        assert!(prec.is_valid(-99))
+    }
+}

vortex-dtype/src/decimal/types.rs

@@ -127,24 +127,24 @@ macro_rules! impl_decimal {
                 const MAX_SCALE: i8 = Self::MAX_PRECISION as i8;
 
                 const MIN_BY_PRECISION: &'static [Self] = &{
-                    let mut mins = [$T::ZERO; Self::MAX_PRECISION as usize];
+                    let mut mins = [$T::ZERO; Self::MAX_PRECISION as usize + 1];
                     let mut p = $T::ONE;
                     let mut i = 0;
                     while i < Self::MAX_PRECISION as usize {
                         p = p * 10;
-                        mins[i] = -(p - 1);
+                        mins[i + 1] = -(p - 1);
                         i += 1;
                     }
                     mins
                 };
 
                 const MAX_BY_PRECISION: &'static [Self] = &{
-                    let mut maxs = [$T::ZERO; Self::MAX_PRECISION as usize];
+                    let mut maxs = [$T::ZERO; Self::MAX_PRECISION as usize + 1];
                     let mut p = $T::ONE;
                     let mut i = 0;
                     while i < Self::MAX_PRECISION as usize {
                         p = p * 10;
-                        maxs[i] = p - 1;
+                        maxs[i + 1] = p - 1;
                         i += 1;
                     }
                     maxs

vortex-scalar/src/arbitrary.rs

@@ -86,8 +86,7 @@ pub fn random_decimal(u: &mut Unstructured, decimal_type: &DecimalDType) -> Resu
     let precision = decimal_type.precision();
     let value = match_each_decimal_value_type!(smallest_decimal_value_type(decimal_type), |D| {
         DecimalValue::from(u.int_in_range(
-            D::MIN_BY_PRECISION[precision as usize - 1]
-                ..=D::MAX_BY_PRECISION[precision as usize - 1],
+            D::MIN_BY_PRECISION[precision as usize]..=D::MAX_BY_PRECISION[precision as usize],
         )?)
     });