Returning

.github/workflows/rust.yml

@@ -288,6 +288,7 @@ jobs:
     name: Examples
     runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
         os: [ubuntu-latest]
         path: [basic, actix_example, actix4_example, axum_example, rocket_example]
@@ -312,6 +313,7 @@ jobs:
     if: ${{ (needs.init.outputs.run-partial == 'true' && needs.init.outputs.run-issues == 'true') }}
     runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
         os: [ubuntu-latest]
         path: [86, 249, 262]
@@ -350,6 +352,7 @@ jobs:
     env:
       DATABASE_URL: "sqlite::memory:"
     strategy:
+      fail-fast: false
       matrix:
         runtime: [async-std, actix, tokio]
         tls: [native-tls, rustls]
@@ -392,6 +395,7 @@ jobs:
     env:
       DATABASE_URL: "mysql://root:@localhost"
     strategy:
+      fail-fast: false
       matrix:
         version: [8.0, 5.7]
         runtime: [async-std, actix, tokio]
@@ -452,8 +456,9 @@ jobs:
     env:
       DATABASE_URL: "mysql://root:@localhost"
     strategy:
+      fail-fast: false
       matrix:
-        version: [10.6]
+        version: [10.6, 10.5, 10.4]
         runtime: [async-std, actix, tokio]
         tls: [native-tls]
     services:
@@ -512,8 +517,9 @@ jobs:
     env:
       DATABASE_URL: "postgres://root:root@localhost"
     strategy:
+      fail-fast: false
       matrix:
-        version: [13.3, 12.7, 11.12, 10.17, 9.6.22]
+        version: [13, 12, 11, 10, 9]
         runtime: [tokio]
         tls: [native-tls]
     services:

src/database/connection.rs

@@ -45,6 +45,12 @@ pub trait ConnectionTrait<'a>: Sync {
         T: Send,
         E: std::error::Error + Send;
 
+    /// Check if the connection supports `RETURNING` syntax on insert and update
+    fn support_returning(&self) -> bool {
+        let db_backend = self.get_database_backend();
+        db_backend.support_returning()
+    }
+
     /// Check if the connection is a test connection for the Mock database
     fn is_mock_connection(&self) -> bool {
         false

src/database/db_connection.rs

@@ -267,6 +267,11 @@ impl DbBackend {
             Self::Sqlite => Box::new(SqliteQueryBuilder),
         }
     }
+
+    /// Check if the database supports `RETURNING` syntax on insert and update
+    pub fn support_returning(&self) -> bool {
+        matches!(self, Self::Postgres)
+    }
 }
 
 #[cfg(test)]

src/entity/active_model.rs

@@ -147,20 +147,16 @@ pub trait ActiveModelTrait: Clone + Debug {
         C: ConnectionTrait<'a>,
     {
         let am = ActiveModelBehavior::before_save(self, true)?;
-        let res = <Self::Entity as EntityTrait>::insert(am).exec(db).await?;
-        let found = <Self::Entity as EntityTrait>::find_by_id(res.last_insert_id)
-            .one(db)
+        let am = <Self::Entity as EntityTrait>::insert(am)
+            .exec_with_returning(db)
             .await?;
-        let am = match found {
-            Some(model) => model.into_active_model(),
-            None => return Err(DbErr::Exec("Failed to find inserted item".to_owned())),
-        };
         ActiveModelBehavior::after_save(am, true)
     }
 
     /// Perform the `UPDATE` operation on an ActiveModel
     async fn update<'a, C>(self, db: &'a C) -> Result<Self, DbErr>
     where
