Merge pull request diesel-rs#948 from diesel-rs/sg-rm-has-many

Remove `#[has_many]`, it has become useless

Author: sgrif

CHANGELOG.md

@@ -34,6 +34,12 @@ for Rust libraries in [RFC #1105](https://github.com/rust-lang/rfcs/blob/master/
 * Trait bounds along the lines of `T: LoadDsl<Conn>, U: Queryable<T::SqlType,
   Conn::Backend>` should be changed to `T: LoadQuery<Conn, U>`.
 
+### Removed
+
+* `#[has_many]` has been removed. Its functionality is now provided by
+  `#[belongs_to]` on the child struct. If there is no child struct to
+  put `#[belongs_to]` on, you can invoke `joinable!` directly instead.
+
 ## [0.13.0] - 2017-05-15
 
 ### Added

diesel/Cargo.toml

@@ -28,7 +28,7 @@ ipnetwork = { version = "0.12.2", optional = true }
 
 [dev-dependencies]
 cfg-if = "0.1.0"
-diesel_codegen = "0.12.0"
+diesel_codegen = "0.13.0"
 dotenv = ">=0.8, <0.11"
 quickcheck = "0.3.1"
 tempdir = "^0.3.4"

diesel/src/associations/mod.rs

@@ -12,7 +12,7 @@
 //! `#[macro_use] extern crate diesel_codegen;` at the root of your crate.
 //!
 //! Associations in Diesel are bidirectional, but primarily focus on the child-to-parent
-//! relationship. You can declare an association between two records with `#[has_many]` and
+//! relationship. You can declare an association between two records with
 //! `#[belongs_to]`.
 //!
 //! ```rust
@@ -23,8 +23,7 @@
 //! # include!("src/doctest_setup.rs");
 //! use schema::{posts, users};
 //!
-//! #[derive(Identifiable, Queryable, Associations)]
-//! #[has_many(posts)]
+//! #[derive(Identifiable, Queryable)]
 //! pub struct User {
 //!     id: i32,
 //!     name: String,
@@ -47,24 +46,19 @@
 //! # }
 //! ```
 //!
-//! Note that in addition to the `#[has_many]` and `#[belongs_to]` annotations, we also need to
+//! Note that in addition to the `#[belongs_to]` annotation, we also need to
 //! `#[derive(Associations)]`
 //!
-//! `#[has_many]` should be passed the name of the table that the children will be loaded from,
-//! while `#[belongs_to]` is given the name of the struct that represents the parent. Both types
+//! `#[belongs_to]` is given the name of the struct that represents the parent. Both types
 //! must implement the [`Identifiable`][identifiable] trait. The struct or table referenced in your
 //! association has to be in scope, so you'll need `use schema::posts` or similar to bring the
 //! table into scope, and `use some_module::User` if `User` were in a different module.
 //!
 //! [Identifiable]: trait.Identifiable.html
 //!
 //! If the name of your foreign key doesn't follow the convention `tablename_id`, you can specify a
-//! custom one to `#[has_many]` and `#[belongs_to]` by adding a `foreign_key` argument to the
-//! attribute like so `#[has_many, foreign_key="mykey"]`.
-//!
-//! `#[has_many]` actually has no behavior on its own. It only enables joining between the two
-//! tables. If you are only writing `children.inner_join(parents)` or
-//! `Child::belonging_to(&parents)`, you only need to define the `#[belongs_to]` side.
+//! custom one to `#[belongs_to]` by adding a `foreign_key` argument to the
+//! attribute like so `#[belongs_to(Foo, foreign_key="mykey")]`.
 //!
 //! Once the associations are defined, you can join between the two tables using the
 //! [`inner_join`][inner-join] or [`left_outer_join`][left-outer-join].

diesel/src/macros/associations/belongs_to.rs

@@ -235,6 +235,14 @@ macro_rules! BelongsTo {
                 primary_key_ty = <<$parent_struct as $crate::associations::HasTable>::Table as $crate::Table>::PrimaryKey,
                 primary_key_expr = $crate::Table::primary_key(&<$parent_struct as $crate::associations::HasTable>::table()),
             );
+            joinable_inner!(
+                left_table_ty = $child_table_name::table,
+                right_table_ty = $crate::query_source::joins::PleaseGenerateInverseJoinImpls<<$parent_struct as $crate::associations::HasTable>::Table>,
+                right_table_expr = <$parent_struct as $crate::associations::HasTable>::table(),
+                foreign_key = $child_table_name::$foreign_key_name,
+                primary_key_ty = <<$parent_struct as $crate::associations::HasTable>::Table as $crate::Table>::PrimaryKey,
+                primary_key_expr = $crate::Table::primary_key(&<$parent_struct as $crate::associations::HasTable>::table()),
+            );
         });
     };
 

