16331938722

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

Build # 16331938722

Build Type

push

github

Committed by

web-flow

Commit Message

feat: build with stable rust (#3881)

Run Details

120 of 173 new or added lines in 28 files covered. (69.36%)

174 existing lines in 102 files now uncovered.

41861 of 51871 relevant lines covered (80.7%)

157487.71 hits per line

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

86.08

/vortex-array/src/context.rs

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

use std::fmt::Display;
use std::sync::Arc;

use itertools::Itertools;
use parking_lot::RwLock;
use vortex_error::{VortexExpect, VortexResult, vortex_err};
use vortex_utils::aliases::hash_map::HashMap;

use crate::EncodingRef;
use crate::arrays::{
    BoolEncoding, ChunkedEncoding, ConstantEncoding, DecimalEncoding, ExtensionEncoding,
    ListEncoding, NullEncoding, PrimitiveEncoding, StructEncoding, VarBinEncoding,
    VarBinViewEncoding,
};

/// A collection of array encodings.
// TODO(ngates): it feels weird that this has interior mutability. I think maybe it shouldn't.
pub type ArrayContext = VTableContext<EncodingRef>;
pub type ArrayRegistry = VTableRegistry<EncodingRef>;

impl ArrayRegistry {
    pub fn canonical_only() -> Self {
        let mut this = Self::empty();

        // Register the canonical encodings
        this.register_many([
            EncodingRef::new_ref(NullEncoding.as_ref()) as EncodingRef,
            EncodingRef::new_ref(BoolEncoding.as_ref()),
            EncodingRef::new_ref(PrimitiveEncoding.as_ref()),
            EncodingRef::new_ref(DecimalEncoding.as_ref()),
            EncodingRef::new_ref(StructEncoding.as_ref()),
            EncodingRef::new_ref(ListEncoding.as_ref()),
            EncodingRef::new_ref(VarBinEncoding.as_ref()),
            EncodingRef::new_ref(VarBinViewEncoding.as_ref()),
            EncodingRef::new_ref(ExtensionEncoding.as_ref()),
        ]);

        // Register the utility encodings
        this.register_many([
            EncodingRef::new_ref(ConstantEncoding.as_ref()) as EncodingRef,
            EncodingRef::new_ref(ChunkedEncoding.as_ref()),
        ]);

        this
    }
}

/// A collection of encodings that can be addressed by a u16 positional index.
/// This is used to map array encodings and layout encodings when reading from a file.
#[derive(Debug, Clone)]
pub struct VTableContext<T>(Arc<RwLock<Vec<T>>>);

impl<T: Clone + Eq> VTableContext<T> {
    pub fn empty() -> Self {
        Self(Arc::new(RwLock::new(Vec::new())))
    }

    pub fn with(self, encoding: T) -> Self {
        {
            let mut write = self.0.write();
            if write.iter().all(|e| e != &encoding) {
                write.push(encoding);
            }
        }
        self
    }

    pub fn with_many<E: IntoIterator<Item = T>>(self, items: E) -> Self {
        items.into_iter().fold(self, |ctx, e| ctx.with(e))
    }

    pub fn encodings(&self) -> Vec<T> {
        self.0.read().clone()
    }

    /// Returns the index of the encoding in the context, or adds it if it doesn't exist.
    pub fn encoding_idx(&self, encoding: &T) -> u16 {
        let mut write = self.0.write();
        if let Some(idx) = write.iter().position(|e| e == encoding) {
            return u16::try_from(idx).vortex_expect("Cannot have more than u16::MAX encodings");
        }
        assert!(
            write.len() < u16::MAX as usize,
            "Cannot have more than u16::MAX encodings"
        );
        write.push(encoding.clone());
        u16::try_from(write.len() - 1).vortex_expect("checked already")
    }

    /// Find an encoding by its position.
    pub fn lookup_encoding(&self, idx: u16) -> Option<T> {
        self.0.read().get(idx as usize).cloned()
    }
}

/// A registry of encodings that can be used to construct a context for serde.
///
/// In the future, we will support loading encodings from shared libraries or even from within
/// the Vortex file itself. This registry will be used to manage the available encodings.
#[derive(Clone, Debug)]
pub struct VTableRegistry<T>(HashMap<String, T>);

// TODO(ngates): define a trait for `T` that requires an `id` method returning a `Arc<str>` and
//  auto-implement `Display` and `Eq` for it.
impl<T: Clone + Display + Eq> VTableRegistry<T> {
    pub fn empty() -> Self {
        Self(Default::default())
    }

    /// Create a new [`VTableContext`] with the provided encodings.
    pub fn new_context<'a>(
        &self,
        encoding_ids: impl Iterator<Item = &'a str>,
    ) -> VortexResult<VTableContext<T>> {
        let mut ctx = VTableContext::<T>::empty();
        for id in encoding_ids {
            let encoding = self.0.get(id).ok_or_else(|| {
                vortex_err!(
                    "Array encoding {} not found in registry {}",
                    id,
                    self.0.values().join(", ")
                )
            })?;
            ctx = ctx.with(encoding.clone());
        }
        Ok(ctx)
    }

    /// List the vtables in the registry.
    pub fn vtables(&self) -> impl Iterator<Item = &T> + '_ {
        self.0.values()
    }

    /// Find the encoding with the given ID.
    pub fn get(&self, id: &str) -> Option<&T> {
        self.0.get(id)
    }

    /// Register a new encoding, replacing any existing encoding with the same ID.
    pub fn register(&mut self, encoding: T) {
        self.0.insert(encoding.to_string(), encoding);
    }

    /// Register a new encoding, replacing any existing encoding with the same ID.
    pub fn register_many<I: IntoIterator<Item = T>>(&mut self, encodings: I) {
        self.0
            .extend(encodings.into_iter().map(|e| (e.to_string(), e)));
    }
}

