Adding find_with_linked

src/executor/select.rs

@@ -4,7 +4,8 @@ use crate::{
     SelectB, SelectTwo, SelectTwoMany, Statement, StreamTrait, TryGetableMany,
 };
 use futures::{Stream, TryStreamExt};
-use sea_query::SelectStatement;
+use sea_query::{SelectStatement, Value};
+use std::collections::HashMap;
 use std::marker::PhantomData;
 use std::pin::Pin;
 
@@ -997,6 +998,27 @@ where
     L: EntityTrait,
     R: EntityTrait,
 {
+    // #[cfg(feature = "hashable-value")]
+    {
+        let pkcol = <L::PrimaryKey as Iterable>::iter()
+            .next()
+            .expect("should have primary key")
+            .into_column();
+
+        let hashmap: HashMap<Value, Vec<R::Model>> = rows.into_iter().fold(
+            HashMap::<Value, Vec<R::Model>>::new(),
+            |mut acc: HashMap<Value, Vec<R::Model>>, value: (L::Model, Option<R::Model>)| {
+                {
+                    let key = value.0.get(pkcol);
+
+                    acc.insert(key, value.1);
+                }
+
+                acc
+            },
+        );
+    }
+
     let mut acc: Vec<(L::Model, Vec<R::Model>)> = Vec::new();
     for (l, r) in rows {
         if let Some((last_l, last_r)) = acc.last_mut() {

src/query/combine.rs

@@ -119,11 +119,16 @@ where
     F: EntityTrait,
 {
     pub(crate) fn new(query: SelectStatement) -> Self {
+        Self::new_without_prepare(query)
+            .prepare_select()
+            .prepare_order_by()
+    }
+
+    pub(crate) fn new_without_prepare(query: SelectStatement) -> Self {
         Self {
             query,
             entity: PhantomData,
         }
-        .prepare_select()
         .prepare_order_by()
     }
 

src/query/join.rs

@@ -107,6 +107,52 @@ where
         }
         select_two
     }
+
+    /// Left Join with a Linked Entity and select Entity as a `Vec`.
+    pub fn find_with_linked<L, T>(self, l: L) -> SelectTwoMany<E, T>
+    where
+        L: Linked<FromEntity = E, ToEntity = T>,
+        T: EntityTrait,
+    {
+        let mut slf = self;
+        for (i, mut rel) in l.link().into_iter().enumerate() {
+            let to_tbl = Alias::new(format!("r{i}")).into_iden();
+            let from_tbl = if i > 0 {
+                Alias::new(format!("r{}", i - 1)).into_iden()
+            } else {
+                unpack_table_ref(&rel.from_tbl)
+            };
+            let table_ref = rel.to_tbl;
+
+            let mut condition = Condition::all().add(join_tbl_on_condition(
+                SeaRc::clone(&from_tbl),
+                SeaRc::clone(&to_tbl),
+                rel.from_col,
+                rel.to_col,
+            ));
+            if let Some(f) = rel.on_condition.take() {
+                condition = condition.add(f(SeaRc::clone(&from_tbl), SeaRc::clone(&to_tbl)));
+            }
+
+            slf.query()
+                .join_as(JoinType::LeftJoin, table_ref, to_tbl, condition);
+        }
+        slf = slf.apply_alias(SelectA.as_str());
+        let mut select_two_many = SelectTwoMany::new_without_prepare(slf.query);
+        for col in <T::Column as Iterable>::iter() {
+            let alias = format!("{}{}", SelectB.as_str(), col.as_str());
+            let expr = Expr::col((
+                Alias::new(format!("r{}", l.link().len() - 1)).into_iden(),
+                col.into_iden(),
+            ));
+            select_two_many.query().expr(SelectExpr {
+                expr: col.select_as(expr),
+                alias: Some(SeaRc::new(Alias::new(alias))),
+                window: None,
+            });
+        }
+        select_two_many
+    }
 }
 
 #[cfg(test)]

tests/relational_tests.rs

@@ -2,6 +2,7 @@ pub mod common;
 
 pub use chrono::offset::Utc;
 pub use common::{bakery_chain::*, setup::*, TestContext};
+use pretty_assertions::assert_eq;
 pub use rust_decimal::prelude::*;
 pub use rust_decimal_macros::dec;
 use sea_orm::{entity::*, query::*, DbErr, DerivePartialModel, FromQueryResult};
@@ -747,6 +748,106 @@ pub async fn linked() -> Result<(), DbErr> {
         }]
     );
 
