use actual type names in vortex-vector

connortsui20 · connortsui20 · commit b1cf08bcd1bd · 2025-11-03T18:06:35.000-05:00
Signed-off-by: Connor Tsui &lt;connor.tsui20@gmail.com&gt;
diff --git a/vortex-vector/src/bool/vector.rs b/vortex-vector/src/bool/vector.rs
@@ -83,7 +83,7 @@ impl VectorOps for BoolVector {
         &self.validity
     }
 
-    fn try_into_mut(self) -> Result<Self::Mutable, Self>
+    fn try_into_mut(self) -> Result<BoolVectorMut, Self>
     where
         Self: Sized,
     {
diff --git a/vortex-vector/src/bool/vector_mut.rs b/vortex-vector/src/bool/vector_mut.rs
@@ -152,7 +152,7 @@ impl VectorMutOps for BoolVectorMut {
         self.validity.append_n(false, n);
     }
 
-    fn freeze(self) -> Self::Immutable {
+    fn freeze(self) -> BoolVector {
         BoolVector {
             bits: self.bits.freeze(),
             validity: self.validity.freeze(),
diff --git a/vortex-vector/src/decimal/generic.rs b/vortex-vector/src/decimal/generic.rs
@@ -97,7 +97,7 @@ impl<D: NativeDecimalType> VectorOps for DVector<D> {
         &self.validity
     }
 
-    fn try_into_mut(self) -> Result<Self::Mutable, Self>
+    fn try_into_mut(self) -> Result<DVectorMut<D>, Self>
     where
         Self: Sized,
     {
diff --git a/vortex-vector/src/decimal/generic_mut.rs b/vortex-vector/src/decimal/generic_mut.rs
@@ -31,7 +31,7 @@ impl<D: NativeDecimalType> VectorMutOps for DVectorMut<D> {
         self.validity.reserve(additional);
     }
 
-    fn extend_from_vector(&mut self, other: &Self::Immutable) {
+    fn extend_from_vector(&mut self, other: &DVector<D>) {
         self.elements.extend_from_slice(&other.elements);
         self.validity.append_mask(other.validity());
     }
@@ -41,7 +41,7 @@ impl<D: NativeDecimalType> VectorMutOps for DVectorMut<D> {
         self.validity.append_n(false, n);
     }
 
-    fn freeze(self) -> Self::Immutable {
+    fn freeze(self) -> DVector<D> {
         DVector {
             ps: self.ps,
             elements: self.elements.freeze(),
diff --git a/vortex-vector/src/decimal/vector.rs b/vortex-vector/src/decimal/vector.rs
@@ -36,7 +36,7 @@ impl VectorOps for DecimalVector {
         match_each_dvector!(self, |v| { v.validity() })
     }
 
-    fn try_into_mut(self) -> Result<Self::Mutable, Self>
+    fn try_into_mut(self) -> Result<DecimalVectorMut, Self>
     where
         Self: Sized,
     {
diff --git a/vortex-vector/src/decimal/vector_mut.rs b/vortex-vector/src/decimal/vector_mut.rs
@@ -39,7 +39,7 @@ impl VectorMutOps for DecimalVectorMut {
         match_each_dvector_mut!(self, |d| { d.reserve(additional) })
     }
 
-    fn extend_from_vector(&mut self, other: &Self::Immutable) {
+    fn extend_from_vector(&mut self, other: &DecimalVector) {
         match (self, other) {
             (DecimalVectorMut::D8(s), DecimalVector::D8(o)) => s.extend_from_vector(o),
             (DecimalVectorMut::D16(s), DecimalVector::D16(o)) => s.extend_from_vector(o),
@@ -55,7 +55,7 @@ impl VectorMutOps for DecimalVectorMut {
         match_each_dvector_mut!(self, |d| { d.append_nulls(n) })
     }
 
-    fn freeze(self) -> Self::Immutable {
+    fn freeze(self) -> DecimalVector {
         match_each_dvector_mut!(self, |d| { d.freeze().into() })
     }
 
diff --git a/vortex-vector/src/null/vector.rs b/vortex-vector/src/null/vector.rs
@@ -43,7 +43,7 @@ impl VectorOps for NullVector {
         &self.validity
     }
 
-    fn try_into_mut(self) -> Result<Self::Mutable, Self>
+    fn try_into_mut(self) -> Result<NullVectorMut, Self>
     where
         Self: Sized,
     {
diff --git a/vortex-vector/src/null/vector_mut.rs b/vortex-vector/src/null/vector_mut.rs
@@ -39,15 +39,15 @@ impl VectorMutOps for NullVectorMut {
         // We do not allocate memory for `NullVector`, so this is a no-op.
     }
 
-    fn extend_from_vector(&mut self, other: &Self::Immutable) {
+    fn extend_from_vector(&mut self, other: &NullVector) {
         self.len += other.len;
     }
 
     fn append_nulls(&mut self, n: usize) {
         self.len += n;
     }
 
-    fn freeze(self) -> Self::Immutable {
+    fn freeze(self) -> NullVector {
         NullVector::new(self.len)
     }
 
diff --git a/vortex-vector/src/primitive/vector.rs b/vortex-vector/src/primitive/vector.rs
@@ -73,7 +73,7 @@ impl VectorOps for PrimitiveVector {
         match_each_pvector!(self, |v| { v.validity() })
     }
 
-    fn try_into_mut(self) -> Result<Self::Mutable, Self>
+    fn try_into_mut(self) -> Result<PrimitiveVectorMut, Self>
     where
         Self: Sized,
     {
diff --git a/vortex-vector/src/primitive/vector_mut.rs b/vortex-vector/src/primitive/vector_mut.rs
@@ -96,7 +96,7 @@ impl VectorMutOps for PrimitiveVectorMut {
         match_each_pvector_mut!(self, |v| { v.reserve(additional) })
     }
 
-    fn extend_from_vector(&mut self, other: &Self::Immutable) {
+    fn extend_from_vector(&mut self, other: &PrimitiveVector) {
         match (self, other) {
             (PrimitiveVectorMut::U8(a), PrimitiveVector::U8(b)) => a.extend_from_vector(b),
             (PrimitiveVectorMut::U16(a), PrimitiveVector::U16(b)) => a.extend_from_vector(b),
@@ -117,7 +117,7 @@ impl VectorMutOps for PrimitiveVectorMut {
         match_each_pvector_mut!(self, |v| { v.append_nulls(n) })
     }
 
-    fn freeze(self) -> Self::Immutable {
+    fn freeze(self) -> PrimitiveVector {
         match_each_pvector_mut!(self, |v| { v.freeze().into() })
     }
 
diff --git a/vortex-vector/src/struct_/vector.rs b/vortex-vector/src/struct_/vector.rs
@@ -132,7 +132,7 @@ impl VectorOps for StructVector {
         &self.validity
     }
 
-    fn try_into_mut(self) -> Result<Self::Mutable, Self>
+    fn try_into_mut(self) -> Result<StructVectorMut, Self>
     where
         Self: Sized,
     {
diff --git a/vortex-vector/src/struct_/vector_mut.rs b/vortex-vector/src/struct_/vector_mut.rs
@@ -279,7 +279,7 @@ impl VectorMutOps for StructVectorMut {
         debug_assert_eq!(self.len, self.validity.len());
     }
 
-    fn freeze(self) -> Self::Immutable {
+    fn freeze(self) -> StructVector {
         let frozen_fields: Vec<Vector> = self
             .fields
             .into_iter()
diff --git a/vortex-vector/src/varbin/vector.rs b/vortex-vector/src/varbin/vector.rs
@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Variable-length binary vector implementation.
+
+use std::sync::Arc;
+
+use vortex_buffer::{Buffer, ByteBuffer};
+use vortex_mask::Mask;
+
+use crate::VectorOps;
+use crate::varbin::VarBinType;
+use crate::varbin::vector_mut::VarBinVectorMut;
+use crate::varbin::view::BinaryView;
+
+/// A variable-length binary vector.
+#[derive(Debug, Clone)]
+pub struct VarBinVector<T: VarBinType> {
+    /// Views into the binary data.
+    views: Buffer<BinaryView>,
+    /// Buffers holding the referenced binary data.
+    buffers: Arc<Box<[ByteBuffer]>>,
+    /// Validity mask for the vector.
+    validity: Mask,
+    /// Marker trait for the [`VarBinType`].
+    _marker: std::marker::PhantomData<T>,
+}
+
+impl<T: VarBinType> VarBinVector<T> {
+    /// Creates a new [`VarBinVector`] from the provided components.
+    ///
+    /// # Safety
+    ///
+    /// This function is unsafe because it does not validate the consistency of the provided
+    /// components.
+    ///
+    /// The caller must ensure that:
+    /// - The length of the `validity` mask matches the length of the `views` buffer.
+    /// - The `views` buffer correctly references the data in the `buffers`.
+    pub unsafe fn new_unchecked(
+        views: Buffer<BinaryView>,
+        buffers: Arc<Box<[ByteBuffer]>>,
+        validity: Mask,
+    ) -> Self {
+        Self {
+            views,
+            buffers,
+            validity,
+            _marker: std::marker::PhantomData,
+        }
+    }
+
+    /// Decomposes the vector into its constituent parts.
+    pub fn into_parts(self) -> (Buffer<BinaryView>, Arc<Box<[ByteBuffer]>>, Mask) {
+        (self.views, self.buffers, self.validity)
+    }
+}
+
+impl<T: VarBinType> VectorOps for VarBinVector<T> {
+    type Mutable = VarBinVectorMut<T>;
+
+    fn len(&self) -> usize {
+        self.views.len()
+    }
+
+    fn validity(&self) -> &Mask {
+        &self.validity
+    }
+
+    fn try_into_mut(self) -> Result<VarBinVectorMut<T>, Self>
+    where
+        Self: Sized,
+    {
+        todo!()
+    }
+}
diff --git a/vortex-vector/src/varbin/vector_mut.rs b/vortex-vector/src/varbin/vector_mut.rs
@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Mutable variable-length binary vector.
+
+use vortex_buffer::{BufferMut, ByteBuffer, ByteBufferMut};
+use vortex_mask::MaskMut;
+
+use crate::VectorMutOps;
+use crate::varbin::VarBinType;
+use crate::varbin::vector::VarBinVector;
+use crate::varbin::view::BinaryView;
+
+/// Mutable variable-length binary vector.
+#[allow(dead_code)] // FIXME(ngates): remove after implementing the methods
+#[derive(Clone, Debug)]
+pub struct VarBinVectorMut<T: VarBinType> {
+    /// Views into the binary data.
+    views: BufferMut<BinaryView>,
+    /// Validity mask for the vector.
+    validity: MaskMut,
+
+    /// The completed buffers holding referenced binary data.
+    buffers: Vec<ByteBuffer>,
+    /// The current buffer being appended to, if any.
+    open_buffer: Option<ByteBufferMut>,
+
+    /// Marker trait for the [`VarBinType`].
+    _marker: std::marker::PhantomData<T>,
+}
+
+impl<T: VarBinType> VectorMutOps for VarBinVectorMut<T> {
+    type Immutable = VarBinVector<T>;
+
+    fn len(&self) -> usize {
+        self.views.len()
+    }
+
+    fn capacity(&self) -> usize {
+        self.views.capacity()
+    }
+
+    fn reserve(&mut self, additional: usize) {
+        self.views.reserve(additional);
+    }
+
+    fn extend_from_vector(&mut self, _other: &VarBinVector<T>) {
+        todo!()
+    }
+
+    fn append_nulls(&mut self, n: usize) {
+        self.views.push_n(BinaryView::empty_view(), n);
+        self.validity.append_n(false, n);
+    }
+
+    fn freeze(self) -> VarBinVector<T> {
+        todo!()
+    }
+
+    fn split_off(&mut self, _at: usize) -> Self {
+        todo!()
+    }
+
+    fn unsplit(&mut self, _other: Self) {
+        todo!()
+    }
+}
diff --git a/vortex-vector/src/vector.rs b/vortex-vector/src/vector.rs
@@ -58,7 +58,7 @@ impl VectorOps for Vector {
         match_each_vector!(self, |v| { v.validity() })
     }
 
-    fn try_into_mut(self) -> Result<Self::Mutable, Self>
+    fn try_into_mut(self) -> Result<VectorMut, Self>
     where
         Self: Sized,
     {
diff --git a/vortex-vector/src/vector_mut.rs b/vortex-vector/src/vector_mut.rs
@@ -82,7 +82,7 @@ impl VectorMutOps for VectorMut {
         match_each_vector_mut!(self, |v| { v.reserve(additional) })
     }
 
-    fn extend_from_vector(&mut self, other: &Self::Immutable) {
+    fn extend_from_vector(&mut self, other: &Vector) {
         match_vector_pair!(self, other, |a: VectorMut, b: Vector| {
             a.extend_from_vector(b)
         })
@@ -92,7 +92,7 @@ impl VectorMutOps for VectorMut {
         match_each_vector_mut!(self, |v| { v.append_nulls(n) })
     }
 
-    fn freeze(self) -> Self::Immutable {
+    fn freeze(self) -> Vector {
         match_each_vector_mut!(self, |v| { v.freeze().into() })
     }
 

Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ impl VectorOps for BoolVector {`
`83`	`83`	`&self.validity`
`84`	`84`	`}`
`85`	`85`
`86`		`- fn try_into_mut(self) -> Result<Self::Mutable, Self>`
	`86`	`+ fn try_into_mut(self) -> Result<BoolVectorMut, Self>`
`87`	`87`	`where`
`88`	`88`	`Self: Sized,`
`89`	`89`	`{`
Original file line number	Diff line number	Diff line change
`@@ -152,7 +152,7 @@ impl VectorMutOps for BoolVectorMut {`
`152`	`152`	`self.validity.append_n(false, n);`
`153`	`153`	`}`
`154`	`154`
`155`		`- fn freeze(self) -> Self::Immutable {`
	`155`	`+ fn freeze(self) -> BoolVector {`
`156`	`156`	`BoolVector {`
`157`	`157`	`bits: self.bits.freeze(),`
`158`	`158`	`validity: self.validity.freeze(),`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ impl<D: NativeDecimalType> VectorOps for DVector<D> {`
`97`	`97`	`&self.validity`
`98`	`98`	`}`
`99`	`99`
`100`		`- fn try_into_mut(self) -> Result<Self::Mutable, Self>`
	`100`	`+ fn try_into_mut(self) -> Result<DVectorMut<D>, Self>`
`101`	`101`	`where`
`102`	`102`	`Self: Sized,`
`103`	`103`	`{`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ impl<D: NativeDecimalType> VectorMutOps for DVectorMut<D> {`
`31`	`31`	`self.validity.reserve(additional);`
`32`	`32`	`}`
`33`	`33`
`34`		`- fn extend_from_vector(&mut self, other: &Self::Immutable) {`
	`34`	`+ fn extend_from_vector(&mut self, other: &DVector<D>) {`
`35`	`35`	`self.elements.extend_from_slice(&other.elements);`
`36`	`36`	`self.validity.append_mask(other.validity());`
`37`	`37`	`}`
`@@ -41,7 +41,7 @@ impl<D: NativeDecimalType> VectorMutOps for DVectorMut<D> {`
`41`	`41`	`self.validity.append_n(false, n);`
`42`	`42`	`}`
`43`	`43`
`44`		`- fn freeze(self) -> Self::Immutable {`
	`44`	`+ fn freeze(self) -> DVector<D> {`
`45`	`45`	`DVector {`
`46`	`46`	`ps: self.ps,`
`47`	`47`	`elements: self.elements.freeze(),`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ impl VectorOps for DecimalVector {`
`36`	`36`	`match_each_dvector!(self, \|v\| { v.validity() })`
`37`	`37`	`}`
`38`	`38`
`39`		`- fn try_into_mut(self) -> Result<Self::Mutable, Self>`
	`39`	`+ fn try_into_mut(self) -> Result<DecimalVectorMut, Self>`
`40`	`40`	`where`
`41`	`41`	`Self: Sized,`
`42`	`42`	`{`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ impl VectorMutOps for DecimalVectorMut {`
`39`	`39`	`match_each_dvector_mut!(self, \|d\| { d.reserve(additional) })`
`40`	`40`	`}`
`41`	`41`
`42`		`- fn extend_from_vector(&mut self, other: &Self::Immutable) {`
	`42`	`+ fn extend_from_vector(&mut self, other: &DecimalVector) {`
`43`	`43`	`match (self, other) {`
`44`	`44`	`(DecimalVectorMut::D8(s), DecimalVector::D8(o)) => s.extend_from_vector(o),`
`45`	`45`	`(DecimalVectorMut::D16(s), DecimalVector::D16(o)) => s.extend_from_vector(o),`
`@@ -55,7 +55,7 @@ impl VectorMutOps for DecimalVectorMut {`
`55`	`55`	`match_each_dvector_mut!(self, \|d\| { d.append_nulls(n) })`
`56`	`56`	`}`
`57`	`57`
`58`		`- fn freeze(self) -> Self::Immutable {`
	`58`	`+ fn freeze(self) -> DecimalVector {`
`59`	`59`	`match_each_dvector_mut!(self, \|d\| { d.freeze().into() })`
`60`	`60`	`}`
`61`	`61`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ impl VectorOps for NullVector {`
`43`	`43`	`&self.validity`
`44`	`44`	`}`
`45`	`45`
`46`		`- fn try_into_mut(self) -> Result<Self::Mutable, Self>`
	`46`	`+ fn try_into_mut(self) -> Result<NullVectorMut, Self>`
`47`	`47`	`where`
`48`	`48`	`Self: Sized,`
`49`	`49`	`{`
Original file line number	Diff line number	Diff line change
`@@ -39,15 +39,15 @@ impl VectorMutOps for NullVectorMut {`
`39`	`39`	// We do not allocate memory for `NullVector`, so this is a no-op.
`40`	`40`	`}`
`41`	`41`
`42`		`- fn extend_from_vector(&mut self, other: &Self::Immutable) {`
	`42`	`+ fn extend_from_vector(&mut self, other: &NullVector) {`
`43`	`43`	`self.len += other.len;`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`fn append_nulls(&mut self, n: usize) {`
`47`	`47`	`self.len += n;`
`48`	`48`	`}`
`49`	`49`
`50`		`- fn freeze(self) -> Self::Immutable {`
	`50`	`+ fn freeze(self) -> NullVector {`
`51`	`51`	`NullVector::new(self.len)`
`52`	`52`	`}`
`53`	`53`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ impl VectorOps for PrimitiveVector {`
`73`	`73`	`match_each_pvector!(self, \|v\| { v.validity() })`
`74`	`74`	`}`
`75`	`75`
`76`		`- fn try_into_mut(self) -> Result<Self::Mutable, Self>`
	`76`	`+ fn try_into_mut(self) -> Result<PrimitiveVectorMut, Self>`
`77`	`77`	`where`
`78`	`78`	`Self: Sized,`
`79`	`79`	`{`
Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,7 @@ impl VectorMutOps for PrimitiveVectorMut {`
`96`	`96`	`match_each_pvector_mut!(self, \|v\| { v.reserve(additional) })`
`97`	`97`	`}`
`98`	`98`
`99`		`- fn extend_from_vector(&mut self, other: &Self::Immutable) {`
	`99`	`+ fn extend_from_vector(&mut self, other: &PrimitiveVector) {`
`100`	`100`	`match (self, other) {`
`101`	`101`	`(PrimitiveVectorMut::U8(a), PrimitiveVector::U8(b)) => a.extend_from_vector(b),`
`102`	`102`	`(PrimitiveVectorMut::U16(a), PrimitiveVector::U16(b)) => a.extend_from_vector(b),`
`@@ -117,7 +117,7 @@ impl VectorMutOps for PrimitiveVectorMut {`
`117`	`117`	`match_each_pvector_mut!(self, \|v\| { v.append_nulls(n) })`
`118`	`118`	`}`
`119`	`119`
`120`		`- fn freeze(self) -> Self::Immutable {`
	`120`	`+ fn freeze(self) -> PrimitiveVector {`
`121`	`121`	`match_each_pvector_mut!(self, \|v\| { v.freeze().into() })`
`122`	`122`	`}`
`123`	`123`