Support for Postgres enums

diesel/src/macros/macros_from_codegen.rs

@@ -12,6 +12,22 @@
 /// This macro can only be used in combination with the `diesel_codegen` or
 /// `diesel_codegen_syntex` crates. It will not work on its own.
 macro_rules! infer_schema {
+    (extra_types_module = $extra_types_module: expr, $database_url: expr) => {
+        mod __diesel_infer_schema {
+            #[derive(InferSchema)]
+            #[infer_schema_options(database_url=$database_url, extra_types_module=$extra_types_module)]
+            struct _Dummy;
+        }
+        pub use self::__diesel_infer_schema::*;
+    };
+    (extra_types_module = $extra_types_module: expr, $database_url: expr, $schema_name: expr) => {
+        mod __diesel_infer_schema {
+            #[derive(InferSchema)]
+            #[infer_schema_options(database_url=$database_url, schema_name=$schema_name, extra_types_module=$extra_types_module)]
+            struct _Dummy;
+        }
+        pub use self::__diesel_infer_schema::*;
+    };
     ($database_url: expr) => {
         mod __diesel_infer_schema {
             #[derive(InferSchema)]
@@ -51,11 +67,16 @@ macro_rules! infer_schema {
 /// This macro can only be used in combination with the `diesel_codegen` or
 /// `diesel_codegen_syntex` crates. It will not work on its own.
 macro_rules! infer_table_from_schema {
+    (extra_types_module = $extra_types_module: expr, $database_url: expr, $table_name: expr) => {
+        #[derive(InferTableFromSchema)]
+        #[infer_table_from_schema_options(database_url=$database_url, table_name=$table_name, extra_types_module=$extra_types_module)]
+        struct __DieselInferTableFromSchema;
+    };
     ($database_url: expr, $table_name: expr) => {
         #[derive(InferTableFromSchema)]
         #[infer_table_from_schema_options(database_url=$database_url, table_name=$table_name)]
         struct __DieselInferTableFromSchema;
-    }
+    };
 }
 
 #[macro_export]
@@ -88,3 +109,33 @@ macro_rules! embed_migrations {
         }
     }
 }
+
+#[macro_export]
+/// Queries the database for the names of all enum types and creates a Rust enum
+/// type for each one in the current namespace. The enum type name and variants
+/// of the database enum type will be translated from snake case to camel case
+/// (so enum_type::variant becomes EnumType::Variant). For types in a schema
+/// other than the default, the type will be created in a submodule with the
+/// schema name.
+///
+/// This macro can only be used in combination with the `diesel_codegen` or
+/// `diesel_codegen_syntex` crates. It will not work on its own.
+macro_rules! infer_enums {
+    ($database_url: expr) => {
+        mod __diesel_infer_enums {
+            #[derive(InferEnums)]
+            #[infer_enum_options(database_url=$database_url)]
+            struct _Dummy;
+        }
+        pub use self::__diesel_infer_enums::*;
+    };
+
+    ($database_url: expr, $schema_name: expr) => {
+        mod __diesel_infer_enums {
+            #[derive(InferEnums)]
+            #[infer_enum_options(databsae_url=$database_url, schema_name=$schema_name)]
+            struct _Dummy;
+        }
+        pub use self::__diesel_infer_enums::*;
+    };
+}

diesel/src/types/impls/option.rs

@@ -7,12 +7,12 @@ use expression::*;
 use expression::bound::Bound;
 use query_builder::QueryId;
 use query_source::Queryable;
-use types::{HasSqlType, FromSql, FromSqlRow, Nullable, ToSql, IsNull, NotNull};
+use types::{ProvidesSqlTypeFor, HasSqlType, FromSql, FromSqlRow, Nullable, ToSql, IsNull, NotNull};
 
-impl<T, DB> HasSqlType<Nullable<T>> for DB where
+impl<T, DB> ProvidesSqlTypeFor<DB> for Nullable<T> where
     DB: Backend + HasSqlType<T>, T: NotNull,
 {
-    fn metadata() -> DB::TypeMetadata{
+    fn self_metadata() -> DB::TypeMetadata{
         <DB as HasSqlType<T>>::metadata()
     }
 }

diesel/src/types/impls/tuples.rs

@@ -7,7 +7,7 @@ use query_source::{QuerySource, Queryable, Table, Column};
 use result::QueryResult;
 use row::Row;
 use std::error::Error;
-use types::{HasSqlType, FromSqlRow, Nullable, IntoNullable, NotNull};
+use types::{ProvidesSqlTypeFor, HasSqlType, FromSqlRow, Nullable, IntoNullable, NotNull};
 
 macro_rules! tuple_impls {
     ($(
@@ -16,11 +16,11 @@ macro_rules! tuple_impls {
         }
     )+) => {
         $(
-            impl<$($T),+, DB> HasSqlType<($($T,)+)> for DB where
+            impl<$($T),+, DB> ProvidesSqlTypeFor<DB> for ($($T,)+) where
                 $(DB: HasSqlType<$T>),+,
                 DB: Backend,
             {
-                fn metadata() -> DB::TypeMetadata {
+                fn self_metadata() -> DB::TypeMetadata {
                     unreachable!("Tuples should never implement `ToSql` directly");
                 }
             }

diesel/src/types/mod.rs

@@ -249,10 +249,20 @@ pub type VarChar = Text;
 #[cfg(feature = "postgres")]
 pub use pg::types::sql_types::*;
 
+pub trait ProvidesSqlTypeFor<DB> where DB: TypeMetadata {
+    fn self_metadata() -> DB::TypeMetadata;
+}
+
 pub trait HasSqlType<ST>: TypeMetadata {
     fn metadata() -> Self::TypeMetadata;
 }
 
+impl<ST, DB> HasSqlType<ST> for DB where DB: TypeMetadata, ST: ProvidesSqlTypeFor<DB> {
+    fn metadata() -> Self::TypeMetadata {
+        <ST as ProvidesSqlTypeFor<DB>>::self_metadata()
+    }
+}
+
 pub trait NotNull {
 }
 

diesel_codegen/Cargo.toml

@@ -10,11 +10,15 @@ repository = "https://github.com/diesel-rs/diesel/tree/master/diesel_codegen"
 keywords = ["orm", "database", "postgres", "sql", "codegen"]
 
 [dependencies]
-syn = "0.10.3"
+syntex_syntax = "0.52.0"
 quote = "0.3.10"
 diesel = { version = "0.9.0", default-features = false }
 diesel_codegen_shared = { version = "0.9.0", default-features = false }
 
+[dependencies.syn]
+version = "0.10.3"
+features = ["full"]
+
 [lib]
 proc-macro = true
 

diesel_codegen/src/lib.rs

@@ -1,4 +1,5 @@
 #![deny(warnings)]
+#![recursion_limit = "512"]
 
 macro_rules! t {
     ($expr:expr) => {
@@ -13,6 +14,7 @@ extern crate diesel_codegen_shared;
 extern crate diesel;
 #[macro_use]
 extern crate quote;
+extern crate syntex_syntax;
 extern crate proc_macro;
 extern crate syn;
 
@@ -25,6 +27,8 @@ mod identifiable;
 mod insertable;
 mod model;
 mod queryable;
+#[cfg(feature = "postgres")]
+mod type_inference;
 #[cfg(any(feature = "postgres", feature = "sqlite"))]
 mod schema_inference;
 mod util;
@@ -74,6 +78,12 @@ pub fn derive_embed_migrations(input: TokenStream) -> TokenStream {
     expand_derive(input, embed_migrations::derive_embed_migrations)
 }
 
+#[proc_macro_derive(InferEnums, attributes(infer_enum_options))]
+#[cfg(feature = "postgres")]
+pub fn derive_infer_enums(input: TokenStream) -> TokenStream {
+    expand_derive(input, type_inference::derive_infer_enums)
+}
+
 fn expand_derive(input: TokenStream, f: fn(syn::MacroInput) -> quote::Tokens) -> TokenStream {
     let item = parse_macro_input(&input.to_string()).unwrap();
     f(item).to_string().parse().unwrap()

diesel_codegen/src/schema_inference.rs

@@ -1,4 +1,5 @@
 use syn;
+// use syntex_syntax::symbol::keywords;
 use quote;
 
 use diesel_codegen_shared::*;
@@ -15,8 +16,9 @@ pub fn derive_infer_schema(input: syn::MacroInput) -> quote::Tokens {
         .unwrap_or_else(|| bug());
     let database_url = get_option(&options, "database_url", bug);
     let schema_name = get_optional_option(&options, "schema_name");
+    let extra_types_module = get_optional_option(&options, "extra_types_module");
 
-    infer_schema_for_schema_name(&database_url, schema_name.as_ref().map(|s| &**s))
+    infer_schema_for_schema_name(&database_url, schema_name.as_ref().map(|s| &**s), extra_types_module)
 }
 
 pub fn derive_infer_table_from_schema(input: syn::MacroInput) -> quote::Tokens {
@@ -27,6 +29,7 @@ pub fn derive_infer_table_from_schema(input: syn::MacroInput) -> quote::Tokens {
 
     let options = get_options_from_input("infer_table_from_schema_options", &input.attrs, bug)
         .unwrap_or_else(|| bug());
+    let extra_types_module = get_optional_option(&options, "extra_types_module");
     let database_url = get_option(&options, "database_url", bug);
     let table_name = get_option(&options, "table_name", bug);
 
@@ -36,7 +39,7 @@ pub fn derive_infer_table_from_schema(input: syn::MacroInput) -> quote::Tokens {
         .into_iter().map(syn::Ident::new);
     let table_name = syn::Ident::new(table_name);
 
-    let tokens = data.iter().map(|a| column_def_tokens(a, &connection));
+    let tokens = data.iter().map(|a| column_def_tokens(extra_types_module, a, &connection));
 
     quote!(table! {
         #table_name (#(#primary_keys),*) {
@@ -45,19 +48,28 @@ pub fn derive_infer_table_from_schema(input: syn::MacroInput) -> quote::Tokens {
     })
 }
 
-fn infer_schema_for_schema_name(database_url: &str, schema_name: Option<&str>) -> quote::Tokens {
+fn infer_schema_for_schema_name(database_url: &str, schema_name: Option<&str>,
+                                extra_types_module: Option<&str>) -> quote::Tokens {
     let table_names = load_table_names(&database_url, schema_name).unwrap();
     let schema_inferences = table_names.into_iter().map(|table_name| {
         let mod_ident = syn::Ident::new(format!("infer_{}", table_name));
         let table_name = match schema_name {
             Some(name) => format!("{}.{}", name, table_name),
             None => table_name,
         };
-        quote! {
-            mod #mod_ident {
-                infer_table_from_schema!(#database_url, #table_name);
-            }
-            pub use self::#mod_ident::*;
+        match extra_types_module {
+            Some(m) => quote! {
+                mod #mod_ident {
+                    infer_table_from_schema!(extra_types_module=#m, #database_url, #table_name);
+                }
+                pub use self::#mod_ident::*;
+            },
+            None => quote! {
+                mod #mod_ident {
+                    infer_table_from_schema!(#database_url, #table_name);
+                }
+                pub use self::#mod_ident::*;
+            },
         }
     });
 
@@ -71,16 +83,15 @@ fn infer_schema_for_schema_name(database_url: &str, schema_name: Option<&str>) -
 }
 
 fn column_def_tokens(
+    extra_types_module: Option<&str>,
     column: &ColumnInformation,
     connection: &InferConnection,
 ) -> quote::Tokens {
     let column_name = syn::Ident::new(&*column.column_name);
-    let column_type = determine_column_type(column, connection).unwrap();
-    let path_segments = column_type.path
-        .into_iter()
-        .map(syn::PathSegment::from)
-        .collect();
-    let tpe = syn::Path { global: true, segments: path_segments };
+    let column_type = determine_column_type(extra_types_module, column, connection).unwrap();
+    let path_segments =
+        column_type.path.into_iter().map(syn::PathSegment::from).collect();
+    let tpe = syn::Path { global: column_type.is_builtin, segments: path_segments };
     let mut tpe = quote!(#tpe);
 
     if column_type.is_array {