clean up decimal vector modules and docs

Signed-off-by: Connor Tsui <[email protected]>

Author: connortsui20

vortex-vector/src/decimal/generic.rs

@@ -17,13 +17,26 @@ pub struct DVector<D> {
 }
 
 impl<D: NativeDecimalType> DVector<D> {
+    /// Try to create a new decimal vector from the given elements and validity.
+    ///
+    /// # Panics
+    ///
+    /// Panics if:
+    ///
+    /// - The lengths of the `elements` and `validity` do not match.
+    /// - Any of the elements are out of bounds for the given [`PrecisionScale`].
+    pub fn new(ps: PrecisionScale<D>, elements: Buffer<D>, validity: Mask) -> Self {
+        Self::try_new(ps, elements, validity).vortex_expect("Failed to create `DVector`")
+    }
+
     /// Try to create a new decimal vector from the given elements and validity.
     ///
     /// # Errors
     ///
-    /// Returns an error if the precision/scale is invalid, the lengths of the elements
-    /// and validity do not match, or any of the elements are out of bounds for the given
-    /// precision/scale.
+    /// Returns an error if:
+    ///
+    /// - The lengths of the `elements` and `validity` do not match.
+    /// - Any of the elements are out of bounds for the given [`PrecisionScale`].
     pub fn try_new(
         ps: PrecisionScale<D>,
         elements: Buffer<D>,
@@ -57,8 +70,10 @@ impl<D: NativeDecimalType> DVector<D> {
     ///
     /// # Safety
     ///
-    /// The caller must ensure that the precision/scale is valid, the lengths of the elements
-    /// and validity match, and all the elements are within bounds for the given precision/scale.
+    /// The caller must ensure:
+    ///
+    /// - The lengths of the elements and validity are equal.
+    /// - All elements are in bounds for the given [`PrecisionScale`].
     pub unsafe fn new_unchecked(
         ps: PrecisionScale<D>,
         elements: Buffer<D>,
@@ -75,15 +90,16 @@ impl<D: NativeDecimalType> DVector<D> {
         }
     }
 
+    /// Decomposes the decimal vector into its constituent parts ([`PrecisionScale`], decimal
+    /// buffer, and validity).
+    pub fn into_parts(self) -> (PrecisionScale<D>, Buffer<D>, Mask) {
+        (self.ps, self.elements, self.validity)
+    }
+
     /// Get the precision/scale of the decimal vector.
     pub fn precision_scale(&self) -> PrecisionScale<D> {
         self.ps
     }
-
-    /// Decomposes the decimal vector into its constituent parts (precision/scale, buffer and validity).
-    pub fn into_parts(self) -> (PrecisionScale<D>, Buffer<D>, Mask) {
-        (self.ps, self.elements, self.validity)
-    }
 }
 
 impl<D: NativeDecimalType> VectorOps for DVector<D> {

vortex-vector/src/decimal/generic_mut_impl.rs

@@ -26,14 +26,15 @@ impl<D: NativeDecimalType> DVectorMut<D> {
         if !self.ps.is_valid(value) {
             vortex_bail!("Value {:?} is out of bounds for {}", value, self.ps,);
         }
+
         self.elements.push(value);
         self.validity.append_n(true, 1);
         Ok(())
     }
 
     /// Returns a mutable reference to the underlying elements buffer.
     ///
-    /// # SAFETY
+    /// # Safety
     ///
     /// Modifying the elements buffer directly may violate the precision/scale constraints.
     /// The caller must ensure that any modifications maintain these invariants.

vortex-vector/src/decimal/mod.rs

@@ -2,16 +2,20 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod generic;
+pub use generic::DVector;
+
 mod generic_mut;
 mod generic_mut_impl;
-mod macros;
+pub use generic_mut::DVectorMut;
+
 mod vector;
+pub use vector::DecimalVector;
+
 mod vector_mut;
+pub use vector_mut::DecimalVectorMut;
+
+mod macros;
 
-pub use generic::*;
-pub use generic_mut::*;
-pub use vector::*;
-pub use vector_mut::*;
 use vortex_dtype::NativeDecimalType;
 
 use crate::{Vector, VectorMut};
@@ -22,18 +26,18 @@ impl From<DecimalVector> for Vector {
     }
 }
 
-impl<D: NativeDecimalType> From<DVector<D>> for Vector {
-    fn from(v: DVector<D>) -> Self {
-        Self::Decimal(DecimalVector::from(v))
-    }
-}
-
 impl<D: NativeDecimalType> From<DVector<D>> for DecimalVector {
     fn from(value: DVector<D>) -> Self {
         D::upcast(value)
     }
 }
 
+impl<D: NativeDecimalType> From<DVector<D>> for Vector {
+    fn from(v: DVector<D>) -> Self {
+        Self::Decimal(DecimalVector::from(v))
+    }
+}
+
 impl From<DecimalVectorMut> for VectorMut {
     fn from(v: DecimalVectorMut) -> Self {
         Self::Decimal(v)

vortex-vector/src/primitive/mod.rs

@@ -18,13 +18,13 @@ mod generic;
 pub use generic::PVector;
 
 mod generic_mut;
+mod generic_mut_impl;
+mod iter;
 pub use generic_mut::PVectorMut;
 
 mod vector;
 pub use vector::PrimitiveVector;
 
-mod generic_mut_impl;
-mod iter;
 mod vector_mut;
 pub use vector_mut::PrimitiveVectorMut;