1use std::collections::{HashMap, HashSet};
2use std::time::Duration;
3
4use chrono_tz::Tz;
5use http::uri::Scheme;
6use reqwest::Url;
7
8use crate::error::*;
9use crate::selected_role::SelectedRole;
10use crate::transaction::TransactionId;
11
12fn default<T: Default>() -> T {
14 Default::default()
15}
16
17#[derive(Debug)]
18pub struct Session {
19 pub url: Url,
20 pub user: String,
21 pub source: String,
22 pub trace_token: Option<String>,
23 pub client_tags: HashSet<String>,
24 pub client_info: Option<String>,
25 pub catalog: Option<String>,
26 pub schema: Option<String>,
27 pub path: Option<String>,
28 pub timezone: Option<Tz>,
30 pub resource_estimates: HashMap<String, String>,
32 pub properties: HashMap<String, String>,
33 pub prepared_statements: HashMap<String, String>,
34 pub roles: HashMap<String, SelectedRole>,
35 pub extra_credentials: HashMap<String, String>,
36 pub transaction_id: TransactionId,
37 pub client_request_timeout: Duration,
38 pub compression_disabled: bool,
39}
40
41#[derive(Debug)]
42pub(crate) struct SessionBuilder {
43 pub(crate) host: String,
44 pub(crate) port: u16,
45 pub(crate) secure: bool,
46 pub(crate) user: String,
47 pub(crate) source: String,
48 pub(crate) trace_token: Option<String>,
49 pub(crate) client_tags: HashSet<String>,
50 pub(crate) client_info: Option<String>,
51 pub(crate) catalog: Option<String>,
52 pub(crate) schema: Option<String>,
53 pub(crate) path: Option<String>,
54 pub(crate) timezone: Option<Tz>,
55 pub(crate) resource_estimates: HashMap<String, String>,
57 pub(crate) properties: HashMap<String, String>,
58 pub(crate) prepared_statements: HashMap<String, String>,
59 pub(crate) roles: HashMap<String, SelectedRole>,
60 pub(crate) extra_credentials: HashMap<String, String>,
61 pub(crate) transaction_id: TransactionId,
62 pub(crate) client_request_timeout: Duration,
63 pub(crate) compression_disabled: bool,
64}
65
66impl SessionBuilder {
67 pub fn new(user: impl ToString, host: impl ToString) -> SessionBuilder {
68 SessionBuilder {
69 host: host.to_string(),
70 port: 80,
71 secure: false,
72 user: user.to_string(),
73 source: "trino-rust-client".to_string(),
74 trace_token: None,
75 client_tags: default(),
76 client_info: None,
77 catalog: None,
78 schema: None,
79 path: None,
80 timezone: None,
81 resource_estimates: default(),
82 properties: default(),
83 prepared_statements: default(),
84 roles: default(),
85 extra_credentials: default(),
86 transaction_id: TransactionId::NoTransaction,
87 client_request_timeout: Duration::from_secs(30),
88 compression_disabled: false,
89 }
90 }
91
92 pub fn build(self) -> Result<Session> {
93 let scheme = if self.secure {
94 Scheme::HTTPS
95 } else {
96 Scheme::HTTP
97 };
98 let host = self.host;
99 let s = format!("{}://{}:{}/v1/statement", scheme, host, self.port);
100 let url = Url::parse(&s).map_err(|_| Error::InvalidHost(host))?;
101 let ret = Session {
102 url,
103 user: self.user,
104 source: self.source,
105 trace_token: self.trace_token,
106 client_tags: self.client_tags,
107 client_info: self.client_info,
108 catalog: self.catalog,
109 schema: self.schema,
110 path: self.path,
111 timezone: self.timezone,
112 resource_estimates: self.resource_estimates,
113 properties: self.properties,
114 prepared_statements: self.prepared_statements,
115 roles: self.roles,
116 extra_credentials: self.extra_credentials,
117 transaction_id: self.transaction_id,
118 client_request_timeout: self.client_request_timeout,
119 compression_disabled: self.compression_disabled,
120 };
121 Ok(ret)
122 }
123}