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

@@ -413,7 +413,7 @@ 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()]
     ///     )]);
     /// ```

src/executor/insert.rs

@@ -1,8 +1,10 @@
 use crate::{
-    error::*, ActiveModelTrait, ConnectionTrait, DbBackend, EntityTrait, Insert, PrimaryKeyTrait,
-    Statement, TryFromU64,
+    error::*, ActiveModelTrait, ColumnTrait, ConnectionTrait, EntityTrait, Insert, IntoActiveModel,
+    Iterable, PrimaryKeyTrait, SelectModel, SelectorRaw, Statement, TryFromU64,
+};
+use sea_query::{
+    Alias, Expr, FromValueTuple, Iden, InsertStatement, IntoColumnRef, Query, ValueTuple,
 };
-use sea_query::{FromValueTuple, InsertStatement, ValueTuple};
 use std::{future::Future, marker::PhantomData};
 
 /// Defines a structure to perform INSERT operations in an ActiveModel
@@ -39,18 +41,28 @@ where
     {
         // so that self is dropped before entering await
         let mut query = self.query;
-        if db.get_database_backend() == DbBackend::Postgres {
-            use crate::{sea_query::Query, Iterable};
-            if <A::Entity as EntityTrait>::PrimaryKey::iter().count() > 0 {
-                query.returning(
-                    Query::select()
-                        .columns(<A::Entity as EntityTrait>::PrimaryKey::iter())
-                        .take(),
-                );
-            }
+        if db.support_returning() && <A::Entity as EntityTrait>::PrimaryKey::iter().count() > 0 {
+            let mut returning = Query::select();
+            returning.columns(
+                <A::Entity as EntityTrait>::PrimaryKey::iter().map(|c| c.into_column_ref()),
+            );
+            query.returning(returning);
         }
         Inserter::<A>::new(self.primary_key, query).exec(db)
     }
+
+    /// Execute an insert operation and return the inserted model (use `RETURNING` syntax if database supported)
+    pub fn exec_with_returning<'a, C>(
+        self,
+        db: &'a C,
+    ) -> impl Future<Output = Result<A, DbErr>> + '_
+    where
+        <A::Entity as EntityTrait>::Model: IntoActiveModel<A>,
+        C: ConnectionTrait<'a>,
+        A: 'a,
+    {
+        Inserter::<A>::new(self.primary_key, self.query).exec_with_returning(db)
+    }
 }
 
 impl<A> Inserter<A>
@@ -75,6 +87,19 @@ where
         let builder = db.get_database_backend();
         exec_insert(self.primary_key, builder.build(&self.query), db)
     }
+
+    /// Execute an insert operation and return the inserted model (use `RETURNING` syntax if database supported)
+    pub fn exec_with_returning<'a, C>(
+        self,
+        db: &'a C,
+    ) -> impl Future<Output = Result<A, DbErr>> + '_
+    where
+        <A::Entity as EntityTrait>::Model: IntoActiveModel<A>,
+        C: ConnectionTrait<'a>,
+        A: 'a,
+    {
+        exec_insert_with_returning(self.primary_key, self.query, db)
+    }
 }
 
 async fn exec_insert<'a, A, C>(
