16324698785

Committed 16 Jul 2025 04:12PM UTC coverage: 80.702% (-0.9%) from 81.557%

Build # 16324698785

Build Type

Pull #3881

github

Committed by

web-flow

Commit Message

Merge afc822f8d into ced09d9a8

Pull Request Pull Request #3881: feat: build with stable rust

Run Details

119 of 172 new or added lines in 28 files covered. (69.19%)

174 existing lines in 102 files now uncovered.

41861 of 51871 relevant lines covered (80.7%)

157493.2 hits per line

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

98.89

/vortex-layout/src/flatbuffers.rs

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

use std::env;
use std::sync::LazyLock;

use flatbuffers::{FlatBufferBuilder, VerifierOptions, WIPOffset, root_with_opts};
use vortex_array::ArrayContext;
use vortex_dtype::DType;
use vortex_error::{VortexExpect, VortexResult, vortex_err};
use vortex_flatbuffers::{FlatBuffer, FlatBufferRoot, WriteFlatBuffer, layout};

use crate::children::ViewedLayoutChildren;
use crate::segments::SegmentId;
use crate::{Layout, LayoutContext, LayoutRef};

static LAYOUT_VERIFIER: LazyLock<VerifierOptions> = LazyLock::new(|| {
    VerifierOptions {
        // Overriden
        max_tables: env::var("VORTEX_MAX_LAYOUT_TABLES")
            .ok()
            .and_then(|lmt| lmt.parse::<usize>().ok())
            .unwrap_or(1000000),
        max_depth: env::var("VORTEX_MAX_LAYOUT_DEPTH")
            .ok()
            .and_then(|lmt| lmt.parse::<usize>().ok())
            .unwrap_or(64),
        // Defaults from flatbuffers
        max_apparent_size: 1 << 31,
        ignore_missing_null_terminator: false,
    }
});

/// Parse a [`LayoutRef`] from a layout flatbuffer.
pub fn layout_from_flatbuffer(
    flatbuffer: FlatBuffer,
    dtype: &DType,
    layout_ctx: &LayoutContext,
    array_ctx: &ArrayContext,
) -> VortexResult<LayoutRef> {
    let fb_layout = root_with_opts::<layout::Layout>(&LAYOUT_VERIFIER, &flatbuffer)?;
    let encoding = layout_ctx
        .lookup_encoding(fb_layout.encoding())
        .ok_or_else(|| vortex_err!("Invalid encoding ID: {}", fb_layout.encoding()))?;

    // SAFETY: we validate the flatbuffer above in the `root` call, and extract a loc.
    let viewed_children = unsafe {
        ViewedLayoutChildren::new_unchecked(
            flatbuffer.clone(),
            fb_layout._tab.loc(),
            array_ctx.clone(),
            layout_ctx.clone(),
        )
    };

    let layout = encoding.build(
        dtype,
        fb_layout.row_count(),
        fb_layout
            .metadata()
            .map(|m| m.bytes())
            .unwrap_or_else(|| &[]),
        fb_layout
            .segments()
            .unwrap_or_default()
            .iter()
            .map(SegmentId::from)
            .collect(),
        &viewed_children,
        array_ctx.clone(),
    )?;

    Ok(layout)
}

impl dyn Layout + '_ {
    /// Serialize the layout into a [`FlatBufferBuilder`].
    pub fn flatbuffer_writer<'a>(
        &'a self,
        ctx: &'a LayoutContext,
    ) -> impl WriteFlatBuffer<Target<'a> = layout::Layout<'a>> + FlatBufferRoot + 'a {
        LayoutFlatBufferWriter { layout: self, ctx }
    }
}

/// An adapter struct for writing a layout to a FlatBuffer.
struct LayoutFlatBufferWriter<'a> {
    layout: &'a dyn Layout,
    ctx: &'a LayoutContext,
}

impl FlatBufferRoot for LayoutFlatBufferWriter<'_> {}

