Merge branch 'sfackler:master' into tdinh/hostaddr

Author: trungda

codegen/src/errcodes.txt

@@ -2,7 +2,7 @@
 # errcodes.txt
 #      PostgreSQL error codes
 #
-# Copyright (c) 2003-2020, PostgreSQL Global Development Group
+# Copyright (c) 2003-2022, PostgreSQL Global Development Group
 #
 # This list serves as the basis for generating source files containing error
 # codes. It is kept in a common format to make sure all these source files have
@@ -222,6 +222,7 @@ Section: Class 22 - Data Exception
 2203D    E    ERRCODE_TOO_MANY_JSON_ARRAY_ELEMENTS                           too_many_json_array_elements
 2203E    E    ERRCODE_TOO_MANY_JSON_OBJECT_MEMBERS                           too_many_json_object_members
 2203F    E    ERRCODE_SQL_JSON_SCALAR_REQUIRED                               sql_json_scalar_required
+2203G    E    ERRCODE_SQL_JSON_ITEM_CANNOT_BE_CAST_TO_TARGET_TYPE            sql_json_item_cannot_be_cast_to_target_type
 
 Section: Class 23 - Integrity Constraint Violation
 
@@ -428,6 +429,7 @@ Section: Class 57 - Operator Intervention
 57P02    E    ERRCODE_CRASH_SHUTDOWN                                         crash_shutdown
 57P03    E    ERRCODE_CANNOT_CONNECT_NOW                                     cannot_connect_now
 57P04    E    ERRCODE_DATABASE_DROPPED                                       database_dropped
+57P05    E    ERRCODE_IDLE_SESSION_TIMEOUT                                   idle_session_timeout
 
 Section: Class 58 - System Error (errors external to PostgreSQL itself)
 

codegen/src/pg_range.dat

@@ -3,7 +3,7 @@
 # pg_range.dat
 #    Initial contents of the pg_range system catalog.
 #
-# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+# Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
 # Portions Copyright (c) 1994, Regents of the University of California
 #
 # src/include/catalog/pg_range.dat
@@ -12,20 +12,23 @@
 
 [
 
-{ rngtypid => 'int4range', rngsubtype => 'int4', rngsubopc => 'btree/int4_ops',
+{ rngtypid => 'int4range', rngsubtype => 'int4',
+  rngmultitypid => 'int4multirange', rngsubopc => 'btree/int4_ops',
   rngcanonical => 'int4range_canonical', rngsubdiff => 'int4range_subdiff' },
 { rngtypid => 'numrange', rngsubtype => 'numeric',
-  rngsubopc => 'btree/numeric_ops', rngcanonical => '-',
-  rngsubdiff => 'numrange_subdiff' },
+  rngmultitypid => 'nummultirange', rngsubopc => 'btree/numeric_ops',
+  rngcanonical => '-', rngsubdiff => 'numrange_subdiff' },
 { rngtypid => 'tsrange', rngsubtype => 'timestamp',
-  rngsubopc => 'btree/timestamp_ops', rngcanonical => '-',
-  rngsubdiff => 'tsrange_subdiff' },
+  rngmultitypid => 'tsmultirange', rngsubopc => 'btree/timestamp_ops',
+  rngcanonical => '-', rngsubdiff => 'tsrange_subdiff' },
 { rngtypid => 'tstzrange', rngsubtype => 'timestamptz',
-  rngsubopc => 'btree/timestamptz_ops', rngcanonical => '-',
-  rngsubdiff => 'tstzrange_subdiff' },
-{ rngtypid => 'daterange', rngsubtype => 'date', rngsubopc => 'btree/date_ops',
+  rngmultitypid => 'tstzmultirange', rngsubopc => 'btree/timestamptz_ops',
+  rngcanonical => '-', rngsubdiff => 'tstzrange_subdiff' },
+{ rngtypid => 'daterange', rngsubtype => 'date',
+  rngmultitypid => 'datemultirange', rngsubopc => 'btree/date_ops',
   rngcanonical => 'daterange_canonical', rngsubdiff => 'daterange_subdiff' },
