athena_rs 3.26.2

Hyper performant polyglot Database driver
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
128
129
130
131
132
133
134
135
136
137

use serde_json::Value;

use crate::drivers::cloudflare_d1::client::D1ConnectionInfo;
use crate::drivers::scylla::client::ScyllaConnectionInfo;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AthenaEngine {
    Postgres,
    D1,
    Scylla,
    S3,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AthenaClientLifecycle {
    Active,
    Frozen,
    Inactive,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct AthenaCapabilities {
    pub gateway_query: bool,
    pub raw_sql: bool,
    pub raw_cql: bool,
    pub schema_read: bool,
    pub migrations_read: bool,
    pub provisioning: bool,
    pub deferred_query: bool,
    pub cdc: bool,
    pub object_read: bool,
    pub object_write: bool,
}

impl AthenaCapabilities {
    pub fn for_engine(engine: AthenaEngine) -> Self {
        match engine {
            AthenaEngine::Postgres => Self {
                gateway_query: true,
                raw_sql: true,
                raw_cql: false,
                schema_read: true,
                migrations_read: true,
                provisioning: true,
                deferred_query: true,
                cdc: true,
                object_read: false,
                object_write: false,
            },
            AthenaEngine::D1 => Self {
                gateway_query: true,
                raw_sql: true,
                raw_cql: false,
                schema_read: false,
                migrations_read: false,
                provisioning: false,
                deferred_query: false,
                cdc: false,
                object_read: false,
                object_write: false,
            },
            AthenaEngine::Scylla => Self {
                gateway_query: true,
                raw_sql: false,
                raw_cql: true,
                schema_read: false,
                migrations_read: false,
                provisioning: false,
                deferred_query: false,
                cdc: false,
                object_read: false,
                object_write: false,
            },
            AthenaEngine::S3 => Self {
                gateway_query: false,
                raw_sql: false,
                raw_cql: false,
                schema_read: false,
                migrations_read: false,
                provisioning: false,
                deferred_query: false,
                cdc: false,
                object_read: true,
                object_write: true,
            },
        }
    }
}

#[derive(Debug, Clone)]
pub struct AthenaPostgresConnection {
    pub pg_uri: Option<String>,
    pub pg_uri_env_var: Option<String>,
    pub config_uri_template: Option<String>,
}

#[derive(Debug, Clone)]
pub struct AthenaD1Connection {
    pub worker_base_url: String,
    pub auth_token_env_var: String,
    pub database_binding: String,
    pub default_session_mode: Option<String>,
}

impl From<D1ConnectionInfo> for AthenaD1Connection {
    fn from(value: D1ConnectionInfo) -> Self {
        Self {
            worker_base_url: value.worker_base_url,
            auth_token_env_var: value.auth_token_env_var,
            database_binding: value.database_binding,
            default_session_mode: value.default_session_mode,
        }
    }
}

#[derive(Debug, Clone, Default)]
pub struct AthenaS3Connection;

#[derive(Debug, Clone)]
pub enum AthenaConnection {
    Postgres(AthenaPostgresConnection),
    D1(AthenaD1Connection),
    Scylla(ScyllaConnectionInfo),
    S3(AthenaS3Connection),
}

#[derive(Debug, Clone)]
pub struct AthenaClientDefinition {
    pub client_name: String,
    pub description: Option<String>,
    pub source: String,
    pub engine: AthenaEngine,
    pub lifecycle: AthenaClientLifecycle,
    pub capabilities: AthenaCapabilities,
    pub connection: AthenaConnection,
    pub metadata: Value,
}