sqlx-postgres: add support to abstract sockets

PostgreSQL treats hosts starting by @ as abstract sockets (linux
only). This patch modifies parse to correctly read host parameter as
socket in these cases. It also modifies fetch_socket to provide the
proper argument to net::connect_uds.

Author: rafonseca

sqlx-postgres/src/options/mod.rs

@@ -455,10 +455,13 @@ impl PgConnectOptions {
     /// We try using a socket if hostname starts with `/` or if socket parameter
     /// is specified.
     pub(crate) fn fetch_socket(&self) -> Option<String> {
-        match self.socket {
-            Some(ref socket) => {
-                let full_path = format!("{}/.s.PGSQL.{}", socket.display(), self.port);
-                Some(full_path)
+        match self.socket.to_str() {
+            Some(socket_str) => {
+                if let Some(abstract_dir) = socket_str.strip_prefix('@') {
+                    Some(format!("\0{}/.s.PGSQL.{}", abstract_dir, self.port));
+                } else {
+                    Some(format!("{}/.s.PGSQL.{}", socket_str, self.port));
+                };
             }
             None if self.host.starts_with('/') => {
                 let full_path = format!("{}/.s.PGSQL.{}", self.host, self.port);

sqlx-postgres/src/options/parse.rs

@@ -12,7 +12,9 @@ impl PgConnectOptions {
         if let Some(host) = url.host_str() {
             let host_decoded = percent_decode_str(host);
             options = match host_decoded.clone().next() {
-                Some(b'/') => options.socket(&*host_decoded.decode_utf8().map_err(Error::config)?),
+                Some(b'/') | Some(b'@') => {
+                    options.socket(&*host_decoded.decode_utf8().map_err(Error::config)?)
+                }
                 _ => options.host(host),
             }
         }
@@ -67,7 +69,7 @@ impl PgConnectOptions {
                 }
 
                 "host" => {
-                    if value.starts_with('/') {
+                    if value.starts_with('/') || value.starts_with('@') {
                         options = options.socket(&*value);
                     } else {
                         options = options.host(&value);
@@ -188,6 +190,14 @@ fn it_parses_socket_correctly_from_parameter() {
     assert_eq!(Some("/var/run/postgres/".into()), opts.socket);
 }
 
+#[test]
+fn it_parses_abstract_socket_correctly_from_parameter() {
+    let url = "postgres:///?host=@pgdata";
+    let opts = PgConnectOptions::from_str(url).unwrap();
+
+    assert_eq!(Some("@pgdata".into()), opts.socket);
+}
+
 #[test]
 fn it_parses_host_correctly_from_parameter() {
     let url = "postgres:///?host=google.database.com";

tests/postgres/postgres.rs

@@ -28,6 +28,23 @@ async fn it_connects() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[ignore = "requires a PostgreSQL instance listening on the abstract Unix socket @pg_data"]
+#[sqlx_macros::test]
+async fn it_connects_via_abstract_socket() -> anyhow::Result<()> {
+    setup_if_needed();
+
+    let opts: PgConnectOptions = env::var("DATABASE_URL")?.parse().unwrap();
+    let opts = opts.socket("@pg_data");
+    
+    let mut conn = PgConnection::connect_with(&opts).await?;
+
+    let value: i32 = sqlx::query_scalar("SELECT 1").fetch_one(&mut conn).await?;
+    assert_eq!(1, value);
+
+    Ok(())
+}
+
 #[sqlx_macros::test]
 async fn it_can_select_void() -> anyhow::Result<()> {
     let mut conn = new::<Postgres>().await?;