Represent several relations between same types

src/entity/identity.rs

@@ -1,5 +1,6 @@
 use crate::{ColumnTrait, EntityTrait, IdenStatic};
-use sea_query::{DynIden, IntoIden};
+use sea_query::{Alias, DynIden, Iden, IntoIden, SeaRc};
+use std::fmt;
 
 #[derive(Debug, Clone)]
 pub enum Identity {
@@ -8,6 +9,25 @@ pub enum Identity {
     Ternary(DynIden, DynIden, DynIden),
 }
 
+impl Iden for Identity {
+    fn unquoted(&self, s: &mut dyn fmt::Write) {
+        match self {
+            Identity::Unary(iden) => {
+                write!(s, "{}", iden.to_string()).unwrap();
+            }
+            Identity::Binary(iden1, iden2) => {
+                write!(s, "{}", iden1.to_string()).unwrap();
+                write!(s, "{}", iden2.to_string()).unwrap();
+            }
+            Identity::Ternary(iden1, iden2, iden3) => {
+                write!(s, "{}", iden1.to_string()).unwrap();
+                write!(s, "{}", iden2.to_string()).unwrap();
+                write!(s, "{}", iden3.to_string()).unwrap();
+            }
+        }
+    }
+}
+
 pub trait IntoIdentity {
     fn into_identity(self) -> Identity;
 }
@@ -19,6 +39,18 @@ where
     fn identity_of(self) -> Identity;
 }
 
+impl IntoIdentity for String {
+    fn into_identity(self) -> Identity {
+        self.as_str().into_identity()
+    }
+}
+
+impl IntoIdentity for &str {
+    fn into_identity(self) -> Identity {
+        Identity::Unary(SeaRc::new(Alias::new(self)))
+    }
+}
+
 impl<T> IntoIdentity for T
 where
     T: IdenStatic,

src/entity/model.rs

@@ -1,4 +1,4 @@
-use crate::{DbErr, EntityTrait, QueryFilter, QueryResult, Related, Select};
+use crate::{DbErr, EntityTrait, Linked, QueryFilter, QueryResult, Related, Select};
 pub use sea_query::Value;
 use std::fmt::Debug;
 
@@ -16,6 +16,13 @@ pub trait ModelTrait: Clone + Debug {
     {
         <Self::Entity as Related<R>>::find_related().belongs_to(self)
     }
+
+    fn find_linked<L>(&self, l: L) -> Select<L::ToEntity>
+    where
+        L: Linked<FromEntity = Self::Entity>,
+    {
+        l.find_linked()
+    }
 }
 
 pub trait FromQueryResult {

src/entity/prelude.rs

@@ -2,8 +2,8 @@ pub use crate::{
     error::*, ActiveModelBehavior, ActiveModelTrait, ColumnDef, ColumnTrait, ColumnType,
     DeriveActiveModel, DeriveActiveModelBehavior, DeriveColumn, DeriveCustomColumn, DeriveEntity,
     DeriveModel, DerivePrimaryKey, EntityName, EntityTrait, EnumIter, ForeignKeyAction, Iden,
-    IdenStatic, ModelTrait, PrimaryKeyToColumn, PrimaryKeyTrait, QueryFilter, QueryResult, Related,
-    RelationDef, RelationTrait, Select, Value,
+    IdenStatic, Linked, ModelTrait, PrimaryKeyToColumn, PrimaryKeyTrait, QueryFilter, QueryResult,
+    Related, RelationDef, RelationTrait, Select, Value,
 };
 
 #[cfg(feature = "with-json")]

src/entity/relation.rs

@@ -30,6 +30,22 @@ where
     }
 }
 
+pub trait Linked {
+    type FromEntity: EntityTrait;
+
+    type ToEntity: EntityTrait;
+
+    fn link(&self) -> Vec<RelationDef>;
+
+    fn find_linked(&self) -> Select<Self::ToEntity> {
+        let mut select = Select::new();
+        for rel in self.link().into_iter().rev() {
+            select = select.join_rev(JoinType::InnerJoin, rel);
+        }
+        select
+    }
+}
+
 pub struct RelationDef {
     pub rel_type: RelationType,
     pub from_tbl: TableRef,

src/executor/query.rs

@@ -264,9 +264,12 @@ impl TryGetable for Decimal {
                     .map_err(|e| TryGetError::DbErr(crate::sqlx_error_to_query_err(e)))?;
                 use rust_decimal::prelude::FromPrimitive;
                 match val {
-                    Some(v) => Decimal::from_f64(v)
-                        .ok_or_else(|| TryGetError::DbErr(DbErr::Query("Failed to convert f64 into Decimal".to_owned()))),
-                    None => Err(TryGetError::Null)
+                    Some(v) => Decimal::from_f64(v).ok_or_else(|| {
+                        TryGetError::DbErr(DbErr::Query(
+                            "Failed to convert f64 into Decimal".to_owned(),
+                        ))
+                    }),
+                    None => Err(TryGetError::Null),
                 }
             }
             #[cfg(feature = "mock")]

src/executor/select.rs

@@ -1,6 +1,6 @@
 use crate::{
-    error::*, query::combine, DatabaseConnection, EntityTrait, FromQueryResult, Iterable,
-    JsonValue, ModelTrait, Paginator, PrimaryKeyToColumn, QueryResult, Select, SelectTwo,
+    error::*, DatabaseConnection, EntityTrait, FromQueryResult, IdenStatic, Iterable, JsonValue,
+    ModelTrait, Paginator, PrimaryKeyToColumn, QueryResult, Select, SelectA, SelectB, SelectTwo,
     SelectTwoMany, Statement,
 };
 use sea_query::SelectStatement;
@@ -66,8 +66,8 @@ where
 
     fn from_raw_query_result(res: QueryResult) -> Result<Self::Item, DbErr> {
         Ok((
-            M::from_query_result(&res, combine::SELECT_A)?,
-            N::from_query_result_optional(&res, combine::SELECT_B)?,
+            M::from_query_result(&res, SelectA.as_str())?,
+            N::from_query_result_optional(&res, SelectB.as_str())?,
         ))
     }
 }
