sqlx_core_oldapi/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                "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(&*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                _ => log::warn!("ignoring unrecognized connect parameter: {}={}", key, value),
108            }
109        }
110
111        let options = options.apply_pgpass();
112
113        Ok(options)
114    }
115}
116
117#[test]
118fn it_parses_socket_correctly_from_parameter() {
119    let url = "postgres:///?host=/var/run/postgres/";
120    let opts = PgConnectOptions::from_str(url).unwrap();
121
122    assert_eq!(Some("/var/run/postgres/".into()), opts.socket);
123}
124
125#[test]
126fn it_parses_host_correctly_from_parameter() {
127    let url = "postgres:///?host=google.database.com";
128    let opts = PgConnectOptions::from_str(url).unwrap();
129
130    assert_eq!(None, opts.socket);
131    assert_eq!("google.database.com", &opts.host);
132}
133
134#[test]
135fn it_parses_hostaddr_correctly_from_parameter() {
136    let url = "postgres:///?hostaddr=8.8.8.8";
137    let opts = PgConnectOptions::from_str(url).unwrap();
138
139    assert_eq!(None, opts.socket);
140    assert_eq!("8.8.8.8", &opts.host);
141}
142
143#[test]
144fn it_parses_port_correctly_from_parameter() {
145    let url = "postgres:///?port=1234";
146    let opts = PgConnectOptions::from_str(url).unwrap();
147
148    assert_eq!(None, opts.socket);
149    assert_eq!(1234, opts.port);
150}
151
152#[test]
153fn it_parses_dbname_correctly_from_parameter() {
154    let url = "postgres:///?dbname=some_db";
155    let opts = PgConnectOptions::from_str(url).unwrap();
156
157    assert_eq!(None, opts.socket);
158    assert_eq!(Some("some_db"), opts.database.as_deref());
159}
160
161#[test]
162fn it_parses_user_correctly_from_parameter() {
163    let url = "postgres:///?user=some_user";
164    let opts = PgConnectOptions::from_str(url).unwrap();
165
166    assert_eq!(None, opts.socket);
167    assert_eq!("some_user", opts.username);
168}
169
170#[test]
171fn it_parses_password_correctly_from_parameter() {
172    let url = "postgres:///?password=some_pass";
173    let opts = PgConnectOptions::from_str(url).unwrap();
174
175    assert_eq!(None, opts.socket);
176    assert_eq!(Some("some_pass"), opts.password.as_deref());
177}
178
179#[test]
180fn it_parses_application_name_correctly_from_parameter() {
181    let url = "postgres:///?application_name=some_name";
182    let opts = PgConnectOptions::from_str(url).unwrap();
183
184    assert_eq!(Some("some_name"), opts.application_name.as_deref());
185}
186
187#[test]
188fn it_parses_username_with_at_sign_correctly() {
189    let url = "postgres://user@hostname:password@hostname:5432/database";
190    let opts = PgConnectOptions::from_str(url).unwrap();
191
192    assert_eq!("user@hostname", &opts.username);
193}
194
195#[test]
196fn it_parses_password_with_non_ascii_chars_correctly() {
197    let url = "postgres://username:p@ssw0rd@hostname:5432/database";
198    let opts = PgConnectOptions::from_str(url).unwrap();
199
200    assert_eq!(Some("p@ssw0rd".into()), opts.password);
201}
202
203#[test]
204fn it_parses_socket_correctly_percent_encoded() {
205    let url = "postgres://%2Fvar%2Flib%2Fpostgres/database";
206    let opts = PgConnectOptions::from_str(url).unwrap();
207
208    assert_eq!(Some("/var/lib/postgres/".into()), opts.socket);
209}
210#[test]
211fn it_parses_socket_correctly_with_username_percent_encoded() {
212    let url = "postgres://some_user@%2Fvar%2Flib%2Fpostgres/database";
213    let opts = PgConnectOptions::from_str(url).unwrap();
214
215    assert_eq!("some_user", opts.username);
216    assert_eq!(Some("/var/lib/postgres/".into()), opts.socket);
217    assert_eq!(Some("database"), opts.database.as_deref());
218}
219#[test]
220fn it_parses_libpq_options_correctly() {
221    let url = "postgres:///?options=-c%20synchronous_commit%3Doff%20--search_path%3Dpostgres";
222    let opts = PgConnectOptions::from_str(url).unwrap();
223
224    assert_eq!(
225        Some("-c synchronous_commit=off --search_path=postgres".into()),
226        opts.options
227    );
228}
229#[test]
230fn it_parses_sqlx_options_correctly() {
231    let url = "postgres:///?options[synchronous_commit]=off&options[search_path]=postgres";
232    let opts = PgConnectOptions::from_str(url).unwrap();
233
234    assert_eq!(
235        Some("-c synchronous_commit=off -c search_path=postgres".into()),
236        opts.options
237    );
238}
sqlx_core_oldapi/postgres/options/parse.rs

sqlx_core_oldapi/postgres/options/
parse.rs
