fix: allow LEFT JOIN to produce None for nested models

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

@@ -103,28 +103,74 @@ 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
+        let field_types = &self.field_types;
+        let ignore_attrs = &self.ignore_attrs;
+
+        let (field_readers, field_values): (Vec<TokenStream>, Vec<TokenStream>) = field_idents
             .iter()
-            .zip(&self.ignore_attrs)
-            .map(|(column_ident, ignore)| {
-                if *ignore {
-                    quote! {
-                        Default::default()
-                    }
+            .zip(column_idents)
+            .zip(field_types)
+            .zip(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 {
-                    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 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)
                 }
             })
-            .collect();
+            .unzip();
+
+        let all_null_check = field_idents
+            .iter()
+            .zip(ignore_attrs.iter().cloned())
+            .filter(|(_, ignore)| !ignore)
+            .fold(quote! { true }, |acc, (field_ident, _)| {
+                quote! { #acc && #field_ident.is_none() }
+            });
 
         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(|e| e.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,14 @@ struct BakeryFlat {
     profit: f64,
 }
 
+#[derive(FromQueryResult)]
+struct CakeWithOptionalBakeryModel {
+    id: i32,
+    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 +85,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(cake::Column::Id)
+        .column(cake::Column::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;