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 pub spooling_encoding: Option<String>,
40}
41
42#[derive(Debug)]
43pub(crate) struct SessionBuilder {
44 pub(crate) host: String,
45 pub(crate) port: u16,
46 pub(crate) secure: bool,
47 pub(crate) user: String,
48 pub(crate) source: String,
49 pub(crate) trace_token: Option<String>,
50 pub(crate) client_tags: HashSet<String>,
51 pub(crate) client_info: Option<String>,
52 pub(crate) catalog: Option<String>,
53 pub(crate) schema: Option<String>,
54 pub(crate) path: Option<String>,
55 pub(crate) timezone: Option<Tz>,
56 pub(crate) resource_estimates: HashMap<String, String>,
58 pub(crate) properties: HashMap<String, String>,
59 pub(crate) prepared_statements: HashMap<String, String>,
60 pub(crate) roles: HashMap<String, SelectedRole>,
61 pub(crate) extra_credentials: HashMap<String, String>,
62 pub(crate) transaction_id: TransactionId,
63 pub(crate) client_request_timeout: Duration,
64 pub(crate) compression_disabled: bool,
65 pub(crate) spooling_encoding: Option<String>,
66}
67
68impl SessionBuilder {
69 pub fn new(user: impl ToString, host: impl ToString) -> SessionBuilder {
70 SessionBuilder {
71 host: host.to_string(),
72 port: 80,
73 secure: false,
74 user: user.to_string(),
75 source: "trino-rust-client".to_string(),
76 trace_token: None,
77 client_tags: default(),
78 client_info: None,
79 catalog: None,
80 schema: None,
81 path: None,
82 timezone: None,
83 resource_estimates: default(),
84 properties: default(),
85 prepared_statements: default(),
86 roles: default(),
87 extra_credentials: default(),
88 transaction_id: TransactionId::NoTransaction,
89 client_request_timeout: Duration::from_secs(30),
90 compression_disabled: false,
91 spooling_encoding: Some("json+zstd".to_string()),
92 }
93 }
94
95 pub fn build(self) -> Result<Session> {
96 let scheme = if self.secure {
97 Scheme::HTTPS
98 } else {
99 Scheme::HTTP
100 };
101 let host = self.host;
102 let s = format!("{}://{}:{}", scheme, host, self.port);
103 let url = Url::parse(&s).map_err(|_| Error::InvalidHost(host))?;
104 let ret = Session {
105 url,
106 user: self.user,
107 source: self.source,
108 trace_token: self.trace_token,
109 client_tags: self.client_tags,
110 client_info: self.client_info,
111 catalog: self.catalog,
112 schema: self.schema,
113 path: self.path,
114 timezone: self.timezone,
115 resource_estimates: self.resource_estimates,
116 properties: self.properties,
117 prepared_statements: self.prepared_statements,
118 roles: self.roles,
119 extra_credentials: self.extra_credentials,
120 transaction_id: self.transaction_id,
121 client_request_timeout: self.client_request_timeout,
122 compression_disabled: self.compression_disabled,
123 spooling_encoding: self.spooling_encoding,
124 };
125 Ok(ret)
126 }
127}