Add domain types configuration

diesel_cli/src/config.rs

@@ -465,6 +465,8 @@ pub struct PrintSchema {
     pub custom_type_derives: Option<Vec<String>>,
     #[serde(default)]
     pub sqlite_integer_primary_key_is_bigint: Option<bool>,
+    #[serde(default)]
+    pub domain_types: bool,
 }
 
 impl PrintSchema {

diesel_cli/src/infer_schema_internals/inference.rs

@@ -162,14 +162,17 @@ fn get_column_information(
     conn: &mut InferConnection,
     table: &TableName,
     column_sorting: &ColumnSorting,
+    domain_types_enabled: bool,
 ) -> Result<Vec<ColumnInformation>, crate::errors::Error> {
     let column_info = match *conn {
         #[cfg(feature = "sqlite")]
         InferConnection::Sqlite(ref mut c) => {
             super::sqlite::get_table_data(c, table, column_sorting)
         }
         #[cfg(feature = "postgres")]
-        InferConnection::Pg(ref mut c) => super::pg::get_table_data(c, table, column_sorting),
+        InferConnection::Pg(ref mut c) => {
+            super::pg::get_table_data(c, table, column_sorting, domain_types_enabled)
+        }
         #[cfg(feature = "mysql")]
         InferConnection::Mysql(ref mut c) => super::mysql::get_table_data(c, table, column_sorting),
     };
@@ -277,26 +280,31 @@ pub fn load_table_data(
 
     let primary_key = get_primary_keys(connection, &name)?;
 
-    let column_data = get_column_information(connection, &name, &config.column_sorting)?
-        .into_iter()
-        .map(|c| {
-            let ty = determine_column_type(&c, connection, &name, &primary_key, config)?;
+    let column_data = get_column_information(
+        connection,
+        &name,
+        &config.column_sorting,
+        config.domain_types,
+    )?
+    .into_iter()
+    .map(|c| {
+        let ty = determine_column_type(&c, connection, &name, &primary_key, config)?;
 
-            let ColumnInformation {
-                column_name,
-                comment,
-                ..
-            } = c;
-            let rust_name = rust_name_for_sql_name(&column_name);
+        let ColumnInformation {
+            column_name,
+            comment,
+            ..
+        } = c;
+        let rust_name = rust_name_for_sql_name(&column_name);
 
-            Ok(ColumnDefinition {
-                sql_name: column_name,
-                ty,
-                rust_name,
-                comment,
-            })
+        Ok(ColumnDefinition {
+            sql_name: column_name,
+            ty,
+            rust_name,
+            comment,
         })
-        .collect::<Result<_, crate::errors::Error>>()?;
+    })
+    .collect::<Result<_, crate::errors::Error>>()?;
 
     let primary_key = primary_key
         .iter()

diesel_cli/src/infer_schema_internals/pg.rs

@@ -90,25 +90,47 @@ pub fn get_table_data(
     conn: &mut PgConnection,
     table: &TableName,
     column_sorting: &ColumnSorting,
+    domain_types_enabled: bool,
 ) -> QueryResult<Vec<ColumnInformation>> {
     use self::information_schema::columns::dsl::*;
+    use diesel::sql_types::{Nullable, SingleValue};
 
     let schema_name = match table.schema {
         Some(ref name) => Cow::Borrowed(name),
         None => Cow::Owned(Pg::default_schema(conn)?),
     };
 
-    let query = columns
-        .select((
-            column_name,
-            udt_name,
-            udt_schema.nullable(),
-            __is_nullable,
-            character_maximum_length,
-            col_description(regclass(table), ordinal_position),
-        ))
-        .filter(table_name.eq(&table.sql_name))
-        .filter(table_schema.eq(schema_name));
+    let query = if domain_types_enabled {
+        define_sql_function!(#[sql_name = "coalesce"] fn coalesce_maybe<T: SingleValue>(x: Nullable<T>, y: Nullable<T>) -> Nullable<T>);
+        define_sql_function!(#[sql_name = "coalesce"] fn coalesce_strict<T: SingleValue>(x: Nullable<T>, y: T) -> T);
+
+        columns
+            .select((
+                column_name,
+                coalesce_strict(domain_name, udt_name),
+                coalesce_maybe(domain_schema, udt_schema.nullable()),
+                __is_nullable,
+                character_maximum_length,
+                col_description(regclass(table), ordinal_position),
+            ))
+            .filter(table_name.eq(&table.sql_name))
+            .filter(table_schema.eq(schema_name))
+            .into_boxed()
+    } else {
+        columns
+            .select((
+                column_name,
+                udt_name,
+                udt_schema.nullable(),
+                __is_nullable,
+                character_maximum_length,
+                col_description(regclass(table), ordinal_position),
+            ))
+            .filter(table_name.eq(&table.sql_name))
+            .filter(table_schema.eq(schema_name))
+            .into_boxed()
+    };
+
     match column_sorting {
         ColumnSorting::OrdinalPosition => query.order(ordinal_position).load(conn),
         ColumnSorting::Name => query.order(column_name).load(conn),
@@ -174,6 +196,8 @@ mod information_schema {
             ordinal_position -> BigInt,
             udt_name -> VarChar,
             udt_schema -> VarChar,
+            domain_name -> Nullable<VarChar>,
+            domain_schema -> Nullable<VarChar>,
         }
     }
 }
@@ -290,11 +314,21 @@ mod test {
             ColumnInformation::new("array_col", "_varchar", pg_catalog, false, None, None);
         assert_eq!(
             Ok(vec![id, text_col, not_null]),
-            get_table_data(&mut connection, &table_1, &ColumnSorting::OrdinalPosition)
+            get_table_data(
+                &mut connection,
+                &table_1,
+                &ColumnSorting::OrdinalPosition,
+                false
+            )
         );
         assert_eq!(
             Ok(vec![array_col]),
-            get_table_data(&mut connection, &table_2, &ColumnSorting::OrdinalPosition)
+            get_table_data(
+                &mut connection,
+                &table_2,
+                &ColumnSorting::OrdinalPosition,
+                false
+            )
         );
     }
 

diesel_cli/tests/print_schema.rs

@@ -49,6 +49,12 @@ fn run_infer_schema_django_bool_case() {
     );
 }
 
+#[test]
+#[cfg(feature = "postgres")]
+fn run_infer_schema_domain_types_default_case() {
+    test_print_schema("print_schema_domain_types_default", vec!["--with-docs"]);
+}
+
 #[test]
 fn run_infer_schema_exclude() {
     test_print_schema(

diesel_cli/tests/print_schema/print_schema_domain_types_default/diesel.toml

@@ -0,0 +1,3 @@
+[print_schema]
+file = "src/schema.rs"
+with_docs = true

diesel_cli/tests/print_schema/print_schema_domain_types_default/postgres/expected.snap

@@ -0,0 +1,20 @@
+---
+source: diesel_cli/tests/print_schema.rs
+assertion_line: 509
+description: "Test: print_schema_domain_types_default"
+---
+// @generated automatically by Diesel CLI.
+
+diesel::table! {
+    /// Representation of the `mytable` table.
+    ///
+    /// (Automatically generated by Diesel.)
+    mytable (id) {
+        /// The `id` column of the `mytable` table.
+        ///
+        /// Its SQL type is `Int4`.
+        ///
+        /// (Automatically generated by Diesel.)
+        id -> Int4,
+    }
+}

diesel_cli/tests/print_schema/print_schema_domain_types_default/postgres/schema.sql

@@ -0,0 +1,4 @@
+-- https://www.postgresql.org/docs/current/domains.html
+CREATE DOMAIN posint AS integer CHECK (VALUE > 0);
+
+CREATE TABLE mytable (id posint PRIMARY KEY);

diesel_cli/tests/print_schema/print_schema_domain_types_enabled/diesel.toml

@@ -0,0 +1,4 @@
+[print_schema]
+file = "src/schema.rs"
+with_docs = true
+with_domain_types = true

diesel_cli/tests/print_schema/print_schema_domain_types_enabled/postgres/expected.snap

@@ -0,0 +1,35 @@
+---
+source: diesel_cli/tests/print_schema.rs
+assertion_line: 509
+description: "Test: print_schema_domain_types_default"
+---
+// @generated automatically by Diesel CLI.
+
+/// A module containing custom SQL type definitions
+///
+/// (Automatically generated by Diesel.)
+pub mod sql_types {
+    /// The `posint` SQL type
+    ///
+    /// (Automatically generated by Diesel.)
+    #[derive(diesel::query_builder::QueryId, Clone, diesel::sql_types::SqlType)]
+    #[diesel(postgres_type(name = "posint"))]
+    pub struct Posint;
+}
+
+diesel::table! {
+    use diesel::sql_types::*;
+    use super::sql_types::Posint;
+
+    /// Representation of the `mytable` table.
+    ///
+    /// (Automatically generated by Diesel.)
+    mytable (id) {
+        /// The `id` column of the `mytable` table.
+        ///
+        /// Its SQL type is `Posint`.
+        ///
+        /// (Automatically generated by Diesel.)
+        id -> Posint,
+    }
+}

diesel_cli/tests/print_schema/print_schema_domain_types_enabled/postgres/schema.sql

@@ -0,0 +1,4 @@
+-- https://www.postgresql.org/docs/current/domains.html
+CREATE DOMAIN posint AS integer CHECK (VALUE > 0);
+
+CREATE TABLE mytable (id posint PRIMARY KEY);