Add support for deriving FromSql and ToSql for structs with references

Author: alexwl

postgres-derive-test/src/compile-fail/invalid-types.rs

@@ -22,4 +22,9 @@ enum FromSqlEnum {
     Foo(i32),
 }
 
+#[derive(FromSql)]
+struct FromSqlTypeParameter<T> {
+    foo: T,
+}
+
 fn main() {}

postgres-derive-test/src/compile-fail/invalid-types.stderr

@@ -33,3 +33,9 @@ error: non-C-like enums are not supported
    |
 22 |     Foo(i32),
    |     ^^^^^^^^
+
+error: #[derive(FromSql)] does not support type parameters.
+  --> $DIR/invalid-types.rs:26:28
+   |
+26 | struct FromSqlTypeParameter<T> {
+   |                            ^^^

postgres-derive-test/src/composites.rs

@@ -215,3 +215,32 @@ fn wrong_type() {
         .unwrap_err();
     assert!(err.source().unwrap().is::<WrongType>());
 }
+
+#[test]
+fn struct_with_references() {
+    #[derive(FromSql, ToSql, Debug, PartialEq)]
+    #[postgres(name = "item")]
+    struct Item<'a, 'b: 'a> {
+        name: &'a str,
+        data: &'b [u8],
+    }
+
+    let mut conn = Client::connect("user=postgres host=localhost port=5433", NoTls).unwrap();
+    conn.batch_execute(
+        "CREATE TYPE pg_temp.item AS (
+            name TEXT,
+            data BYTEA
+        );",
+    )
+    .unwrap();
+
+    let item = Item {
+        name: "foobar",
+        data: b"12345",
+    };
+
+    let row = conn.query_one("SELECT $1::item", &[&item]).unwrap();
+    let result: Item<'_, '_> = row.get(0);
+    assert_eq!(item.name, result.name);
+    assert_eq!(item.data, result.data);
+}

postgres-derive-test/src/domains.rs

@@ -119,3 +119,23 @@ fn domain_in_composite() {
         )],
     );
 }
+
+#[test]
+fn struct_with_reference() {
+    #[derive(FromSql, ToSql, Debug, PartialEq)]
+    struct SessionId<'b>(&'b [u8]);
+
+    let mut conn = Client::connect("user=postgres host=localhost port=5433", NoTls).unwrap();
+    conn.execute(
+        "CREATE DOMAIN pg_temp.\"SessionId\" AS bytea CHECK(octet_length(VALUE) = 16);",
+        &[],
+    )
+    .unwrap();
+
+    let session_id = b"0123456789abcdef";
+    let row = conn
+        .query_one("SELECT $1::\"SessionId\"", &[&SessionId(session_id)])
+        .unwrap();
+    let result: SessionId<'_> = row.get(0);
+    assert_eq!(session_id, result.0);
+}

postgres-derive/Cargo.toml

@@ -12,6 +12,6 @@ proc-macro = true
 test = false
 
 [dependencies]
-syn = "1.0"
+syn = {version = "1.0", features = ["visit-mut"]}
 proc-macro2 = "1.0"
 quote = "1.0"

postgres-derive/src/accepts.rs

@@ -1,14 +1,21 @@
 use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use std::iter;
+use syn::visit_mut::VisitMut;
 use syn::Ident;
 
 use crate::composites::Field;
+use crate::composites::RenameLifetimes;
 use crate::enums::Variant;
 
