chdb 0.1.2

Use clickhouse as library (chdb)
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use std::ffi::CString;

use chdb_bindings_rs::query_stable;

use crate::{options::QueryOption, result::QueryResult};

#[derive(Debug)]
pub struct Query {
    query: String,
    params: Vec<QueryOption>,
}

impl Query {
    pub fn new(query: impl Into<String>) -> Self {
        Self {
            query: query.into(),
            params: Vec::new(),
        }
    }

    pub fn option(self, param: QueryOption) -> Self {
        Self {
            query: self.query,
            params: self
                .params
                .into_iter()
                .chain(std::iter::once(param))
                .collect(),
        }
    }

    pub fn exec(self) -> Option<QueryResult> {
        let mut args: Vec<String> =
            Vec::from(["clickhouse".to_string(), format!("--query={}", self.query)]);

        args.extend(
            self.params
                .iter()
                .map(|p| p.to_string())
                .collect::<Vec<_>>(),
        );

        let c_strings: Vec<CString> = args
            .iter()
            .map(|s| CString::new(s.as_str()).expect("Failed to convert &str to CString"))
            .collect();

        let raw_pointers: Vec<*const std::os::raw::c_char> =
            c_strings.iter().map(|c_string| c_string.as_ptr()).collect();

        let result = unsafe { query_stable(c_strings.len() as i32, raw_pointers.as_ptr()) };

        if result.is_null() {
            return None;
        }

        let result = unsafe { &*result };

        Some(QueryResult {
            elapsed: result.elapsed,
            rows_read: result.rows_read,
            bytes_read: result.bytes_read,
            buf: unsafe { Vec::from_raw_parts(result.buf as *mut u8, result.size, 16) },
        })
    }
}