Rename TryFromU64 to TryFromRawValue for more origin primary key types.

langyo · langyo · commit 10add180c3b0 · 2024-10-20T17:06:53.000+08:00
diff --git a/issues/324/src/model.rs b/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);
diff --git a/issues/400/src/model.rs b/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 {
diff --git a/src/database/proxy.rs b/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,
             })
         }
diff --git a/src/entity/active_enum.rs b/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)]
diff --git a/src/entity/primary_key.rs b/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
diff --git a/src/error.rs b/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,
diff --git a/src/executor/execute.rs b/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!(),
         }
diff --git a/src/executor/insert.rs b/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,
diff --git a/src/executor/query.rs b/src/executor/query.rs
diff --git a/tests/type_tests.rs b/tests/type_tests.rs

Original file line number	Diff line number	Diff line change
`@@ -22,12 +22,16 @@ impl From<AccountId> for Uuid {`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
`25`		`-macro_rules! impl_try_from_u64_err {`
	`25`	`+macro_rules! impl_try_from_raw_err {`
`26`	`26`	`($newtype: ident) => {`
`27`		`- impl sea_orm::TryFromU64 for $newtype {`
	`27`	`+ impl sea_orm::TryFromRawValue for $newtype {`
`28`	`28`	`fn try_from_u64(_n: u64) -> Result<Self, sea_orm::DbErr> {`
`29`	`29`	`Err(sea_orm::DbErr::ConvertFromU64(stringify!($newtype)))`
`30`	`30`	`}`
	`31`	`+`
	`32`	`+ fn try_from_string(_s: String) -> Result<Self, sea_orm::DbErr> {`
	`33`	`+ Err(sea_orm::DbErr::ConvertFromString(stringify!($newtype)))`
	`34`	`+ }`
`31`	`35`	`}`
`32`	`36`	`};`
`33`	`37`	`}`
`@@ -81,4 +85,4 @@ macro_rules! into_sea_query_value {`
`81`	`85`	`}`
`82`	`86`
`83`	`87`	`into_sea_query_value!(AccountId: Box(Uuid));`
`84`		`-impl_try_from_u64_err!(AccountId);`
	`88`	`+impl_try_from_raw_err!(AccountId);`
Original file line number	Diff line number	Diff line change
`@@ -29,10 +29,14 @@ impl<T> From<AccountId<T>> for Uuid {`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
`32`		`-impl<T> sea_orm::TryFromU64 for AccountId<T> {`
	`32`	`+impl<T> sea_orm::TryFromRawValue for AccountId<T> {`
`33`	`33`	`fn try_from_u64(_n: u64) -> Result<Self, sea_orm::DbErr> {`
`34`	`34`	`Err(sea_orm::DbErr::ConvertFromU64(stringify!(AccountId<T>)))`
`35`	`35`	`}`
	`36`	`+`
	`37`	`+ fn try_from_string(_s: String) -> Result<Self, sea_orm::DbErr> {`
	`38`	`+ Err(sea_orm::DbErr::ConvertFromString(stringify!(AccountId<T>)))`
	`39`	`+ }`
`36`	`40`	`}`
`37`	`41`
`38`	`42`	`impl<T> From<AccountId<T>> for sea_orm::Value {`