WIP

src/driver/sqlx_postgres.rs

@@ -107,16 +107,6 @@ impl From<PgQueryResult> for ExecResult {
     }
 }
 
-pub(crate) fn query_result_into_exec_result(res: QueryResult) -> Result<ExecResult, DbErr> {
-    let result = match res {
-        QueryResult::SqlxPostgres(result) => result,
-        _ => panic!("Should be QueryResult::SqlxPostgres"),
-    };
-    Ok(ExecResult {
-        result: ExecResultHolder::SqlxPostgres(result),
-    })
-}
-
 fn sqlx_query(stmt: &Statement) -> sqlx::query::Query<'_, Postgres, PgArguments> {
     let mut query = sqlx::query(&stmt.sql);
     if let Some(values) = &stmt.values {

src/executor/execute.rs

@@ -1,6 +1,3 @@
-use crate::TryGetable;
-use std::str::FromStr;
-
 #[derive(Debug)]
 pub struct ExecResult {
     pub(crate) result: ExecResultHolder,
@@ -21,36 +18,23 @@ pub(crate) enum ExecResultHolder {
 // ExecResult //
 
 impl ExecResult {
-    pub fn last_insert_id<T>(&self) -> T
+    pub fn last_insert_id(&self) -> u64 {
-    where
-        T: TryGetable + Default + FromStr,
-    {
         match &self.result {
             #[cfg(feature = "sqlx-mysql")]
-            ExecResultHolder::SqlxMySql(result) => result
+            ExecResultHolder::SqlxMySql(result) => result.last_insert_id(),
-                .last_insert_id()
-                .to_string()
-                .parse()
-                .unwrap_or_default(),
             #[cfg(feature = "sqlx-postgres")]
-            ExecResultHolder::SqlxPostgres(result) => {
+            ExecResultHolder::SqlxPostgres(_) => panic!("Should not retrieve last_insert_id this way"),
-                res.try_get("", "last_insert_id").unwrap_or_default()
-            }
             #[cfg(feature = "sqlx-sqlite")]
             ExecResultHolder::SqlxSqlite(result) => {
                 let last_insert_rowid = result.last_insert_rowid();
                 if last_insert_rowid < 0 {
                     panic!("negative last_insert_rowid")
                 } else {
-                    last_insert_rowid.to_string().parse().unwrap_or_default()
+                    last_insert_rowid as u64
                 }
             }
             #[cfg(feature = "mock")]
-            ExecResultHolder::Mock(result) => result
+            ExecResultHolder::Mock(result) => result.last_insert_id,
-                .last_insert_id
-                .to_string()
-                .parse()
-                .unwrap_or_default(),
         }
     }
 

src/executor/insert.rs

@@ -37,7 +37,7 @@ where
         let mut query = self.query;
         #[cfg(feature = "sqlx-postgres")]
         if let DatabaseConnection::SqlxPostgresPoolConnection(_) = db {
-            use crate::{EntityTrait, Iterable};
+            use crate::Iterable;
             use sea_query::{Alias, Expr, Query};
             for key in <A::Entity as EntityTrait>::PrimaryKey::iter() {
                 query.returning(
@@ -83,15 +83,21 @@ where
     A: ActiveModelTrait,
 {
     // TODO: Postgres instead use query_one + returning clause
-    let result = match db {
+    let last_insert_id = match db {
         #[cfg(feature = "sqlx-postgres")]
         DatabaseConnection::SqlxPostgresPoolConnection(conn) => {
             let res = conn.query_one(statement).await?.unwrap();
-            crate::query_result_into_exec_result(res)?
+            res.try_get("", "last_insert_id").unwrap_or_default()
         }
-        _ => db.execute(statement).await?,
+        _ => {
+            db.execute(statement).await?
+            .last_insert_id()
+            .to_string()
+            .parse()
+            .unwrap_or_default()
+        },
     };
     Ok(InsertResult {
-        last_insert_id: result.last_insert_id(),
+        last_insert_id,
     })
 }