vortex_vector/primitive/
mod.rs

1// SPDX-License-Identifier: Apache-2.0
2// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4//! Definitions and implementations of native primitive vector types.
5//!
6//! The types that hold data are [`PVector`] and [`PVectorMut`], which are generic over types `T`
7//! that implement [`NativePType`] (which are just the integer and floating-point types that are
8//! native to Rust plus [`f16`]).
9//!
10//! [`PrimitiveVector`] and [`PrimitiveVectorMut`] are enums that wrap all of the different possible
11//! [`PVector`]s. There are several macros defined in this crate to make working with these
12//! primitive vector types easier.
13//!
14//! # Examples
15//!
16//! ## Creating and building a vector
17//!
18//! ```
19//! use vortex_vector::primitive::PVectorMut;
20//! use vortex_vector::VectorMutOps;
21//!
22//! // Create with initial capacity for i32 values.
23//! let mut vec = PVectorMut::<i32>::with_capacity(10);
24//! assert_eq!(vec.len(), 0);
25//! assert!(vec.capacity() >= 10);
26//!
27//! // Create from an iterator of optional values.
28//! let mut vec = PVectorMut::<i32>::from_iter([Some(1), None, Some(3)]);
29//! assert_eq!(vec.len(), 3);
30//!
31//! // Works with different primitive types.
32//! let mut f64_vec = PVectorMut::<f64>::from_iter([1.5, 2.5, 3.5].map(Some));
33//! assert_eq!(f64_vec.len(), 3);
34//! ```
35//!
36//! ## Extending and appending
37//!
38//! ```
39//! use vortex_vector::primitive::PVectorMut;
40//! use vortex_vector::VectorMutOps;
41//!
42//! let mut vec1 = PVectorMut::<i32>::from_iter([1, 2].map(Some));
43//! let vec2 = PVectorMut::<i32>::from_iter([3, 4].map(Some)).freeze();
44//!
45//! // Extend from another vector.
46//! vec1.extend_from_vector(&vec2);
47//! assert_eq!(vec1.len(), 4);
48//!
49//! // Append null values.
50//! vec1.append_nulls(2);
51//! assert_eq!(vec1.len(), 6);
52//! ```
53//!
54//! ## Splitting and unsplitting
55//!
56//! ```
57//! use vortex_vector::primitive::PVectorMut;
58//! use vortex_vector::VectorMutOps;
59//!
60//! let mut vec = PVectorMut::<i64>::from_iter([10, 20, 30, 40, 50].map(Some));
61//!
62//! // Split the vector at index 3.
63//! let mut second_half = vec.split_off(3);
64//! assert_eq!(vec.len(), 3);
65//! assert_eq!(second_half.len(), 2);
66//!
67//! // Rejoin the vectors.
68//! vec.unsplit(second_half);
69//! assert_eq!(vec.len(), 5);
70//! ```
71//!
72//! ## Working with nulls
73//!
74//! ```
75//! use vortex_vector::primitive::PVectorMut;
76//! use vortex_vector::VectorMutOps;
77//!
78//! // Create a vector with some null values.
79//! let mut vec = PVectorMut::<u32>::from_iter([Some(100), None, Some(200), None]);
80//! assert_eq!(vec.len(), 4);
81//!
82//! // Add more nulls.
83//! vec.append_nulls(3);
84//! assert_eq!(vec.len(), 7);
85//! ```
86//!
87//! ## Converting to immutable
88//!
89//! ```
90//! use vortex_vector::primitive::PVectorMut;
91//! use vortex_vector::{VectorMutOps, VectorOps};
92//!
93//! let mut vec = PVectorMut::<f32>::from_iter([1.0, 2.0, 3.0].map(Some));
94//!
95//! // Freeze into an immutable vector.
96//! let immutable = vec.freeze();
97//! assert_eq!(immutable.len(), 3);
98//! ```
99//!
100//! [`f16`]: vortex_dtype::half::f16
101
102mod generic;
103pub use generic::PVector;
104
105mod generic_mut;
106mod generic_mut_impl;
107mod iter;
108pub use generic_mut::PVectorMut;
109
110mod vector;
111pub use vector::PrimitiveVector;
112
113mod vector_mut;
114pub use vector_mut::PrimitiveVectorMut;
115
116mod scalar;
117pub use scalar::{PScalar, PrimitiveScalar};
118
119mod macros;
120
121use vortex_dtype::NativePType;
122
123use crate::{Vector, VectorMut};
124
125impl From<PrimitiveVector> for Vector {
126    fn from(v: PrimitiveVector) -> Self {
127        Self::Primitive(v)
128    }
129}
130
131impl<T: NativePType> From<PVector<T>> for PrimitiveVector {
132    fn from(v: PVector<T>) -> Self {
133        T::upcast(v)
134    }
135}
136
137impl<T: NativePType> From<PVector<T>> for Vector {
138    fn from(v: PVector<T>) -> Self {
139        Self::Primitive(PrimitiveVector::from(v))
140    }
141}
142
143impl From<PrimitiveVectorMut> for VectorMut {
144    fn from(v: PrimitiveVectorMut) -> Self {
145        Self::Primitive(v)
146    }
147}
148
149impl<T: NativePType> From<PVectorMut<T>> for PrimitiveVectorMut {
150    fn from(v: PVectorMut<T>) -> Self {
151        T::upcast(v)
152    }
153}
154
155impl<T: NativePType> From<PVectorMut<T>> for VectorMut {
156    fn from(val: PVectorMut<T>) -> Self {
157        Self::Primitive(PrimitiveVectorMut::from(val))
158    }
159}
vortex_vector/primitive/mod.rs

vortex_vector/primitive/
mod.rs