diesel/src/macros/associations/has_many.rs

@@ -1,2 +1 @@
 #[macro_use] mod belongs_to;
-#[macro_use] mod has_many;

diesel/src/macros/associations/mod.rs

@@ -325,11 +325,13 @@ macro_rules! table_body {
             use $crate::{
                 QuerySource,
                 Table,
+                JoinTo,
             };
             use $crate::associations::HasTable;
             use $crate::query_builder::*;
             use $crate::query_builder::nodes::Identifier;
-            use $crate::query_source::{AppearsInFromClause, Once};
+            use $crate::query_source::{AppearsInFromClause, Once, Never};
+            use $crate::query_source::joins::PleaseGenerateInverseJoinImpls;
             $(use $($import)::+;)+
             pub use self::columns::*;
 
@@ -413,6 +415,22 @@ macro_rules! table_body {
                 type Count = Once;
             }
 
+            impl<T> AppearsInFromClause<T> for table where
+                T: Table + JoinTo<table>,
+            {
+                type Count = Never;
+            }
+
+            impl<T> JoinTo<T> for table where
+                T: JoinTo<table> + JoinTo<PleaseGenerateInverseJoinImpls<table>>,
+            {
+                type JoinOnClause = <T as JoinTo<table>>::JoinOnClause;
+
+                fn join_on_clause() -> Self::JoinOnClause {
+                    <T as JoinTo<table>>::join_on_clause()
+                }
+            }
+
             impl_query_id!(table);
 
             /// Contains all of the columns of this table
@@ -560,9 +578,6 @@ macro_rules! joinable_inner {
         primary_key_ty = $primary_key_ty:ty,
         primary_key_expr = $primary_key_expr:expr,
     ) => {
-        impl $crate::query_source::AppearsInFromClause<$right_table_ty> for $left_table_ty {
-            type Count = $crate::query_source::Never;
-        }
         impl $crate::JoinTo<$right_table_ty> for $left_table_ty {
             type JoinOnClause = $crate::expression::helper_types::Eq<
                 $crate::expression::nullable::Nullable<$foreign_key>,

diesel/src/macros/mod.rs

@@ -225,36 +225,6 @@ impl<DB: Backend> QueryFragment<DB> for LeftOuter {
     }
 }
 
-impl<T, From> JoinTo<SelectStatement<From>> for T where
-    T: Table + JoinTo<From>,
-{
-    type JoinOnClause = T::JoinOnClause;
-
-    fn join_on_clause() -> Self::JoinOnClause {
-        T::join_on_clause()
-    }
-}
-
-impl<T, Join, On> JoinTo<JoinOn<Join, On>> for T where
-    T: Table + JoinTo<Join>,
-{
-    type JoinOnClause = T::JoinOnClause;
-
-    fn join_on_clause() -> Self::JoinOnClause {
-        T::join_on_clause()
-    }
-}
-
-impl<Left, Mid, Right, Kind> JoinTo<Join<Mid, Right, Kind>> for Left where
-    Left: Table + JoinTo<Mid>,
-{
-    type JoinOnClause = Left::JoinOnClause;
-
-    fn join_on_clause() -> Self::JoinOnClause {
-        Left::join_on_clause()
-    }
-}
-
 impl<Left, Mid, Right, Kind> JoinTo<Right> for Join<Left, Mid, Kind> where
     Left: JoinTo<Right>,
 {
@@ -275,7 +245,6 @@ impl<Join, On, Right> JoinTo<Right> for JoinOn<Join, On> where
     }
 }
 
-
 use super::{Succ, Never, AppearsInFromClause};
 
 impl<T, Left, Right, Kind> AppearsInFromClause<T> for Join<Left, Right, Kind> where
@@ -292,6 +261,22 @@ impl<T, Join, On> AppearsInFromClause<T> for JoinOn<Join, On> where
     type Count = Join::Count;
 }
 