+        <Self::Entity as EntityTrait>::Model: IntoActiveModel<Self>,
         Self: ActiveModelBehavior + 'a,
         C: ConnectionTrait<'a>,
     {

src/entity/base_entity.rs

@@ -272,7 +272,7 @@ pub trait EntityTrait: EntityName {
 
     /// Insert an model into database
     ///
-    /// # Example
+    /// # Example (Postgres)
     ///
     /// ```
     /// # #[cfg(feature = "mock")]
@@ -299,15 +299,56 @@ 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.rows_affected, 1);
     /// #
     /// # Ok(())
     /// # });
     ///
     /// assert_eq!(
     ///     db.into_transaction_log(),
     ///     vec![Transaction::from_sql_and_values(
-    ///         DbBackend::Postgres, r#"INSERT INTO "cake" ("name") VALUES ($1) RETURNING "id""#, vec!["Apple Pie".into()]
+    ///         DbBackend::Postgres,
+    ///         r#"INSERT INTO "cake" ("name") VALUES ($1) RETURNING "id""#,
+    ///         vec!["Apple Pie".into()]
+    ///     )]);
+    /// ```
+    ///
+    /// # Example (MySQL)
+    ///
+    /// ```
+    /// # #[cfg(feature = "mock")]
+    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, DbBackend};
+    /// #
+    /// # let db = MockDatabase::new(DbBackend::MySql)
+    /// #     .append_exec_results(vec![
+    /// #         MockExecResult {
+    /// #             last_insert_id: 15,
+    /// #             rows_affected: 1,
+    /// #         },
+    /// #     ])
+    /// #     .into_connection();
+    /// #
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake};
+    ///
+    /// let apple = cake::ActiveModel {
+    ///     name: Set("Apple Pie".to_owned()),
+    ///     ..Default::default()
+    /// };
+    ///
+    /// # let _: Result<(), DbErr> = smol::block_on(async {
+    /// #
+    /// let insert_result = cake::Entity::insert(apple).exec(&db).await?;
+    ///
+    /// assert_eq!(insert_result.last_insert_id, 15);
+    /// #
+    /// # Ok(())
+    /// # });
+    ///
+    /// assert_eq!(
+    ///     db.into_transaction_log(),
+    ///     vec![Transaction::from_sql_and_values(
+    ///         DbBackend::MySql,
+    ///         r#"INSERT INTO `cake` (`name`) VALUES (?)"#,
+    ///         vec!["Apple Pie".into()]
     ///     )]);
     /// ```
     fn insert<A>(model: A) -> Insert<A>
@@ -319,7 +360,7 @@ pub trait EntityTrait: EntityName {
 
     /// Insert many models into database
     ///
-    /// # Example
+    /// # Example (Postgres)
     ///
     /// ```
     /// # #[cfg(feature = "mock")]
@@ -350,15 +391,59 @@ pub trait EntityTrait: EntityName {
     /// let insert_result = cake::Entity::insert_many(vec![apple, orange]).exec(&db).await?;
     ///
     /// assert_eq!(insert_result.last_insert_id, 28);
-    /// // assert_eq!(insert_result.rows_affected, 2);
     /// #
     /// # Ok(())
     /// # });
     ///
     /// assert_eq!(
     ///     db.into_transaction_log(),
     ///     vec![Transaction::from_sql_and_values(
-    ///         DbBackend::Postgres, r#"INSERT INTO "cake" ("name") VALUES ($1), ($2) RETURNING "id""#,
+    ///         DbBackend::Postgres,
+    ///         r#"INSERT INTO "cake" ("name") VALUES ($1), ($2) RETURNING "id""#,
+    ///         vec!["Apple Pie".into(), "Orange Scone".into()]
+    ///     )]);
+    /// ```
+    ///
+    /// # Example (MySQL)
+    ///
+    /// ```
+    /// # #[cfg(feature = "mock")]
+    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, DbBackend};
+    /// #
+    /// # let db = MockDatabase::new(DbBackend::MySql)
+    /// #     .append_exec_results(vec![
+    /// #         MockExecResult {
+    /// #             last_insert_id: 28,
+    /// #             rows_affected: 2,
+    /// #         },
+    /// #     ])
+    /// #     .into_connection();
+    /// #
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake};
+    ///
+    /// let apple = cake::ActiveModel {
+    ///     name: Set("Apple Pie".to_owned()),
+    ///     ..Default::default()
+    /// };
+    /// let orange = cake::ActiveModel {
+    ///     name: Set("Orange Scone".to_owned()),
+    ///     ..Default::default()
+    /// };
+    ///
+    /// # let _: Result<(), DbErr> = smol::block_on(async {
+    /// #
+    /// let insert_result = cake::Entity::insert_many(vec![apple, orange]).exec(&db).await?;
+    ///
+    /// assert_eq!(insert_result.last_insert_id, 28);
+    /// #
+    /// # Ok(())
+    /// # });
+    ///
+    /// assert_eq!(
+    ///     db.into_transaction_log(),
+    ///     vec![Transaction::from_sql_and_values(
+    ///         DbBackend::MySql,
+    ///         r#"INSERT INTO `cake` (`name`) VALUES (?), (?)"#,
     ///         vec!["Apple Pie".into(), "Orange Scone".into()]
     ///     )]);
     /// ```
