Merge pull request #4749 from weiznich/fix/better_generate_migrations_for_postgres

Improve support for various postgres types in generated migrations

Author: weiznich

diesel_cli/src/infer_schema_internals/data_structures.rs

@@ -20,12 +20,13 @@ pub struct ColumnType {
     pub is_array: bool,
     pub is_nullable: bool,
     pub is_unsigned: bool,
+    pub record: Option<Vec<ColumnType>>,
     pub max_length: Option<u64>,
 }
 
 impl ColumnType {
     pub(crate) fn for_column_def(c: &ColumnDef) -> Result<Self, crate::errors::Error> {
-        Ok(Self::for_type_path(
+        Self::for_type_path(
             &c.tpe,
             c.max_length
                 .as_ref()
@@ -34,10 +35,13 @@ impl ColumnType {
                         .map_err(crate::errors::Error::ColumnLiteralParseError)
                 })
                 .transpose()?,
-        ))
+        )
     }
 
-    fn for_type_path(t: &syn::TypePath, max_length: Option<u64>) -> Self {
+    fn for_type_path(
+        t: &syn::TypePath,
+        max_length: Option<u64>,
+    ) -> Result<Self, crate::errors::Error> {
         let last = t
             .path
             .segments
@@ -51,31 +55,80 @@ impl ColumnType {
             is_array: last.ident == "Array",
             is_nullable: last.ident == "Nullable",
             is_unsigned: last.ident == "Unsigned",
+            record: None,
             max_length,
         };
+        let is_range = last.ident == "Range";
+        let is_multirange = last.ident == "Multirange";
+        let is_record = last.ident == "Record";
 
-        let sql_name = if !ret.is_nullable && !ret.is_array && !ret.is_unsigned {
+        let sql_name = if !ret.is_nullable
+            && !ret.is_array
+            && !ret.is_unsigned
+            && !is_range
+            && !is_multirange
+            && !is_record
+        {
             if last.ident == "PgLsn" {
                 "pg_lsn".to_string()
             } else {
                 last.ident.to_string()
             }
         } else if let syn::PathArguments::AngleBracketed(ref args) = last.arguments {
             let arg = args.args.first().expect("There is at least one argument");
-            if let syn::GenericArgument::Type(syn::Type::Path(p)) = arg {
-                let s = Self::for_type_path(p, max_length);
-                ret.is_nullable |= s.is_nullable;
-                ret.is_array |= s.is_array;
-                ret.is_unsigned |= s.is_unsigned;
-                s.sql_name
+            if let syn::GenericArgument::Type(syn::Type::Tuple(t)) = arg {
+                ret.record = Some(
+                    t.elems
+                        .iter()
+                        .map(|t| {
+                            if let syn::Type::Path(p) = t {
+                                Self::for_type_path(p, None)
+                            } else {
+                                panic!();
+                            }
+                        })
+                        .collect::<Result<_, _>>()?,
+                );
+                "record".to_owned()
+            } else if let syn::GenericArgument::Type(syn::Type::Path(p)) = arg {
+                let s = Self::for_type_path(p, max_length)?;
+                if is_range {
+                    match s.sql_name.to_uppercase().as_str() {
+                        "INT4" | "INTEGER" => "int4range".to_owned(),
+                        "INT8" | "BIGINT" => "int8range".into(),
+                        "NUMERIC" => "numrange".into(),
+                        "TIMESTAMP" | "TIMESTAMP WITHOUT TIME ZONE" => "tsrange".into(),
+                        "TIMESTAMPTZ" | "TIMESTAMP WITH TIME ZONE" => "tstzrange".into(),
+                        "DATE" => "daterange".into(),
+                        s => format!("{s}range"),
+                    }
+                } else if is_multirange {
+                    match s.sql_name.to_uppercase().as_str() {
+                        "INT4" | "INTEGER" => "int4multirange".to_owned(),
+                        "INT8" | "BIGINT" => "int8multirange".into(),
+                        "NUMERIC" => "nummultirange".into(),
+                        "TIMESTAMP" | "TIMESTAMP WITHOUT TIME ZONE" => "tsmultirange".into(),
+                        "TIMESTAMPTZ" | "TIMESTAMP WITH TIME ZONE" => "tstzmultirange".into(),
+                        "DATE" => "datemultirange".into(),
+                        s => format!("{s}multirange"),
+                    }
+                } else {
+                    if !ret.is_array {
+                        ret.is_nullable |= s.is_nullable;
+                        ret.is_array |= s.is_array;
+                    }
+                    ret.is_unsigned |= s.is_unsigned;
+                    ret.record = ret.record.or(s.record);
+                    s.sql_name
+                }
             } else {
                 unreachable!("That shouldn't happen")
             }
         } else {
             unreachable!("That shouldn't happen")
         };
         ret.sql_name = sql_name;
-        ret
+        Ok(ret)
     }
 }
 
@@ -106,7 +159,7 @@ impl fmt::Display for ColumnType {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct ColumnDefinition {
     pub sql_name: String,
     pub rust_name: String,

diesel_cli/src/infer_schema_internals/mysql.rs

@@ -222,6 +222,7 @@ pub fn determine_column_type(attr: &ColumnInformation) -> Result<ColumnType, cra
         is_array: false,
         is_nullable: attr.nullable,
         is_unsigned: unsigned,
+        record: None,
         max_length: attr.max_length,
     })
 }

diesel_cli/src/infer_schema_internals/pg.rs

@@ -68,6 +68,7 @@ pub fn determine_column_type(
         is_array,
         is_nullable: attr.nullable,
         is_unsigned: false,
+        record: None,
         max_length: attr.max_length,
     })
 }

diesel_cli/src/infer_schema_internals/sqlite.rs

@@ -374,6 +374,7 @@ pub fn determine_column_type(
         is_array: false,
         is_nullable: attr.nullable,
         is_unsigned: false,
+        record: None,
         max_length: attr.max_length,
     })
 }