Rewrite last_insert_id type.

Author: langyo

src/database/proxy.rs

@@ -31,14 +31,14 @@ pub trait ProxyDatabaseTrait: Send + Sync + std::fmt::Debug {
 #[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 pub struct ProxyExecResult {
     /// The last inserted id on auto-increment
-    pub last_insert_id: u64,
+    pub last_insert_id: Option<u64>,
     /// The number of rows affected by the database operation
     pub rows_affected: u64,
 }
 
 impl ProxyExecResult {
     /// Create a new [ProxyExecResult] from the last inserted id and the number of rows affected
-    pub fn new(last_insert_id: u64, rows_affected: u64) -> Self {
+    pub fn new(last_insert_id: Option<u64>, rows_affected: u64) -> Self {
         Self {
             last_insert_id,
             rows_affected,

src/entity/base_entity.rs

@@ -314,7 +314,7 @@ pub trait EntityTrait: EntityName {
     ///
     /// let insert_result = cake::Entity::insert(apple).exec(&db).await?;
     ///
-    /// assert_eq!(dbg!(insert_result.last_insert_id), 15);
+    /// assert_eq!(dbg!(insert_result.last_insert_id), Some(15));
     ///
     /// assert_eq!(
     ///     db.into_transaction_log(),
@@ -356,7 +356,7 @@ pub trait EntityTrait: EntityName {
     ///
     /// let insert_result = cake::Entity::insert(apple).exec(&db).await?;
     ///
-    /// assert_eq!(insert_result.last_insert_id, 15);
+    /// assert_eq!(insert_result.last_insert_id, Some(15));
     ///
     /// assert_eq!(
     ///     db.into_transaction_log(),
@@ -407,7 +407,7 @@ pub trait EntityTrait: EntityName {
     ///
     /// let insert_result = cake::Entity::insert_many([apple, orange]).exec(&db).await?;
     ///
-    /// assert_eq!(insert_result.last_insert_id, 28);
+    /// assert_eq!(insert_result.last_insert_id, Some(28));
     ///
     /// assert_eq!(
     ///     db.into_transaction_log(),
@@ -453,7 +453,7 @@ pub trait EntityTrait: EntityName {
     ///
     /// let insert_result = cake::Entity::insert_many([apple, orange]).exec(&db).await?;
     ///
-    /// assert_eq!(insert_result.last_insert_id, 28);
+    /// assert_eq!(insert_result.last_insert_id, Some(28));
     ///
     /// assert_eq!(
     ///     db.into_transaction_log(),

src/executor/execute.rs

@@ -32,28 +32,24 @@ pub(crate) enum ExecResultHolder {
 impl ExecResult {
     /// Get the last id after `AUTOINCREMENT` is done on the primary key
     ///
-    /// # Panics
-    ///
-    /// Postgres does not support retrieving last insert id this way except through `RETURNING` clause
-    pub fn last_insert_id(&self) -> u64 {
+    /// Postgres always returns `None`
+    pub fn last_insert_id(&self) -> Option<u64> {
         match &self.result {
             #[cfg(feature = "sqlx-mysql")]
-            ExecResultHolder::SqlxMySql(result) => result.last_insert_id(),
+            ExecResultHolder::SqlxMySql(result) => Some(result.last_insert_id()),
             #[cfg(feature = "sqlx-postgres")]
-            ExecResultHolder::SqlxPostgres(_) => {
-                panic!("Should not retrieve last_insert_id this way")
-            }
+            ExecResultHolder::SqlxPostgres(_) => None,
             #[cfg(feature = "sqlx-sqlite")]
             ExecResultHolder::SqlxSqlite(result) => {
                 let last_insert_rowid = result.last_insert_rowid();
                 if last_insert_rowid < 0 {
                     unreachable!("negative last_insert_rowid")
                 } else {
-                    last_insert_rowid as u64
+                    Some(last_insert_rowid as u64)
                 }
             }
             #[cfg(feature = "mock")]
-            ExecResultHolder::Mock(result) => result.last_insert_id,
+            ExecResultHolder::Mock(result) => Some(result.last_insert_id),
             #[cfg(feature = "proxy")]
             ExecResultHolder::Proxy(result) => result.last_insert_id,
             #[allow(unreachable_patterns)]

src/executor/insert.rs

@@ -24,7 +24,7 @@ where
     A: ActiveModelTrait,
 {
     /// The id performed when AUTOINCREMENT was performed on the PrimaryKey
-    pub last_insert_id: <<<A as ActiveModelTrait>::Entity as EntityTrait>::PrimaryKey as PrimaryKeyTrait>::ValueType,
+    pub last_insert_id: Option<<<<A as ActiveModelTrait>::Entity as EntityTrait>::PrimaryKey as PrimaryKeyTrait>::ValueType>,
 }
 
 /// The types of results for an INSERT operation
@@ -226,7 +226,7 @@ where
             if res.rows_affected() == 0 {
                 return Err(DbErr::RecordNotInserted);
             }
-            FromValueTuple::from_value_tuple(value_tuple)
+            Some(FromValueTuple::from_value_tuple(value_tuple))
         }
         (None, true) => {
             let mut rows = db.query_all(statement).await?;
@@ -237,24 +237,32 @@ where
             let cols = PrimaryKey::<A>::iter()
                 .map(|col| col.to_string())
                 .collect::<Vec<_>>();
-            row.try_get_many("", cols.as_ref())
-                .map_err(|_| DbErr::UnpackInsertId)?
+            Some(
+                row.try_get_many("", cols.as_ref())
+                    .map_err(|_| DbErr::UnpackInsertId)?,
+            )
         }
         (None, false) => {
             let res = db.execute(statement).await?;
             if res.rows_affected() == 0 {
                 return Err(DbErr::RecordNotInserted);
             }
-            let last_insert_id = res.last_insert_id();
-            // For MySQL, the affected-rows number:
-            //   - The affected-rows value per row is `1` if the row is inserted as a new row,
-            //   - `2` if an existing row is updated,
-            //   - and `0` if an existing row is set to its current values.
-            // Reference: https://dev.mysql.com/doc/refman/8.4/en/insert-on-duplicate.html
-            if db_backend == DbBackend::MySql && last_insert_id == 0 {
-                return Err(DbErr::RecordNotInserted);
+            if let Some(last_insert_id) = res.last_insert_id() {
+                // For MySQL, the affected-rows number:
+                //   - The affected-rows value per row is `1` if the row is inserted as a new row,
+                //   - `2` if an existing row is updated,
+                //   - and `0` if an existing row is set to its current values.
+                // Reference: https://dev.mysql.com/doc/refman/8.4/en/insert-on-duplicate.html
+                if db_backend == DbBackend::MySql && last_insert_id == 0 {
+                    return Err(DbErr::RecordNotInserted);
+                }
+                Some(
+                    ValueTypeOf::<A>::try_from_u64(last_insert_id)
+                        .map_err(|_| DbErr::UnpackInsertId)?,
+                )
+            } else {
+                None
             }
-            ValueTypeOf::<A>::try_from_u64(last_insert_id).map_err(|_| DbErr::UnpackInsertId)?
         }
     };
 
@@ -301,9 +309,11 @@ where
         }
         false => {
             let insert_res = exec_insert::<A, _>(primary_key, insert_statement, db).await?;
-            <A::Entity as EntityTrait>::find_by_id(insert_res.last_insert_id)
-                .one(db)
-                .await?
+            <A::Entity as EntityTrait>::find_by_id(insert_res.last_insert_id.ok_or(
+                DbErr::RecordNotFound("No last insert id returned from the database".to_owned()),
+            )?)
+            .one(db)
+            .await?
         }
     };
     match found {

tests/byte_primary_key_tests.rs

@@ -30,7 +30,7 @@ pub async fn create_and_update(db: &DatabaseConnection) -> Result<(), DbErr> {
 
     assert_eq!(Entity::find().one(db).await?, Some(model.clone()));
 
-    assert_eq!(res.last_insert_id, model.id);
+    assert_eq!(res.last_insert_id, Some(model.id.clone()));
 
     let updated_active_model = ActiveModel {
         value: Set("First Row (Updated)".to_owned()),

tests/crud/create_baker.rs

@@ -27,18 +27,21 @@ pub async fn test_create_baker(db: &DbConn) {
     let baker_bob = baker::ActiveModel {
         name: Set("Baker Bob".to_owned()),
         contact_details: Set(serde_json::json!(baker_bob_contact)),
-        bakery_id: Set(Some(bakery_insert_res.last_insert_id)),
+        bakery_id: Set(bakery_insert_res.last_insert_id),
         ..Default::default()
     };
     let res = Baker::insert(baker_bob)
         .exec(db)
         .await
         .expect("could not insert baker");
 
-    let baker: Option<baker::Model> = Baker::find_by_id(res.last_insert_id)
-        .one(db)
-        .await
-        .expect("could not find baker");
+    let baker: Option<baker::Model> = Baker::find_by_id(
+        res.last_insert_id
+            .expect("could not get last insert id for baker"),
+    )
+    .one(db)
+    .await
+    .expect("could not find baker");
 
     assert!(baker.is_some());
     let baker_model = baker.unwrap();
@@ -63,10 +66,14 @@ pub async fn test_create_baker(db: &DbConn) {
         "SeaSide Bakery"
     );
 
-    let bakery: Option<bakery::Model> = Bakery::find_by_id(bakery_insert_res.last_insert_id)
-        .one(db)
-        .await
-        .unwrap();
+    let bakery: Option<bakery::Model> = Bakery::find_by_id(
+        bakery_insert_res
+            .last_insert_id
+            .expect("could not get last insert id for bakery"),
+    )
+    .one(db)
+    .await
+    .unwrap();
 
     let related_bakers: Vec<baker::Model> = bakery
         .unwrap()

tests/crud/create_cake.rs

@@ -19,7 +19,7 @@ pub async fn test_create_cake(db: &DbConn) {
             "home": "0395555555",
             "address": "12 Test St, Testville, Vic, Australia"
         })),
-        bakery_id: Set(Some(bakery_insert_res.last_insert_id)),
+        bakery_id: Set(bakery_insert_res.last_insert_id),
         ..Default::default()
     };
     let baker_insert_res = Baker::insert(baker_bob)
@@ -33,7 +33,7 @@ pub async fn test_create_cake(db: &DbConn) {
         price: Set(rust_dec(-10.25)),
         gluten_free: Set(false),
         serial: Set(uuid),
-        bakery_id: Set(Some(bakery_insert_res.last_insert_id)),
+        bakery_id: Set(bakery_insert_res.last_insert_id),
         ..Default::default()
     };
 
@@ -42,22 +42,30 @@ pub async fn test_create_cake(db: &DbConn) {
         .await
         .expect("could not insert cake");
 
-    let cake: Option<cake::Model> = Cake::find_by_id(cake_insert_res.last_insert_id)
-        .one(db)
-        .await
-        .expect("could not find cake");
+    let cake: Option<cake::Model> = Cake::find_by_id(
+        cake_insert_res
+            .last_insert_id
+            .expect("could not get last insert id for cake"),
+    )
+    .one(db)
+    .await
+    .expect("could not find cake");
 
     let cake_baker = cakes_bakers::ActiveModel {
-        cake_id: Set(cake_insert_res.last_insert_id),
-        baker_id: Set(baker_insert_res.last_insert_id),
+        cake_id: Set(cake_insert_res
+            .last_insert_id
+            .expect("could not get last insert id for cake")),
+        baker_id: Set(baker_insert_res
+            .last_insert_id
+            .expect("could not get last insert id for baker")),
     };
     let cake_baker_res = CakesBakers::insert(cake_baker.clone())
         .exec(db)
         .await
         .expect("could not insert cake_baker");
     assert_eq!(
         cake_baker_res.last_insert_id,
-        (cake_baker.cake_id.unwrap(), cake_baker.baker_id.unwrap())
+        Some((cake_baker.cake_id.unwrap(), cake_baker.baker_id.unwrap()))
     );
 
     assert!(cake.is_some());
@@ -85,10 +93,14 @@ pub async fn test_create_cake(db: &DbConn) {
     assert_eq!(related_bakers.len(), 1);
     assert_eq!(related_bakers[0].name, "Baker Bob");
 
-    let baker: Option<baker::Model> = Baker::find_by_id(baker_insert_res.last_insert_id)
-        .one(db)
-        .await
-        .expect("could not find baker");
+    let baker: Option<baker::Model> = Baker::find_by_id(
+        baker_insert_res
+            .last_insert_id
+            .expect("could not get last insert id for baker"),
+    )
+    .one(db)
+    .await
+    .expect("could not find baker");
 
     let related_cakes: Vec<cake::Model> = baker
         .unwrap()

tests/crud/create_lineitem.rs

@@ -22,7 +22,7 @@ pub async fn test_create_lineitem(db: &DbConn) {
             "home": "0395555555",
             "address": "12 Test St, Testville, Vic, Australia"
         })),
-        bakery_id: Set(Some(bakery_insert_res.last_insert_id)),
+        bakery_id: Set(bakery_insert_res.last_insert_id),
         ..Default::default()
     };
     let baker_insert_res = Baker::insert(baker_bob)
@@ -36,7 +36,7 @@ pub async fn test_create_lineitem(db: &DbConn) {
         price: Set(rust_dec(10.25)),
         gluten_free: Set(false),
         serial: Set(Uuid::new_v4()),
-        bakery_id: Set(Some(bakery_insert_res.last_insert_id)),
+        bakery_id: Set(bakery_insert_res.last_insert_id),
         ..Default::default()
     };
 
@@ -47,16 +47,20 @@ pub async fn test_create_lineitem(db: &DbConn) {
 
     // Cake_Baker
     let cake_baker = cakes_bakers::ActiveModel {
-        cake_id: Set(cake_insert_res.last_insert_id),
-        baker_id: Set(baker_insert_res.last_insert_id),
+        cake_id: Set(cake_insert_res
+            .last_insert_id
+            .expect("could not get last insert id for cake")),
+        baker_id: Set(baker_insert_res
+            .last_insert_id
+            .expect("could not get last insert id for baker")),
     };
     let cake_baker_res = CakesBakers::insert(cake_baker.clone())
         .exec(db)
         .await
         .expect("could not insert cake_baker");
     assert_eq!(
         cake_baker_res.last_insert_id,
-        (cake_baker.cake_id.unwrap(), cake_baker.baker_id.unwrap())
+        Some((cake_baker.cake_id.unwrap(), cake_baker.baker_id.unwrap()))
     );
 
     // Customer
@@ -72,8 +76,12 @@ pub async fn test_create_lineitem(db: &DbConn) {
 
     // Order
     let order_1 = order::ActiveModel {
-        bakery_id: Set(bakery_insert_res.last_insert_id),
-        customer_id: Set(customer_insert_res.last_insert_id),
+        bakery_id: Set(bakery_insert_res
+            .last_insert_id
+            .expect("could not get last insert id for bakery")),
+        customer_id: Set(customer_insert_res
+            .last_insert_id
+            .expect("could not get last insert id for customer")),
         total: Set(rust_dec(7.55)),
         placed_at: Set(Utc::now().naive_utc()),
         ..Default::default()
@@ -85,8 +93,12 @@ pub async fn test_create_lineitem(db: &DbConn) {
 
     // Lineitem
     let lineitem_1 = lineitem::ActiveModel {
-        cake_id: Set(cake_insert_res.last_insert_id),
-        order_id: Set(order_insert_res.last_insert_id),
+        cake_id: Set(cake_insert_res
+            .last_insert_id
+            .expect("could not get last insert id for cake")),
+        order_id: Set(order_insert_res
+            .last_insert_id
+            .expect("could not get last insert id for order")),
         price: Set(rust_dec(7.55)),
         quantity: Set(1),
         ..Default::default()
@@ -96,11 +108,14 @@ pub async fn test_create_lineitem(db: &DbConn) {
         .await
         .expect("could not insert lineitem");
 
-    let lineitem: Option<lineitem::Model> =
-        Lineitem::find_by_id(lineitem_insert_res.last_insert_id)
-            .one(db)
-            .await
-            .expect("could not find lineitem");
+    let lineitem: Option<lineitem::Model> = Lineitem::find_by_id(
+        lineitem_insert_res
+            .last_insert_id
+            .expect("could not get last insert id for lineitem"),
+    )
+    .one(db)
+    .await
+    .expect("could not find lineitem");
 
     assert!(lineitem.is_some());
     let lineitem_model = lineitem.unwrap();
@@ -121,5 +136,8 @@ pub async fn test_create_lineitem(db: &DbConn) {
         .expect("could not find order");
 
     let order_model = order.unwrap();
-    assert_eq!(order_model.customer_id, customer_insert_res.last_insert_id);
+    assert_eq!(
+        Some(order_model.customer_id),
+        customer_insert_res.last_insert_id
+    );
 }