@@ -88,16 +113,15 @@ where
 {
     type PrimaryKey<A> = <<A as ActiveModelTrait>::Entity as EntityTrait>::PrimaryKey;
     type ValueTypeOf<A> = <PrimaryKey<A> as PrimaryKeyTrait>::ValueType;
-    let last_insert_id_opt = match db.get_database_backend() {
-        DbBackend::Postgres => {
-            use crate::{sea_query::Iden, Iterable};
+    let last_insert_id_opt = match db.support_returning() {
+        true => {
             let cols = PrimaryKey::<A>::iter()
                 .map(|col| col.to_string())
                 .collect::<Vec<_>>();
             let res = db.query_one(statement).await?.unwrap();
             res.try_get_many("", cols.as_ref()).ok()
         }
-        _ => {
+        false => {
             let last_insert_id = db.execute(statement).await?.last_insert_id();
             ValueTypeOf::<A>::try_from_u64(last_insert_id).ok()
         }
@@ -111,3 +135,47 @@ where
     };
     Ok(InsertResult { last_insert_id })
 }
+
+async fn exec_insert_with_returning<'a, A, C>(
+    primary_key: Option<ValueTuple>,
+    mut insert_statement: InsertStatement,
+    db: &'a C,
+) -> Result<A, DbErr>
+where
+    <A::Entity as EntityTrait>::Model: IntoActiveModel<A>,
+    C: ConnectionTrait<'a>,
+    A: ActiveModelTrait,
+{
+    let db_backend = db.get_database_backend();
+    let found = match db.support_returning() {
+        true => {
+            let mut returning = Query::select();
+            returning.exprs(<A::Entity as EntityTrait>::Column::iter().map(|c| {
+                let col = Expr::col(c);
+                let col_def = ColumnTrait::def(&c);
+                let col_type = col_def.get_column_type();
+                match col_type.get_enum_name() {
+                    Some(_) => col.as_enum(Alias::new("text")),
+                    None => col.into(),
+                }
+            }));
+            insert_statement.returning(returning);
+            SelectorRaw::<SelectModel<<A::Entity as EntityTrait>::Model>>::from_statement(
+                db_backend.build(&insert_statement),
+            )
+            .one(db)
+            .await?
+        }
+        false => {
+            let insert_res =
+                exec_insert::<A, _>(primary_key, db_backend.build(&insert_statement), db).await?;
+            <A::Entity as EntityTrait>::find_by_id(insert_res.last_insert_id)
+                .one(db)
+                .await?
+        }
+    };
+    match found {
+        Some(model) => Ok(model.into_active_model()),
+        None => Err(DbErr::Exec("Failed to find inserted item".to_owned())),
+    }
+}

src/executor/update.rs

@@ -1,7 +1,8 @@
 use crate::{
-    error::*, ActiveModelTrait, ConnectionTrait, EntityTrait, Statement, UpdateMany, UpdateOne,
+    error::*, ActiveModelTrait, ColumnTrait, ConnectionTrait, EntityTrait, IntoActiveModel,
+    Iterable, SelectModel, SelectorRaw, Statement, UpdateMany, UpdateOne,
 };
-use sea_query::UpdateStatement;
+use sea_query::{Alias, Expr, FromValueTuple, Query, UpdateStatement};
 use std::future::Future;
 
 /// Defines an update operation
@@ -25,10 +26,11 @@ where
     /// Execute an update operation on an ActiveModel
     pub async fn exec<'b, C>(self, db: &'b C) -> Result<A, DbErr>
     where
+        <A::Entity as EntityTrait>::Model: IntoActiveModel<A>,
         C: ConnectionTrait<'b>,
     {
         // so that self is dropped before entering await
-        exec_update_and_return_original(self.query, self.model, db).await
+        exec_update_and_return_updated(self.query, self.model, db).await
     }
 }
 
@@ -78,17 +80,61 @@ where
     Updater::new(query).exec(db).await
 }
 
-async fn exec_update_and_return_original<'a, A, C>(
-    query: UpdateStatement,
+async fn exec_update_and_return_updated<'a, A, C>(
+    mut query: UpdateStatement,
     model: A,
     db: &'a C,
 ) -> Result<A, DbErr>
 where
