datatypes/vectors/
null.rs

1// Copyright 2023 Greptime Team
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use std::any::Any;
16use std::fmt;
17use std::sync::Arc;
18
19use arrow::array::{Array, ArrayRef, NullArray};
20use snafu::{ensure, OptionExt};
21
22use crate::data_type::ConcreteDataType;
23use crate::error::{self, Result};
24use crate::serialize::Serializable;
25use crate::types::NullType;
26use crate::value::{Value, ValueRef};
27use crate::vectors::{self, MutableVector, Validity, Vector, VectorRef};
28
29/// A vector where all elements are nulls.
30#[derive(PartialEq)]
31pub struct NullVector {
32    array: NullArray,
33}
34
35// TODO(yingwen): Support null vector with other logical types.
36impl NullVector {
37    /// Create a new `NullVector` with `n` elements.
38    pub fn new(n: usize) -> Self {
39        Self {
40            array: NullArray::new(n),
41        }
42    }
43
44    pub(crate) fn as_arrow(&self) -> &dyn Array {
45        &self.array
46    }
47}
48
49impl From<NullArray> for NullVector {
50    fn from(array: NullArray) -> Self {
51        Self { array }
52    }
53}
54
55impl Vector for NullVector {
56    fn data_type(&self) -> ConcreteDataType {
57        ConcreteDataType::Null(NullType)
58    }
59
60    fn vector_type_name(&self) -> String {
61        "NullVector".to_string()
62    }
63
64    fn as_any(&self) -> &dyn Any {
65        self
66    }
67
68    fn len(&self) -> usize {
69        self.array.len()
70    }
71
72    fn to_arrow_array(&self) -> ArrayRef {
73        Arc::new(self.array.clone())
74    }
75
76    fn to_boxed_arrow_array(&self) -> Box<dyn Array> {
77        Box::new(self.array.clone())
78    }
79
80    fn validity(&self) -> Validity {
81        Validity::all_null(self.array.len())
82    }
83
84    fn memory_size(&self) -> usize {
85        0
86    }
87
88    fn null_count(&self) -> usize {
89        self.array.len()
90    }
91
92    fn is_null(&self, _row: usize) -> bool {
93        true
94    }
95
96    fn only_null(&self) -> bool {
97        true
98    }
99
100    fn slice(&self, _offset: usize, length: usize) -> VectorRef {
101        Arc::new(Self::new(length))
102    }
103
104    fn get(&self, _index: usize) -> Value {
105        // Skips bound check for null array.
106        Value::Null
107    }
108
109    fn get_ref(&self, _index: usize) -> ValueRef {
110        // Skips bound check for null array.
111        ValueRef::Null
112    }
113}
114
115impl fmt::Debug for NullVector {
116    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
117        write!(f, "NullVector({})", self.len())
118    }
119}
120
121impl Serializable for NullVector {
122    fn serialize_to_json(&self) -> Result<Vec<serde_json::Value>> {
123        Ok(std::iter::repeat_n(serde_json::Value::Null, self.len()).collect())
124    }
125}
126
127vectors::impl_try_from_arrow_array_for_vector!(NullArray, NullVector);
128
129#[derive(Default)]
130pub struct NullVectorBuilder {
131    length: usize,
132}
133
134impl MutableVector for NullVectorBuilder {
135    fn data_type(&self) -> ConcreteDataType {
136        ConcreteDataType::null_datatype()
137    }
138
139    fn len(&self) -> usize {
140        self.length
141    }
142
143    fn as_any(&self) -> &dyn Any {
144        self
145    }
146
147    fn as_mut_any(&mut self) -> &mut dyn Any {
148        self
149    }
150
151    fn to_vector(&mut self) -> VectorRef {
152        let vector = Arc::new(NullVector::new(self.length));
153        self.length = 0;
154        vector
155    }
156
157    fn to_vector_cloned(&self) -> VectorRef {
158        Arc::new(NullVector::new(self.length))
159    }
160
161    fn try_push_value_ref(&mut self, value: ValueRef) -> Result<()> {
162        ensure!(
163            value.is_null(),
164            error::CastTypeSnafu {
165                msg: format!("Failed to cast value ref {value:?} to null"),
166            }
167        );
168
169        self.length += 1;
170        Ok(())
171    }
172
173    fn extend_slice_of(&mut self, vector: &dyn Vector, offset: usize, length: usize) -> Result<()> {
174        let _ = vector
175            .as_any()
176            .downcast_ref::<NullVector>()
177            .with_context(|| error::CastTypeSnafu {
178                msg: format!(
179                    "Failed to convert vector from {} to NullVector",
180                    vector.vector_type_name()
181                ),
182            })?;
183        assert!(
184            offset + length <= vector.len(),
185            "offset {} + length {} must less than {}",
186            offset,
187            length,
188            vector.len()
189        );
190
191        self.length += length;
192        Ok(())
193    }
194
195    fn push_null(&mut self) {
196        self.length += 1;
197    }
198}
199
200pub(crate) fn replicate_null(vector: &NullVector, offsets: &[usize]) -> VectorRef {
201    assert_eq!(offsets.len(), vector.len());
202
203    if offsets.is_empty() {
204        return vector.slice(0, 0);
205    }
206
207    Arc::new(NullVector::new(*offsets.last().unwrap()))
208}
209
210#[cfg(test)]
211mod tests {
212    use serde_json;
213
214    use super::*;
215    use crate::data_type::DataType;
216
217    #[test]
218    fn test_null_vector_misc() {
219        let v = NullVector::new(32);
220
221        assert_eq!(v.len(), 32);
222        assert_eq!(0, v.memory_size());
223        assert_eq!(v.null_count(), 32);
224
225        let vector2 = v.slice(8, 16);
226        assert_eq!(vector2.len(), 16);
227        assert_eq!(vector2.null_count(), 16);
228
229        assert_eq!("NullVector", v.vector_type_name());
230        assert!(!v.is_const());
231        assert!(v.validity().is_all_null());
232        assert!(v.only_null());
233
234        for i in 0..32 {
235            assert!(v.is_null(i));
236            assert_eq!(Value::Null, v.get(i));
237            assert_eq!(ValueRef::Null, v.get_ref(i));
238        }
239    }
240
241    #[test]
242    fn test_debug_null_vector() {
243        let array = NullVector::new(1024 * 1024);
244        assert_eq!(format!("{array:?}"), "NullVector(1048576)");
245    }
246
247    #[test]
248    fn test_serialize_json() {
249        let vector = NullVector::new(3);
250        let json_value = vector.serialize_to_json().unwrap();
251        assert_eq!(
252            "[null,null,null]",
253            serde_json::to_string(&json_value).unwrap()
254        );
255    }
256
257    #[test]
258    fn test_null_vector_validity() {
259        let vector = NullVector::new(5);
260        assert!(vector.validity().is_all_null());
261        assert_eq!(5, vector.null_count());
262    }
263
264    #[test]
265    fn test_null_vector_builder() {
266        let mut builder = NullType.create_mutable_vector(3);
267        builder.push_null();
268        assert!(builder.try_push_value_ref(ValueRef::Int32(123)).is_err());
269
270        let input = NullVector::new(3);
271        builder.extend_slice_of(&input, 1, 2).unwrap();
272        assert!(builder
273            .extend_slice_of(&crate::vectors::Int32Vector::from_slice([13]), 0, 1)
274            .is_err());
275        let vector = builder.to_vector();
276
277        let expect: VectorRef = Arc::new(input);
278        assert_eq!(expect, vector);
279    }
280
281    #[test]
282    fn test_null_vector_builder_finish_cloned() {
283        let mut builder = NullType.create_mutable_vector(3);
284        builder.push_null();
285        builder.push_null();
286        let vector = builder.to_vector_cloned();
287        assert_eq!(vector.len(), 2);
288        assert_eq!(vector.null_count(), 2);
289    }
290}
datatypes/vectors/null.rs

datatypes/vectors/
null.rs