1	// SPDX-License-Identifier: Apache-2.0
2	// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4	use std::fmt::Display;
5	use std::sync::Arc;
6
7	use itertools::Itertools;
8	use parking_lot::RwLock;
9	use vortex_error::{VortexExpect, VortexResult, vortex_err};
10	use vortex_utils::aliases::hash_map::HashMap;
11
12	use crate::EncodingRef;
13	use crate::arrays::{
14	BoolEncoding, ChunkedEncoding, ConstantEncoding, DecimalEncoding, ExtensionEncoding,
15	ListEncoding, NullEncoding, PrimitiveEncoding, StructEncoding, VarBinEncoding,
16	VarBinViewEncoding,
17	};
18
19	/// A collection of array encodings.
20	// TODO(ngates): it feels weird that this has interior mutability. I think maybe it shouldn't.
21	pub type ArrayContext = VTableContext<EncodingRef>;
22	pub type ArrayRegistry = VTableRegistry<EncodingRef>;
23
24	impl ArrayRegistry {
25	pub fn canonical_only() -> Self {	1,680✔
26	let mut this = Self::empty();	1,680✔
27
28	// Register the canonical encodings
29	this.register_many([	1,680✔
30	EncodingRef::new_ref(NullEncoding.as_ref()) as EncodingRef,	1,680✔
31	EncodingRef::new_ref(BoolEncoding.as_ref()),	1,680✔
32	EncodingRef::new_ref(PrimitiveEncoding.as_ref()),	1,680✔
33	EncodingRef::new_ref(DecimalEncoding.as_ref()),	1,680✔
34	EncodingRef::new_ref(StructEncoding.as_ref()),	1,680✔
35	EncodingRef::new_ref(ListEncoding.as_ref()),	1,680✔
36	EncodingRef::new_ref(VarBinEncoding.as_ref()),	1,680✔
37	EncodingRef::new_ref(VarBinViewEncoding.as_ref()),	1,680✔
38	EncodingRef::new_ref(ExtensionEncoding.as_ref()),	1,680✔
39	]);	1,680✔
40
41	// Register the utility encodings
42	this.register_many([	1,680✔
43	EncodingRef::new_ref(ConstantEncoding.as_ref()) as EncodingRef,	1,680✔
44	EncodingRef::new_ref(ChunkedEncoding.as_ref()),	1,680✔
45	]);	1,680✔
46
47	this	1,680✔
48	}	1,680✔
49	}
50
51	/// A collection of encodings that can be addressed by a u16 positional index.
52	/// This is used to map array encodings and layout encodings when reading from a file.
53	#[derive(Debug, Clone)]
54	pub struct VTableContext<T>(Arc<RwLock<Vec<T>>>);
55
56	impl<T: Clone + Eq> VTableContext<T> {
57	pub fn empty() -> Self {	1,771✔
58	Self(Arc::new(RwLock::new(Vec::new())))	1,771✔
59	}	1,771✔
60
61	pub fn with(self, encoding: T) -> Self {	5,478✔
62	{
63	let mut write = self.0.write();	5,478✔
64	if write.iter().all(\|e\| e != &encoding) {	17,801✔
65	write.push(encoding);	5,478✔
66	}	5,478✔
67	}
68	self	5,478✔
69	}	5,478✔
70
71	pub fn with_many<E: IntoIterator<Item = T>>(self, items: E) -> Self {	×
72	items.into_iter().fold(self, \|ctx, e\| ctx.with(e))	×
73	}	×
74
75	pub fn encodings(&self) -> Vec<T> {	686✔
76	self.0.read().clone()	686✔
77	}	686✔
78
79	/// Returns the index of the encoding in the context, or adds it if it doesn't exist.
80	pub fn encoding_idx(&self, encoding: &T) -> u16 {	30,671✔
81	let mut write = self.0.write();	30,671✔
82	if let Some(idx) = write.iter().position(\|e\| e == encoding) {	79,607✔
83	return u16::try_from(idx).vortex_expect("Cannot have more than u16::MAX encodings");	20,367✔
84	}	10,304✔
85	assert!(	10,304✔
86	write.len() < u16::MAX as usize,	10,304✔
87	"Cannot have more than u16::MAX encodings"	×
88	);
89	write.push(encoding.clone());	10,304✔
90	u16::try_from(write.len() - 1).vortex_expect("checked already")	10,304✔
91	}	30,671✔
92
93	/// Find an encoding by its position.
94	pub fn lookup_encoding(&self, idx: u16) -> Option<T> {	40,377✔
95	self.0.read().get(idx as usize).cloned()	40,377✔
96	}	40,377✔
97	}
98
99	/// A registry of encodings that can be used to construct a context for serde.
100	///
101	/// In the future, we will support loading encodings from shared libraries or even from within
102	/// the Vortex file itself. This registry will be used to manage the available encodings.
103	#[derive(Clone, Debug)]
104	pub struct VTableRegistry<T>(HashMap<String, T>);
105
106	// TODO(ngates): define a trait for `T` that requires an `id` method returning a `Arc<str>` and
107	// auto-implement `Display` and `Eq` for it.
108	impl<T: Clone + Display + Eq> VTableRegistry<T> {
109	pub fn empty() -> Self {	3,401✔
110	Self(Default::default())	3,401✔
111	}	3,401✔
112
113	/// Create a new [`VTableContext`] with the provided encodings.
114	pub fn new_context<'a>(	1,060✔
115	&self,	1,060✔
116	encoding_ids: impl Iterator<Item = &'a str>,	1,060✔
117	) -> VortexResult<VTableContext<T>> {	1,060✔
118	let mut ctx = VTableContext::<T>::empty();	1,060✔
119	for id in encoding_ids {	6,537✔
120	let encoding = self.0.get(id).ok_or_else(\|\| {	5,477✔
121	vortex_err!(	×
122	"Array encoding {} not found in registry {}",	×
123	id,
124	self.0.values().join(", ")	×
125	)
UNCOV 126	})?;	×
127	ctx = ctx.with(encoding.clone());	5,477✔
128	}
129	Ok(ctx)	1,060✔
130	}	1,060✔
131
132	/// List the vtables in the registry.
133	pub fn vtables(&self) -> impl Iterator<Item = &T> + '_ {	×
134	self.0.values()	×
135	}	×
136
137	/// Find the encoding with the given ID.
138	pub fn get(&self, id: &str) -> Option<&T> {	11✔
139	self.0.get(id)	11✔
140	}	11✔
141
142	/// Register a new encoding, replacing any existing encoding with the same ID.
143	pub fn register(&mut self, encoding: T) {	72✔
144	self.0.insert(encoding.to_string(), encoding);	72✔
145	}	72✔
146
147	/// Register a new encoding, replacing any existing encoding with the same ID.
148	pub fn register_many<I: IntoIterator<Item = T>>(&mut self, encodings: I) {	5,447✔
149	self.0	5,447✔
150	.extend(encodings.into_iter().map(\|e\| (e.to_string(), e)));	33,607✔
151	}	5,447✔
152	}

vortex-data / vortex / 16331938722

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