HACK: allow custom types in the records

Author: myypo

postgres-derive-test/src/records.rs

@@ -117,6 +117,73 @@ fn nested_structs() {
     assert_eq!(result, expected);
 }
 
+#[test]
+fn domains() {
+    #[derive(FromSql, Debug, PartialEq)]
+    struct SpecialId(i32);
+
+    #[derive(FromSql, Debug, PartialEq)]
+    struct Person {
+        name: String,
+        age: Option<i32>,
+        id: SpecialId,
+    }
+
+    let mut conn = Client::connect("user=postgres host=localhost port=5433", NoTls).unwrap();
+    conn.execute("CREATE DOMAIN pg_temp.\"special_id\" AS integer;", &[])
+        .unwrap();
+
+    let result: Person = conn
+        .query_one("SELECT ('John', 30, 42::special_id)", &[])
+        .unwrap()
+        .get(0);
+
+    let expected = Person {
+        name: "John".to_owned(),
+        age: Some(30),
+        id: SpecialId(42),
+    };
+
+    assert_eq!(result, expected);
+}
+
+#[test]
+fn enums() {
+    #[derive(FromSql, Debug, PartialEq)]
+    enum Employment {
+        Salaried,
+        Hourly,
+        Unemployed,
+    }
+
+    #[derive(FromSql, Debug, PartialEq)]
+    struct Person {
+        name: String,
+        age: Option<i32>,
+        employment: Employment,
+    }
+
+    let mut conn = Client::connect("user=postgres host=localhost port=5433", NoTls).unwrap();
+    conn.execute(
+        "CREATE TYPE pg_temp.employment AS ENUM ('Salaried', 'Hourly', 'Unemployed')",
+        &[],
+    )
+    .unwrap();
+
+    let result: Person = conn
+        .query_one("SELECT ('John', 30, 'Hourly'::employment)", &[])
+        .unwrap()
+        .get(0);
+
+    let expected = Person {
+        name: "John".to_owned(),
+        age: Some(30),
+        employment: Employment::Hourly,
+    };
+
+    assert_eq!(result, expected);
+}
+
 #[test]
 fn generics() {
     #[derive(FromSql, ToSql, Debug, PartialEq)]

postgres-derive/src/accepts.rs

@@ -41,6 +41,9 @@ pub fn enum_body(name: &str, variants: &[Variant], allow_mismatch: bool) -> Toke
         }
     } else {
         quote! {
+            if *type_ == postgres_types::Type::UNKNOWN {
+                return true;
+            }
             if type_.name() != #name {
                 return false;
             }

postgres-derive/src/fromsql.rs

@@ -171,6 +171,9 @@ fn domain_accepts_body(name: &str, field: &syn::Field) -> TokenStream {
         if <#ty as postgres_types::FromSql>::accepts(type_) {
             return true;
         }
+        if *type_ == postgres_types::Type::UNKNOWN {
+            return true;
+        }
 
         #normal_body
     }
@@ -250,13 +253,9 @@ fn composite_body(ident: &Ident, fields: &[Field]) -> TokenStream {
 
                 for i in 0..num_fields {
                     let oid = postgres_types::private::read_be_i32(&mut buf)? as u32;
-                    let ty = match postgres_types::Type::from_oid(oid) {
-                        std::option::Option::None => {
-                            return std::result::Result::Err(std::convert::Into::into(
-                                format!("cannot decode OID {} inside of anonymous record", oid)));
-                        }
-                        std::option::Option::Some(ty) => ty,
-                    };
+                    // FIXME: I see no other way to make this work with non-builtin types
+                    // besides expanding the FromSql trait to also require passing the client
+                    let ty = postgres_types::Type::from_oid(oid).unwrap_or(postgres_types::Type::UNKNOWN);
 
                     match i as usize {
                         #(