impl WriteFlatBuffer for LayoutFlatBufferWriter<'_> {
    type Target<'t> = layout::Layout<'t>;

    fn write_flatbuffer<'fb>(
        &self,
        fbb: &mut FlatBufferBuilder<'fb>,
    ) -> WIPOffset<Self::Target<'fb>> {
        // First we recurse into the children and write them out
        let child_layouts = self
            .layout
            .children()
            .vortex_expect("Failed to load layout children");
        let children = child_layouts
            .iter()
            .map(|layout| {
                LayoutFlatBufferWriter {
                    layout: layout.as_ref(),
                    ctx: self.ctx,
                }
                .write_flatbuffer(fbb)
            })
            .collect::<Vec<_>>();
        let children = (!children.is_empty()).then(|| fbb.create_vector(&children));

        // Next we write out the metadata if it's non-empty.
        let metadata = self.layout.metadata();
        let metadata = (!metadata.is_empty()).then(|| fbb.create_vector(&metadata));

        let segments = self
            .layout
            .segment_ids()
            .into_iter()
            .map(|s| *s)
            .collect::<Vec<_>>();
        let segments = (!segments.is_empty()).then(|| fbb.create_vector(&segments));

        // Dictionary-encode the layout ID
        let encoding = self.ctx.encoding_idx(&self.layout.encoding());

        layout::Layout::create(
            fbb,
            &layout::LayoutArgs {
                encoding,
                row_count: self.layout.row_count(),
                metadata,
                children,
                segments,
            },
        )
    }
}

