[Blog] Edit

Author: tyt2y3

Blog/blog/2025-11-11-sea-orm-2.0.md

@@ -182,7 +182,7 @@ Let's say we have a `staff` table, where each staff has a manager that they repo
 
 ```rust title="staff.rs"
 #[sea_orm::model]
-#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
 #[sea_orm(table_name = "staff")]
 pub struct Model {
     #[sea_orm(primary_key)]
@@ -192,10 +192,13 @@ pub struct Model {
     #[sea_orm(
         self_ref,
         relation_enum = "ReportsTo",
+        relation_reverse = "Manages",
         from = "reports_to_id",
         to = "id"
     )]
     pub reports_to: HasOne<Entity>,
+    #[sea_orm(self_ref, relation_enum = "Manages", relation_reverse = "ReportsTo")]
+    pub manages: HasMany<Entity>,
 }
 ```
 
@@ -204,17 +207,26 @@ pub struct Model {
 ```rust
 let staff = staff::Entity::load()
     .with(staff::Relation::ReportsTo)
+    .with(staff::Relation::Manages)
     .all(db)
     .await?;
 
 assert_eq!(staff[0].name, "Alan");
 assert_eq!(staff[0].reports_to, None);
+assert_eq!(staff[0].manages[0].name, "Ben");
+assert_eq!(staff[0].manages[1].name, "Alice");
 
 assert_eq!(staff[1].name, "Ben");
 assert_eq!(staff[1].reports_to.as_ref().unwrap().name, "Alan");
+assert!(staff[1].manages.is_empty());
 
 assert_eq!(staff[2].name, "Alice");
 assert_eq!(staff[2].reports_to.as_ref().unwrap().name, "Alan");
+assert!(staff[2].manages.is_empty());
+
+assert_eq!(staff[3].name, "Elle");
+assert_eq!(staff[3].reports_to, None);
+assert!(staff[3].manages.is_empty());
 ```
 
 #### Model Loader
@@ -230,27 +242,35 @@ assert_eq!(staff[0].name, "Alan");
 assert_eq!(reports_to[0], None);
 
 assert_eq!(staff[1].name, "Ben");
-assert_eq!(reports_to[1].unwrap().name, "Alan");
+assert_eq!(reports_to[1].as_ref().unwrap().name, "Alan");
 
 assert_eq!(staff[2].name, "Alice");
-assert_eq!(reports_to[2].unwrap().name, "Alan");
+assert_eq!(reports_to[2].as_ref().unwrap().name, "Alan");
+
+assert_eq!(staff[3].name, "Elle");
+assert_eq!(reports_to[3], None);
 ```
 
 It can work in reverse too.
 
 ```rust
 let manages = staff
-    .load_self_rev(
-        staff::Entity::find().order_by_asc(staff::COLUMN.id),
-        staff::Relation::ReportsTo,
-        db,
-    )
+    .load_self_many(staff::Entity, staff::Relation::Manages, db)
     .await?;
 
 assert_eq!(staff[0].name, "Alan");
 assert_eq!(manages[0].len(), 2);
 assert_eq!(manages[0][0].name, "Ben");
 assert_eq!(manages[0][1].name, "Alice");
+
+assert_eq!(staff[1].name, "Ben");
+assert_eq!(manages[1].len(), 0);
+
+assert_eq!(staff[2].name, "Alice");
+assert_eq!(manages[2].len(), 0);
+
+assert_eq!(staff[3].name, "Elle");
+assert_eq!(manages[3].len(), 0);
 ```
 
 ### Unix Timestamp Column Type