16992591828

Committed 15 Aug 2025 02:51PM UTC coverage: 87.203% (-0.5%) from 87.72%

Build # 16992591828

Build Type

Pull #2456

github

Committed by

web-flow

Commit Message

Merge fe7e226a7 into 4a23f65b3

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

Run Details

476 of 1230 new or added lines in 107 files covered. (38.7%)

74 existing lines in 19 files now uncovered.

56525 of 64820 relevant lines covered (87.2%)

623751.88 hits per line

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

94.87

/vortex-array/src/arrays/bool/serde.rs

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

use arrow_buffer::BooleanBuffer;
use vortex_buffer::{Alignment, ByteBuffer};
use vortex_dtype::DType;
use vortex_error::{VortexExpect, VortexResult, vortex_bail};

use super::BoolArray;
use crate::arrays::BoolVTable;
use crate::serde::ArrayChildren;
use crate::validity::Validity;
use crate::vtable::{SerdeVTable, VTable, VisitorVTable};
use crate::{ArrayBufferVisitor, ArrayChildVisitor, ProstMetadata};

#[derive(prost::Message)]
pub struct BoolMetadata {
    // The offset in bits must be <8
    #[prost(uint32, tag = "1")]
    pub offset: u32,
}

impl SerdeVTable<BoolVTable> for BoolVTable {
    type Metadata = ProstMetadata<BoolMetadata>;

    fn metadata(array: &BoolArray) -> VortexResult<Option<Self::Metadata>> {
        let bit_offset = array.boolean_buffer().offset();
        assert!(bit_offset < 8, "Offset must be <8, got {bit_offset}");
        Ok(Some(ProstMetadata(BoolMetadata {
            offset: u32::try_from(bit_offset).vortex_expect("checked"),
        })))
    }

    fn build(
        _encoding: &<BoolVTable as VTable>::Encoding,
        dtype: &DType,
        len: usize,
        metadata: &BoolMetadata,
        buffers: &[ByteBuffer],
        children: &dyn ArrayChildren,
    ) -> VortexResult<BoolArray> {
        if buffers.len() != 1 {
            vortex_bail!("Expected 1 buffer, got {}", buffers.len());
        }
        let buffer = BooleanBuffer::new(
            buffers[0].clone().into_arrow_buffer(),
            metadata.offset as usize,
            len,
        );

        let validity = if children.is_empty() {
            Validity::from(dtype.nullability())
        } else if children.len() == 1 {
            let validity = children.get(0, &Validity::DTYPE, len)?;
            Validity::Array(validity)
        } else {
            vortex_bail!("Expected 0 or 1 child, got {}", children.len());
        };

        Ok(BoolArray::new(buffer, validity))
    }
}

impl VisitorVTable<BoolVTable> for BoolVTable {
    fn visit_buffers(array: &BoolArray, visitor: &mut dyn ArrayBufferVisitor) {
        visitor.visit_buffer(&ByteBuffer::from_arrow_buffer(
            array.boolean_buffer().clone().into_inner(),
            Alignment::none(),
        ))
    }

    fn visit_children(array: &BoolArray, visitor: &mut dyn ArrayChildVisitor) {
        visitor.visit_validity(&array.validity, array.len());
    }
}

1	// SPDX-License-Identifier: Apache-2.0
2	// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4	use arrow_buffer::BooleanBuffer;
5	use vortex_buffer::{Alignment, ByteBuffer};
6	use vortex_dtype::DType;
7	use vortex_error::{VortexExpect, VortexResult, vortex_bail};
8
9	use super::BoolArray;
10	use crate::arrays::BoolVTable;
11	use crate::serde::ArrayChildren;
12	use crate::validity::Validity;
13	use crate::vtable::{SerdeVTable, VTable, VisitorVTable};
14	use crate::{ArrayBufferVisitor, ArrayChildVisitor, ProstMetadata};
15
16	#[derive(prost::Message)]
17	pub struct BoolMetadata {
18	// The offset in bits must be <8
19	#[prost(uint32, tag = "1")]
20	pub offset: u32,
21	}
22
23	impl SerdeVTable<BoolVTable> for BoolVTable {
24	type Metadata = ProstMetadata<BoolMetadata>;
25		16✔
26	fn metadata(array: &BoolArray) -> VortexResult<Option<Self::Metadata>> {	12,605✔
27	let bit_offset = array.boolean_buffer().offset();	12,605✔
28	assert!(bit_offset < 8, "Offset must be <8, got {bit_offset}");	12,605✔
29	Ok(Some(ProstMetadata(BoolMetadata {	12,605✔
30	offset: u32::try_from(bit_offset).vortex_expect("checked"),	12,605✔
31	})))	12,605✔
32	}	12,589✔
33
34	fn build(	2,226✔
35	_encoding: &<BoolVTable as VTable>::Encoding,	2,226✔
36	dtype: &DType,	2,226✔
37	len: usize,	2,226✔
38	metadata: &BoolMetadata,	2,226✔
39	buffers: &[ByteBuffer],	2,226✔
40	children: &dyn ArrayChildren,	2,226✔
41	) -> VortexResult<BoolArray> {	2,226✔
42	if buffers.len() != 1 {	2,226✔
UNCOV 43	vortex_bail!("Expected 1 buffer, got {}", buffers.len());	×
44	}	2,226✔
45	let buffer = BooleanBuffer::new(	2,226✔
46	buffers[0].clone().into_arrow_buffer(),	2,226✔
47	metadata.offset as usize,	2,226✔
48	len,	2,226✔
49	);
50
51	let validity = if children.is_empty() {	2,226✔
52	Validity::from(dtype.nullability())	2,226✔
53	} else if children.len() == 1 {
54	let validity = children.get(0, &Validity::DTYPE, len)?;
UNCOV 55	Validity::Array(validity)	×
56	} else {
57	vortex_bail!("Expected 0 or 1 child, got {}", children.len());
58	};
59
60	Ok(BoolArray::new(buffer, validity))	2,250✔
61	}	2,250✔
62	}	24✔
63
64	impl VisitorVTable<BoolVTable> for BoolVTable {	32✔
65	fn visit_buffers(array: &BoolArray, visitor: &mut dyn ArrayBufferVisitor) {	29,896✔
66	visitor.visit_buffer(&ByteBuffer::from_arrow_buffer(	29,896✔
67	array.boolean_buffer().clone().into_inner(),	29,864✔
68	Alignment::none(),	29,864✔
69	))	29,864✔
70	}	29,864✔
71
72	fn visit_children(array: &BoolArray, visitor: &mut dyn ArrayChildVisitor) {	36,159✔
73	visitor.visit_validity(&array.validity, array.len());	36,159✔
74	}	36,159✔
75	}

vortex-data / vortex / 16992591828

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