Replace string types implementations with Into<String>

Cargo.toml

@@ -34,8 +34,8 @@ tracing = { version = "0.1", default-features = false, features = ["attributes",
 rust_decimal = { version = "1", default-features = false, optional = true }
 bigdecimal = { version = "0.3", default-features = false, optional = true }
 sea-orm-macros = { version = "0.10.3", path = "sea-orm-macros", default-features = false, optional = true }
-sea-query = { version = "0.28.3", features = ["thread-safe"] }
-sea-query-binder = { version = "0.3", default-features = false, optional = true }
+sea-query = { version = "0.28.3", git = "https://github.com/SeaQL/sea-query", rev = "cf4dcd31", features = ["thread-safe"] }
+sea-query-binder = { version = "0.3", git = "https://github.com/SeaQL/sea-query", rev = "cf4dcd31", default-features = false, optional = true }
 sea-strum = { version = "0.23", default-features = false, features = ["derive", "sea-orm"] }
 serde = { version = "1.0", default-features = false }
 serde_json = { version = "1.0", default-features = false, optional = true }

src/database/db_connection.rs

@@ -139,7 +139,7 @@ impl ConnectionTrait for DatabaseConnection {
             #[cfg(feature = "mock")]
             DatabaseConnection::MockDatabaseConnection(conn) => {
                 let db_backend = conn.get_database_backend();
-                let stmt = Statement::from_string(db_backend, sql.into());
+                let stmt = Statement::from_string(db_backend, sql);
                 conn.execute(stmt)
             }
             DatabaseConnection::Disconnected => {

src/database/mock.rs

@@ -289,31 +289,27 @@ where
     }
 }
 
-impl IntoMockRow for BTreeMap<String, Value> {
-    fn into_mock_row(self) -> MockRow {
-        MockRow {
-            values: self.into_iter().map(|(k, v)| (k, v)).collect(),
-        }
-    }
-}
-
-impl IntoMockRow for BTreeMap<&str, Value> {
+impl<T> IntoMockRow for BTreeMap<T, Value>
+where
+    T: Into<String>,
+{
     fn into_mock_row(self) -> MockRow {
         MockRow {
-            values: self.into_iter().map(|(k, v)| (k.to_owned(), v)).collect(),
+            values: self.into_iter().map(|(k, v)| (k.into(), v)).collect(),
         }
     }
 }
 
 impl Transaction {
     /// Get the [Value]s from s raw SQL statement depending on the [DatabaseBackend](crate::DatabaseBackend)
-    pub fn from_sql_and_values<I>(db_backend: DbBackend, sql: &str, values: I) -> Self
+    pub fn from_sql_and_values<I, T>(db_backend: DbBackend, sql: T, values: I) -> Self
     where
         I: IntoIterator<Item = Value>,
+        T: Into<String>,
     {
         Self::one(Statement::from_string_values_tuple(
             db_backend,
-            (sql.to_string(), Values(values.into_iter().collect())),
+            (sql, Values(values.into_iter().collect())),
         ))
     }
 
@@ -344,10 +340,7 @@ impl Transaction {
 impl OpenTransaction {
     fn init() -> Self {
         Self {
-            stmts: vec![Statement::from_string(
-                DbBackend::Postgres,
-                "BEGIN".to_owned(),
-            )],
+            stmts: vec![Statement::from_string(DbBackend::Postgres, "BEGIN")],
             transaction_depth: 0,
         }
     }
@@ -362,7 +355,7 @@ impl OpenTransaction {
 
     fn commit(&mut self, db_backend: DbBackend) -> bool {
         if self.transaction_depth == 0 {
-            self.push(Statement::from_string(db_backend, "COMMIT".to_owned()));
+            self.push(Statement::from_string(db_backend, "COMMIT"));
             true
         } else {
             self.push(Statement::from_string(
@@ -376,7 +369,7 @@ impl OpenTransaction {
 
     fn rollback(&mut self, db_backend: DbBackend) -> bool {
         if self.transaction_depth == 0 {
-            self.push(Statement::from_string(db_backend, "ROLLBACK".to_owned()));
+            self.push(Statement::from_string(db_backend, "ROLLBACK"));
             true
         } else {
             self.push(Statement::from_string(
@@ -441,7 +434,7 @@ mod tests {
             db.into_transaction_log(),
             [
                 Transaction::many([
-                    Statement::from_string(DbBackend::Postgres, "BEGIN".to_owned()),
+                    Statement::from_string(DbBackend::Postgres, "BEGIN"),
                     Statement::from_sql_and_values(
                         DbBackend::Postgres,
                         r#"SELECT "cake"."id", "cake"."name" FROM "cake" LIMIT $1"#,
@@ -452,7 +445,7 @@ mod tests {
                         r#"SELECT "fruit"."id", "fruit"."name", "fruit"."cake_id" FROM "fruit""#,
                         []
                     ),
-                    Statement::from_string(DbBackend::Postgres, "COMMIT".to_owned()),
+                    Statement::from_string(DbBackend::Postgres, "COMMIT"),
                 ]),
                 Transaction::from_sql_and_values(
                     DbBackend::Postgres,
@@ -486,13 +479,13 @@ mod tests {
         assert_eq!(
             db.into_transaction_log(),
             [Transaction::many([
-                Statement::from_string(DbBackend::Postgres, "BEGIN".to_owned()),
+                Statement::from_string(DbBackend::Postgres, "BEGIN"),
                 Statement::from_sql_and_values(
                     DbBackend::Postgres,
                     r#"SELECT "cake"."id", "cake"."name" FROM "cake" LIMIT $1"#,
                     [1u64.into()]
                 ),
-                Statement::from_string(DbBackend::Postgres, "ROLLBACK".to_owned()),
+                Statement::from_string(DbBackend::Postgres, "ROLLBACK"),
             ])]
         );
     }
@@ -524,23 +517,20 @@ mod tests {
         assert_eq!(
             db.into_transaction_log(),
             [Transaction::many([
-                Statement::from_string(DbBackend::Postgres, "BEGIN".to_owned()),
+                Statement::from_string(DbBackend::Postgres, "BEGIN"),
                 Statement::from_sql_and_values(
                     DbBackend::Postgres,
                     r#"SELECT "cake"."id", "cake"."name" FROM "cake" LIMIT $1"#,
                     [1u64.into()]
                 ),
-                Statement::from_string(DbBackend::Postgres, "SAVEPOINT savepoint_1".to_owned()),
+                Statement::from_string(DbBackend::Postgres, "SAVEPOINT savepoint_1"),
                 Statement::from_sql_and_values(
                     DbBackend::Postgres,
                     r#"SELECT "fruit"."id", "fruit"."name", "fruit"."cake_id" FROM "fruit""#,
                     []
                 ),
-                Statement::from_string(
-                    DbBackend::Postgres,
-                    "RELEASE SAVEPOINT savepoint_1".to_owned()
-                ),
-                Statement::from_string(DbBackend::Postgres, "COMMIT".to_owned()),
+                Statement::from_string(DbBackend::Postgres, "RELEASE SAVEPOINT savepoint_1"),
+                Statement::from_string(DbBackend::Postgres, "COMMIT"),
             ]),]
         );
     }
@@ -582,33 +572,27 @@ mod tests {
         assert_eq!(
             db.into_transaction_log(),
             [Transaction::many([
-                Statement::from_string(DbBackend::Postgres, "BEGIN".to_owned()),
+                Statement::from_string(DbBackend::Postgres, "BEGIN"),
                 Statement::from_sql_and_values(
                     DbBackend::Postgres,
                     r#"SELECT "cake"."id", "cake"."name" FROM "cake" LIMIT $1"#,
                     [1u64.into()]
                 ),
-                Statement::from_string(DbBackend::Postgres, "SAVEPOINT savepoint_1".to_owned()),
+                Statement::from_string(DbBackend::Postgres, "SAVEPOINT savepoint_1"),
                 Statement::from_sql_and_values(
                     DbBackend::Postgres,
                     r#"SELECT "fruit"."id", "fruit"."name", "fruit"."cake_id" FROM "fruit""#,
                     []
                 ),
-                Statement::from_string(DbBackend::Postgres, "SAVEPOINT savepoint_2".to_owned()),
+                Statement::from_string(DbBackend::Postgres, "SAVEPOINT savepoint_2"),
                 Statement::from_sql_and_values(
                     DbBackend::Postgres,
                     r#"SELECT "cake"."id", "cake"."name" FROM "cake""#,
                     []
                 ),
-                Statement::from_string(
-                    DbBackend::Postgres,
-                    "RELEASE SAVEPOINT savepoint_2".to_owned()
-                ),
-                Statement::from_string(
-                    DbBackend::Postgres,
-                    "RELEASE SAVEPOINT savepoint_1".to_owned()
-                ),
-                Statement::from_string(DbBackend::Postgres, "COMMIT".to_owned()),
+                Statement::from_string(DbBackend::Postgres, "RELEASE SAVEPOINT savepoint_2"),
+                Statement::from_string(DbBackend::Postgres, "RELEASE SAVEPOINT savepoint_1"),
+                Statement::from_string(DbBackend::Postgres, "COMMIT"),
             ]),]
         );
     }

src/database/mod.rs

@@ -84,29 +84,23 @@ impl Database {
     }
 }
 
-impl From<&str> for ConnectOptions {
-    fn from(string: &str) -> ConnectOptions {
-        ConnectOptions::from_str(string)
-    }
-}
-
-impl From<&String> for ConnectOptions {
-    fn from(string: &String) -> ConnectOptions {
-        ConnectOptions::from_str(string.as_str())
-    }
-}
-
-impl From<String> for ConnectOptions {
-    fn from(string: String) -> ConnectOptions {
-        ConnectOptions::new(string)
+impl<T> From<T> for ConnectOptions
+where
+    T: Into<String>,
+{
+    fn from(s: T) -> ConnectOptions {
+        ConnectOptions::new(s.into())
     }
 }
 
 impl ConnectOptions {
     /// Create new [ConnectOptions] for a [Database] by passing in a URI string
-    pub fn new(url: String) -> Self {
+    pub fn new<T>(url: T) -> Self
+    where
+        T: Into<String>,
+    {
         Self {
-            url,
+            url: url.into(),
             max_connections: None,
             min_connections: None,
             connect_timeout: None,
@@ -120,10 +114,6 @@ impl ConnectOptions {
         }
     }
 
-    fn from_str(url: &str) -> Self {
-        Self::new(url.to_owned())
-    }
-
     #[cfg(feature = "sqlx-dep")]
     /// Convert [ConnectOptions] into [sqlx::pool::PoolOptions]
     pub fn pool_options<DB>(self) -> sqlx::pool::PoolOptions<DB>

src/database/statement.rs

@@ -23,32 +23,33 @@ pub trait StatementBuilder {
 
 impl Statement {
     /// Create a [Statement] from a [crate::DatabaseBackend] and a raw SQL statement
-    pub fn from_string(db_backend: DbBackend, stmt: String) -> Statement {
+    pub fn from_string<T>(db_backend: DbBackend, stmt: T) -> Statement
+    where
+        T: Into<String>,
+    {
         Statement {
-            sql: stmt,
+            sql: stmt.into(),
             values: None,
             db_backend,
         }
     }
 
     /// Create a SQL statement from a [crate::DatabaseBackend], a
     /// raw SQL statement and param values
-    pub fn from_sql_and_values<I>(db_backend: DbBackend, sql: &str, values: I) -> Self
+    pub fn from_sql_and_values<I, T>(db_backend: DbBackend, sql: T, values: I) -> Self
     where
         I: IntoIterator<Item = Value>,
+        T: Into<String>,
     {
-        Self::from_string_values_tuple(
-            db_backend,
-            (sql.to_owned(), Values(values.into_iter().collect())),
-        )
+        Self::from_string_values_tuple(db_backend, (sql, Values(values.into_iter().collect())))
     }
 
-    pub(crate) fn from_string_values_tuple(
-        db_backend: DbBackend,
-        stmt: (String, Values),
-    ) -> Statement {
+    pub(crate) fn from_string_values_tuple<T>(db_backend: DbBackend, stmt: (T, Values)) -> Statement
+    where
+        T: Into<String>,
+    {
         Statement {
-            sql: stmt.0,
+            sql: stmt.0.into(),
             values: Some(stmt.1),
             db_backend,
         }

src/database/transaction.rs

@@ -354,7 +354,7 @@ impl ConnectionTrait for DatabaseTransaction {
             #[cfg(feature = "mock")]
             InnerConnection::Mock(conn) => {
                 let db_backend = conn.get_database_backend();
-                let stmt = Statement::from_string(db_backend, sql.into());
+                let stmt = Statement::from_string(db_backend, sql);
                 conn.execute(stmt)
             }
             #[allow(unreachable_patterns)]

src/entity/column.rs

@@ -149,7 +149,10 @@ pub trait ColumnTrait: IdenStatic + Iterable + FromStr {
     ///     "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` LIKE 'cheese'"
     /// );
     /// ```
-    fn like(&self, s: &str) -> SimpleExpr {
+    fn like<T>(&self, s: T) -> SimpleExpr
+    where
+        T: Into<String>,
+    {
         Expr::col((self.entity_name(), *self)).like(s)
     }
 
@@ -164,7 +167,10 @@ pub trait ColumnTrait: IdenStatic + Iterable + FromStr {
     ///     "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` NOT LIKE 'cheese'"
     /// );
     /// ```
-    fn not_like(&self, s: &str) -> SimpleExpr {
+    fn not_like<T>(&self, s: T) -> SimpleExpr
+    where
+        T: Into<String>,
+    {
         Expr::col((self.entity_name(), *self)).not_like(s)
     }
 
@@ -179,8 +185,11 @@ pub trait ColumnTrait: IdenStatic + Iterable + FromStr {
     ///     "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` LIKE 'cheese%'"
     /// );
     /// ```
-    fn starts_with(&self, s: &str) -> SimpleExpr {
-        let pattern = format!("{s}%");
+    fn starts_with<T>(&self, s: T) -> SimpleExpr
+    where
+        T: Into<String>,
+    {
+        let pattern = format!("{}%", s.into());
         Expr::col((self.entity_name(), *self)).like(pattern)
     }
 
@@ -195,8 +204,11 @@ pub trait ColumnTrait: IdenStatic + Iterable + FromStr {
     ///     "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` LIKE '%cheese'"
     /// );
     /// ```
-    fn ends_with(&self, s: &str) -> SimpleExpr {
-        let pattern = format!("%{s}");
+    fn ends_with<T>(&self, s: T) -> SimpleExpr
+    where
+        T: Into<String>,
+    {
+        let pattern = format!("%{}", s.into());
         Expr::col((self.entity_name(), *self)).like(pattern)
     }
 
@@ -211,8 +223,11 @@ pub trait ColumnTrait: IdenStatic + Iterable + FromStr {
     ///     "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` LIKE '%cheese%'"
     /// );
     /// ```
-    fn contains(&self, s: &str) -> SimpleExpr {
-        let pattern = format!("%{s}%");
+    fn contains<T>(&self, s: T) -> SimpleExpr
+    where
+        T: Into<String>,
+    {
+        let pattern = format!("%{}%", s.into());
         Expr::col((self.entity_name(), *self)).like(pattern)
     }
 

tests/common/features/schema.rs

@@ -339,7 +339,7 @@ pub async fn create_json_struct_table(db: &DbConn) -> Result<ExecResult, DbErr>
 pub async fn create_collection_table(db: &DbConn) -> Result<ExecResult, DbErr> {
     db.execute(sea_orm::Statement::from_string(
         db.get_database_backend(),
-        "CREATE EXTENSION IF NOT EXISTS citext".into(),
+        "CREATE EXTENSION IF NOT EXISTS citext",
     ))
     .await?;