@@ -128,7 +128,7 @@ where
     E: EntityTrait,
     F: EntityTrait,
 {
-    fn into_model<M, N>(self) -> Selector<SelectTwoModel<M, N>>
+    pub fn into_model<M, N>(self) -> Selector<SelectTwoModel<M, N>>
     where
         M: FromQueryResult,
         N: FromQueryResult,

src/query/combine.rs

@@ -1,10 +1,31 @@
-use crate::{EntityTrait, IntoSimpleExpr, Iterable, QueryTrait, Select, SelectTwo, SelectTwoMany};
+use crate::{
+    EntityTrait, IdenStatic, IntoSimpleExpr, Iterable, QueryTrait, Select, SelectTwo, SelectTwoMany,
+};
 use core::marker::PhantomData;
 pub use sea_query::JoinType;
 use sea_query::{Alias, ColumnRef, Iden, Order, SeaRc, SelectExpr, SelectStatement, SimpleExpr};
 
-pub const SELECT_A: &str = "A_";
-pub const SELECT_B: &str = "B_";
+macro_rules! select_def {
+    ( $ident: ident, $str: expr ) => {
+        #[derive(Debug, Clone, Copy)]
+        pub struct $ident;
+
+        impl Iden for $ident {
+            fn unquoted(&self, s: &mut dyn std::fmt::Write) {
+                write!(s, "{}", self.as_str()).unwrap();
+            }
+        }
+
+        impl IdenStatic for $ident {
+            fn as_str(&self) -> &str {
+                $str
+            }
+        }
+    };
+}
+
+select_def!(SelectA, "A_");
+select_def!(SelectB, "B_");
 
 impl<E> Select<E>
 where
@@ -37,15 +58,15 @@ where
     where
         F: EntityTrait,
     {
-        self = self.apply_alias(SELECT_A);
+        self = self.apply_alias(SelectA.as_str());
         SelectTwo::new(self.into_query())
     }
 
     pub fn select_with<F>(mut self, _: F) -> SelectTwoMany<E, F>
     where
         F: EntityTrait,
     {
-        self = self.apply_alias(SELECT_A);
+        self = self.apply_alias(SelectA.as_str());
         SelectTwoMany::new(self.into_query())
     }
 }
