WIP FullOuter join impl

Author: oeed

diesel/src/internal/table_macro.rs

@@ -19,6 +19,9 @@ pub use crate::query_source::aliasing::{
     AliasAppearsInFromClause, FieldAliasMapperAssociatedTypesDisjointnessTrick,
 };
 #[doc(hidden)]
+#[cfg(any(feature = "postgres_backend", feature = "sqlite"))]
+pub use crate::query_source::joins::FullOuter;
+#[doc(hidden)]
 pub use crate::query_source::joins::{Inner, Join, JoinOn, LeftOuter};
 #[doc(hidden)]
 pub use crate::query_source::private::Pick;

diesel/src/lib.rs

@@ -129,7 +129,7 @@
 //!    executing a query:
 //!    This error message indicates that you're trying to select a field from a table
 //!    that does not appear in your from clause. If your query joins the relevant table via
-//!    [`left_join`](crate::query_dsl::QueryDsl::left_join) you need to call
+//!    [`left_join`](crate::query_dsl::QueryDsl::left_join) or [`full_join`](crate::query_dsl::QueryDsl::full_join) you need to call
 //!    [`.nullable()`](crate::expression_methods::NullableExpressionMethods::nullable)
 //!    on the relevant column in your select clause.
 //!
@@ -467,6 +467,16 @@ pub mod helper_types {
     pub type LeftJoinOn<Source, Rhs, On> =
         <Source as InternalJoinDsl<Rhs, joins::LeftOuter, On>>::Output;
 
+    #[cfg(any(feature = "postgres_backend", feature = "sqlite"))]
+    /// Represents the return type of [`.full_join(rhs)`](crate::prelude::QueryDsl::full_join)
+    pub type FullJoin<Source, Rhs> =
+        <Source as JoinWithImplicitOnClause<Rhs, joins::FullOuter>>::Output;
+
+    #[cfg(any(feature = "postgres_backend", feature = "sqlite"))]
+    /// Represents the return type of [`.full_join(rhs.on(on))`](crate::prelude::QueryDsl::full_join)
+    pub type FullJoinOn<Source, Rhs, On> =
+        <Source as InternalJoinDsl<Rhs, joins::FullOuter, On>>::Output;
+
     /// Represents the return type of [`rhs.on(on)`](crate::query_dsl::JoinOnDsl::on)
     pub type On<Source, On> = joins::OnClauseWrapper<Source, On>;
 
@@ -646,6 +656,11 @@ pub mod helper_types {
     pub type LeftJoinQuerySource<Left, Right, On = <Left as joins::JoinTo<Right>>::OnClause> =
         JoinQuerySource<Left, Right, joins::LeftOuter, On>;
 
+    #[cfg(any(feature = "postgres_backend", feature = "sqlite"))]
+    // TODO: doc comment
+    pub type FullJoinQuerySource<Left, Right, On = <Left as joins::JoinTo<Right>>::OnClause> =
+        JoinQuerySource<Left, Right, joins::FullOuter, On>;
+
     /// Maps `F` to `Alias<S>`
     ///
     /// Any column `F` that belongs to `S::Table` will be transformed into

diesel/src/query_dsl/mod.rs

@@ -618,6 +618,26 @@ pub trait QueryDsl: Sized {
         self.left_outer_join(rhs)
     }
 
+    // TODO: doc  comment
+    #[cfg(any(feature = "postgres_backend", feature = "sqlite"))]
+    fn full_outer_join<Rhs>(self, rhs: Rhs) -> FullJoin<Self, Rhs>
+    where
+        Self: JoinWithImplicitOnClause<Rhs, joins::FullOuter>,
+    {
+        self.join_with_implicit_on_clause(rhs, joins::FullOuter)
+    }
+
+    #[cfg(any(feature = "postgres_backend", feature = "sqlite"))]
+    /// Alias for [`full_outer_join`].
+    ///
+    /// [`full_outer_join`]: QueryDsl::full_outer_join()
+    fn full_join<Rhs>(self, rhs: Rhs) -> FullJoin<Self, Rhs>
+    where
+        Self: JoinWithImplicitOnClause<Rhs, joins::FullOuter>,
+    {
+        self.full_outer_join(rhs)
+    }
+
     /// Adds to the `WHERE` clause of a query.
     ///
     /// If there is already a `WHERE` clause, the result will be `old AND new`.

diesel/src/query_source/aliasing/joins.rs

@@ -6,6 +6,8 @@ use super::{Alias, AliasSource, AliasedField};
 use crate::expression::{AppearsOnTable, SelectableExpression};
 use crate::query_builder::AsQuery;
 use crate::query_dsl::InternalJoinDsl;
+#[cfg(any(feature = "postgres_backend", feature = "sqlite"))]
+use crate::query_source::joins::FullOuter;
 use crate::query_source::joins::{
     AppendSelection, Inner, Join, JoinOn, JoinTo, LeftOuter, OnClauseWrapper, ToInnerJoin,
 };
@@ -99,6 +101,17 @@ where
 {
 }
 
+#[cfg(any(feature = "postgres_backend", feature = "sqlite"))]
+impl<Left, Right, S, C> SelectableExpression<Join<Left, Right, FullOuter>> for AliasedField<S, C>
+where
+    Self: AppearsOnTable<Join<Left, Right, FullOuter>>,
+    Self: SelectableExpression<Left>,
+    Left: AppearsInFromClause<Alias<S>, Count = Never> + QuerySource,
+    Right: AppearsInFromClause<Alias<S>, Count = Never> + QuerySource,
+    // TODO: unsure what specifics are needed here
+{
+}
+
 impl<Left, Right, S, C> SelectableExpression<Join<Left, Right, Inner>> for AliasedField<S, C>
 where
     Self: AppearsOnTable<Join<Left, Right, Inner>>,

diesel/src/query_source/joins.rs

@@ -160,6 +160,43 @@ where
     }
 }
 