-pub fn domain_body(name: &str, field: &syn::Field) -> TokenStream {
-    let ty = &field.ty;
-
+pub fn domain_body(name: &str, trait_: &str, field: &syn::Field) -> TokenStream {
+    let ty = if trait_ == "FromSql" {
+        let mut ty = field.ty.clone();
+        RenameLifetimes.visit_type_mut(&mut ty);
+        ty
+    } else {
+        field.ty.clone()
+    };
     quote! {
         if type_.name() != #name {
             return false;
@@ -57,7 +64,15 @@ pub fn composite_body(name: &str, trait_: &str, fields: &[Field]) -> TokenStream
     let trait_ = Ident::new(trait_, Span::call_site());
     let traits = iter::repeat(&trait_);
     let field_names = fields.iter().map(|f| &f.name);
-    let field_types = fields.iter().map(|f| &f.type_);
+    let field_types = fields.iter().map(|f| {
+        if trait_ == "FromSql" {
+            let mut type_ = f.type_.clone();
+            RenameLifetimes.visit_type_mut(&mut type_);
+            type_
+        } else {
+            f.type_.clone()
+        }
+    });
 
     quote! {
         if type_.name() != #name {

postgres-derive/src/composites.rs

@@ -1,4 +1,6 @@
-use syn::{Error, Ident, Type};
+use proc_macro2::Span;
+use syn::visit_mut::VisitMut;
+use syn::{Error, Ident, Lifetime, Type};
 
 use crate::overrides::Overrides;
 
@@ -20,3 +22,13 @@ impl Field {
         })
     }
 }
+
+pub struct RenameLifetimes;
+
+pub const DEFAULT_LIFETIME: &str = "a";
+
+impl VisitMut for RenameLifetimes {
+    fn visit_lifetime_mut(&mut self, node: &mut Lifetime) {
+        node.ident = Ident::new(DEFAULT_LIFETIME, Span::call_site())
+    }
+}

postgres-derive/src/fromsql.rs

@@ -1,10 +1,11 @@
 use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use std::iter;
-use syn::{Data, DataStruct, DeriveInput, Error, Fields, Ident};
+use syn::visit_mut::VisitMut;
+use syn::{Data, DataStruct, DeriveInput, Error, Fields, Ident, Lifetime};
 
 use crate::accepts;
-use crate::composites::Field;
+use crate::composites::{Field, RenameLifetimes, DEFAULT_LIFETIME};
 use crate::enums::Variant;
 use crate::overrides::Overrides;
 
@@ -58,10 +59,25 @@ pub fn expand_derive_fromsql(input: DeriveInput) -> Result<TokenStream, Error> {
     };
 
     let ident = &input.ident;
+    let mut generics = input.generics;
+    if generics.type_params().count() > 0 {
+        return Err(Error::new_spanned(
+            &generics,
+            "#[derive(FromSql)] does not support type parameters.",
+        ));
+    }
+    let type_generics = if generics.lifetimes().count() > 0 {
+        RenameLifetimes.visit_generics_mut(&mut generics);
+        let (_impl, typ, _where) = generics.split_for_impl();
+        Some(typ)
+    } else {
+        None
+    };
+    let lifetime = Lifetime::new(&format!("'{}", DEFAULT_LIFETIME), Span::call_site());
     let out = quote! {
-        impl<'a> postgres_types::FromSql<'a> for #ident {
-            fn from_sql(_type: &postgres_types::Type, buf: &'a [u8])
-                        -> std::result::Result<#ident,
+        impl <#lifetime> postgres_types::FromSql<#lifetime> for #ident #type_generics {
+            fn from_sql(_type: &postgres_types::Type, buf: & #lifetime [u8])
+                        -> std::result::Result<#ident #type_generics,
                                                std::boxed::Box<dyn std::error::Error +
                                                                std::marker::Sync +
                                                                std::marker::Send>> {
@@ -97,9 +113,9 @@ fn enum_body(ident: &Ident, variants: &[Variant]) -> TokenStream {
 
 // Domains are sometimes but not always just represented by the bare type (!?)
 fn domain_accepts_body(name: &str, field: &syn::Field) -> TokenStream {
-    let ty = &field.ty;
-    let normal_body = accepts::domain_body(name, field);
-
+    let mut ty = field.ty.clone();
+    RenameLifetimes.visit_type_mut(&mut ty);
+    let normal_body = accepts::domain_body(name, "FromSql", field);
     quote! {
         if <#ty as postgres_types::FromSql>::accepts(type_) {
             return true;
@@ -110,7 +126,8 @@ fn domain_accepts_body(name: &str, field: &syn::Field) -> TokenStream {
 }
 
 fn domain_body(ident: &Ident, field: &syn::Field) -> TokenStream {
-    let ty = &field.ty;
+    let mut ty = field.ty.clone();
+    RenameLifetimes.visit_type_mut(&mut ty);
     quote! {
         <#ty as postgres_types::FromSql>::from_sql(_type, buf).map(#ident)
     }

postgres-derive/src/tosql.rs

@@ -30,7 +30,7 @@ pub fn expand_derive_tosql(input: DeriveInput) -> Result<TokenStream, Error> {
             ..
         }) if fields.unnamed.len() == 1 => {
             let field = fields.unnamed.first().unwrap();
-            (accepts::domain_body(&name, &field), domain_body())
+            (accepts::domain_body(&name, "ToSql", &field), domain_body())
         }
         Data::Struct(DataStruct {
             fields: Fields::Named(ref fields),
@@ -55,8 +55,10 @@ pub fn expand_derive_tosql(input: DeriveInput) -> Result<TokenStream, Error> {
     };
 
     let ident = &input.ident;
+    let generics = &input.generics;
+    let (impl_generics, type_generics, where_clause) = generics.split_for_impl();
     let out = quote! {
-        impl postgres_types::ToSql for #ident {
+        impl #impl_generics postgres_types::ToSql for #ident #type_generics #where_clause {
             fn to_sql(&self,
                       _type: &postgres_types::Type,
                       buf: &mut postgres_types::private::BytesMut)