@@ -102,7 +123,7 @@ where
     S: QueryTrait<QueryStatement = SelectStatement>,
 {
     for col in <F::Column as Iterable>::iter() {
-        let alias = format!("{}{}", SELECT_B, col.to_string().as_str());
+        let alias = format!("{}{}", SelectB.as_str(), col.as_str());
         selector.query().expr(SelectExpr {
             expr: col.into_simple_expr(),
             alias: Some(SeaRc::new(Alias::new(&alias))),

src/query/helper.rs

@@ -1,11 +1,9 @@
 use crate::{
-    ColumnTrait, EntityTrait, Identity, IntoSimpleExpr, Iterable, ModelTrait, PrimaryKeyToColumn,
-    RelationDef,
-};
-use sea_query::{
-    Alias, Expr, IntoCondition, SeaRc, SelectExpr, SelectStatement, SimpleExpr, TableRef,
+    ColumnTrait, EntityTrait, Identity, IntoIdentity, IntoSimpleExpr, Iterable, ModelTrait,
+    PrimaryKeyToColumn, RelationDef,
 };
 pub use sea_query::{Condition, ConditionalStatement, DynIden, JoinType, Order, OrderedStatement};
+use sea_query::{Expr, IntoCondition, SeaRc, SelectExpr, SelectStatement, SimpleExpr, TableRef};
 
 // LINT: when the column does not appear in tables selected from
 // LINT: when there is a group by clause, but some columns don't have aggregate functions
@@ -55,13 +53,14 @@ pub trait QuerySelect: Sized {
     ///     r#"SELECT COUNT("cake"."id") AS "count" FROM "cake""#
     /// );
     /// ```
-    fn column_as<C>(mut self, col: C, alias: &str) -> Self
+    fn column_as<C, I>(mut self, col: C, alias: I) -> Self
     where
         C: IntoSimpleExpr,
+        I: IntoIdentity,
     {
         self.query().expr(SelectExpr {
             expr: col.into_simple_expr(),
-            alias: Some(SeaRc::new(Alias::new(alias))),
+            alias: Some(SeaRc::new(alias.into_identity())),
         });
         self
     }

src/query/join.rs

@@ -1,4 +1,4 @@
-use crate::{EntityTrait, QuerySelect, Related, Select, SelectTwo, SelectTwoMany};
+use crate::{EntityTrait, Linked, QuerySelect, Related, Select, SelectTwo, SelectTwoMany};
 pub use sea_query::JoinType;
 
 impl<E> Select<E>
@@ -57,6 +57,19 @@ where
     {
         self.left_join(r).select_with(r)
     }
+
+    /// Left Join with a Linked Entity and select both Entity.
+    pub fn find_also_linked<L, T>(self, l: L) -> SelectTwo<E, T>
+    where
+        L: Linked<FromEntity = E, ToEntity = T>,
+        T: EntityTrait,
+    {
+        let mut slf = self;
+        for rel in l.link() {
+            slf = slf.join(JoinType::LeftJoin, rel);
+        }
+        slf.select_also(T::default())
+    }
 }
 
 #[cfg(test)]
@@ -220,4 +233,44 @@ mod tests {
             .join(" ")
         );
     }
+
+    #[test]
+    fn join_10() {
+        let cake_model = cake::Model {
+            id: 12,
+            name: "".to_owned(),
+        };
+
+        assert_eq!(
+            cake_model
+                .find_linked(cake::CakeToFilling)
+                .build(DbBackend::MySql)
+                .to_string(),
+            [
+                r#"SELECT `filling`.`id`, `filling`.`name`"#,
+                r#"FROM `filling`"#,
+                r#"INNER JOIN `cake_filling` ON `cake_filling`.`filling_id` = `filling`.`id`"#,
+                r#"INNER JOIN `cake` ON `cake`.`id` = `cake_filling`.`cake_id`"#,
+            ]
+            .join(" ")
+        );
+    }
+
+    #[test]
+    fn join_11() {
+        assert_eq!(
+            cake::Entity::find()
+                .find_also_linked(cake::CakeToFilling)
+                .build(DbBackend::MySql)
+                .to_string(),
+            [
+                r#"SELECT `cake`.`id` AS `A_id`, `cake`.`name` AS `A_name`,"#,
+                r#"`filling`.`id` AS `B_id`, `filling`.`name` AS `B_name`"#,
+                r#"FROM `cake`"#,
+                r#"LEFT JOIN `cake_filling` ON `cake`.`id` = `cake_filling`.`cake_id`"#,
+                r#"LEFT JOIN `filling` ON `cake_filling`.`filling_id` = `filling`.`id`"#,
+            ]
+            .join(" ")
+        );
+    }
 }

src/query/mod.rs

@@ -9,7 +9,7 @@ mod select;
 mod traits;
 mod update;
 
-// pub use combine::*;
+pub use combine::{SelectA, SelectB};
 pub use delete::*;
 pub use helper::*;
 pub use insert::*;

src/tests_cfg/cake.rs

@@ -73,4 +73,19 @@ impl Related<super::filling::Entity> for Entity {
     }
 }
 
+pub struct CakeToFilling;
+
+impl Linked for CakeToFilling {
+    type FromEntity = Entity;
+
+    type ToEntity = super::filling::Entity;
+
+    fn link(&self) -> Vec<RelationDef> {
+        vec![
+            super::cake_filling::Relation::Cake.def().rev(),
+            super::cake_filling::Relation::Filling.def(),
+        ]
+    }
+}
+
 impl ActiveModelBehavior for ActiveModel {}

tests/common/bakery_chain/baker.rs

@@ -83,4 +83,22 @@ impl Related<super::cake::Entity> for Entity {
     }
 }
 
+pub struct BakedForCustomer;
+
+impl Linked for BakedForCustomer {
+    type FromEntity = Entity;
+
+    type ToEntity = super::customer::Entity;
+
+    fn link(&self) -> Vec<RelationDef> {
+        vec![
+            super::cakes_bakers::Relation::Baker.def().rev(),
+            super::cakes_bakers::Relation::Cake.def(),
+            super::lineitem::Relation::Cake.def().rev(),
+            super::lineitem::Relation::Order.def(),
+            super::order::Relation::Customer.def(),
+        ]
+    }
+}
+
 impl ActiveModelBehavior for ActiveModel {}