-{ rngtypid => 'int8range', rngsubtype => 'int8', rngsubopc => 'btree/int8_ops',
+{ rngtypid => 'int8range', rngsubtype => 'int8',
+  rngmultitypid => 'int8multirange', rngsubopc => 'btree/int8_ops',
   rngcanonical => 'int8range_canonical', rngsubdiff => 'int8range_subdiff' },
 
 ]

codegen/src/pg_type.dat

@@ -17,6 +17,7 @@ struct Type {
     variant: String,
     ident: String,
     kind: String,
+    typtype: Option<String>,
     element: u32,
     doc: String,
 }
@@ -185,6 +186,15 @@ fn parse_types() -> BTreeMap<u32, Type> {
             )
         })
         .collect::<HashMap<_, _>>();
+    let multi_range_elements = raw_ranges
+        .iter()
+        .map(|m| {
+            (
+                oids_by_name[&*m["rngmultitypid"]],
+                oids_by_name[&*m["rngsubtype"]],
+            )
+        })
+        .collect::<HashMap<_, _>>();
 
     let range_vector_re = Regex::new("(range|vector)$").unwrap();
     let array_re = Regex::new("^_(.*)").unwrap();
@@ -208,8 +218,18 @@ fn parse_types() -> BTreeMap<u32, Type> {
             continue;
         }
 
+        let typtype = raw_type.get("typtype").cloned();
+
         let element = match &*kind {
-            "R" => range_elements[&oid],
+            "R" => match typtype
+                .as_ref()
+                .expect("range type must have typtype")
+                .as_str()
+            {
+                "r" => range_elements[&oid],
+                "m" => multi_range_elements[&oid],
+                typtype => panic!("invalid range typtype {}", typtype),
+            },
             "A" => oids_by_name[&raw_type["typelem"]],
             _ => 0,
         };
@@ -235,6 +255,7 @@ fn parse_types() -> BTreeMap<u32, Type> {
                 variant,
                 ident,
                 kind: "A".to_string(),
+                typtype: None,
                 element: oid,
                 doc,
             };
@@ -246,6 +267,7 @@ fn parse_types() -> BTreeMap<u32, Type> {
             variant,
             ident,
             kind,
+            typtype,
             element,
             doc,
         };
@@ -349,7 +371,16 @@ fn make_impl(w: &mut BufWriter<File>, types: &BTreeMap<u32, Type>) {
         let kind = match &*type_.kind {
             "P" => "Pseudo".to_owned(),
             "A" => format!("Array(Type(Inner::{}))", types[&type_.element].variant),
-            "R" => format!("Range(Type(Inner::{}))", types[&type_.element].variant),
+            "R" => match type_
+                .typtype
+                .as_ref()
+                .expect("range type must have typtype")
+                .as_str()
+            {
+                "r" => format!("Range(Type(Inner::{}))", types[&type_.element].variant),
+                "m" => format!("Multirange(Type(Inner::{}))", types[&type_.element].variant),
+                typtype => panic!("invalid range typtype {}", typtype),
+            },
             _ => "Simple".to_owned(),
         };
 

codegen/src/type_gen.rs

@@ -1,4 +1,4 @@
-use crate::test_type;
+use crate::{test_type, test_type_asymmetric};
 use postgres::{Client, NoTls};
 use postgres_types::{FromSql, ToSql, WrongType};
 use std::error::Error;
@@ -238,3 +238,68 @@ fn raw_ident_field() {
 
     test_type(&mut conn, "inventory_item", &[(item, "ROW('foo')")]);
 }
+
+#[test]
+fn generics() {
+    #[derive(FromSql, Debug, PartialEq)]
+    struct InventoryItem<T: Clone, U>
+    where
+        U: Clone,
+    {
+        name: String,
+        supplier_id: T,
+        price: Option<U>,
+    }
+
+    // doesn't make sense to implement derived FromSql on a type with borrows
+    #[derive(ToSql, Debug, PartialEq)]
+    #[postgres(name = "InventoryItem")]
+    struct InventoryItemRef<'a, T: 'a + Clone, U>
+    where
+        U: 'a + Clone,
+    {
+        name: &'a str,
+        supplier_id: &'a T,
+        price: Option<&'a U>,
+    }
+
+    const NAME: &str = "foobar";
+    const SUPPLIER_ID: i32 = 100;
+    const PRICE: f64 = 15.50;
+
+    let mut conn = Client::connect("user=postgres host=localhost port=5433", NoTls).unwrap();
+    conn.batch_execute(
+        "CREATE TYPE pg_temp.\"InventoryItem\" AS (
+            name TEXT,
+            supplier_id INT,
+            price DOUBLE PRECISION
+        );",
+    )
+    .unwrap();
+
+    let item = InventoryItemRef {
+        name: NAME,
+        supplier_id: &SUPPLIER_ID,
+        price: Some(&PRICE),
+    };
+
+    let item_null = InventoryItemRef {
+        name: NAME,
+        supplier_id: &SUPPLIER_ID,
+        price: None,
+    };
+
+    test_type_asymmetric(
+        &mut conn,
+        "\"InventoryItem\"",
+        &[
+            (item, "ROW('foobar', 100, 15.50)"),
+            (item_null, "ROW('foobar', 100, NULL)"),
+        ],
+        |t: &InventoryItemRef<i32, f64>, f: &InventoryItem<i32, f64>| {
+            t.name == f.name.as_str()
+                && t.supplier_id == &f.supplier_id
+                && t.price == f.price.as_ref()
+        },
+    );
+}

