fix: allow LEFT JOIN to produce None for nested models (#2845)

* fix: handle nested Option<Model> in FromQueryResult

* fix: fix test by aliasing columns

* fix: fixes per feedback for optional nested model

Author: denyszhak

sea-orm-macros/Cargo.toml

@@ -20,6 +20,7 @@ proc-macro = true
 [dependencies]
 bae = { version = "0.2", package = "sea-bae", default-features = false, optional = true }
 heck = { version = "0.5", default-features = false }
+itertools = "0.14"
 pluralizer = { version = "0.5" }
 proc-macro-crate = { version = "3.2.0", optional = true }
 proc-macro2 = { version = "1", default-features = false }

sea-orm-macros/src/derives/model.rs

@@ -3,6 +3,7 @@ use super::{
     util::{escape_rust_keyword, field_not_ignored, trim_starting_raw_identifier},
 };
 use heck::ToUpperCamelCase;
+use itertools::izip;
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
 use std::iter::FromIterator;
@@ -103,28 +104,84 @@ impl DeriveModel {
         let ident = &self.ident;
         let field_idents = &self.field_idents;
         let column_idents = &self.column_idents;
-        let field_values: Vec<TokenStream> = column_idents
-            .iter()
-            .zip(&self.ignore_attrs)
-            .map(|(column_ident, ignore)| {
-                if *ignore {
-                    quote! {
-                        Default::default()
-                    }
-                } else {
-                    quote! {
-                        row.try_get(pre, sea_orm::IdenStatic::as_str(&<<Self as sea_orm::ModelTrait>::Entity as sea_orm::entity::EntityTrait>::Column::#column_ident).into())?
+        let field_types = &self.field_types;
+        let ignore_attrs = &self.ignore_attrs;
+
+        let (field_readers, field_values): (Vec<TokenStream>, Vec<TokenStream>) = izip!(
+            field_idents.iter(),
+            column_idents,
+            field_types,
+            ignore_attrs,
+        )
+        .map(|(field_ident, column_ident, field_type, &ignore)| {
+            if ignore {
+                let reader = quote! {
+                    let #field_ident: Option<()> = None;
+                };
+                let unwrapper = quote! {
+                    #field_ident: Default::default()
+                };
+                (reader, unwrapper)
+            } else {
+                let reader = quote! {
+                    let #field_ident =
+                        row.try_get_nullable::<Option<#field_type>>(
+                            pre,
+                            sea_orm::IdenStatic::as_str(
+                                &<<Self as sea_orm::ModelTrait>::Entity
+                                    as sea_orm::entity::EntityTrait>::Column::#column_ident
+                            ).into()
+                        )?;
+                };
+                let unwrapper = quote! {
+                    #field_ident: #field_ident.ok_or_else(|| sea_orm::DbErr::Type(
+                        format!(
+                            "Missing value for column '{}'",
+                            sea_orm::IdenStatic::as_str(
+                                &<<Self as sea_orm::ModelTrait>::Entity
+                                    as sea_orm::entity::EntityTrait>::Column::#column_ident
+                            )
+                        )
+                    ))?
+                };
+                (reader, unwrapper)
+            }
+        })
+        .unzip();
+
+        // When a nested model is loaded via LEFT JOIN, all its fields may be NULL.
+        // In that case we interpret it as "no nested row" (i.e., Option::None).
+        // This check detects that condition by testing if all non-ignored fields are NULL.
+        let all_null_check = {
+            let checks: Vec<_> = izip!(field_idents, ignore_attrs)
+                .filter_map(|(field_ident, &ignore)| {
+                    if ignore {
+                        None
+                    } else {
+                        Some(quote! { #field_ident.is_none() })
                     }
-                }
-            })
-            .collect();
+                })
+                .collect();
+
+            quote! { true #( && #checks )* }
+        };
 
         quote!(
             #[automatically_derived]
             impl sea_orm::FromQueryResult for #ident {
                 fn from_query_result(row: &sea_orm::QueryResult, pre: &str) -> std::result::Result<Self, sea_orm::DbErr> {
+                    Self::from_query_result_nullable(row, pre).map_err(Into::into)
+                }
+
+                fn from_query_result_nullable(row: &sea_orm::QueryResult, pre: &str) -> std::result::Result<Self, sea_orm::TryGetError> {
+                    #(#field_readers)*
+
+                    if #all_null_check {
+                        return Err(sea_orm::TryGetError::Null("All fields of nested model are null".into()));
+                    }
+
                     Ok(Self {
-                        #(#field_idents: #field_values),*
+                        #(#field_values),*
                     })
                 }
             }

tests/from_query_result_tests.rs

@@ -49,6 +49,16 @@ struct BakeryFlat {
     profit: f64,
 }
 
+#[derive(FromQueryResult)]
+struct CakeWithOptionalBakeryModel {
+    #[sea_orm(alias = "cake_id")]
+    id: i32,
+    #[sea_orm(alias = "cake_name")]
+    name: String,
+    #[sea_orm(nested)]
+    bakery: Option<bakery::Model>,
+}
+
 #[sea_orm_macros::test]
 async fn from_query_result_left_join_does_not_exist() {
     let ctx = TestContext::new("from_query_result_left_join_does_not_exist").await;
@@ -77,6 +87,36 @@ async fn from_query_result_left_join_does_not_exist() {
     ctx.delete().await;
 }
 
+#[sea_orm_macros::test]
+async fn from_query_result_left_join_with_optional_model_does_not_exist() {
+    let ctx =
+        TestContext::new("from_query_result_left_join_with_optional_model_does_not_exist").await;
+    create_tables(&ctx.db).await.unwrap();
+
+    seed_data::init_1(&ctx, false).await;
+
+    let cake: CakeWithOptionalBakeryModel = cake::Entity::find()
+        .select_only()
+        .column_as(cake::Column::Id, "cake_id")
+        .column_as(cake::Column::Name, "cake_name")
+        .column(bakery::Column::Id)
+        .column(bakery::Column::Name)
+        .column(bakery::Column::ProfitMargin)
+        .left_join(bakery::Entity)
+        .order_by_asc(cake::Column::Id)
+        .into_model()
+        .one(&ctx.db)
+        .await
+        .expect("succeeds to get the result")
+        .expect("exactly one model in DB");
+
+    assert_eq!(cake.id, 13);
+    assert_eq!(cake.name, "Cheesecake");
+    assert!(cake.bakery.is_none());
+
+    ctx.delete().await;
+}
+
 #[sea_orm_macros::test]
 async fn from_query_result_left_join_exists() {
     let ctx = TestContext::new("from_query_result_left_join_exists").await;