mito_codec/row_converter/
sparse.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::collections::{HashMap, HashSet};
16use std::sync::Arc;
17
18use bytes::BufMut;
19use common_recordbatch::filter::SimpleFilterEvaluator;
20use datatypes::prelude::ConcreteDataType;
21use datatypes::value::{Value, ValueRef};
22use memcomparable::{Deserializer, Serializer};
23use serde::{Deserialize, Serialize};
24use snafu::ResultExt;
25use store_api::codec::PrimaryKeyEncoding;
26use store_api::metadata::RegionMetadataRef;
27use store_api::storage::consts::ReservedColumnId;
28use store_api::storage::ColumnId;
29
30use crate::error::{DeserializeFieldSnafu, Result, SerializeFieldSnafu, UnsupportedOperationSnafu};
31use crate::key_values::KeyValue;
32use crate::primary_key_filter::SparsePrimaryKeyFilter;
33use crate::row_converter::dense::SortField;
34use crate::row_converter::{CompositeValues, PrimaryKeyCodec, PrimaryKeyFilter};
35
36/// A codec for sparse key of metrics.
37/// It requires the input primary key columns are sorted by the column name in lexicographical order.
38/// It encodes the column id of the physical region.
39#[derive(Clone, Debug)]
40pub struct SparsePrimaryKeyCodec {
41    inner: Arc<SparsePrimaryKeyCodecInner>,
42}
43
44#[derive(Debug)]
45struct SparsePrimaryKeyCodecInner {
46    // Internal fields
47    table_id_field: SortField,
48    // Internal fields
49    tsid_field: SortField,
50    // User defined label field
51    label_field: SortField,
52    // Columns in primary key
53    //
54    // None means all unknown columns is primary key(`Self::label_field`).
55    columns: Option<HashSet<ColumnId>>,
56}
57
58/// Sparse values representation.
59///
60/// A map of [`ColumnId`] to [`Value`].
61#[derive(Debug, Clone, PartialEq, Eq)]
62pub struct SparseValues {
63    values: HashMap<ColumnId, Value>,
64}
65
66impl SparseValues {
67    /// Creates a new [`SparseValues`] instance.
68    pub fn new(values: HashMap<ColumnId, Value>) -> Self {
69        Self { values }
70    }
71
72    /// Returns the value of the given column, or [`Value::Null`] if the column is not present.
73    pub fn get_or_null(&self, column_id: ColumnId) -> &Value {
74        self.values.get(&column_id).unwrap_or(&Value::Null)
75    }
76
77    /// Returns the value of the given column, or [`None`] if the column is not present.
78    pub fn get(&self, column_id: &ColumnId) -> Option<&Value> {
79        self.values.get(column_id)
80    }
81
82    /// Inserts a new value into the [`SparseValues`].
83    pub fn insert(&mut self, column_id: ColumnId, value: Value) {
84        self.values.insert(column_id, value);
85    }
86}
87
88/// The column id of the tsid.
89pub const RESERVED_COLUMN_ID_TSID: ColumnId = ReservedColumnId::tsid();
90/// The column id of the table id.
91pub const RESERVED_COLUMN_ID_TABLE_ID: ColumnId = ReservedColumnId::table_id();
92/// The size of the column id in the encoded sparse row.
93pub const COLUMN_ID_ENCODE_SIZE: usize = 4;
94
95impl SparsePrimaryKeyCodec {
96    /// Creates a new [`SparsePrimaryKeyCodec`] instance.
97    pub fn from_columns(columns_ids: impl Iterator<Item = ColumnId>) -> Self {
98        let columns = columns_ids.collect();
99        Self {
100            inner: Arc::new(SparsePrimaryKeyCodecInner {
101                table_id_field: SortField::new(ConcreteDataType::uint32_datatype()),
102                tsid_field: SortField::new(ConcreteDataType::uint64_datatype()),
103                label_field: SortField::new(ConcreteDataType::string_datatype()),
104                columns: Some(columns),
105            }),
106        }
107    }
108
109    /// Creates a new [`SparsePrimaryKeyCodec`] instance.
110    pub fn new(region_metadata: &RegionMetadataRef) -> Self {
111        Self::from_columns(region_metadata.primary_key_columns().map(|c| c.column_id))
112    }
113
114    /// Returns a new [`SparsePrimaryKeyCodec`] instance.
115    ///
116    /// It treats all unknown columns as primary key(label field).
117    pub fn schemaless() -> Self {
118        Self {
119            inner: Arc::new(SparsePrimaryKeyCodecInner {
120                table_id_field: SortField::new(ConcreteDataType::uint32_datatype()),
121                tsid_field: SortField::new(ConcreteDataType::uint64_datatype()),
122                label_field: SortField::new(ConcreteDataType::string_datatype()),
123                columns: None,
124            }),
125        }
126    }
127
128    /// Creates a new [`SparsePrimaryKeyCodec`] instance with additional label `fields`.
129    pub fn with_fields(fields: Vec<(ColumnId, SortField)>) -> Self {
130        Self {
131            inner: Arc::new(SparsePrimaryKeyCodecInner {
132                columns: Some(fields.iter().map(|f| f.0).collect()),
133                table_id_field: SortField::new(ConcreteDataType::uint32_datatype()),
134                tsid_field: SortField::new(ConcreteDataType::uint64_datatype()),
135                label_field: SortField::new(ConcreteDataType::string_datatype()),
136            }),
137        }
138    }
139
140    /// Returns the field of the given column id.
141    fn get_field(&self, column_id: ColumnId) -> Option<&SortField> {
142        // if the `columns` is not specified, all unknown columns is primary key(label field).
143        if let Some(columns) = &self.inner.columns {
144            if !columns.contains(&column_id) {
145                return None;
146            }
147        }
148
149        match column_id {
150            RESERVED_COLUMN_ID_TABLE_ID => Some(&self.inner.table_id_field),
151            RESERVED_COLUMN_ID_TSID => Some(&self.inner.tsid_field),
152            _ => Some(&self.inner.label_field),
153        }
154    }
155
156    /// Encodes the given bytes into a [`SparseValues`].
157    pub fn encode_to_vec<'a, I>(&self, row: I, buffer: &mut Vec<u8>) -> Result<()>
158    where
159        I: Iterator<Item = (ColumnId, ValueRef<'a>)>,
160    {
161        let mut serializer = Serializer::new(buffer);
162        for (column_id, value) in row {
163            if value.is_null() {
164                continue;
165            }
166
167            if let Some(field) = self.get_field(column_id) {
168                column_id
169                    .serialize(&mut serializer)
170                    .context(SerializeFieldSnafu)?;
171                field.serialize(&mut serializer, &value)?;
172            } else {
173                // TODO(weny): handle the error.
174                common_telemetry::warn!("Column {} is not in primary key, skipping", column_id);
175            }
176        }
177        Ok(())
178    }
179
180    pub fn encode_raw_tag_value<'a, I>(&self, row: I, buffer: &mut Vec<u8>) -> Result<()>
181    where
182        I: Iterator<Item = (ColumnId, &'a [u8])>,
183    {
184        for (tag_column_id, tag_value) in row {
185            let value_len = tag_value.len();
186            buffer.reserve(6 + value_len / 8 * 9);
187            buffer.put_u32(tag_column_id);
188            buffer.put_u8(1);
189            buffer.put_u8(!tag_value.is_empty() as u8);
190
191            // Manual implementation of memcomparable::ser::Serializer::serialize_bytes
192            // to avoid byte-by-byte put.
193            let mut len = 0;
194            let num_chucks = value_len / 8;
195            let remainder = value_len % 8;
196
197            for idx in 0..num_chucks {
198                buffer.extend_from_slice(&tag_value[idx * 8..idx * 8 + 8]);
199                len += 8;
200                // append an extra byte that signals the number of significant bytes in this chunk
201                // 1-8: many bytes were significant and this group is the last group
202                // 9: all 8 bytes were significant and there is more data to come
203                let extra = if len == value_len { 8 } else { 9 };
204                buffer.put_u8(extra);
205            }
206
207            if remainder != 0 {
208                buffer.extend_from_slice(&tag_value[len..value_len]);
209                buffer.put_bytes(0, 8 - remainder);
210                buffer.put_u8(remainder as u8);
211            }
212        }
213        Ok(())
214    }
215
216    /// Encodes the given bytes into a [`SparseValues`].
217    pub fn encode_internal(&self, table_id: u32, tsid: u64, buffer: &mut Vec<u8>) -> Result<()> {
218        buffer.reserve_exact(22);
219        buffer.put_u32(RESERVED_COLUMN_ID_TABLE_ID);
220        buffer.put_u8(1);
221        buffer.put_u32(table_id);
222        buffer.put_u32(RESERVED_COLUMN_ID_TSID);
223        buffer.put_u8(1);
224        buffer.put_u64(tsid);
225        Ok(())
226    }
227
228    /// Decodes the given bytes into a [`SparseValues`].
229    fn decode_sparse(&self, bytes: &[u8]) -> Result<SparseValues> {
230        let mut deserializer = Deserializer::new(bytes);
231        let mut values = SparseValues::new(HashMap::new());
232
233        let column_id = u32::deserialize(&mut deserializer).context(DeserializeFieldSnafu)?;
234        let value = self.inner.table_id_field.deserialize(&mut deserializer)?;
235        values.insert(column_id, value);
236
237        let column_id = u32::deserialize(&mut deserializer).context(DeserializeFieldSnafu)?;
238        let value = self.inner.tsid_field.deserialize(&mut deserializer)?;
239        values.insert(column_id, value);
240        while deserializer.has_remaining() {
241            let column_id = u32::deserialize(&mut deserializer).context(DeserializeFieldSnafu)?;
242            let value = self.inner.label_field.deserialize(&mut deserializer)?;
243            values.insert(column_id, value);
244        }
245
246        Ok(values)
247    }
248
249    /// Decodes the given bytes into a [`Value`].
250    fn decode_leftmost(&self, bytes: &[u8]) -> Result<Option<Value>> {
251        let mut deserializer = Deserializer::new(bytes);
252        // Skip the column id.
253        deserializer.advance(COLUMN_ID_ENCODE_SIZE);
254        let value = self.inner.table_id_field.deserialize(&mut deserializer)?;
255        Ok(Some(value))
256    }
257
258    /// Returns the offset of the given column id in the given primary key.
259    pub fn has_column(
260        &self,
261        pk: &[u8],
262        offsets_map: &mut HashMap<u32, usize>,
263        column_id: ColumnId,
264    ) -> Option<usize> {
265        if offsets_map.is_empty() {
266            let mut deserializer = Deserializer::new(pk);
267            let mut offset = 0;
268            while deserializer.has_remaining() {
269                let column_id = u32::deserialize(&mut deserializer).unwrap();
270                offset += 4;
271                offsets_map.insert(column_id, offset);
272                let Some(field) = self.get_field(column_id) else {
273                    break;
274                };
275
276                let skip = field.skip_deserialize(pk, &mut deserializer).unwrap();
277                offset += skip;
278            }
279
280            offsets_map.get(&column_id).copied()
281        } else {
282            offsets_map.get(&column_id).copied()
283        }
284    }
285
286    /// Decode value at `offset` in `pk`.
287    pub fn decode_value_at(&self, pk: &[u8], offset: usize, column_id: ColumnId) -> Result<Value> {
288        let mut deserializer = Deserializer::new(pk);
289        deserializer.advance(offset);
290        // Safety: checked by `has_column`
291        let field = self.get_field(column_id).unwrap();
292        field.deserialize(&mut deserializer)
293    }
294}
295
296impl PrimaryKeyCodec for SparsePrimaryKeyCodec {
297    fn encode_key_value(&self, _key_value: &KeyValue, _buffer: &mut Vec<u8>) -> Result<()> {
298        UnsupportedOperationSnafu {
299            err_msg: "The encode_key_value method is not supported in SparsePrimaryKeyCodec.",
300        }
301        .fail()
302    }
303
304    fn encode_values(&self, values: &[(ColumnId, Value)], buffer: &mut Vec<u8>) -> Result<()> {
305        self.encode_to_vec(values.iter().map(|v| (v.0, v.1.as_value_ref())), buffer)
306    }
307
308    fn encode_value_refs(
309        &self,
310        values: &[(ColumnId, ValueRef)],
311        buffer: &mut Vec<u8>,
312    ) -> Result<()> {
313        self.encode_to_vec(values.iter().map(|v| (v.0, v.1)), buffer)
314    }
315
316    fn estimated_size(&self) -> Option<usize> {
317        None
318    }
319
320    fn num_fields(&self) -> Option<usize> {
321        None
322    }
323
324    fn encoding(&self) -> PrimaryKeyEncoding {
325        PrimaryKeyEncoding::Sparse
326    }
327
328    fn primary_key_filter(
329        &self,
330        metadata: &RegionMetadataRef,
331        filters: Arc<Vec<SimpleFilterEvaluator>>,
332    ) -> Box<dyn PrimaryKeyFilter> {
333        Box::new(SparsePrimaryKeyFilter::new(
334            metadata.clone(),
335            filters,
336            self.clone(),
337        ))
338    }
339
340    fn decode(&self, bytes: &[u8]) -> Result<CompositeValues> {
341        Ok(CompositeValues::Sparse(self.decode_sparse(bytes)?))
342    }
343
344    fn decode_leftmost(&self, bytes: &[u8]) -> Result<Option<Value>> {
345        self.decode_leftmost(bytes)
346    }
347}
348
349/// Field with column id.
350pub struct FieldWithId {
351    pub field: SortField,
352    pub column_id: ColumnId,
353}
354
355/// A special encoder for memtable.
356pub struct SparseEncoder {
357    fields: Vec<FieldWithId>,
358}
359
360impl SparseEncoder {
361    pub fn new(fields: Vec<FieldWithId>) -> Self {
362        Self { fields }
363    }
364
365    pub fn encode_to_vec<'a, I>(&self, row: I, buffer: &mut Vec<u8>) -> Result<()>
366    where
367        I: Iterator<Item = ValueRef<'a>>,
368    {
369        let mut serializer = Serializer::new(buffer);
370        for (value, field) in row.zip(self.fields.iter()) {
371            if !value.is_null() {
372                field
373                    .column_id
374                    .serialize(&mut serializer)
375                    .context(SerializeFieldSnafu)?;
376                field.field.serialize(&mut serializer, &value)?;
377            }
378        }
379        Ok(())
380    }
381}
382
383#[cfg(test)]
384mod tests {
385    use std::sync::Arc;
386
387    use api::v1::SemanticType;
388    use common_time::timestamp::TimeUnit;
389    use common_time::Timestamp;
390    use datatypes::schema::ColumnSchema;
391    use datatypes::value::{OrderedFloat, Value};
392    use store_api::metadata::{ColumnMetadata, RegionMetadataBuilder};
393    use store_api::metric_engine_consts::{
394        DATA_SCHEMA_TABLE_ID_COLUMN_NAME, DATA_SCHEMA_TSID_COLUMN_NAME,
395    };
396    use store_api::storage::{ColumnId, RegionId};
397
398    use super::*;
399
400    fn test_region_metadata() -> RegionMetadataRef {
401        let mut builder = RegionMetadataBuilder::new(RegionId::new(1, 1));
402        builder
403            .push_column_metadata(ColumnMetadata {
404                column_schema: ColumnSchema::new(
405                    DATA_SCHEMA_TABLE_ID_COLUMN_NAME,
406                    ConcreteDataType::uint32_datatype(),
407                    false,
408                ),
409                semantic_type: SemanticType::Tag,
410                column_id: ReservedColumnId::table_id(),
411            })
412            .push_column_metadata(ColumnMetadata {
413                column_schema: ColumnSchema::new(
414                    DATA_SCHEMA_TSID_COLUMN_NAME,
415                    ConcreteDataType::uint64_datatype(),
416                    false,
417                ),
418                semantic_type: SemanticType::Tag,
419                column_id: ReservedColumnId::tsid(),
420            })
421            .push_column_metadata(ColumnMetadata {
422                column_schema: ColumnSchema::new("pod", ConcreteDataType::string_datatype(), true),
423                semantic_type: SemanticType::Tag,
424                column_id: 1,
425            })
426            .push_column_metadata(ColumnMetadata {
427                column_schema: ColumnSchema::new(
428                    "namespace",
429                    ConcreteDataType::string_datatype(),
430                    true,
431                ),
432                semantic_type: SemanticType::Tag,
433                column_id: 2,
434            })
435            .push_column_metadata(ColumnMetadata {
436                column_schema: ColumnSchema::new(
437                    "container",
438                    ConcreteDataType::string_datatype(),
439                    true,
440                ),
441                semantic_type: SemanticType::Tag,
442                column_id: 3,
443            })
444            .push_column_metadata(ColumnMetadata {
445                column_schema: ColumnSchema::new(
446                    "pod_name",
447                    ConcreteDataType::string_datatype(),
448                    true,
449                ),
450                semantic_type: SemanticType::Tag,
451                column_id: 4,
452            })
453            .push_column_metadata(ColumnMetadata {
454                column_schema: ColumnSchema::new(
455                    "pod_ip",
456                    ConcreteDataType::string_datatype(),
457                    true,
458                ),
459                semantic_type: SemanticType::Tag,
460                column_id: 5,
461            })
462            .push_column_metadata(ColumnMetadata {
463                column_schema: ColumnSchema::new(
464                    "greptime_value",
465                    ConcreteDataType::float64_datatype(),
466                    false,
467                ),
468                semantic_type: SemanticType::Field,
469                column_id: 6,
470            })
471            .push_column_metadata(ColumnMetadata {
472                column_schema: ColumnSchema::new(
473                    "greptime_timestamp",
474                    ConcreteDataType::timestamp_nanosecond_datatype(),
475                    false,
476                ),
477                semantic_type: SemanticType::Timestamp,
478                column_id: 7,
479            })
480            .primary_key(vec![
481                ReservedColumnId::table_id(),
482                ReservedColumnId::tsid(),
483                1,
484                2,
485                3,
486                4,
487                5,
488            ]);
489        let metadata = builder.build().unwrap();
490        Arc::new(metadata)
491    }
492
493    #[test]
494    fn test_sparse_value_new_and_get_or_null() {
495        let mut values = HashMap::new();
496        values.insert(1, Value::Int32(42));
497        let sparse_value = SparseValues::new(values);
498
499        assert_eq!(sparse_value.get_or_null(1), &Value::Int32(42));
500        assert_eq!(sparse_value.get_or_null(2), &Value::Null);
501    }
502
503    #[test]
504    fn test_sparse_value_insert() {
505        let mut sparse_value = SparseValues::new(HashMap::new());
506        sparse_value.insert(1, Value::Int32(42));
507
508        assert_eq!(sparse_value.get_or_null(1), &Value::Int32(42));
509    }
510
511    fn test_row() -> Vec<(ColumnId, ValueRef<'static>)> {
512        vec![
513            (RESERVED_COLUMN_ID_TABLE_ID, ValueRef::UInt32(42)),
514            (
515                RESERVED_COLUMN_ID_TSID,
516                ValueRef::UInt64(123843349035232323),
517            ),
518            // label: pod
519            (1, ValueRef::String("greptime-frontend-6989d9899-22222")),
520            // label: namespace
521            (2, ValueRef::String("greptime-cluster")),
522            // label: container
523            (3, ValueRef::String("greptime-frontend-6989d9899-22222")),
524            // label: pod_name
525            (4, ValueRef::String("greptime-frontend-6989d9899-22222")),
526            // label: pod_ip
527            (5, ValueRef::String("10.10.10.10")),
528            // field: greptime_value
529            (6, ValueRef::Float64(OrderedFloat(1.0))),
530            // field: greptime_timestamp
531            (
532                7,
533                ValueRef::Timestamp(Timestamp::new(1618876800000000000, TimeUnit::Nanosecond)),
534            ),
535        ]
536    }
537
538    #[test]
539    fn test_encode_by_short_cuts() {
540        let region_metadata = test_region_metadata();
541        let codec = SparsePrimaryKeyCodec::new(&region_metadata);
542        let mut buffer = Vec::new();
543        let internal_columns = [
544            (RESERVED_COLUMN_ID_TABLE_ID, ValueRef::UInt32(1024)),
545            (RESERVED_COLUMN_ID_TSID, ValueRef::UInt64(42)),
546        ];
547        let tags = [
548            (1, "greptime-frontend-6989d9899-22222"),
549            (2, "greptime-cluster"),
550            (3, "greptime-frontend-6989d9899-22222"),
551            (4, "greptime-frontend-6989d9899-22222"),
552            (5, "10.10.10.10"),
553        ];
554        codec
555            .encode_to_vec(internal_columns.into_iter(), &mut buffer)
556            .unwrap();
557        codec
558            .encode_to_vec(
559                tags.iter()
560                    .map(|(col_id, tag_value)| (*col_id, ValueRef::String(tag_value))),
561                &mut buffer,
562            )
563            .unwrap();
564
565        let mut buffer_by_raw_encoding = Vec::new();
566        codec
567            .encode_internal(1024, 42, &mut buffer_by_raw_encoding)
568            .unwrap();
569        let tags: Vec<_> = tags
570            .into_iter()
571            .map(|(col_id, tag_value)| (col_id, tag_value.as_bytes()))
572            .collect();
573        codec
574            .encode_raw_tag_value(
575                tags.iter().map(|(c, b)| (*c, *b)),
576                &mut buffer_by_raw_encoding,
577            )
578            .unwrap();
579        assert_eq!(buffer, buffer_by_raw_encoding);
580    }
581
582    #[test]
583    fn test_encode_to_vec() {
584        let region_metadata = test_region_metadata();
585        let codec = SparsePrimaryKeyCodec::new(&region_metadata);
586        let mut buffer = Vec::new();
587
588        let row = test_row();
589        codec.encode_to_vec(row.into_iter(), &mut buffer).unwrap();
590        assert!(!buffer.is_empty());
591        let sparse_value = codec.decode_sparse(&buffer).unwrap();
592        assert_eq!(
593            sparse_value.get_or_null(RESERVED_COLUMN_ID_TABLE_ID),
594            &Value::UInt32(42)
595        );
596        assert_eq!(
597            sparse_value.get_or_null(1),
598            &Value::String("greptime-frontend-6989d9899-22222".into())
599        );
600        assert_eq!(
601            sparse_value.get_or_null(2),
602            &Value::String("greptime-cluster".into())
603        );
604        assert_eq!(
605            sparse_value.get_or_null(3),
606            &Value::String("greptime-frontend-6989d9899-22222".into())
607        );
608        assert_eq!(
609            sparse_value.get_or_null(4),
610            &Value::String("greptime-frontend-6989d9899-22222".into())
611        );
612        assert_eq!(
613            sparse_value.get_or_null(5),
614            &Value::String("10.10.10.10".into())
615        );
616    }
617
618    #[test]
619    fn test_decode_leftmost() {
620        let region_metadata = test_region_metadata();
621        let codec = SparsePrimaryKeyCodec::new(&region_metadata);
622        let mut buffer = Vec::new();
623        let row = test_row();
624        codec.encode_to_vec(row.into_iter(), &mut buffer).unwrap();
625        assert!(!buffer.is_empty());
626        let result = codec.decode_leftmost(&buffer).unwrap().unwrap();
627        assert_eq!(result, Value::UInt32(42));
628    }
629
630    #[test]
631    fn test_has_column() {
632        let region_metadata = test_region_metadata();
633        let codec = SparsePrimaryKeyCodec::new(&region_metadata);
634        let mut buffer = Vec::new();
635        let row = test_row();
636        codec.encode_to_vec(row.into_iter(), &mut buffer).unwrap();
637        assert!(!buffer.is_empty());
638
639        let mut offsets_map = HashMap::new();
640        for column_id in [
641            RESERVED_COLUMN_ID_TABLE_ID,
642            RESERVED_COLUMN_ID_TSID,
643            1,
644            2,
645            3,
646            4,
647            5,
648        ] {
649            let offset = codec.has_column(&buffer, &mut offsets_map, column_id);
650            assert!(offset.is_some());
651        }
652
653        let offset = codec.has_column(&buffer, &mut offsets_map, 6);
654        assert!(offset.is_none());
655    }
656
657    #[test]
658    fn test_decode_value_at() {
659        let region_metadata = test_region_metadata();
660        let codec = SparsePrimaryKeyCodec::new(&region_metadata);
661        let mut buffer = Vec::new();
662        let row = test_row();
663        codec.encode_to_vec(row.into_iter(), &mut buffer).unwrap();
664        assert!(!buffer.is_empty());
665
666        let row = test_row();
667        let mut offsets_map = HashMap::new();
668        for column_id in [
669            RESERVED_COLUMN_ID_TABLE_ID,
670            RESERVED_COLUMN_ID_TSID,
671            1,
672            2,
673            3,
674            4,
675            5,
676        ] {
677            let offset = codec
678                .has_column(&buffer, &mut offsets_map, column_id)
679                .unwrap();
680            let value = codec.decode_value_at(&buffer, offset, column_id).unwrap();
681            let expected_value = row.iter().find(|(id, _)| *id == column_id).unwrap().1;
682            assert_eq!(value.as_value_ref(), expected_value);
683        }
684    }
685}
mito_codec/row_converter/sparse.rs

mito_codec/row_converter/
sparse.rs