postgres-derive-test/src/composites.rs

@@ -16,17 +16,41 @@ where
 {
     for &(ref val, ref repr) in checks.iter() {
         let stmt = conn
-            .prepare(&*format!("SELECT {}::{}", *repr, sql_type))
+            .prepare(&format!("SELECT {}::{}", *repr, sql_type))
             .unwrap();
         let result = conn.query_one(&stmt, &[]).unwrap().get(0);
         assert_eq!(val, &result);
 
-        let stmt = conn.prepare(&*format!("SELECT $1::{}", sql_type)).unwrap();
+        let stmt = conn.prepare(&format!("SELECT $1::{}", sql_type)).unwrap();
         let result = conn.query_one(&stmt, &[val]).unwrap().get(0);
         assert_eq!(val, &result);
     }
 }
 
+pub fn test_type_asymmetric<T, F, S, C>(
+    conn: &mut Client,
+    sql_type: &str,
+    checks: &[(T, S)],
+    cmp: C,
+) where
+    T: ToSql + Sync,
+    F: FromSqlOwned,
+    S: fmt::Display,
+    C: Fn(&T, &F) -> bool,
+{
+    for &(ref val, ref repr) in checks.iter() {
+        let stmt = conn
+            .prepare(&format!("SELECT {}::{}", *repr, sql_type))
+            .unwrap();
+        let result: F = conn.query_one(&stmt, &[]).unwrap().get(0);
+        assert!(cmp(val, &result));
+
+        let stmt = conn.prepare(&format!("SELECT $1::{}", sql_type)).unwrap();
+        let result: F = conn.query_one(&stmt, &[val]).unwrap().get(0);
+        assert!(cmp(val, &result));
+    }
+}
+
 #[test]
 fn compile_fail() {
     trybuild::TestCases::new().compile_fail("src/compile-fail/*.rs");

postgres-derive-test/src/lib.rs

@@ -1,5 +1,11 @@
 # Change Log
 
+## v0.4.3 - 2022-09-07
+
+### Added
+
+* Added support for parameterized structs.
+
 ## v0.4.2 - 2022-04-30
 
 ### Added

postgres-derive/CHANGELOG.md

@@ -1,6 +1,6 @@
 [package]
 name = "postgres-derive"
-version = "0.4.2"
+version = "0.4.3"
 authors = ["Steven Fackler <[email protected]>"]
 license = "MIT/Apache-2.0"
 edition = "2018"

postgres-derive/Cargo.toml

@@ -1,4 +1,8 @@
-use syn::{Error, Ident, Type};
+use proc_macro2::Span;
+use syn::{
+    punctuated::Punctuated, Error, GenericParam, Generics, Ident, Path, PathSegment, Type,
+    TypeParamBound,
+};
 
 use crate::overrides::Overrides;
 
@@ -26,3 +30,23 @@ impl Field {
         })
     }
 }
