Set up the groundwork for multi-table joins

This solves the fundamental problem of needing
`SelectableExpression<Join<Left, Right>> for column` to work when we
don't know where the table concretely appears, just that it appears
somewhere. With this commit, the logic is now that a column can be
selected from any join where its table appears within the join exactly
once. This disallows `users.inner_join(posts.inner_join(users))`, which
we don't want to allow as it would require the second instance of
`users` to be aliased.

This does require that there is an `impl ContainsTable<left> for right`
for every two tables that would appear. Right now I'm just brute-forcing
these when the association between the two tables is defined. For
multi-table joins to work when two of the tables in the join do not have
an association, this will require a manual impl. We'll probably provide
something like `enable_multi_table_joins!(users, comments)` or similar.
This *may* go away eventually with specialization, if projections on
default associated types are eventually allowed in the fully monomorphic
case.

It should be noted that this commit does not enable multi-table joins on
itself. `Join` still does not implement `JoinDsl`, and tables do not
implement `JoinTo<Join<Mid, Right>>`. The code required to enable that
is pretty minimal, but I don't want to flip the switch just yet, as
we're actually generating invalid SQL at the moment and that needs to be
resolved.

However, with this change, all of the limitations that prevent
multi-table joins at the type level are eliminated.

Author: sgrif

diesel/src/macros/mod.rs

@@ -26,47 +26,31 @@ macro_rules! __diesel_column {
         impl SelectableExpression<$($table)::*> for $column_name {
         }
 
-        impl AppearsOnTable<$($table)::*> for $column_name {
-        }
-
-        impl<Right, Kind> SelectableExpression<
-            Join<$($table)::*, Right, Kind>,
-        > for $column_name where
-            $column_name: AppearsOnTable<Join<$($table)::*, Right, Kind>>,
-        {
-        }
-
-        impl<Left> SelectableExpression<
-            Join<Left, $($table)::*, Inner>,
-        > for $column_name where
-            Left: $crate::JoinTo<$($table)::*>
+        impl<QS> AppearsOnTable<QS> for $column_name where
+            QS: ContainsTable<$($table)::*, Count=Once>,
         {
         }
 
-        impl<Right, Kind> AppearsOnTable<
-            Join<$($table)::*, Right, Kind>,
+        impl<Left, Right> SelectableExpression<
+            Join<Left, Right, LeftOuter>,
         > for $column_name where
-            Right: QuerySource,
-            $($table)::*: $crate::JoinTo<Right>
+            $column_name: AppearsOnTable<Join<Left, Right, LeftOuter>>,
+            Left: ContainsTable<$($table)::*, Count=Once>,
+            Right: ContainsTable<$($table)::*, Count=Never>,
         {
         }
 
-        impl<Left, Kind> AppearsOnTable<
-            Join<Left, $($table)::*, Kind>,
+        impl<Left, Right> SelectableExpression<
+            Join<Left, Right, Inner>,
         > for $column_name where
-            Left: $crate::JoinTo<$($table)::*>
-        {
-        }
-
-        // FIXME: Remove this when overlapping marker traits are stable
-        impl<Join, On> AppearsOnTable<JoinOn<Join, On>> for $column_name where
-            $column_name: AppearsOnTable<Join>,
+            $column_name: AppearsOnTable<Join<Left, Right, Inner>>,
+            Join<Left, Right, Inner>: ContainsTable<$($table)::*, Count=Once>,
         {
         }
 
         // FIXME: Remove this when overlapping marker traits are stable
         impl<Join, On> SelectableExpression<JoinOn<Join, On>> for $column_name where
-            $column_name: SelectableExpression<Join>,
+            $column_name: SelectableExpression<Join> + AppearsOnTable<JoinOn<Join, On>>,
         {
         }
 
@@ -339,6 +323,7 @@ macro_rules! table_body {
             use $crate::associations::HasTable;
             use $crate::query_builder::*;
             use $crate::query_builder::nodes::Identifier;
+            use $crate::query_source::{ContainsTable, Once};
             $(use $($import)::+;)+
             pub use self::columns::*;
 
@@ -418,6 +403,10 @@ macro_rules! table_body {
                 }
             }
 
+            impl ContainsTable<table> for table {
+                type Count = Once;
+            }
+
             impl_query_id!(table);
 
             /// Contains all of the columns of this table
@@ -426,7 +415,8 @@ macro_rules! table_body {
                 use $crate::{Expression, SelectableExpression, AppearsOnTable, QuerySource};
                 use $crate::backend::Backend;
                 use $crate::query_builder::{QueryFragment, AstPass};
-                use $crate::query_source::joins::{Join, JoinOn, Inner};
+                use $crate::query_source::joins::{Join, JoinOn, Inner, LeftOuter};
+                use $crate::query_source::{ContainsTable, Once, Never};
                 use $crate::result::QueryResult;
                 $(use $($import)::+;)+
 
@@ -534,6 +524,9 @@ macro_rules! joinable_inner {
         primary_key_ty = $primary_key_ty:ty,
         primary_key_expr = $primary_key_expr:expr,
     ) => {
+        impl $crate::query_source::ContainsTable<$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/query_source/joins.rs

@@ -133,12 +133,6 @@ impl<Left, Right, On, T> SelectableExpression<JoinOn<Join<Left, Right, LeftOuter
 {
 }
 
-// FIXME: We want these blanket impls when overlapping marker traits are stable
-// impl<T, Join, On> AppearsOnTable<JoinOn<Join, On>> for T where
-//     T: AppearsOnTable<Join>,
-// {
-// }
-
 // FIXME: We want these blanket impls when overlapping marker traits are stable
 // impl<T, Join, On> SelectableExpression<JoinOn<Join, On>> for T where
 //     T: SelectableExpression<Join> + AppearsOnTable<JoinOn<Join, On>>,
@@ -180,3 +174,33 @@ impl<DB: Backend> QueryFragment<DB> for LeftOuter {
         Ok(())
     }
 }
+
+use super::{Succ, Never, ContainsTable};
+
+impl<T, Left, Right, Kind> ContainsTable<T> for Join<Left, Right, Kind> where
+    Left: ContainsTable<T>,
+    Right: ContainsTable<T>,
+    Left::Count: Plus<Right::Count>,
+{
+    type Count = <Left::Count as Plus<Right::Count>>::Output;
+}
+
+impl<T, Join, On> ContainsTable<T> for JoinOn<Join, On> where
+    Join: ContainsTable<T>,
+{
+    type Count = Join::Count;
+}
+
+pub trait Plus<T> {
+    type Output;
+}
+
+impl<T, U> Plus<T> for Succ<U> where
+    U: Plus<T>,
+{
+    type Output = Succ<U::Output>;
+}
+
+impl<T> Plus<T> for Never {
+    type Output = T;
+}

diesel/src/query_source/mod.rs

@@ -48,3 +48,13 @@ pub trait Table: QuerySource + AsQuery + Sized {
     fn primary_key(&self) -> Self::PrimaryKey;
     fn all_columns() -> Self::AllColumns;
 }
+
+pub trait ContainsTable<QS> {
+    type Count;
+}
+
+#[allow(missing_debug_implementations, missing_copy_implementations)]
+pub struct Never;
+#[allow(missing_debug_implementations, missing_copy_implementations)]
+pub struct Succ<T>(T);
+pub type Once = Succ<Never>;