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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

mod query_builder;
mod client;
mod error;

pub use query_builder::ClickHouseQueryBuilder;
pub use client::{DeserializeError, ClickhouseClient, DatabaseError};
pub use error::Error;

#[cfg(test)]
mod tests {
    use sea_query::{Alias, Condition, Expr, Query};
    use serde_json::Value;
    use crate::client::ClickhouseClient;
    use crate::error::Error;
    use crate::query_builder::ClickHouseQueryBuilder;

    #[test]
    fn basic_select()  {
        let query = Query::select()
            .from(Alias::new("users"))
            .column(Alias::new("name"))
            .to_string(ClickHouseQueryBuilder);
        assert_eq!("SELECT \"name\" FROM \"users\"", query);
    }

    #[test]
    fn select_with_eq() {
        let query = Query::select()
            .from(Alias::new("users"))
            .column(Alias::new("name"))
            .cond_where(Condition::all().add(Expr::col(Alias::new("name")).eq("serega")))
            .to_string(ClickHouseQueryBuilder);
        assert_eq!("SELECT \"name\" FROM \"users\" WHERE \"name\" = 'serega'", query);
    }

    #[tokio::test(flavor = "current_thread")]
    async fn fetch_many() -> Result<(), Error> {
        dotenv::dotenv().ok();
        let client = ClickhouseClient::from_env()?;
        let sql = Query::select()
            .expr(Expr::asterisk())
            .from(Alias::new("service_cycles"))
            .limit(100)
            .to_string(ClickHouseQueryBuilder);
        let _ = client.fetch_many::<Value>(&sql).await?;
        Ok(())
    }
    #[tokio::test(flavor = "current_thread")]
    async fn fetch_one() -> Result<(), Error> {
        dotenv::dotenv().ok();
        let client = ClickhouseClient::from_env()?;
        let sql = Query::select()
            .expr(Expr::asterisk())
            .from(Alias::new("service_cycles"))
            .limit(1)
            .to_string(ClickHouseQueryBuilder);
        let _ = client.fetch_one::<Value>(&sql).await?;
        Ok(())
    }
    #[tokio::test(flavor = "current_thread")]
    async fn handle_database_error() -> Result<(), Error> {
        dotenv::dotenv().ok();
        let client = ClickhouseClient::from_env()?;
        let sql = Query::select()
            .expr(Expr::asterisk())
            .from(Alias::new("service_cycles_exception"))
            .limit(1)
            .to_string(ClickHouseQueryBuilder);
        let error = client.fetch_one::<Value>(&sql).await;
        let is_database_error =  match error {
            Err(Error::Database(_)) => true,
            _ => false
        };
        assert!(is_database_error);
        Ok(())
    }
    #[tokio::test(flavor = "current_thread")]
    async fn handle_deserialize_error() -> Result<(), Error> {
        dotenv::dotenv().ok();
        let client = ClickhouseClient::from_env()?;
        let sql = Query::select()
            .expr(Expr::asterisk())
            .from(Alias::new("service_cycles"))
            .limit(1)
            .to_string(ClickHouseQueryBuilder);
        let error = client.fetch_one::<i32>(&sql).await;
        let is_deserialize_error =  match error {
            Err(Error::DeserializeError(error)) => {
                println!("{}", error);
                true
            },
            _ => false
        };
        assert!(is_deserialize_error);
        Ok(())
    }
}