+
+pub(crate) fn append_generic_bound(mut generics: Generics, bound: &TypeParamBound) -> Generics {
+    for param in &mut generics.params {
+        if let GenericParam::Type(param) = param {
+            param.bounds.push(bound.to_owned())
+        }
+    }
+    generics
+}
+
+pub(crate) fn new_derive_path(last: PathSegment) -> Path {
+    let mut path = Path {
+        leading_colon: None,
+        segments: Punctuated::new(),
+    };
+    path.segments
+        .push(Ident::new("postgres_types", Span::call_site()).into());
+    path.segments.push(last);
+    path
+}

postgres-derive/src/composites.rs

@@ -1,10 +1,16 @@
-use proc_macro2::TokenStream;
+use proc_macro2::{Span, TokenStream};
 use quote::{format_ident, quote};
 use std::iter;
-use syn::{Data, DataStruct, DeriveInput, Error, Fields, Ident};
+use syn::{
+    punctuated::Punctuated, token, AngleBracketedGenericArguments, Data, DataStruct, DeriveInput,
+    Error, Fields, GenericArgument, GenericParam, Generics, Ident, Lifetime, LifetimeDef,
+    PathArguments, PathSegment,
+};
+use syn::{TraitBound, TraitBoundModifier, TypeParamBound};
 
 use crate::accepts;
 use crate::composites::Field;
+use crate::composites::{append_generic_bound, new_derive_path};
 use crate::enums::Variant;
 use crate::overrides::Overrides;
 
@@ -86,10 +92,13 @@ pub fn expand_derive_fromsql(input: DeriveInput) -> Result<TokenStream, Error> {
     };
 
     let ident = &input.ident;
+    let (generics, lifetime) = build_generics(&input.generics);
+    let (impl_generics, _, _) = generics.split_for_impl();
+    let (_, ty_generics, where_clause) = input.generics.split_for_impl();
     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#impl_generics postgres_types::FromSql<#lifetime> for #ident#ty_generics #where_clause {
+            fn from_sql(_type: &postgres_types::Type, buf: &#lifetime [u8])
+                        -> std::result::Result<#ident#ty_generics,
                                                std::boxed::Box<dyn std::error::Error +
                                                                std::marker::Sync +
                                                                std::marker::Send>> {
@@ -200,3 +209,35 @@ fn composite_body(ident: &Ident, fields: &[Field]) -> TokenStream {
         })
     }
 }
+
+fn build_generics(source: &Generics) -> (Generics, Lifetime) {
+    // don't worry about lifetime name collisions, it doesn't make sense to derive FromSql on a struct with a lifetime
+    let lifetime = Lifetime::new("'a", Span::call_site());
+
+    let mut out = append_generic_bound(source.to_owned(), &new_fromsql_bound(&lifetime));
+    out.params.insert(
+        0,
+        GenericParam::Lifetime(LifetimeDef::new(lifetime.to_owned())),
+    );
+
+    (out, lifetime)
+}
+
+fn new_fromsql_bound(lifetime: &Lifetime) -> TypeParamBound {
+    let mut path_segment: PathSegment = Ident::new("FromSql", Span::call_site()).into();
+    let mut seg_args = Punctuated::new();
+    seg_args.push(GenericArgument::Lifetime(lifetime.to_owned()));
+    path_segment.arguments = PathArguments::AngleBracketed(AngleBracketedGenericArguments {
+        colon2_token: None,
+        lt_token: token::Lt::default(),
+        args: seg_args,
+        gt_token: token::Gt::default(),
+    });
+
+    TypeParamBound::Trait(TraitBound {
+        lifetimes: None,
+        modifier: TraitBoundModifier::None,
+        paren_token: None,
+        path: new_derive_path(path_segment),
+    })
+}