1	// SPDX-License-Identifier: Apache-2.0
2	// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4	use std::env;
5	use std::sync::LazyLock;
6
7	use flatbuffers::{FlatBufferBuilder, VerifierOptions, WIPOffset, root_with_opts};
8	use vortex_array::ArrayContext;
9	use vortex_dtype::DType;
10	use vortex_error::{VortexExpect, VortexResult, vortex_err};
11	use vortex_flatbuffers::{FlatBuffer, FlatBufferRoot, WriteFlatBuffer, layout};
12
13	use crate::children::ViewedLayoutChildren;
14	use crate::segments::SegmentId;
15	use crate::{Layout, LayoutContext, LayoutRef};
16
17	static LAYOUT_VERIFIER: LazyLock<VerifierOptions> = LazyLock::new(\|\| {	668✔
18	VerifierOptions {
19	// Overriden
20	max_tables: env::var("VORTEX_MAX_LAYOUT_TABLES")	668✔
21	.ok()	668✔
22	.and_then(\|lmt\| lmt.parse::<usize>().ok())	668✔
23	.unwrap_or(1000000),	668✔
24	max_depth: env::var("VORTEX_MAX_LAYOUT_DEPTH")	668✔
25	.ok()	668✔
26	.and_then(\|lmt\| lmt.parse::<usize>().ok())	668✔
27	.unwrap_or(64),	668✔
28	// Defaults from flatbuffers
29	max_apparent_size: 1 << 31,	668✔
30	ignore_missing_null_terminator: false,
31	}
32	});	668✔
33
34	/// Parse a [`LayoutRef`] from a layout flatbuffer.
35	pub fn layout_from_flatbuffer(	906✔
36	flatbuffer: FlatBuffer,	906✔
37	dtype: &DType,	906✔
38	layout_ctx: &LayoutContext,	906✔
39	array_ctx: &ArrayContext,	906✔
40	) -> VortexResult<LayoutRef> {	906✔
41	let fb_layout = root_with_opts::<layout::Layout>(&LAYOUT_VERIFIER, &flatbuffer)?;	906✔
42	let encoding = layout_ctx	906✔
43	.lookup_encoding(fb_layout.encoding())	906✔
44	.ok_or_else(\|\| vortex_err!("Invalid encoding ID: {}", fb_layout.encoding()))?;	906✔
45
46	// SAFETY: we validate the flatbuffer above in the `root` call, and extract a loc.
47	let viewed_children = unsafe {	906✔
48	ViewedLayoutChildren::new_unchecked(	906✔
49	flatbuffer.clone(),	906✔
50	fb_layout._tab.loc(),	906✔
51	array_ctx.clone(),	906✔
52	layout_ctx.clone(),	906✔
53	)
54	};
55
56	let layout = encoding.build(	906✔
57	dtype,	906✔
58	fb_layout.row_count(),	906✔
59	fb_layout	906✔
60	.metadata()	906✔
61	.map(\|m\| m.bytes())	906✔
62	.unwrap_or_else(\|\| &[]),	906✔
63	fb_layout	906✔
64	.segments()	906✔
65	.unwrap_or_default()	906✔
66	.iter()	906✔
67	.map(SegmentId::from)	906✔
68	.collect(),	906✔
69	&viewed_children,	906✔
70	array_ctx.clone(),	906✔
UNCOV 71	)?;	×
72
73	Ok(layout)	906✔
74	}	906✔
75
76	impl dyn Layout + '_ {
77	/// Serialize the layout into a [`FlatBufferBuilder`].
78	pub fn flatbuffer_writer<'a>(	736✔
79	&'a self,	736✔
80	ctx: &'a LayoutContext,	736✔
81	) -> impl WriteFlatBuffer<Target<'a> = layout::Layout<'a>> + FlatBufferRoot + 'a {	736✔
82	LayoutFlatBufferWriter { layout: self, ctx }	736✔
83	}	736✔
84	}
85
86	/// An adapter struct for writing a layout to a FlatBuffer.
87	struct LayoutFlatBufferWriter<'a> {
88	layout: &'a dyn Layout,
89	ctx: &'a LayoutContext,
90	}
91
92	impl FlatBufferRoot for LayoutFlatBufferWriter<'_> {}
93
94	impl WriteFlatBuffer for LayoutFlatBufferWriter<'_> {
95	type Target<'t> = layout::Layout<'t>;
96
97	fn write_flatbuffer<'fb>(	5,168✔
98	&self,	5,168✔
99	fbb: &mut FlatBufferBuilder<'fb>,	5,168✔
100	) -> WIPOffset<Self::Target<'fb>> {	5,168✔
101	// First we recurse into the children and write them out
102	let child_layouts = self	5,168✔
103	.layout	5,168✔
104	.children()	5,168✔
105	.vortex_expect("Failed to load layout children");	5,168✔
106	let children = child_layouts	5,168✔
107	.iter()	5,168✔
108	.map(\|layout\| {	5,168✔
109	LayoutFlatBufferWriter {	4,432✔
110	layout: layout.as_ref(),	4,432✔
111	ctx: self.ctx,	4,432✔
112	}	4,432✔
113	.write_flatbuffer(fbb)	4,432✔
114	})	4,432✔
115	.collect::<Vec<_>>();	5,168✔
116	let children = (!children.is_empty()).then(\|\| fbb.create_vector(&children));	5,168✔
117
118	// Next we write out the metadata if it's non-empty.
119	let metadata = self.layout.metadata();	5,168✔
120	let metadata = (!metadata.is_empty()).then(\|\| fbb.create_vector(&metadata));	5,168✔
121
122	let segments = self	5,168✔
123	.layout	5,168✔
124	.segment_ids()	5,168✔
125	.into_iter()	5,168✔
126	.map(\|s\| *s)	5,168✔
127	.collect::<Vec<_>>();	5,168✔
128	let segments = (!segments.is_empty()).then(\|\| fbb.create_vector(&segments));	5,168✔
129
130	// Dictionary-encode the layout ID
131	let encoding = self.ctx.encoding_idx(&self.layout.encoding());	5,168✔
132
133	layout::Layout::create(	5,168✔
134	fbb,	5,168✔
135	&layout::LayoutArgs {	5,168✔
136	encoding,	5,168✔
137	row_count: self.layout.row_count(),	5,168✔
138	metadata,	5,168✔
139	children,	5,168✔
140	segments,	5,168✔
141	},	5,168✔
142	)
143	}	5,168✔
144	}

vortex-data / vortex / 16324698785

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