+#[cfg(any(feature = "postgres_backend", feature = "sqlite"))]
+impl<Left, Right> QuerySource for Join<Left, Right, FullOuter>
+where
+    Left: QuerySource,
+    Right: QuerySource,
+    Nullable<Left::DefaultSelection>: AppendSelection<Nullable<Right::DefaultSelection>>,
+    <Nullable<Left::DefaultSelection> as AppendSelection<Nullable<Right::DefaultSelection>>>::Output:
+        AppearsOnTable<Self>,
+    Self: Clone,
+{
+    type FromClause = Self;
+    // combining two valid selectable expressions for both tables will always yield a
+    // valid selectable expressions for the whole join, so no need to check that here
+    // again. These checked turned out to be quite expensive in terms of compile time
+    // so we use a wrapper type to just skip the check and forward other more relevant
+    // trait implementations to the inner type
+    //
+    // See https://github.com/diesel-rs/diesel/issues/3223 for details
+    type DefaultSelection = self::private::SkipSelectableExpressionBoundCheckWrapper<
+        <Nullable<Left::DefaultSelection> as AppendSelection<Nullable<Right::DefaultSelection>>>::Output,
+    >;
+
+    fn from_clause(&self) -> Self::FromClause {
+        self.clone()
+    }
+
+    fn default_selection(&self) -> Self::DefaultSelection {
+        self::private::SkipSelectableExpressionBoundCheckWrapper(
+            self.left
+                .source
+                .default_selection()
+                .nullable()
+                .append_selection(self.right.source.default_selection().nullable()),
+        )
+    }
+}
+
 #[derive(Debug, Clone, Copy)]
 pub struct OnKeyword;
 
@@ -251,6 +288,15 @@ impl<T: Table, Selection> AppendSelection<Selection> for T {
     }
 }
 
+// TODO: not sure if this is the best way, but the existing impls aren't sufficient
+impl<Left: Expression + Clone, Selection> AppendSelection<Selection> for Nullable<Left> {
+    type Output = (Nullable<Left>, Selection);
+
+    fn append_selection(&self, selection: Selection) -> Self::Output {
+        (self.clone(), selection)
+    }
+}
+
 impl<Left, Mid, Selection, Kind> AppendSelection<Selection> for Join<Left, Mid, Kind>
 where
     Left: QuerySource,
@@ -304,6 +350,22 @@ where
     }
 }
 
+#[cfg(any(feature = "postgres_backend", feature = "sqlite"))]
+#[doc(hidden)]
+#[derive(Debug, Clone, Copy, Default, QueryId)]
+pub struct FullOuter;
+
+#[cfg(any(feature = "postgres_backend", feature = "sqlite"))]
+impl<DB> QueryFragment<DB> for FullOuter
+where
+    DB: Backend + DieselReserveSpecialization,
+{
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, DB>) -> QueryResult<()> {
+        out.push_sql(" FULL OUTER");
+        Ok(())
+    }
+}
+
 impl<Left, Mid, Right, Kind> JoinTo<Right> for Join<Left, Mid, Kind>
 where
     Left: JoinTo<Right> + QuerySource,
@@ -407,6 +469,7 @@ impl<Qs, On> QueryDsl for OnClauseWrapper<Qs, On> {}
 /// may be deeply nested, we need to recursively change any appearances of
 /// `LeftOuter` to `Inner` in order to perform this check.
 pub trait ToInnerJoin {
+    // TODO: does anything need to be done for full join here?
     type InnerJoin;
 }
 

