snowflakedb-rs 1.1.6

A lightweight, comprehensive and familiar database driver for the SnowflakeDB written natively in Rust
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
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use std::collections::HashMap;

use crate::SnowflakeError;
use core::future::Future;

#[cfg(feature = "reqwest")]
use reqwest;

pub trait SnowflakeHttpClient: Clone + Send + 'static {
    // type Body: AsyncRead + Unpin + Send + 'static;

    fn new() -> Self;

    fn get(
        &self,
        url: &str,
        headers: HashMap<String, String>,
    ) -> impl Future<Output = Result<Vec<u8>, SnowflakeError>> + Send;

    fn post(
        &self,
        url: &str,
        body: Vec<u8>,
        headers: HashMap<String, String>,
    ) -> impl Future<Output = Result<Vec<u8>, SnowflakeError>> + Send;
}

#[cfg(feature = "reqwest")]
impl SnowflakeHttpClient for reqwest::Client {
    fn new() -> Self {
        reqwest::Client::builder()
            .gzip(true)
            .referer(false)
            .build()
            .unwrap()
    }

    fn get(
        &self,
        url: &str,
        headers: HashMap<String, String>,
    ) -> impl Future<Output = Result<Vec<u8>, SnowflakeError>> {
        async move {
            use crate::{error, this_errors};
            use reqwest::header::HeaderMap;

            let url = this_errors!("failed to parse url", reqwest::Url::parse(url));

            let headers = this_errors!(
                "failed to convert headers",
                headers
                    .iter()
                    .map(|(k, v)| {
                        Ok((
                            reqwest::header::HeaderName::from_bytes(k.as_bytes())
                                .map_err(|e| error!(e))?,
                            reqwest::header::HeaderValue::from_str(v.as_str())
                                .map_err(|e| error!(e))?,
                        ))
                    })
                    .collect::<Result<
                        Vec<(reqwest::header::HeaderName, reqwest::header::HeaderValue)>,
                        SnowflakeError,
                    >>()
            );

            let resp = this_errors!(
                "failed to send get request",
                self.get(url)
                    .headers(HeaderMap::from_iter(headers))
                    .send()
                    .await
            );

            // TODO: Improve this. This currently waits for entire response body to be returned
            // before it begins processing the data. Ideally this could be streamed into the Gzip Decoder,
            // then streams into the arrow StreamReader
            let bytes = this_errors!("failed to get response as bytes", resp.bytes().await);

            Ok(bytes.to_vec())
        }
    }

    fn post(
        &self,
        url: &str,
        body: Vec<u8>,
        headers: HashMap<String, String>,
    ) -> impl Future<Output = Result<Vec<u8>, SnowflakeError>> {
        use crate::{error, this_errors};

        async move {
            use reqwest::header::HeaderMap;

            let url = this_errors!("failed to parse url", reqwest::Url::parse(url));

            let headers = this_errors!(
                "failed to convert headers",
                headers
                    .iter()
                    .map(|(k, v)| {
                        Ok((
                            reqwest::header::HeaderName::from_bytes(k.as_bytes())
                                .map_err(|e| error!(e))?,
                            reqwest::header::HeaderValue::from_str(v.as_str())
                                .map_err(|e| error!(e))?,
                        ))
                    })
                    .collect::<Result<
                        Vec<(reqwest::header::HeaderName, reqwest::header::HeaderValue)>,
                        SnowflakeError,
                    >>()
            );

            let headers = HeaderMap::from_iter(headers);

            let resp = this_errors!(
                "failed to send post request",
                self.post(url).body(body).headers(headers).send().await
            );

            let bytes = this_errors!("failed to get response bytes", resp.bytes().await);

            Ok(bytes.to_vec())
        }
    }
}