16980200873

Committed 15 Aug 2025 12:53AM UTC coverage: 49.805%. First build

Build # 16980200873

Build Type

Pull #2456

github

Committed by

web-flow

Commit Message

Merge aff477380 into aaf3e36ad

Pull Request Pull Request #2456: feat: basic BoolBuffer / BoolBufferMut

Run Details

574 of 1074 new or added lines in 84 files covered. (53.45%)

20158 of 40474 relevant lines covered (49.8%)

238516.31 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

64.1

/vortex-array/src/builders/primitive.rs

// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright the Vortex contributors

use std::any::Any;
use std::mem::MaybeUninit;
use std::ops::{Deref, DerefMut};

use vortex_buffer::BufferMut;
use vortex_dtype::{DType, NativePType, Nullability};
use vortex_error::{VortexResult, vortex_bail};
use vortex_mask::Mask;

use crate::arrays::PrimitiveArray;
use crate::builders::ArrayBuilder;
use crate::builders::lazy_validity_builder::LazyBitBufferBuilder;
use crate::{Array, ArrayRef, IntoArray, ToCanonical};

/// Builder for [`PrimitiveArray`].
pub struct PrimitiveBuilder<T> {
    values: BufferMut<T>,
    nulls: LazyBitBufferBuilder,
    dtype: DType,
}

impl<T: NativePType> PrimitiveBuilder<T> {
    pub fn new(nullability: Nullability) -> Self {
        Self::with_capacity(nullability, 1024) // Same as Arrow builders
    }

    pub fn with_capacity(nullability: Nullability, capacity: usize) -> Self {
        Self {
            values: BufferMut::with_capacity(capacity),
            nulls: LazyBitBufferBuilder::new(capacity),
            dtype: DType::Primitive(T::PTYPE, nullability),
        }
    }

    /// Append a `Mask` to the null buffer.
    pub fn append_mask(&mut self, mask: Mask) {
        self.nulls.append_validity_mask(mask);
    }

    pub fn append_value(&mut self, value: T) {
        self.values.push(value);
        self.nulls.append(true);
    }

    pub fn append_option(&mut self, value: Option<T>) {
        match value {
            Some(value) => {
                self.values.push(value);
                self.nulls.append(true);
            }
            None => self.append_null(),
        }
    }

    pub fn values(&self) -> &[T] {
        self.values.as_ref()
    }

    /// Create a new handle to the next `len` uninitialized values in the builder.
    ///
    /// All reads/writes through the handle to the values buffer or the validity buffer will operate
    /// on indices relative to the start of the range.
    ///
    ///
    /// ## Example
    ///
    /// ```
    /// use std::mem::MaybeUninit;
    /// use vortex_array::builders::{ArrayBuilder, PrimitiveBuilder};
    /// use vortex_dtype::Nullability;
    ///
    /// // Create a new builder.
    /// let mut builder: PrimitiveBuilder<i32> = PrimitiveBuilder::with_capacity(Nullability::NonNullable, 5);
    ///
    /// // Populate the values in reverse order.
    /// let mut range = builder.uninit_range(5);
    /// for i in [4, 3, 2, 1, 0] {
    ///     range[i] = MaybeUninit::new(i as i32);
    /// }
    /// range.finish();
    ///
    /// let built = builder.finish_into_primitive();
    ///
    /// assert_eq!(built.as_slice::<i32>(), &[0i32, 1, 2, 3, 4]);
    /// ```
    pub fn uninit_range(&mut self, len: usize) -> UninitRange<'_, T> {
        let offset = self.values.len();
        assert!(
            offset + len <= self.values.capacity(),
            "uninit_range of len {len} exceeds builder capacity {}",
            self.values.capacity()
        );

        UninitRange {
            offset,
            len,
            builder: self,
        }
    }

    pub fn finish_into_primitive(&mut self) -> PrimitiveArray {
        let validity = self
            .nulls
            .finish_with_nullability(self.dtype().nullability());

        PrimitiveArray::new(std::mem::take(&mut self.values).freeze(), validity)
    }

    pub fn extend_with_iterator(&mut self, iter: impl IntoIterator<Item = T>, mask: Mask) {
        self.values.extend(iter);
        self.extend_with_validity_mask(mask)
    }

    fn extend_with_validity_mask(&mut self, validity_mask: Mask) {
        self.nulls.append_validity_mask(validity_mask);
    }
}

