sqlx_postgres/options/
parse.rs1use crate::error::Error;
2use crate::{PgConnectOptions, PgSslMode};
3use sqlx_core::percent_encoding::{percent_decode_str, utf8_percent_encode, NON_ALPHANUMERIC};
4use sqlx_core::Url;
5use std::net::IpAddr;
6use std::str::FromStr;
7
8impl PgConnectOptions {
9 pub(crate) fn parse_from_url(url: &Url) -> Result<Self, Error> {
10 let mut options = Self::new_without_pgpass();
11
12 if let Some(host) = url.host_str() {
13 let host_decoded = percent_decode_str(host);
14 options = match host_decoded.clone().next() {
15 Some(b'/') => options.socket(&*host_decoded.decode_utf8().map_err(Error::config)?),
16 _ => options.host(host),
17 }
18 }
19
20 if let Some(port) = url.port() {
21 options = options.port(port);
22 }
23
24 let username = url.username();
25 if !username.is_empty() {
26 options = options.username(
27 &percent_decode_str(username)
28 .decode_utf8()
29 .map_err(Error::config)?,
30 );
31 }
32
33 if let Some(password) = url.password() {
34 options = options.password(
35 &percent_decode_str(password)
36 .decode_utf8()
37 .map_err(Error::config)?,
38 );
39 }
40
41 let path = url.path().trim_start_matches('/');
42 if !path.is_empty() {
43 options = options.database(
44 &percent_decode_str(path)
45 .decode_utf8()
46 .map_err(Error::config)?,
47 );
48 }
49
50 for (key, value) in url.query_pairs().into_iter() {
51 match &*key {
52 "sslmode" | "ssl-mode" => {
53 options = options.ssl_mode(value.parse().map_err(Error::config)?);
54 }
55
56 "sslrootcert" | "ssl-root-cert" | "ssl-ca" => {
57 options = options.ssl_root_cert(&*value);
58 }
59
60 "sslcert" | "ssl-cert" => options = options.ssl_client_cert(&*value),
61
62 "sslkey" | "ssl-key" => options = options.ssl_client_key(&*value),
63
64 "statement-cache-capacity" => {
65 options =
66 options.statement_cache_capacity(value.parse().map_err(Error::config)?);
67 }
68
69 "host" => {
70 if value.starts_with('/') {
71 options = options.socket(&*value);
72 } else {
73 options = options.host(&value);
74 }
75 }
76
77 "hostaddr" => {
78 value.parse::<IpAddr>().map_err(Error::config)?;
79 options = options.host_addr(&value)
80 }
81
82 "port" => options = options.port(value.parse().map_err(Error::config)?),
83
84 "dbname" => options = options.database(&value),
85
86 "user" => options = options.username(&value),
87
88 "password" => options = options.password(&value),
89
90 "application_name" => options = options.application_name(&value),
91
92 "options" => {
93 if let Some(options) = options.options.as_mut() {
94 options.push(' ');
95 options.push_str(&value);
96 } else {
97 options.options = Some(value.to_string());
98 }
99 }
100
101 k if k.starts_with("options[") => {
102 if let Some(key) = k.strip_prefix("options[").unwrap().strip_suffix(']') {
103 options = options.options([(key, &*value)]);
104 }
105 }
106
107 _ => tracing::warn!(%key, %value, "ignoring unrecognized connect parameter"),
108 }
109 }
110
111 let options = options.apply_pgpass();
112
113 Ok(options)
114 }
115
116 pub(crate) fn build_url(&self) -> Url {
117 let host = match &self.socket {
118 Some(socket) => {
119 utf8_percent_encode(&socket.to_string_lossy(), NON_ALPHANUMERIC).to_string()
120 }
121 None => self.host.to_owned(),
122 };
123
124 let mut url = Url::parse(&format!(
125 "postgres://{}@{}:{}",
126 self.username, host, self.port
127 ))
128 .expect("BUG: generated un-parseable URL");
129
130 if let Some(password) = &self.password {
131 let password = utf8_percent_encode(password, NON_ALPHANUMERIC).to_string();
132 let _ = url.set_password(Some(&password));
133 }
134
135 if let Some(database) = &self.database {
136 url.set_path(database);
137 }
138
139 let ssl_mode = match self.ssl_mode {
140 PgSslMode::Allow => "allow",
141 PgSslMode::Disable => "disable",
142 PgSslMode::Prefer => "prefer",
143 PgSslMode::Require => "require",
144 PgSslMode::VerifyCa => "verify-ca",
145 PgSslMode::VerifyFull => "verify-full",
146 };
147 url.query_pairs_mut().append_pair("sslmode", ssl_mode);
148
149 if let Some(ssl_root_cert) = &self.ssl_root_cert {
150 url.query_pairs_mut()
151 .append_pair("sslrootcert", &ssl_root_cert.to_string());
152 }
153
154 if let Some(ssl_client_cert) = &self.ssl_client_cert {
155 url.query_pairs_mut()
156 .append_pair("sslcert", &ssl_client_cert.to_string());
157 }
158
159 if let Some(ssl_client_key) = &self.ssl_client_key {
160 url.query_pairs_mut()
161 .append_pair("sslkey", &ssl_client_key.to_string());
162 }
163
164 url.query_pairs_mut().append_pair(
165 "statement-cache-capacity",
166 &self.statement_cache_capacity.to_string(),
167 );
168
169 url
170 }
171}
172
173impl FromStr for PgConnectOptions {
174 type Err = Error;
175
176 fn from_str(s: &str) -> Result<Self, Error> {
177 let url: Url = s.parse().map_err(Error::config)?;
178
179 Self::parse_from_url(&url)
180 }
181}
182
183#[test]
184fn it_parses_socket_correctly_from_parameter() {
185 let url = "postgres:///?host=/var/run/postgres/";
186 let opts = PgConnectOptions::from_str(url).unwrap();
187
188 assert_eq!(Some("/var/run/postgres/".into()), opts.socket);
189}
190
191#[test]
192fn it_parses_host_correctly_from_parameter() {
193 let url = "postgres:///?host=google.database.com";
194 let opts = PgConnectOptions::from_str(url).unwrap();
195
196 assert_eq!(None, opts.socket);
197 assert_eq!("google.database.com", &opts.host);
198}
199
200#[test]
201fn it_parses_hostaddr_correctly_from_parameter() {
202 let url = "postgres:///?hostaddr=8.8.8.8";
203 let opts = PgConnectOptions::from_str(url).unwrap();
204
205 assert_eq!(None, opts.socket);
206 assert_eq!("localhost", &opts.host);
207 assert_eq!(Some("8.8.8.8"), opts.host_addr.as_deref());
208}
209
210#[test]
211fn it_parses_hostaddr_host_separately_from_parameter() {
212 let url = "postgres://example.com/?hostaddr=8.8.8.8";
213 let opts = PgConnectOptions::from_str(url).unwrap();
214
215 assert_eq!(None, opts.socket);
216 assert_eq!("example.com", &opts.host);
217 assert_eq!(Some("8.8.8.8"), opts.host_addr.as_deref());
218}
219
220#[test]
221fn it_parses_hostaddr_host_host_overwrite_from_query_from_parameter() {
222 let url = "postgres://example.com/?hostaddr=8.8.8.8&host=sqlx.rs";
223 let opts = PgConnectOptions::from_str(url).unwrap();
224
225 assert_eq!(None, opts.socket);
226 assert_eq!("sqlx.rs", &opts.host);
227 assert_eq!(Some("8.8.8.8"), opts.host_addr.as_deref());
228}
229
230#[test]
231fn it_parses_port_correctly_from_parameter() {
232 let url = "postgres:///?port=1234";
233 let opts = PgConnectOptions::from_str(url).unwrap();
234
235 assert_eq!(None, opts.socket);
236 assert_eq!(1234, opts.port);
237}
238
239#[test]
240fn it_parses_dbname_correctly_from_parameter() {
241 let url = "postgres:///?dbname=some_db";
242 let opts = PgConnectOptions::from_str(url).unwrap();
243
244 assert_eq!(None, opts.socket);
245 assert_eq!(Some("some_db"), opts.database.as_deref());
246}
247
248#[test]
249fn it_parses_user_correctly_from_parameter() {
250 let url = "postgres:///?user=some_user";
251 let opts = PgConnectOptions::from_str(url).unwrap();
252
253 assert_eq!(None, opts.socket);
254 assert_eq!("some_user", opts.username);
255}
256
257#[test]
258fn it_parses_password_correctly_from_parameter() {
259 let url = "postgres:///?password=some_pass";
260 let opts = PgConnectOptions::from_str(url).unwrap();
261
262 assert_eq!(None, opts.socket);
263 assert_eq!(Some("some_pass"), opts.password.as_deref());
264}
265
266#[test]
267fn it_parses_application_name_correctly_from_parameter() {
268 let url = "postgres:///?application_name=some_name";
269 let opts = PgConnectOptions::from_str(url).unwrap();
270
271 assert_eq!(Some("some_name"), opts.application_name.as_deref());
272}
273
274#[test]
275fn it_parses_username_with_at_sign_correctly() {
276 let url = "postgres://user@hostname:password@hostname:5432/database";
277 let opts = PgConnectOptions::from_str(url).unwrap();
278
279 assert_eq!("user@hostname", &opts.username);
280}
281
282#[test]
283fn it_parses_password_with_non_ascii_chars_correctly() {
284 let url = "postgres://username:p@ssw0rd@hostname:5432/database";
285 let opts = PgConnectOptions::from_str(url).unwrap();
286
287 assert_eq!(Some("p@ssw0rd".into()), opts.password);
288}
289
290#[test]
291fn it_parses_socket_correctly_percent_encoded() {
292 let url = "postgres://%2Fvar%2Flib%2Fpostgres/database";
293 let opts = PgConnectOptions::from_str(url).unwrap();
294
295 assert_eq!(Some("/var/lib/postgres/".into()), opts.socket);
296}
297#[test]
298fn it_parses_socket_correctly_with_username_percent_encoded() {
299 let url = "postgres://some_user@%2Fvar%2Flib%2Fpostgres/database";
300 let opts = PgConnectOptions::from_str(url).unwrap();
301
302 assert_eq!("some_user", opts.username);
303 assert_eq!(Some("/var/lib/postgres/".into()), opts.socket);
304 assert_eq!(Some("database"), opts.database.as_deref());
305}
306#[test]
307fn it_parses_libpq_options_correctly() {
308 let url = "postgres:///?options=-c%20synchronous_commit%3Doff%20--search_path%3Dpostgres";
309 let opts = PgConnectOptions::from_str(url).unwrap();
310
311 assert_eq!(
312 Some("-c synchronous_commit=off --search_path=postgres".into()),
313 opts.options
314 );
315}
316#[test]
317fn it_parses_sqlx_options_correctly() {
318 let url = "postgres:///?options[synchronous_commit]=off&options[search_path]=postgres";
319 let opts = PgConnectOptions::from_str(url).unwrap();
320
321 assert_eq!(
322 Some("-c synchronous_commit=off -c search_path=postgres".into()),
323 opts.options
324 );
325}
326
327#[test]
328fn it_returns_the_parsed_url_when_socket() {
329 let url = "postgres://username@%2Fvar%2Flib%2Fpostgres/database";
330 let opts = PgConnectOptions::from_str(url).unwrap();
331
332 let mut expected_url = Url::parse(url).unwrap();
333 let query_string = "sslmode=prefer&statement-cache-capacity=100";
335 let port = 5432;
336 expected_url.set_query(Some(query_string));
337 let _ = expected_url.set_port(Some(port));
338
339 assert_eq!(expected_url, opts.build_url());
340}
341
342#[test]
343fn it_returns_the_parsed_url_when_host() {
344 let url = "postgres://username:p@ssw0rd@hostname:5432/database";
345 let opts = PgConnectOptions::from_str(url).unwrap();
346
347 let mut expected_url = Url::parse(url).unwrap();
348 let query_string = "sslmode=prefer&statement-cache-capacity=100";
350 expected_url.set_query(Some(query_string));
351
352 assert_eq!(expected_url, opts.build_url());
353}
354
355#[test]
356fn built_url_can_be_parsed() {
357 let url = "postgres://username:p@ssw0rd@hostname:5432/database";
358 let opts = PgConnectOptions::from_str(url).unwrap();
359
360 let parsed = PgConnectOptions::from_str(opts.build_url().as_ref());
361
362 assert!(parsed.is_ok());
363}