Implement FromSql for tuples up to size 4

- sfackler#626 with feature gate
  additions

Author: wquark

postgres-types/Cargo.toml

@@ -13,6 +13,7 @@ categories = ["database"]
 [features]
 derive = ["postgres-derive"]
 array-impls = ["array-init"]
+tuple-impls = []
 with-bit-vec-0_6 = ["bit-vec-06"]
 with-cidr-0_2 = ["cidr-02"]
 with-chrono-0_4 = ["chrono-04"]

postgres-types/src/lib.rs

@@ -642,6 +642,62 @@ impl<'a, T: FromSql<'a>, const N: usize> FromSql<'a> for [T; N] {
     }
 }
 
+macro_rules! impl_from_sql_tuple {
+    ($n:expr; $($ty_ident:ident),*; $($var_ident:ident),*) => {
+        impl<'a, $($ty_ident),*> FromSql<'a> for ($($ty_ident,)*)
+        where
+            $($ty_ident: FromSql<'a>),*
+        {
+            fn from_sql(
+                _: &Type,
+                mut raw: &'a [u8],
+            ) -> Result<($($ty_ident,)*), Box<dyn Error + Sync + Send>> {
+                let num_fields = private::read_be_i32(&mut raw)?;
+                if num_fields as usize != $n {
+                    return Err(format!(
+                        "Postgres record field count does not match Rust tuple length: {} vs {}",
+                        num_fields,
+                        $n,
+                    ).into());
+                }
+
+                $(
+                    let oid = private::read_be_i32(&mut raw)? as u32;
+                    let ty = match Type::from_oid(oid) {
+                        None => {
+                            return Err(format!(
+                                "cannot decode OID {} inside of anonymous record",
+                                oid,
+                            ).into());
+                        }
+                        Some(ty) if !$ty_ident::accepts(&ty) => {
+                            return Err(Box::new(WrongType::new::<$ty_ident>(ty.clone())));
+                        }
+                        Some(ty) => ty,
+                    };
+                    let $var_ident = private::read_value(&ty, &mut raw)?;
+                )*
+
+                Ok(($($var_ident,)*))
+            }
+
+            fn accepts(ty: &Type) -> bool {
+                match ty.kind() {
+                    Kind::Pseudo => *ty == Type::RECORD,
+                    Kind::Composite(fields) => fields.len() == $n,
+                    _ => false,
+                }
+            }
+        }
+    };
+}
+
+impl_from_sql_tuple!(0; ; );
+impl_from_sql_tuple!(1; T0; v0);
+impl_from_sql_tuple!(2; T0, T1; v0, v1);
+impl_from_sql_tuple!(3; T0, T1, T2; v0, v1, v2);
+impl_from_sql_tuple!(4; T0, T1, T2, T3; v0, v1, v2, v3);
+
 impl<'a, T: FromSql<'a>> FromSql<'a> for Box<[T]> {
     fn from_sql(ty: &Type, raw: &'a [u8]) -> Result<Self, Box<dyn Error + Sync + Send>> {
         Vec::<T>::from_sql(ty, raw).map(Vec::into_boxed_slice)

tokio-postgres/Cargo.toml

@@ -28,6 +28,7 @@ default = ["runtime"]
 runtime = ["tokio/net", "tokio/time"]
 
 array-impls = ["postgres-types/array-impls"]
+tuple-impls = ["postgres-types/tuple-impls"]
 with-bit-vec-0_6 = ["postgres-types/with-bit-vec-0_6"]
 with-chrono-0_4 = ["postgres-types/with-chrono-0_4"]
 with-eui48-0_4 = ["postgres-types/with-eui48-0_4"]

tokio-postgres/tests/test/types/mod.rs

@@ -379,6 +379,58 @@ async fn test_array_array_params() {
     .await;
 }
 
+#[tokio::test]
+async fn tuples() {
+    let client = connect("user=postgres").await;
+
+    let row = client.query_one("SELECT ROW()", &[]).await.unwrap();
+    row.get::<_, ()>(0);
+
+    let row = client.query_one("SELECT ROW(1)", &[]).await.unwrap();
+    let val: (i32,) = row.get(0);
+    assert_eq!(val, (1,));
+
+    let row = client.query_one("SELECT (1, 'a')", &[]).await.unwrap();
+    let val: (i32, String) = row.get(0);
+    assert_eq!(val, (1, "a".into()));
+
+    let row = client.query_one("SELECT (1, (2, 3))", &[]).await.unwrap();
+    let val: (i32, (i32, i32)) = row.get(0);
+    assert_eq!(val, (1, (2, 3)));
+
+    let row = client.query_one("SELECT (1, 2)", &[]).await.unwrap();
+    let err = row.try_get::<_, (i32, String)>(0).unwrap_err();
+    match err.source() {
+        Some(e) if e.is::<WrongType>() => {}
+        _ => panic!("Unexpected error {:?}", err),
+    };
+
+    let row = client.query_one("SELECT (1, 2, 3)", &[]).await.unwrap();
+    let err = row.try_get::<_, (i32, i32)>(0).unwrap_err();
+    assert_eq!(
+        err.to_string(),
+        "error deserializing column 0: \
+        Postgres record field count does not match Rust tuple length: 3 vs 2"
+    );
+
+    client
+        .batch_execute(
+            "CREATE TYPE pg_temp.simple AS (
+                a int,
+                b text
+            )",
+        )
+        .await
+        .unwrap();
+
+    let row = client
+        .query_one("SELECT (1, 'a')::simple", &[])
+        .await
+        .unwrap();
+    let val: (i32, String) = row.get(0);
+    assert_eq!(val, (1, "a".into()));
+}
+
 #[allow(clippy::eq_op)]
 async fn test_nan_param<T>(sql_type: &str)
 where