diesel_compile_tests/tests/fail/invalid_joins.rs

@@ -66,3 +66,20 @@ fn invalid_left_joins() {
     // it also fails if we join to another subjoin
     let _ = users::table.left_join(comments::table).left_join(posts::table.left_join(comments::table));
 }
+
+fn invalid_full_joins() {
+  // This is a valid join
+  let _ = users::table.full_join(posts::table);
+
+  // This fails, because we join the same table more than once
+  let _ = users::table.full_join(posts::table.full_join(users::table));
+
+  // It also fails if we use an explicit on clause
+  let _ = users::table.full_join(posts::table.full_join(users::table.on(posts::user_id.eq(users::id))));
+
+  // Also if we put the on clause on the first join
+  let _ = users::table.full_join(posts::table.on(users::id.eq(posts::user_id)).full_join(users::table));
+
+  // it also fails if we join to another subjoin
+  let _ = users::table.full_join(comments::table).full_join(posts::table.full_join(comments::table));
+}

diesel_compile_tests/tests/fail/selectable.rs

@@ -38,6 +38,24 @@ struct UserWithOptionalPost {
     post: Option<Post>,
 }
 
+#[derive(Selectable, Queryable)]
+#[diesel(table_name = users)]
+struct OptionalUserWithEmbeddedPost {
+    id: Option<i32>,
+    name: Option<String>,
+    #[diesel(embed)]
+    post: Post,
+}
+
+#[derive(Selectable, Queryable)]
+#[diesel(table_name = users)]
+struct OptionalUserWithOptionalPost {
+    id: Option<i32>,
+    name: Option<String>,
+    #[diesel(embed)]
+    post: Option<Post>,
+}
+
 #[derive(Selectable, Queryable)]
 #[diesel(table_name = posts)]
 struct Post {
@@ -125,6 +143,13 @@ fn main() {
         .load(&mut conn)
         .unwrap();
 
+    // full joins require both optional
+    let _ = users::table
+        .full_join(posts::table)
+        .select(OptionalUserWithOptionalPost::as_select())
+        .load(&mut conn)
+        .unwrap();
+
     // allow manual impls with complex expressions
     // (and group by)
     let _ = users::table
@@ -163,6 +188,27 @@ fn main() {
         .load(&mut conn)
         .unwrap();
 
+    // full joins force nullable on both
+    let _ = users::table
+        .left_join(posts::table)
+        .select(UserWithEmbeddedPost::as_select())
+        .load(&mut conn)
+        .unwrap();
+
+    // full joins force nullable on left
+    let _ = users::table
+        .left_join(posts::table)
+        .select(OptionalUserWithEmbeddedPost::as_select())
+        .load(&mut conn)
+        .unwrap();
+
+    // full joins force nullable on right
+    let _ = users::table
+        .left_join(posts::table)
+        .select(UserWithOptionalPost::as_select())
+        .load(&mut conn)
+        .unwrap();
+
     // group by clauses are considered
     let _ = users::table
         .inner_join(posts::table)

diesel_derives/src/table.rs

@@ -690,6 +690,23 @@ fn expand_column_def(column_def: &ColumnDef) -> TokenStream {
     let sql_name = &column_def.sql_name;
     let sql_type = &column_def.tpe;
 
+    let full_join_impl = if cfg!(any(feature = "postgres", feature = "sqlite")) {
+        Some(quote::quote! {
+          impl<Left, Right> diesel::SelectableExpression<
+                  diesel::internal::table_macro::Join<Left, Right, diesel::internal::table_macro::FullOuter>,
+              > for #column_name where
+              #column_name: diesel::AppearsOnTable<diesel::internal::table_macro::Join<Left, Right, diesel::internal::table_macro::FullOuter>>,
+              Self: diesel::SelectableExpression<Left>,
+              // `Nullable<Self>` can be selected for both left and right
+              Left: diesel::query_source::AppearsInFromClause<super::table, Count=diesel::query_source::Never> + diesel::query_source::QuerySource,
+              Right: diesel::query_source::AppearsInFromClause<super::table, Count=diesel::query_source::Never> + diesel::query_source::QuerySource,
+          {
+          }
+        })
+    } else {
+        None
+    };
+
     let backend_specific_column_impl = if cfg!(feature = "postgres") {
         Some(quote::quote! {
             impl diesel::query_source::AppearsInFromClause<diesel::query_builder::Only<super::table>>
@@ -851,6 +868,7 @@ fn expand_column_def(column_def: &ColumnDef) -> TokenStream {
         #max_length
 
         #ops_impls
+        #full_join_impl
         #backend_specific_column_impl
     }
 }