sqlx_core/postgres/options/
parse.rs

1use crate::error::Error;
2use crate::postgres::PgConnectOptions;
3use percent_encoding::percent_decode_str;
4use std::net::IpAddr;
5use std::str::FromStr;
6use url::Url;
7
8impl FromStr for PgConnectOptions {
9    type Err = Error;
10
11    fn from_str(s: &str) -> Result<Self, Error> {
12        let url: Url = s.parse().map_err(Error::config)?;
13
14        let mut options = Self::new_without_pgpass();
15
16        if let Some(host) = url.host_str() {
17            let host_decoded = percent_decode_str(host);
18            options = match host_decoded.clone().next() {
19                Some(b'/') => options.socket(&*host_decoded.decode_utf8().map_err(Error::config)?),
20                _ => options.host(host),
21            }
22        }
23
24        if let Some(port) = url.port() {
25            options = options.port(port);
26        }
27
28        let username = url.username();
29        if !username.is_empty() {
30            options = options.username(
31                &*percent_decode_str(username)
32                    .decode_utf8()
33                    .map_err(Error::config)?,
34            );
35        }
36
37        if let Some(password) = url.password() {
38            options = options.password(
39                &*percent_decode_str(password)
40                    .decode_utf8()
41                    .map_err(Error::config)?,
42            );
43        }
44
45        let path = url.path().trim_start_matches('/');
46        if !path.is_empty() {
47            options = options.database(path);
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                "statement-cache-capacity" => {
61                    options =
62                        options.statement_cache_capacity(value.parse().map_err(Error::config)?);
63                }
64
65                "host" => {
66                    if value.starts_with("/") {
67                        options = options.socket(&*value);
68                    } else {
69                        options = options.host(&*value);
70                    }
71                }
72
73                "hostaddr" => {
74                    value.parse::<IpAddr>().map_err(Error::config)?;
75                    options = options.host(&*value)
76                }
77
78                "port" => options = options.port(value.parse().map_err(Error::config)?),
79
80                "dbname" => options = options.database(&*value),
81
82                "user" => options = options.username(&*value),
83
84                "password" => options = options.password(&*value),
85
86                "application_name" => options = options.application_name(&*value),
87
88                "options" => {
89                    if let Some(options) = options.options.as_mut() {
90                        options.push(' ');
91                        options.push_str(&*value);
92                    } else {
93                        options.options = Some(value.to_string());
94                    }
95                }
96
97                k if k.starts_with("options[") => {
98                    if let Some(key) = k.strip_prefix("options[").unwrap().strip_suffix(']') {
99                        options = options.options([(key, &*value)]);
100                    }
101                }
102
103                _ => log::warn!("ignoring unrecognized connect parameter: {}={}", key, value),
104            }
105        }
106
107        let options = options.apply_pgpass();
108
109        Ok(options)
110    }
111}
112
113#[test]
114fn it_parses_socket_correctly_from_parameter() {
115    let url = "postgres:///?host=/var/run/postgres/";
116    let opts = PgConnectOptions::from_str(url).unwrap();
117
118    assert_eq!(Some("/var/run/postgres/".into()), opts.socket);
119}
120
121#[test]
122fn it_parses_host_correctly_from_parameter() {
123    let url = "postgres:///?host=google.database.com";
124    let opts = PgConnectOptions::from_str(url).unwrap();
125
126    assert_eq!(None, opts.socket);
127    assert_eq!("google.database.com", &opts.host);
128}
129
130#[test]
131fn it_parses_hostaddr_correctly_from_parameter() {
132    let url = "postgres:///?hostaddr=8.8.8.8";
133    let opts = PgConnectOptions::from_str(url).unwrap();
134
135    assert_eq!(None, opts.socket);
136    assert_eq!("8.8.8.8", &opts.host);
137}
138
139#[test]
140fn it_parses_port_correctly_from_parameter() {
141    let url = "postgres:///?port=1234";
142    let opts = PgConnectOptions::from_str(url).unwrap();
143
144    assert_eq!(None, opts.socket);
145    assert_eq!(1234, opts.port);
146}
147
148#[test]
149fn it_parses_dbname_correctly_from_parameter() {
150    let url = "postgres:///?dbname=some_db";
151    let opts = PgConnectOptions::from_str(url).unwrap();
152
153    assert_eq!(None, opts.socket);
154    assert_eq!(Some("some_db"), opts.database.as_deref());
155}
156
157#[test]
158fn it_parses_user_correctly_from_parameter() {
159    let url = "postgres:///?user=some_user";
160    let opts = PgConnectOptions::from_str(url).unwrap();
161
162    assert_eq!(None, opts.socket);
163    assert_eq!("some_user", opts.username);
164}
165
166#[test]
167fn it_parses_password_correctly_from_parameter() {
168    let url = "postgres:///?password=some_pass";
169    let opts = PgConnectOptions::from_str(url).unwrap();
170
171    assert_eq!(None, opts.socket);
172    assert_eq!(Some("some_pass"), opts.password.as_deref());
173}
174
175#[test]
176fn it_parses_application_name_correctly_from_parameter() {
177    let url = "postgres:///?application_name=some_name";
178    let opts = PgConnectOptions::from_str(url).unwrap();
179
180    assert_eq!(Some("some_name"), opts.application_name.as_deref());
181}
182
183#[test]
184fn it_parses_username_with_at_sign_correctly() {
185    let url = "postgres://user@hostname:password@hostname:5432/database";
186    let opts = PgConnectOptions::from_str(url).unwrap();
187
188    assert_eq!("user@hostname", &opts.username);
189}
190
191#[test]
192fn it_parses_password_with_non_ascii_chars_correctly() {
193    let url = "postgres://username:p@ssw0rd@hostname:5432/database";
194    let opts = PgConnectOptions::from_str(url).unwrap();
195
196    assert_eq!(Some("p@ssw0rd".into()), opts.password);
197}
198
199#[test]
200fn it_parses_socket_correctly_percent_encoded() {
201    let url = "postgres://%2Fvar%2Flib%2Fpostgres/database";
202    let opts = PgConnectOptions::from_str(url).unwrap();
203
204    assert_eq!(Some("/var/lib/postgres/".into()), opts.socket);
205}
206#[test]
207fn it_parses_socket_correctly_with_username_percent_encoded() {
208    let url = "postgres://some_user@%2Fvar%2Flib%2Fpostgres/database";
209    let opts = PgConnectOptions::from_str(url).unwrap();
210
211    assert_eq!("some_user", opts.username);
212    assert_eq!(Some("/var/lib/postgres/".into()), opts.socket);
213    assert_eq!(Some("database"), opts.database.as_deref());
214}
215#[test]
216fn it_parses_libpq_options_correctly() {
217    let url = "postgres:///?options=-c%20synchronous_commit%3Doff%20--search_path%3Dpostgres";
218    let opts = PgConnectOptions::from_str(url).unwrap();
219
220    assert_eq!(
221        Some("-c synchronous_commit=off --search_path=postgres".into()),
222        opts.options
223    );
224}
225#[test]
226fn it_parses_sqlx_options_correctly() {
227    let url = "postgres:///?options[synchronous_commit]=off&options[search_path]=postgres";
228    let opts = PgConnectOptions::from_str(url).unwrap();
229
230    assert_eq!(
231        Some("-c synchronous_commit=off -c search_path=postgres".into()),
232        opts.options
233    );
234}
sqlx_core/postgres/options/parse.rs

sqlx_core/postgres/options/
parse.rs
