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 options = options.hostaddr(value.parse::<IpAddr>().map_err(Error::config)?);
79 }
80
81 "port" => options = options.port(value.parse().map_err(Error::config)?),
82
83 "dbname" => options = options.database(&value),
84
85 "user" => options = options.username(&value),
86
87 "password" => options = options.password(&value),
88
89 "application_name" => options = options.application_name(&value),
90
91 "options" => {
92 if let Some(options) = options.options.as_mut() {
93 options.push(' ');
94 options.push_str(&value);
95 } else {
96 options.options = Some(value.to_string());
97 }
98 }
99
100 k if k.starts_with("options[") => {
101 if let Some(key) = k.strip_prefix("options[").unwrap().strip_suffix(']') {
102 options = options.options([(key, &*value)]);
103 }
104 }
105
106 _ => tracing::warn!(%key, %value, "ignoring unrecognized connect parameter"),
107 }
108 }
109
110 let options = options.apply_pgpass();
111
112 Ok(options)
113 }
114
115 pub(crate) fn build_url(&self) -> Url {
116 let url_raw = match &self.socket {
117 Some(socket) => {
118 format!(
119 "postgres://{}@{}:{}",
120 self.username,
121 utf8_percent_encode(&socket.to_string_lossy(), NON_ALPHANUMERIC),
122 self.port
123 )
124 }
125 None => format!("postgres://{}@{}:{}", self.username, self.host, self.port),
126 };
127
128 let mut url = Url::parse(&url_raw)
129 .unwrap_or_else(|e| panic!("BUG: generated un-parseable URL {url_raw:?}; error: {e}"));
130
131 if let Some(password) = &self.password {
132 let password = utf8_percent_encode(password, NON_ALPHANUMERIC).to_string();
133 let _ = url.set_password(Some(&password));
134 }
135
136 if let Some(database) = &self.database {
137 url.set_path(database);
138 }
139
140 let mut url_query = url.query_pairs_mut();
141
142 if let Some(hostaddr) = self.hostaddr {
143 url_query.append_pair("hostaddr", &hostaddr.to_string());
144 }
145
146 let ssl_mode = match self.ssl_options.ssl_mode {
147 PgSslMode::Allow => "allow",
148 PgSslMode::Disable => "disable",
149 PgSslMode::Prefer => "prefer",
150 PgSslMode::Require => "require",
151 PgSslMode::VerifyCa => "verify-ca",
152 PgSslMode::VerifyFull => "verify-full",
153 };
154
155 url_query.append_pair("sslmode", ssl_mode);
156
157 if let Some(ssl_root_cert) = &self.ssl_options.ssl_root_cert {
158 url_query.append_pair("sslrootcert", &ssl_root_cert.to_string());
159 }
160
161 if let Some(ssl_client_cert) = &self.ssl_options.ssl_client_cert {
162 url_query.append_pair("sslcert", &ssl_client_cert.to_string());
163 }
164
165 if let Some(ssl_client_key) = &self.ssl_options.ssl_client_key {
166 url_query.append_pair("sslkey", &ssl_client_key.to_string());
167 }
168
169 url_query.append_pair(
170 "statement-cache-capacity",
171 &self.statement_cache_capacity.to_string(),
172 );
173
174 url_query.finish();
175
176 drop(url_query);
177
178 url
179 }
180}
181
182impl FromStr for PgConnectOptions {
183 type Err = Error;
184
185 fn from_str(s: &str) -> Result<Self, Error> {
186 let url: Url = s.parse().map_err(Error::config)?;
187
188 Self::parse_from_url(&url)
189 }
190}
191
192#[test]
193fn it_parses_socket_correctly_from_parameter() {
194 let url = "postgres:///?host=/var/run/postgres/";
195 let opts = PgConnectOptions::from_str(url).unwrap();
196
197 assert_eq!(Some("/var/run/postgres/".into()), opts.socket);
198}
199
200#[test]
201fn it_parses_host_correctly_from_parameter() {
202 let url = "postgres:///?host=google.database.com";
203 let opts = PgConnectOptions::from_str(url).unwrap();
204
205 assert_eq!(None, opts.socket);
206 assert_eq!("google.database.com", opts.host.original());
207}
208
209#[test]
210fn it_parses_hostaddr_correctly_from_parameter() {
211 let url = "postgres:///?hostaddr=8.8.8.8";
212 let opts = PgConnectOptions::from_str(url).unwrap();
213
214 assert_eq!(None, opts.socket);
215 assert_eq!("localhost", opts.host.original());
216 assert_eq!(Some("8.8.8.8".parse().unwrap()), opts.hostaddr);
217}
218
219#[test]
220fn it_parses_port_correctly_from_parameter() {
221 let url = "postgres:///?port=1234";
222 let opts = PgConnectOptions::from_str(url).unwrap();
223
224 assert_eq!(None, opts.socket);
225 assert_eq!(1234, opts.port);
226}
227
228#[test]
229fn it_parses_dbname_correctly_from_parameter() {
230 let url = "postgres:///?dbname=some_db";
231 let opts = PgConnectOptions::from_str(url).unwrap();
232
233 assert_eq!(None, opts.socket);
234 assert_eq!(Some("some_db"), opts.database.as_deref());
235}
236
237#[test]
238fn it_parses_user_correctly_from_parameter() {
239 let url = "postgres:///?user=some_user";
240 let opts = PgConnectOptions::from_str(url).unwrap();
241
242 assert_eq!(None, opts.socket);
243 assert_eq!("some_user", opts.username);
244}
245
246#[test]
247fn it_parses_password_correctly_from_parameter() {
248 let url = "postgres:///?password=some_pass";
249 let opts = PgConnectOptions::from_str(url).unwrap();
250
251 assert_eq!(None, opts.socket);
252 assert_eq!(Some("some_pass"), opts.password.as_deref());
253}
254
255#[test]
256fn it_parses_application_name_correctly_from_parameter() {
257 let url = "postgres:///?application_name=some_name";
258 let opts = PgConnectOptions::from_str(url).unwrap();
259
260 assert_eq!(Some("some_name"), opts.application_name.as_deref());
261}
262
263#[test]
264fn it_parses_username_with_at_sign_correctly() {
265 let url = "postgres://user@hostname:password@hostname:5432/database";
266 let opts = PgConnectOptions::from_str(url).unwrap();
267
268 assert_eq!("user@hostname", &opts.username);
269}
270
271#[test]
272fn it_parses_password_with_non_ascii_chars_correctly() {
273 let url = "postgres://username:p@ssw0rd@hostname:5432/database";
274 let opts = PgConnectOptions::from_str(url).unwrap();
275
276 assert_eq!(Some("p@ssw0rd".into()), opts.password);
277}
278
279#[test]
280fn it_parses_socket_correctly_percent_encoded() {
281 let url = "postgres://%2Fvar%2Flib%2Fpostgres/database";
282 let opts = PgConnectOptions::from_str(url).unwrap();
283
284 assert_eq!(Some("/var/lib/postgres/".into()), opts.socket);
285}
286#[test]
287fn it_parses_socket_correctly_with_username_percent_encoded() {
288 let url = "postgres://some_user@%2Fvar%2Flib%2Fpostgres/database";
289 let opts = PgConnectOptions::from_str(url).unwrap();
290
291 assert_eq!("some_user", opts.username);
292 assert_eq!(Some("/var/lib/postgres/".into()), opts.socket);
293 assert_eq!(Some("database"), opts.database.as_deref());
294}
295#[test]
296fn it_parses_libpq_options_correctly() {
297 let url = "postgres:///?options=-c%20synchronous_commit%3Doff%20--search_path%3Dpostgres";
298 let opts = PgConnectOptions::from_str(url).unwrap();
299
300 assert_eq!(
301 Some("-c synchronous_commit=off --search_path=postgres".into()),
302 opts.options
303 );
304}
305#[test]
306fn it_parses_sqlx_options_correctly() {
307 let url = "postgres:///?options[synchronous_commit]=off&options[search_path]=postgres";
308 let opts = PgConnectOptions::from_str(url).unwrap();
309
310 assert_eq!(
311 Some("-c synchronous_commit=off -c search_path=postgres".into()),
312 opts.options
313 );
314}
315
316#[test]
317fn it_returns_the_parsed_url_when_socket() {
318 let url = "postgres://username@%2Fvar%2Flib%2Fpostgres/database";
319 let opts = PgConnectOptions::from_str(url).unwrap();
320
321 let mut expected_url = Url::parse(url).unwrap();
322 let query_string = "sslmode=prefer&statement-cache-capacity=100";
324 let port = 5432;
325 expected_url.set_query(Some(query_string));
326 let _ = expected_url.set_port(Some(port));
327
328 assert_eq!(expected_url, opts.build_url());
329}
330
331#[test]
332fn it_returns_the_parsed_url_when_host() {
333 let url = "postgres://username:p@ssw0rd@hostname:5432/database";
334 let opts = PgConnectOptions::from_str(url).unwrap();
335
336 let mut expected_url = Url::parse(url).unwrap();
337 let query_string = "sslmode=prefer&statement-cache-capacity=100";
339 expected_url.set_query(Some(query_string));
340
341 assert_eq!(expected_url, opts.build_url());
342}
343
344#[test]
345fn built_url_can_be_parsed() {
346 let url = "postgres://username:p@ssw0rd@hostname:5432/database";
347 let opts = PgConnectOptions::from_str(url).unwrap();
348
349 let parsed = PgConnectOptions::from_str(opts.build_url().as_ref());
350
351 assert!(parsed.is_ok());
352}
353
354#[test]
355fn ipv6_url_round_trips() {
356 let url = "postgres://username:p%40ssw0rd@[2001:db8::1]:5432/database";
357
358 let opts = PgConnectOptions::from_str(url).unwrap();
359
360 assert_eq!(opts.host.original(), "[2001:db8::1]");
361 assert_eq!(opts.host.stripped(), "2001:db8::1");
362
363 assert_eq!(
364 opts.build_url().as_str(),
365 "postgres://username:p%40ssw0rd@[2001:db8::1]:5432/database?sslmode=prefer&statement-cache-capacity=100"
368 );
369}