@@ -374,7 +459,7 @@ pub trait EntityTrait: EntityName {
     ///
     /// - To apply where conditions / filters, see [`QueryFilter`](crate::query::QueryFilter)
     ///
-    /// # Example
+    /// # Example (Postgres)
     ///
     /// ```
     /// # #[cfg(feature = "mock")]
@@ -413,10 +498,69 @@ pub trait EntityTrait: EntityName {
     /// assert_eq!(
     ///     db.into_transaction_log(),
     ///     vec![Transaction::from_sql_and_values(
-    ///         DbBackend::Postgres, r#"UPDATE "fruit" SET "name" = $1 WHERE "fruit"."id" = $2 AND "fruit"."name" LIKE $3"#,
+    ///         DbBackend::Postgres,
+    ///         r#"UPDATE "fruit" SET "name" = $1 WHERE "fruit"."id" = $2 AND "fruit"."name" LIKE $3 RETURNING "id", "name", "cake_id""#,
     ///         vec!["Orange".into(), 1i32.into(), "%orange%".into()]
     ///     )]);
     /// ```
+    ///
+    /// # Example (MySQL)
+    ///
+    /// ```
+    /// # #[cfg(feature = "mock")]
+    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, DbBackend};
+    /// #
+    /// # let db = MockDatabase::new(DbBackend::MySql)
+    /// #     .append_query_results(vec![
+    /// #         vec![fruit::Model {
+    /// #             id: 1,
+    /// #             name: "Orange".to_owned(),
+    /// #             cake_id: None,
+    /// #         }],
+    /// #     ])
+    /// #     .append_exec_results(vec![
+    /// #         MockExecResult {
+    /// #             last_insert_id: 0,
+    /// #             rows_affected: 1,
+    /// #         },
+    /// #     ])
+    /// #     .into_connection();
+    /// #
+    /// use sea_orm::{entity::*, query::*, tests_cfg::fruit};
+    ///
+    /// let orange = fruit::ActiveModel {
+    ///     id: Set(1),
+    ///     name: Set("Orange".to_owned()),
+    ///     ..Default::default()
+    /// };
+    ///
+    /// # let _: Result<(), DbErr> = smol::block_on(async {
+    /// #
+    /// assert_eq!(
+    ///     fruit::Entity::update(orange.clone())
+    ///         .filter(fruit::Column::Name.contains("orange"))
+    ///         .exec(&db)
+    ///         .await?,
+    ///     orange
+    /// );
+    /// #
+    /// # Ok(())
+    /// # });
+    ///
+    /// assert_eq!(
+    ///     db.into_transaction_log(),
+    ///     vec![
+    ///         Transaction::from_sql_and_values(
+    ///             DbBackend::MySql,
+    ///             r#"UPDATE `fruit` SET `name` = ? WHERE `fruit`.`id` = ? AND `fruit`.`name` LIKE ?"#,
+    ///             vec!["Orange".into(), 1i32.into(), "%orange%".into()]
+    ///         ),
+    ///         Transaction::from_sql_and_values(
+    ///             DbBackend::MySql,
+    ///             r#"SELECT `fruit`.`id`, `fruit`.`name`, `fruit`.`cake_id` FROM `fruit` WHERE `fruit`.`id` = ? LIMIT ?"#,
+    ///             vec![1i32.into(), 1u64.into()]
+    ///         )]);
+    /// ```
     fn update<A>(model: A) -> UpdateOne<A>
     where
         A: ActiveModelTrait<Entity = Self>,
@@ -461,7 +605,9 @@ pub trait EntityTrait: EntityName {
     /// assert_eq!(
     ///     db.into_transaction_log(),
     ///     vec![Transaction::from_sql_and_values(
-    ///         DbBackend::Postgres, r#"UPDATE "fruit" SET "cake_id" = $1 WHERE "fruit"."name" LIKE $2"#, vec![Value::Int(None), "%Apple%".into()]
+    ///         DbBackend::Postgres,
+    ///         r#"UPDATE "fruit" SET "cake_id" = $1 WHERE "fruit"."name" LIKE $2"#,
+    ///         vec![Value::Int(None), "%Apple%".into()]
     ///     )]);
     /// ```
     fn update_many() -> UpdateMany<Self> {
@@ -506,7 +652,8 @@ pub trait EntityTrait: EntityName {
     /// assert_eq!(
     ///     db.into_transaction_log(),
     ///     vec![Transaction::from_sql_and_values(
-    ///         DbBackend::Postgres, r#"DELETE FROM "fruit" WHERE "fruit"."id" = $1"#, vec![3i32.into()]
+    ///         DbBackend::Postgres, r#"DELETE FROM "fruit" WHERE "fruit"."id" = $1"#,
+    ///         vec![3i32.into()]
     ///     )]);
     /// ```
     fn delete<A>(model: A) -> DeleteOne<A>
@@ -552,7 +699,9 @@ pub trait EntityTrait: EntityName {
     /// assert_eq!(
     ///     db.into_transaction_log(),
     ///     vec![Transaction::from_sql_and_values(
-    ///         DbBackend::Postgres, r#"DELETE FROM "fruit" WHERE "fruit"."name" LIKE $1"#, vec!["%Apple%".into()]
+    ///         DbBackend::Postgres,
+    ///         r#"DELETE FROM "fruit" WHERE "fruit"."name" LIKE $1"#,
+    ///         vec!["%Apple%".into()]
     ///     )]);
     /// ```
     fn delete_many() -> DeleteMany<Self> {