+#[allow(missing_debug_implementations, missing_copy_implementations)]
+#[doc(hidden)]
+/// A hack to allow bidirectional joins to be generated from `#[belongs_to]`
+///
+/// This type needs to exist because it is illegal in Rust today to write
+/// `impl JoinTo<posts> for <User as HasTable>::Table`, even though the type
+/// is fully monomorphic and projects to a local type. If this restriction
+/// were ever lifted in the future, this type could be removed.
+///
+/// Instead, after generating `impl JoinTo<<User as HasTable>::Table> for
+/// posts`, we *also* generate `impl JoinTo<PleaseGenerateInverseJoinImpls<<User
+/// as HasTable>::table> for posts`, and rely on the fact that `users::table`
+/// will have a blanket impl on itself for anything that joins to
+/// `PleaseGenerateInverseJoinImpls`.
+pub struct PleaseGenerateInverseJoinImpls<T>(T);
+
 pub trait Plus<T> {
     type Output;
 }

diesel/src/query_source/joins.rs

@@ -9,11 +9,6 @@ pub fn derive_associations(input: syn::MacroInput) -> quote::Tokens {
     let model = t!(Model::from_item(&input, "Associations"));
 
     for attr in input.attrs.as_slice() {
-        if attr.name() == "has_many" {
-            let options = t!(build_association_options(attr, "has_many"));
-            derived_associations.push(expand_has_many(&model, options))
-        }
-
         if attr.name() == "belongs_to" {
             let options = t!(build_association_options(attr, "belongs_to"));
             derived_associations.push(expand_belongs_to(&model, options))
@@ -43,23 +38,6 @@ fn expand_belongs_to(model: &Model, options: AssociationOptions) -> quote::Token
     })
 }
 
-fn expand_has_many(model: &Model, options: AssociationOptions) -> quote::Tokens {
-    let parent_table_name = model.table_name();
-    let child_table_name = options.name;
-    let foreign_key_name = options.foreign_key_name.unwrap_or_else(||
-        to_foreign_key(model.name.as_ref()));
-    let fields = model.attrs.as_slice();
-
-    quote!(HasMany! {
-        (
-            parent_table_name = #parent_table_name,
-            child_table = #child_table_name::table,
-            foreign_key = #child_table_name::#foreign_key_name,
-        ),
-        fields = [#(#fields)*],
-    })
-}
-
 struct AssociationOptions {
     name: syn::Ident,
     foreign_key_name: Option<syn::Ident>,

diesel_codegen/src/associations.rs

@@ -71,7 +71,7 @@ pub fn derive_as_changeset(input: TokenStream) -> TokenStream {
     expand_derive(input, as_changeset::derive_as_changeset)
 }
 
-#[proc_macro_derive(Associations, attributes(table_name, has_many, belongs_to))]
+#[proc_macro_derive(Associations, attributes(table_name, belongs_to))]
 pub fn derive_associations(input: TokenStream) -> TokenStream {
     expand_derive(input, associations::derive_associations)
 }