+    let select_baker_with_customer = Baker::find().find_with_linked(baker::BakedForCustomer);
+
+    assert_eq!(
+        select_baker_with_customer
+            .build(sea_orm::DatabaseBackend::MySql)
+            .to_string(),
+        [
+            // FIXME: This might be faulty!
+            "SELECT `baker`.`id` AS `A_id`,",
+            "`baker`.`name` AS `A_name`,",
+            "`baker`.`contact_details` AS `A_contact_details`,",
+            "`baker`.`bakery_id` AS `A_bakery_id`,",
+            "`r4`.`id` AS `B_id`,",
+            "`r4`.`name` AS `B_name`,",
+            "`r4`.`notes` AS `B_notes`",
+            "FROM `baker`",
+            "LEFT JOIN `cakes_bakers` AS `r0` ON `baker`.`id` = `r0`.`baker_id`",
+            "LEFT JOIN `cake` AS `r1` ON `r0`.`cake_id` = `r1`.`id`",
+            "LEFT JOIN `lineitem` AS `r2` ON `r1`.`id` = `r2`.`cake_id`",
+            "LEFT JOIN `order` AS `r3` ON `r2`.`order_id` = `r3`.`id`",
+            "LEFT JOIN `customer` AS `r4` ON `r3`.`customer_id` = `r4`.`id`",
+            "ORDER BY `baker`.`id` ASC",
+        ]
+        .join(" ")
+    );
+
+    assert_eq!(
+        select_baker_with_customer
+            .build(sea_orm::DatabaseBackend::Sqlite)
+            .to_string(),
+        [
+            // FIXME: This might be faulty!
+            "SELECT \"baker\".\"id\" AS \"A_id\",",
+            "\"baker\".\"name\" AS \"A_name\",",
+            "\"baker\".\"contact_details\" AS \"A_contact_details\",",
+            "\"baker\".\"bakery_id\" AS \"A_bakery_id\",",
+            "\"r4\".\"id\" AS \"B_id\",",
+            "\"r4\".\"name\" AS \"B_name\",",
+            "\"r4\".\"notes\" AS \"B_notes\"",
+            "FROM \"baker\"",
+            "LEFT JOIN \"cakes_bakers\" AS \"r0\" ON \"baker\".\"id\" = \"r0\".\"baker_id\"",
+            "LEFT JOIN \"cake\" AS \"r1\" ON \"r0\".\"cake_id\" = \"r1\".\"id\"",
+            "LEFT JOIN \"lineitem\" AS \"r2\" ON \"r1\".\"id\" = \"r2\".\"cake_id\"",
+            "LEFT JOIN \"order\" AS \"r3\" ON \"r2\".\"order_id\" = \"r3\".\"id\"",
+            "LEFT JOIN \"customer\" AS \"r4\" ON \"r3\".\"customer_id\" = \"r4\".\"id\"",
+            "ORDER BY \"baker\".\"id\" ASC",
+        ]
+        .join(" ")
+    );
+
+    assert_eq!(
+        select_baker_with_customer.all(&ctx.db).await?,
+        [
+            (
+                baker::Model {
+                    id: 1,
+                    name: "Baker Bob".into(),
+                    contact_details: serde_json::json!({
+                        "mobile": "+61424000000",
+                        "home": "0395555555",
+                        "address": "12 Test St, Testville, Vic, Australia",
+                    }),
+                    bakery_id: Some(1),
+                },
+                vec![customer::Model {
+                    id: 2,
+                    name: "Kara".into(),
+                    notes: Some("Loves all cakes".into()),
+                }]
+            ),
+            (
+                baker::Model {
+                    id: 2,
+                    name: "Baker Bobby".into(),
+                    contact_details: serde_json::json!({
+                        "mobile": "+85212345678",
+                    }),
+                    bakery_id: Some(1),
+                },
+                vec![
+                    customer::Model {
+                        id: 2,
+                        name: "Kara".into(),
+                        notes: Some("Loves all cakes".into()),
+                    },
+                    customer::Model {
+                        id: 1,
+                        name: "Kate".into(),
+                        notes: Some("Loves cheese cake".into()),
+                    },
+                    customer::Model {
+                        id: 1,
+                        name: "Kate".into(),
+                        notes: Some("Loves cheese cake".into()),
+                    },
+                ]
+            ),
+        ]
+    );
+
     ctx.delete().await;
 
     Ok(())