impl<T: NativePType> ArrayBuilder for PrimitiveBuilder<T> {
    fn as_any(&self) -> &dyn Any {
        self
    }

    fn as_any_mut(&mut self) -> &mut dyn Any {
        self
    }

    fn dtype(&self) -> &DType {
        &self.dtype
    }

    fn len(&self) -> usize {
        self.values.len()
    }

    fn append_zeros(&mut self, n: usize) {
        self.values.push_n(T::default(), n);
        self.nulls.append_n_non_nulls(n);
    }

    fn append_nulls(&mut self, n: usize) {
        self.values.push_n(T::default(), n);
        self.nulls.append_n_nulls(n);
    }

    fn extend_from_array(&mut self, array: &dyn Array) -> VortexResult<()> {
        let array = array.to_primitive()?;
        if array.ptype() != T::PTYPE {
            vortex_bail!("Cannot extend from array with different ptype");
        }

        self.values.extend_from_slice(array.as_slice::<T>());

        self.extend_with_validity_mask(array.validity_mask()?);

        Ok(())
    }

    fn ensure_capacity(&mut self, capacity: usize) {
        if capacity > self.values.capacity() {
            self.values.reserve(capacity - self.values.len());
            self.nulls.ensure_capacity(capacity);
        }
    }

    fn set_validity(&mut self, validity: Mask) {
        self.nulls = LazyBitBufferBuilder::new(validity.len());
        self.nulls.append_validity_mask(validity);
    }

    fn finish(&mut self) -> ArrayRef {
        self.finish_into_primitive().into_array()
    }
}

pub struct UninitRange<'a, T> {
    offset: usize,
    len: usize,
    builder: &'a mut PrimitiveBuilder<T>,
}

impl<T> Deref for UninitRange<'_, T> {
    type Target = [MaybeUninit<T>];

    fn deref(&self) -> &[MaybeUninit<T>] {
        let start = self.builder.values.as_ptr();
        unsafe {
            // SAFETY: start + len is checked on construction to be in range.
            let dst = std::slice::from_raw_parts(start, self.len);

            // SAFETY: &[T] and &[MaybeUninit<T>] have the same layout
            let dst: &[MaybeUninit<T>] = std::mem::transmute(dst);

            dst
        }
    }
}

impl<T> DerefMut for UninitRange<'_, T> {
    fn deref_mut(&mut self) -> &mut [MaybeUninit<T>] {
        &mut self.builder.values.spare_capacity_mut()[..self.len]
    }
}

impl<T> UninitRange<'_, T> {
    /// Set a validity bit at the given index. The index is relative to the start of this range
    /// of the builder.
    pub fn set_bit(&mut self, index: usize, v: bool) {
        self.builder.nulls.set_bit(self.offset + index, v);
    }

    /// Set values from an initialized range.
    pub fn copy_from_init(&mut self, offset: usize, len: usize, src: &[T])
    where
        T: Copy,
    {
        // SAFETY: &[T] and &[MaybeUninit<T>] have the same layout
        let uninit_src: &[MaybeUninit<T>] = unsafe { std::mem::transmute(src) };

        let dst = &mut self[offset..][..len];
        dst.copy_from_slice(uninit_src);
    }

    /// Finish building this range, marking it as initialized and advancing the length of the
    /// underlying values buffer.
    pub fn finish(self) {
        // SAFETY: constructor enforces that offset + len does not exceed the capacity of the array.
        unsafe { self.builder.values.set_len(self.offset + self.len) };
    }
}

