clickhouse_arrow/native/
block_info.rs

1use tokio::io::{AsyncReadExt, AsyncWriteExt};
2
3use crate::io::{ClickHouseBytesRead, ClickHouseBytesWrite, ClickHouseRead, ClickHouseWrite};
4use crate::{Error, Result};
5
6/// Metadata about a block
7#[derive(Debug, Clone, Copy)]
8pub struct BlockInfo {
9    pub is_overflows: bool,
10    pub bucket_num:   i32,
11}
12
13impl Default for BlockInfo {
14    fn default() -> Self { BlockInfo { is_overflows: false, bucket_num: -1 } }
15}
16
17impl BlockInfo {
18    pub(crate) async fn read_async<R: ClickHouseRead>(reader: &mut R) -> Result<Self> {
19        let mut new = Self::default();
20        loop {
21            let field_num = reader.read_var_uint().await?;
22            match field_num {
23                0 => break,
24                1 => {
25                    new.is_overflows = reader.read_u8().await? != 0;
26                }
27                2 => {
28                    new.bucket_num = reader.read_i32_le().await?;
29                }
30                field_num => {
31                    return Err(Error::Protocol(format!(
32                        "unknown block info field number: {field_num}"
33                    )));
34                }
35            }
36        }
37        Ok(new)
38    }
39
40    pub(crate) async fn write_async<W: ClickHouseWrite>(&self, writer: &mut W) -> Result<()> {
41        writer.write_var_uint(1).await?; // Block info version
42        writer.write_u8(if self.is_overflows { 1 } else { 2 }).await?; // Is overflows
43        writer.write_var_uint(2).await?; // Bucket num
44        writer.write_i32_le(self.bucket_num).await?; // Bucket num
45        writer.write_var_uint(0).await?; // End field
46        Ok(())
47    }
48
49    pub(crate) fn read<R: ClickHouseBytesRead>(reader: &mut R) -> Result<Self> {
50        let mut new = Self::default();
51        loop {
52            let field_num = reader.try_get_var_uint()?;
53            match field_num {
54                0 => break,
55                1 => {
56                    new.is_overflows = reader.try_get_u8()? != 0;
57                }
58                2 => {
59                    new.bucket_num = reader.try_get_i32_le()?;
60                }
61                field_num => {
62                    return Err(Error::Protocol(format!(
63                        "unknown block info field number: {field_num}"
64                    )));
65                }
66            }
67        }
68        Ok(new)
69    }
70
71    pub(crate) fn write<W: ClickHouseBytesWrite>(self, writer: &mut W) -> Result<()> {
72        writer.put_var_uint(1)?; // Block info version
73        writer.put_u8(if self.is_overflows { 1 } else { 2 }); // Is overflows
74        writer.put_var_uint(2)?; // Bucket num
75        writer.put_i32_le(self.bucket_num); // Bucket num
76        writer.put_var_uint(0)?; // End field
77        Ok(())
78    }
79}