+    <A::Entity as EntityTrait>::Model: IntoActiveModel<A>,
     A: ActiveModelTrait,
     C: ConnectionTrait<'a>,
 {
-    Updater::new(query).check_record_exists().exec(db).await?;
-    Ok(model)
+    match db.support_returning() {
+        true => {
+            let mut returning = Query::select();
+            returning.exprs(<A::Entity as EntityTrait>::Column::iter().map(|c| {
+                let col = Expr::col(c);
+                let col_def = c.def();
+                let col_type = col_def.get_column_type();
+                match col_type.get_enum_name() {
+                    Some(_) => col.as_enum(Alias::new("text")),
+                    None => col.into(),
+                }
+            }));
+            query.returning(returning);
+            let db_backend = db.get_database_backend();
+            let found: Option<<A::Entity as EntityTrait>::Model> =
+                SelectorRaw::<SelectModel<<A::Entity as EntityTrait>::Model>>::from_statement(
+                    db_backend.build(&query),
+                )
+                .one(db)
+                .await?;
+            // If we got `None` then we are updating a row that does not exist.
+            match found {
+                Some(model) => Ok(model.into_active_model()),
+                None => Err(DbErr::RecordNotFound(
+                    "None of the database rows are affected".to_owned(),
+                )),
+            }
+        }
+        false => {
+            // If we updating a row that does not exist then an error will be thrown here.
+            Updater::new(query).check_record_exists().exec(db).await?;
+            let primary_key_value = match model.get_primary_key_value() {
+                Some(val) => FromValueTuple::from_value_tuple(val),
+                None => return Err(DbErr::Exec("Fail to get primary key from model".to_owned())),
+            };
+            let found = <A::Entity as EntityTrait>::find_by_id(primary_key_value)
+                .one(db)
+                .await?;
+            // If we cannot select the updated row from db by the cached primary key
+            match found {
+                Some(model) => Ok(model.into_active_model()),
+                None => Err(DbErr::Exec("Failed to find inserted item".to_owned())),
+            }
+        }
+    }
 }
 
 async fn exec_update<'a, C>(
@@ -119,6 +165,15 @@ mod tests {
     #[smol_potat::test]
     async fn update_record_not_found_1() -> Result<(), DbErr> {
         let db = MockDatabase::new(DbBackend::Postgres)
+            .append_query_results(vec![
+                vec![cake::Model {
+                    id: 1,
+                    name: "Cheese Cake".to_owned(),
+                }],
+                vec![],
+                vec![],
+                vec![],
+            ])
             .append_exec_results(vec![
                 MockExecResult {
                     last_insert_id: 0,
@@ -217,22 +272,22 @@ mod tests {
             vec![
                 Transaction::from_sql_and_values(
                     DbBackend::Postgres,
-                    r#"UPDATE "cake" SET "name" = $1 WHERE "cake"."id" = $2"#,
+                    r#"UPDATE "cake" SET "name" = $1 WHERE "cake"."id" = $2 RETURNING "id", "name""#,
                     vec!["Cheese Cake".into(), 1i32.into()]
                 ),
                 Transaction::from_sql_and_values(
                     DbBackend::Postgres,
-                    r#"UPDATE "cake" SET "name" = $1 WHERE "cake"."id" = $2"#,
+                    r#"UPDATE "cake" SET "name" = $1 WHERE "cake"."id" = $2 RETURNING "id", "name""#,
                     vec!["Cheese Cake".into(), 2i32.into()]
                 ),
                 Transaction::from_sql_and_values(
                     DbBackend::Postgres,
-                    r#"UPDATE "cake" SET "name" = $1 WHERE "cake"."id" = $2"#,
+                    r#"UPDATE "cake" SET "name" = $1 WHERE "cake"."id" = $2 RETURNING "id", "name""#,
                     vec!["Cheese Cake".into(), 2i32.into()]
                 ),
                 Transaction::from_sql_and_values(
                     DbBackend::Postgres,
-                    r#"UPDATE "cake" SET "name" = $1 WHERE "cake"."id" = $2"#,
+                    r#"UPDATE "cake" SET "name" = $1 WHERE "cake"."id" = $2 RETURNING "id", "name""#,
                     vec!["Cheese Cake".into(), 2i32.into()]
                 ),
                 Transaction::from_sql_and_values(