nativeclick 0.26.9

Nativeclick is a pure Rust SDK for working with Clickhouse with the native protocol in async environments with minimal boilerplate and maximal performance.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

use crate::{Result, io::ClickhouseRead, values::Value};

use super::{Deserializer, DeserializerState, Type};

pub struct TupleDeserializer;

impl Deserializer for TupleDeserializer {
    async fn read_prefix<R: ClickhouseRead>(
        type_: &Type,
        reader: &mut R,
        state: &mut DeserializerState,
    ) -> Result<()> {
        for item in type_.tuple_types().unwrap_or_default() {
            item.deserialize_prefix(reader, state).await?;
        }
        Ok(())
    }

    async fn read<R: ClickhouseRead>(
        type_: &Type,
        reader: &mut R,
        rows: usize,
        state: &mut DeserializerState,
    ) -> Result<Vec<Value>> {
        let mut columns = vec![];
        for type_ in type_.tuple_types().unwrap_or_default() {
            columns.push(type_.deserialize_column(reader, rows, state).await?);
        }
        Ok(zip_tuples(columns, rows))
    }
}

/// Rows of tuples from one column per element.
pub(crate) fn zip_tuples(columns: Vec<Vec<Value>>, rows: usize) -> Vec<Value> {
    let width = columns.len();
    let mut tuples = vec![Vec::with_capacity(width); rows];
    for column in columns {
        for (tuple, value) in tuples.iter_mut().zip(column) {
            tuple.push(value);
        }
    }
    tuples.into_iter().map(Value::Tuple).collect()
}