Rename TryFromU64 to TryFromRawValue for more origin primary key types.

Author: langyo

issues/324/src/model.rs

@@ -22,12 +22,16 @@ impl From<AccountId> for Uuid {
     }
 }
 
-macro_rules! impl_try_from_u64_err {
+macro_rules! impl_try_from_raw_err {
     ($newtype: ident) => {
-        impl sea_orm::TryFromU64 for $newtype {
+        impl sea_orm::TryFromRawValue for $newtype {
             fn try_from_u64(_n: u64) -> Result<Self, sea_orm::DbErr> {
                 Err(sea_orm::DbErr::ConvertFromU64(stringify!($newtype)))
             }
+
+            fn try_from_string(_s: String) -> Result<Self, sea_orm::DbErr> {
+                Err(sea_orm::DbErr::ConvertFromString(stringify!($newtype)))
+            }
         }
     };
 }
@@ -81,4 +85,4 @@ macro_rules! into_sea_query_value {
 }
 
 into_sea_query_value!(AccountId: Box(Uuid));
-impl_try_from_u64_err!(AccountId);
+impl_try_from_raw_err!(AccountId);

issues/400/src/model.rs

@@ -29,10 +29,14 @@ impl<T> From<AccountId<T>> for Uuid {
     }
 }
 
-impl<T> sea_orm::TryFromU64 for AccountId<T> {
+impl<T> sea_orm::TryFromRawValue for AccountId<T> {
     fn try_from_u64(_n: u64) -> Result<Self, sea_orm::DbErr> {
         Err(sea_orm::DbErr::ConvertFromU64(stringify!(AccountId<T>)))
     }
+
+    fn try_from_string(_s: String) -> Result<Self, sea_orm::DbErr> {
+        Err(sea_orm::DbErr::ConvertFromString(stringify!(AccountId<T>)))
+    }
 }
 
 impl<T> From<AccountId<T>> for sea_orm::Value {

src/database/proxy.rs

@@ -28,17 +28,17 @@ pub trait ProxyDatabaseTrait: Send + Sync + std::fmt::Debug {
 }
 
 /// Defines the results obtained from a [ProxyDatabase]
-#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug, Default)]
 pub struct ProxyExecResult {
     /// The last inserted id on auto-increment
-    pub last_insert_id: Option<u64>,
+    pub last_insert_id: Option<Value>,
     /// 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: Option<u64>, rows_affected: u64) -> Self {
+    pub fn new(last_insert_id: Option<Value>, rows_affected: u64) -> Self {
         Self {
             last_insert_id,
             rows_affected,
@@ -65,22 +65,22 @@ impl From<ExecResult> for ProxyExecResult {
         match result.result {
             #[cfg(feature = "sqlx-mysql")]
             ExecResultHolder::SqlxMySql(result) => Self {
-                last_insert_id: result.last_insert_id() as u64,
+                last_insert_id: Some(Value::BigUnsigned(Some(result.last_insert_id() as u64))),
                 rows_affected: result.rows_affected(),
             },
             #[cfg(feature = "sqlx-postgres")]
             ExecResultHolder::SqlxPostgres(result) => Self {
-                last_insert_id: 0,
+                last_insert_id: None,
                 rows_affected: result.rows_affected(),
             },
             #[cfg(feature = "sqlx-sqlite")]
             ExecResultHolder::SqlxSqlite(result) => Self {
-                last_insert_id: result.last_insert_rowid() as u64,
+                last_insert_id: Some(Value::BigUnsigned(Some(result.last_insert_rowid() as u64))),
                 rows_affected: result.rows_affected(),
             },
             #[cfg(feature = "mock")]
             ExecResultHolder::Mock(result) => Self {
-                last_insert_id: result.last_insert_id,
+                last_insert_id: Some(Value::BigUnsigned(Some(result.last_insert_id))),
                 rows_affected: result.rows_affected,
             },
             ExecResultHolder::Proxy(result) => result,
@@ -202,11 +202,12 @@ mod tests {
         entity::*, tests_cfg::*, Database, DbBackend, DbErr, ProxyDatabaseTrait, ProxyExecResult,
         ProxyRow, Statement,
     };
-    use std::sync::{Arc, Mutex};
+    use std::sync::Arc;
 
     #[derive(Debug)]
     struct ProxyDb {}
 
+    #[async_trait::async_trait]
     impl ProxyDatabaseTrait for ProxyDb {
         async fn query(&self, statement: Statement) -> Result<Vec<ProxyRow>, DbErr> {
             println!("SQL query: {}", statement.sql);
@@ -216,7 +217,7 @@ mod tests {
         async fn execute(&self, statement: Statement) -> Result<ProxyExecResult, DbErr> {
             println!("SQL execute: {}", statement.sql);
             Ok(ProxyExecResult {
-                last_insert_id: 1,
+                last_insert_id: Some(Value::BigUnsigned(Some(1))),
                 rows_affected: 1,
             })
         }

src/entity/active_enum.rs

@@ -1,4 +1,6 @@
-use crate::{ColIdx, ColumnDef, DbErr, Iterable, QueryResult, TryFromU64, TryGetError, TryGetable};
+use crate::{
+    ColIdx, ColumnDef, DbErr, Iterable, QueryResult, TryFromRawValue, TryGetError, TryGetable,
+};
 use sea_query::{DynIden, Expr, Nullable, SimpleExpr, Value, ValueType};
 
 /// A Rust representation of enum defined in database.
@@ -191,7 +193,7 @@ impl_active_enum_value_with_pg_array!(i16);
 impl_active_enum_value_with_pg_array!(i32);
 impl_active_enum_value_with_pg_array!(i64);
 
-impl<T> TryFromU64 for T
+impl<T> TryFromRawValue for T
 where
     T: ActiveEnum,
 {
@@ -200,6 +202,12 @@ where
             "Fail to construct ActiveEnum from a u64, if your primary key consist of a ActiveEnum field, its auto increment should be set to false."
         ))
     }
+
+    fn try_from_string(_: String) -> Result<Self, DbErr> {
+        Err(DbErr::ConvertFromString(
+            "Fail to construct ActiveEnum from a string",
+        ))
+    }
 }
 
 #[cfg(test)]

src/entity/primary_key.rs

@@ -1,5 +1,5 @@
 use super::{ColumnTrait, IdenStatic, Iterable};
-use crate::{TryFromU64, TryGetableMany};
+use crate::{TryFromRawValue, TryGetableMany};
 use sea_query::{FromValueTuple, IntoValueTuple};
 use std::fmt::Debug;
 
@@ -46,7 +46,7 @@ pub trait PrimaryKeyTrait: IdenStatic + Iterable {
         + IntoValueTuple
         + FromValueTuple
         + TryGetableMany
-        + TryFromU64
+        + TryFromRawValue
         + PrimaryKeyArity;
 
     /// Method to call to perform `AUTOINCREMENT` operation on a Primary Key

src/error.rs

@@ -40,6 +40,9 @@ pub enum DbErr {
     /// Type error: the specified type cannot be converted from u64. This is not a runtime error.
     #[error("Type '{0}' cannot be converted from u64")]
     ConvertFromU64(&'static str),
+    /// Type error: the specified type cannot be converted from string. This is not a runtime error.
+    #[error("Type '{0}' cannot be converted from string")]
+    ConvertFromString(&'static str),
     /// After an insert statement it was impossible to retrieve the last_insert_id
     #[error("Failed to unpack last_insert_id")]
     UnpackInsertId,

src/executor/execute.rs

@@ -1,3 +1,5 @@
+use sea_query::Value;
+
 /// Defines the result of executing an operation
 #[derive(Debug)]
 pub struct ExecResult {
@@ -33,10 +35,12 @@ impl ExecResult {
     /// Get the last id after `AUTOINCREMENT` is done on the primary key
     ///
     /// Postgres always returns `None`
-    pub fn last_insert_id(&self) -> Option<u64> {
+    pub fn last_insert_id(&self) -> Option<Value> {
         match &self.result {
             #[cfg(feature = "sqlx-mysql")]
-            ExecResultHolder::SqlxMySql(result) => Some(result.last_insert_id()),
+            ExecResultHolder::SqlxMySql(result) => {
+                Some(Value::BigUnsigned(Some(result.last_insert_id())))
+            }
             #[cfg(feature = "sqlx-postgres")]
             ExecResultHolder::SqlxPostgres(_) => None,
             #[cfg(feature = "sqlx-sqlite")]
@@ -45,13 +49,13 @@ impl ExecResult {
                 if last_insert_rowid < 0 {
                     unreachable!("negative last_insert_rowid")
                 } else {
-                    Some(last_insert_rowid as u64)
+                    Some(Value::BigUnsigned(Some(last_insert_rowid as u64)))
                 }
             }
             #[cfg(feature = "mock")]
-            ExecResultHolder::Mock(result) => Some(result.last_insert_id),
+            ExecResultHolder::Mock(result) => Some(Value::BigUnsigned(Some(result.last_insert_id))),
             #[cfg(feature = "proxy")]
-            ExecResultHolder::Proxy(result) => result.last_insert_id,
+            ExecResultHolder::Proxy(result) => result.last_insert_id.clone(),
             #[allow(unreachable_patterns)]
             _ => unreachable!(),
         }

src/executor/insert.rs

@@ -1,7 +1,7 @@
 use crate::{
     error::*, ActiveModelTrait, ColumnTrait, ConnectionTrait, DbBackend, EntityTrait, Insert,
     IntoActiveModel, Iterable, PrimaryKeyToColumn, PrimaryKeyTrait, SelectModel, SelectorRaw,
-    TryFromU64, TryInsert,
+    TryFromRawValue, TryInsert,
 };
 use sea_query::{FromValueTuple, Iden, InsertStatement, Query, ValueTuple};
 use std::{future::Future, marker::PhantomData};
@@ -247,7 +247,8 @@ where
             if res.rows_affected() == 0 {
                 return Err(DbErr::RecordNotInserted);
             }
-            if let Some(last_insert_id) = res.last_insert_id() {
+            if let Some(sea_query::Value::BigUnsigned(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,