1	// SPDX-License-Identifier: Apache-2.0
2	// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4	use std::any::Any;
5	use std::mem::MaybeUninit;
6	use std::ops::{Deref, DerefMut};
7
8	use vortex_buffer::BufferMut;
9	use vortex_dtype::{DType, NativePType, Nullability};
10	use vortex_error::{VortexResult, vortex_bail};
11	use vortex_mask::Mask;
12
13	use crate::arrays::PrimitiveArray;
14	use crate::builders::ArrayBuilder;
15	use crate::builders::lazy_validity_builder::LazyBitBufferBuilder;
16	use crate::{Array, ArrayRef, IntoArray, ToCanonical};
17
18	/// Builder for [`PrimitiveArray`].
19	pub struct PrimitiveBuilder<T> {
20	values: BufferMut<T>,
21	nulls: LazyBitBufferBuilder,
22	dtype: DType,
23	}
24
25	impl<T: NativePType> PrimitiveBuilder<T> {
26	pub fn new(nullability: Nullability) -> Self {	×
27	Self::with_capacity(nullability, 1024) // Same as Arrow builders	×
28	}	×
29
30	pub fn with_capacity(nullability: Nullability, capacity: usize) -> Self {	11,951✔
31	Self {	11,951✔
32	values: BufferMut::with_capacity(capacity),	11,951✔
33	nulls: LazyBitBufferBuilder::new(capacity),	11,951✔
34	dtype: DType::Primitive(T::PTYPE, nullability),	11,951✔
35	}	11,951✔
36	}	11,951✔
37
38	/// Append a `Mask` to the null buffer.
39	pub fn append_mask(&mut self, mask: Mask) {	9,555✔
40	self.nulls.append_validity_mask(mask);	9,555✔
41	}	9,555✔
42
43	pub fn append_value(&mut self, value: T) {	×
44	self.values.push(value);	×
45	self.nulls.append(true);	×
46	}	×
47
48	pub fn append_option(&mut self, value: Option<T>) {	10,710✔
49	match value {	10,710✔
50	Some(value) => {	10,710✔
51	self.values.push(value);	10,710✔
52	self.nulls.append(true);	10,710✔
53	}	10,710✔
54	None => self.append_null(),	×
55	}
56	}	10,710✔
57
58	pub fn values(&self) -> &[T] {	×
59	self.values.as_ref()	×
60	}	×
61
62	/// Create a new handle to the next `len` uninitialized values in the builder.
63	///
64	/// All reads/writes through the handle to the values buffer or the validity buffer will operate
65	/// on indices relative to the start of the range.
66	///
67	///
68	/// ## Example
69	///
70	/// ```
71	/// use std::mem::MaybeUninit;
72	/// use vortex_array::builders::{ArrayBuilder, PrimitiveBuilder};
73	/// use vortex_dtype::Nullability;
74	///
75	/// // Create a new builder.
76	/// let mut builder: PrimitiveBuilder<i32> = PrimitiveBuilder::with_capacity(Nullability::NonNullable, 5);
77	///
78	/// // Populate the values in reverse order.
79	/// let mut range = builder.uninit_range(5);
80	/// for i in [4, 3, 2, 1, 0] {
81	/// range[i] = MaybeUninit::new(i as i32);
82	/// }
83	/// range.finish();
84	///
85	/// let built = builder.finish_into_primitive();
86	///
87	/// assert_eq!(built.as_slice::<i32>(), &[0i32, 1, 2, 3, 4]);
88	/// ```
89	pub fn uninit_range(&mut self, len: usize) -> UninitRange<'_, T> {	9,555✔
90	let offset = self.values.len();	9,555✔
91	assert!(	9,555✔
92	offset + len <= self.values.capacity(),	9,555✔
93	"uninit_range of len {len} exceeds builder capacity {}",	×
94	self.values.capacity()	×
95	);
96
97	UninitRange {	9,555✔
98	offset,	9,555✔
99	len,	9,555✔
100	builder: self,	9,555✔
101	}	9,555✔
102	}	9,555✔
103
104	pub fn finish_into_primitive(&mut self) -> PrimitiveArray {	11,951✔
105	let validity = self	11,951✔
106	.nulls	11,951✔
107	.finish_with_nullability(self.dtype().nullability());	11,951✔
108
109	PrimitiveArray::new(std::mem::take(&mut self.values).freeze(), validity)	11,951✔
110	}	11,951✔
111
112	pub fn extend_with_iterator(&mut self, iter: impl IntoIterator<Item = T>, mask: Mask) {	×
113	self.values.extend(iter);	×
114	self.extend_with_validity_mask(mask)	×
115	}	×
116
117	fn extend_with_validity_mask(&mut self, validity_mask: Mask) {	19,588✔
118	self.nulls.append_validity_mask(validity_mask);	19,588✔
119	}	19,588✔
120	}
121
122	impl<T: NativePType> ArrayBuilder for PrimitiveBuilder<T> {
123	fn as_any(&self) -> &dyn Any {	×
124	self	×
125	}	×
126
127	fn as_any_mut(&mut self) -> &mut dyn Any {	10,710✔
128	self	10,710✔
129	}	10,710✔
130
131	fn dtype(&self) -> &DType {	43,799✔
132	&self.dtype	43,799✔
133	}	43,799✔
134
135	fn len(&self) -> usize {	53,337✔
136	self.values.len()	53,337✔
137	}	53,337✔
138
139	fn append_zeros(&mut self, n: usize) {	×
140	self.values.push_n(T::default(), n);	×
141	self.nulls.append_n_non_nulls(n);	×
142	}	×
143
144	fn append_nulls(&mut self, n: usize) {	×
145	self.values.push_n(T::default(), n);	×
146	self.nulls.append_n_nulls(n);	×
147	}	×
148
149	fn extend_from_array(&mut self, array: &dyn Array) -> VortexResult<()> {	19,588✔
150	let array = array.to_primitive()?;	19,588✔
151	if array.ptype() != T::PTYPE {	19,588✔
152	vortex_bail!("Cannot extend from array with different ptype");	×
153	}	19,588✔
154
155	self.values.extend_from_slice(array.as_slice::<T>());	19,588✔
156
157	self.extend_with_validity_mask(array.validity_mask()?);	19,588✔
158
159	Ok(())	19,588✔
160	}	19,588✔
161
162	fn ensure_capacity(&mut self, capacity: usize) {	×
163	if capacity > self.values.capacity() {	×
164	self.values.reserve(capacity - self.values.len());	×
165	self.nulls.ensure_capacity(capacity);	×
166	}	×
167	}	×
168
169	fn set_validity(&mut self, validity: Mask) {	×
NEW 170	self.nulls = LazyBitBufferBuilder::new(validity.len());	×
171	self.nulls.append_validity_mask(validity);	×
172	}	×
173
174	fn finish(&mut self) -> ArrayRef {	2,396✔
175	self.finish_into_primitive().into_array()	2,396✔
176	}	2,396✔
177	}
178
179	pub struct UninitRange<'a, T> {
180	offset: usize,
181	len: usize,
182	builder: &'a mut PrimitiveBuilder<T>,
183	}
184
185	impl<T> Deref for UninitRange<'_, T> {
186	type Target = [MaybeUninit<T>];
187
188	fn deref(&self) -> &[MaybeUninit<T>] {	903✔
189	let start = self.builder.values.as_ptr();	903✔
190	unsafe {
191	// SAFETY: start + len is checked on construction to be in range.
192	let dst = std::slice::from_raw_parts(start, self.len);	903✔
193
194	// SAFETY: &[T] and &[MaybeUninit<T>] have the same layout
195	let dst: &[MaybeUninit<T>] = std::mem::transmute(dst);	903✔
196
197	dst	903✔
198	}
199	}	903✔
200	}
201
202	impl<T> DerefMut for UninitRange<'_, T> {
203	fn deref_mut(&mut self) -> &mut [MaybeUninit<T>] {	923,661✔
204	&mut self.builder.values.spare_capacity_mut()[..self.len]	923,661✔
205	}	923,661✔
206	}
207
208	impl<T> UninitRange<'_, T> {
209	/// Set a validity bit at the given index. The index is relative to the start of this range
210	/// of the builder.
211	pub fn set_bit(&mut self, index: usize, v: bool) {	×
212	self.builder.nulls.set_bit(self.offset + index, v);	×
213	}	×
214
215	/// Set values from an initialized range.
216	pub fn copy_from_init(&mut self, offset: usize, len: usize, src: &[T])	5,184✔
217	where	5,184✔
218	T: Copy,	5,184✔
219	{
220	// SAFETY: &[T] and &[MaybeUninit<T>] have the same layout
221	let uninit_src: &[MaybeUninit<T>] = unsafe { std::mem::transmute(src) };	5,184✔
222
223	let dst = &mut self[offset..][..len];	5,184✔
224	dst.copy_from_slice(uninit_src);	5,184✔
225	}	5,184✔
226
227	/// Finish building this range, marking it as initialized and advancing the length of the
228	/// underlying values buffer.
229	pub fn finish(self) {	9,555✔
230	// SAFETY: constructor enforces that offset + len does not exceed the capacity of the array.
231	unsafe { self.builder.values.set_len(self.offset + self.len) };	9,555✔
232	}	9,555✔
233	}

vortex-data / vortex / 16980200873

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous