Refactor/fix clippy errors

clippy.toml

@@ -0,0 +1 @@
+allow-unwrap-in-tests = true

sea-orm-macros/src/strum/helpers/mod.rs

@@ -1,4 +1,3 @@
-pub use self::case_style::CaseStyleHelpers;
 pub use self::type_props::HasTypeProperties;
 pub use self::variant_props::HasStrumVariantProperties;
 

src/database/db_connection.rs

@@ -19,23 +19,23 @@ use std::sync::Arc;
 pub enum DatabaseConnection {
     /// Create a MYSQL database connection and pool
     #[cfg(feature = "sqlx-mysql")]
-    SqlxMySqlPoolConnection(crate::SqlxMySqlPoolConnection),
+    SqlxMySqlPoolConnection(crate::driver::SqlxMySqlPoolConnection),
 
     /// Create a PostgreSQL database connection and pool
     #[cfg(feature = "sqlx-postgres")]
-    SqlxPostgresPoolConnection(crate::SqlxPostgresPoolConnection),
+    SqlxPostgresPoolConnection(crate::driver::SqlxPostgresPoolConnection),
 
     /// Create a SQLite database connection and pool
     #[cfg(feature = "sqlx-sqlite")]
-    SqlxSqlitePoolConnection(crate::SqlxSqlitePoolConnection),
+    SqlxSqlitePoolConnection(crate::driver::SqlxSqlitePoolConnection),
 
     /// Create a Mock database connection useful for testing
     #[cfg(feature = "mock")]
-    MockDatabaseConnection(Arc<crate::MockDatabaseConnection>),
+    MockDatabaseConnection(Arc<crate::driver::MockDatabaseConnection>),
 
     /// Create a Proxy database connection useful for proxying
     #[cfg(feature = "proxy")]
-    ProxyDatabaseConnection(Arc<crate::ProxyDatabaseConnection>),
+    ProxyDatabaseConnection(Arc<crate::driver::ProxyDatabaseConnection>),
 
     /// The connection to the database has been severed
     Disconnected,
@@ -74,9 +74,9 @@ pub(crate) enum InnerConnection {
     #[cfg(feature = "sqlx-sqlite")]
     Sqlite(PoolConnection<sqlx::Sqlite>),
     #[cfg(feature = "mock")]
-    Mock(Arc<crate::MockDatabaseConnection>),
+    Mock(Arc<crate::driver::MockDatabaseConnection>),
     #[cfg(feature = "proxy")]
-    Proxy(Arc<crate::ProxyDatabaseConnection>),
+    Proxy(Arc<crate::driver::ProxyDatabaseConnection>),
 }
 
 impl std::fmt::Debug for DatabaseConnection {
@@ -397,7 +397,7 @@ impl DatabaseConnection {
     /// # Panics
     ///
     /// Panics if [DbConn] is not a mock connection.
-    pub fn as_mock_connection(&self) -> &crate::MockDatabaseConnection {
+    pub fn as_mock_connection(&self) -> &crate::driver::MockDatabaseConnection {
         match self {
             DatabaseConnection::MockDatabaseConnection(mock_conn) => mock_conn,
             _ => panic!("Not mock connection"),
@@ -426,7 +426,7 @@ impl DatabaseConnection {
     /// # Panics
     ///
     /// Panics if [DbConn] is not a proxy connection.
-    pub fn as_proxy_connection(&self) -> &crate::ProxyDatabaseConnection {
+    pub fn as_proxy_connection(&self) -> &crate::driver::ProxyDatabaseConnection {
         match self {
             DatabaseConnection::ProxyDatabaseConnection(proxy_conn) => proxy_conn,
             _ => panic!("Not proxy connection"),

src/database/mock.rs

@@ -1,7 +1,8 @@
 use crate::{
-    error::*, DatabaseConnection, DbBackend, EntityTrait, ExecResult, ExecResultHolder, Iden,
-    IdenStatic, Iterable, MockDatabaseConnection, MockDatabaseTrait, ModelTrait, QueryResult,
-    QueryResultRow, SelectA, SelectB, Statement,
+    driver::{MockDatabaseConnection, MockDatabaseTrait},
+    error::*,
+    DatabaseConnection, DbBackend, EntityTrait, ExecResult, ExecResultHolder, Iden, IdenStatic,
+    Iterable, ModelTrait, QueryResult, QueryResultRow, SelectA, SelectB, Statement,
 };
 use sea_query::{Value, ValueType, Values};
 use std::{collections::BTreeMap, sync::Arc};

src/database/mod.rs

@@ -71,19 +71,19 @@ impl Database {
 
         #[cfg(feature = "sqlx-mysql")]
         if DbBackend::MySql.is_prefix_of(&opt.url) {
-            return crate::SqlxMySqlConnector::connect(opt).await;
+            return crate::driver::SqlxMySqlConnector::connect(opt).await;
         }
         #[cfg(feature = "sqlx-postgres")]
         if DbBackend::Postgres.is_prefix_of(&opt.url) {
-            return crate::SqlxPostgresConnector::connect(opt).await;
+            return crate::driver::SqlxPostgresConnector::connect(opt).await;
         }
         #[cfg(feature = "sqlx-sqlite")]
         if DbBackend::Sqlite.is_prefix_of(&opt.url) {
-            return crate::SqlxSqliteConnector::connect(opt).await;
+            return crate::driver::SqlxSqliteConnector::connect(opt).await;
         }
         #[cfg(feature = "mock")]
-        if crate::MockDatabaseConnector::accepts(&opt.url) {
-            return crate::MockDatabaseConnector::connect(&opt.url).await;
+        if crate::driver::MockDatabaseConnector::accepts(&opt.url) {
+            return crate::driver::MockDatabaseConnector::connect(&opt.url).await;
         }
 
         Err(conn_err(format!(
@@ -101,19 +101,19 @@ impl Database {
     ) -> Result<DatabaseConnection, DbErr> {
         match db_type {
             DbBackend::MySql => {
-                return crate::ProxyDatabaseConnector::connect(
+                return crate::driver::ProxyDatabaseConnector::connect(
                     DbBackend::MySql,
                     proxy_func_arc.to_owned(),
                 );
             }
             DbBackend::Postgres => {
-                return crate::ProxyDatabaseConnector::connect(
+                return crate::driver::ProxyDatabaseConnector::connect(
                     DbBackend::Postgres,
                     proxy_func_arc.to_owned(),
                 );
             }
             DbBackend::Sqlite => {
-                return crate::ProxyDatabaseConnector::connect(
+                return crate::driver::ProxyDatabaseConnector::connect(
                     DbBackend::Sqlite,
                     proxy_func_arc.to_owned(),
                 );

src/database/stream/query.rs

@@ -89,14 +89,14 @@ impl
 #[cfg(feature = "mock")]
 impl
     From<(
-        Arc<crate::MockDatabaseConnection>,
+        Arc<crate::driver::MockDatabaseConnection>,
         Statement,
         Option<crate::metric::Callback>,
     )> for QueryStream
 {
     fn from(
         (conn, stmt, metric_callback): (
-            Arc<crate::MockDatabaseConnection>,
+            Arc<crate::driver::MockDatabaseConnection>,
             Statement,
             Option<crate::metric::Callback>,
         ),
@@ -108,14 +108,14 @@ impl
 #[cfg(feature = "proxy")]
 impl
     From<(
-        Arc<crate::ProxyDatabaseConnection>,
+        Arc<crate::driver::ProxyDatabaseConnection>,
         Statement,
         Option<crate::metric::Callback>,
     )> for QueryStream
 {
     fn from(
         (conn, stmt, metric_callback): (
-            Arc<crate::ProxyDatabaseConnection>,
+            Arc<crate::driver::ProxyDatabaseConnection>,
             Statement,
             Option<crate::metric::Callback>,
         ),

src/database/transaction.rs

@@ -1,10 +1,10 @@
+#[cfg(feature = "sqlx-dep")]
+use crate::driver::{sqlx_error_to_exec_err, sqlx_error_to_query_err};
 use crate::{
     debug_print, error::*, AccessMode, ConnectionTrait, DbBackend, DbErr, ExecResult,
     InnerConnection, IsolationLevel, QueryResult, Statement, StreamTrait, TransactionStream,
     TransactionTrait,
 };
-#[cfg(feature = "sqlx-dep")]
-use crate::{sqlx_error_to_exec_err, sqlx_error_to_query_err};
 use futures::lock::Mutex;
 #[cfg(feature = "sqlx-dep")]
 use sqlx::{pool::PoolConnection, TransactionManager};
@@ -81,7 +81,7 @@ impl DatabaseTransaction {
 
     #[cfg(feature = "mock")]
     pub(crate) async fn new_mock(
-        inner: Arc<crate::MockDatabaseConnection>,
+        inner: Arc<crate::driver::MockDatabaseConnection>,
         metric_callback: Option<crate::metric::Callback>,
     ) -> Result<DatabaseTransaction, DbErr> {
         let backend = inner.get_database_backend();
@@ -97,7 +97,7 @@ impl DatabaseTransaction {
 
     #[cfg(feature = "proxy")]
     pub(crate) async fn new_proxy(
-        inner: Arc<crate::ProxyDatabaseConnection>,
+        inner: Arc<crate::driver::ProxyDatabaseConnection>,
         metric_callback: Option<crate::metric::Callback>,
     ) -> Result<DatabaseTransaction, DbErr> {
         let backend = inner.get_database_backend();

src/driver/mock.rs

@@ -84,22 +84,24 @@ impl MockDatabaseConnector {
         }
 
         #[cfg(feature = "sqlx-mysql")]
-        if crate::SqlxMySqlConnector::accepts(string) {
+        if crate::driver::SqlxMySqlConnector::accepts(string) {
             return connect_mock_db!(DbBackend::MySql);
         }
         #[cfg(feature = "sqlx-postgres")]
-        if crate::SqlxPostgresConnector::accepts(string) {
+        if crate::driver::SqlxPostgresConnector::accepts(string) {
             return connect_mock_db!(DbBackend::Postgres);
         }
         #[cfg(feature = "sqlx-sqlite")]
-        if crate::SqlxSqliteConnector::accepts(string) {
+        if crate::driver::SqlxSqliteConnector::accepts(string) {
             return connect_mock_db!(DbBackend::Sqlite);
         }
         connect_mock_db!(DbBackend::Postgres)
     }
 }
 
 impl MockDatabaseConnection {
+    /// # Panics
+    ///
     /// Create a connection to the [MockDatabase]
     pub fn new<M: 'static>(m: M) -> Self
     where
@@ -116,6 +118,8 @@ impl MockDatabaseConnection {
         &self.mocker
     }
 
+    /// # Panics
+    ///
     /// Get the [DatabaseBackend](crate::DatabaseBackend) being used by the [MockDatabase]
     pub fn get_database_backend(&self) -> DbBackend {
         self.mocker

src/driver/sqlx_mysql.rs

@@ -36,6 +36,7 @@ impl std::fmt::Debug for SqlxMySqlPoolConnection {
 
 impl SqlxMySqlConnector {
     /// Check if the URI provided corresponds to `mysql://` for a MySQL database
+    #[cfg(feature = "mock")]
     pub fn accepts(string: &str) -> bool {
         string.starts_with("mysql://") && string.parse::<MySqlConnectOptions>().is_ok()
     }
@@ -65,16 +66,6 @@ impl SqlxMySqlConnector {
     }
 }
 
-impl SqlxMySqlConnector {
-    /// Instantiate a sqlx pool connection to a [DatabaseConnection]
-    pub fn from_sqlx_mysql_pool(pool: MySqlPool) -> DatabaseConnection {
-        DatabaseConnection::SqlxMySqlPoolConnection(SqlxMySqlPoolConnection {
-            pool,
-            metric_callback: None,
-        })
-    }
-}
-
 impl SqlxMySqlPoolConnection {
     /// Execute a [Statement] on a MySQL backend
     #[instrument(level = "trace")]

src/driver/sqlx_postgres.rs

@@ -36,6 +36,7 @@ impl std::fmt::Debug for SqlxPostgresPoolConnection {
 
 impl SqlxPostgresConnector {
     /// Check if the URI provided corresponds to `postgres://` for a PostgreSQL database
+    #[cfg(feature = "mock")]
     pub fn accepts(string: &str) -> bool {
         string.starts_with("postgres://") && string.parse::<PgConnectOptions>().is_ok()
     }
@@ -80,16 +81,6 @@ impl SqlxPostgresConnector {
     }
 }
 
-impl SqlxPostgresConnector {
-    /// Instantiate a sqlx pool connection to a [DatabaseConnection]
-    pub fn from_sqlx_postgres_pool(pool: PgPool) -> DatabaseConnection {
-        DatabaseConnection::SqlxPostgresPoolConnection(SqlxPostgresPoolConnection {
-            pool,
-            metric_callback: None,
-        })
-    }
-}
-
 impl SqlxPostgresPoolConnection {
     /// Execute a [Statement] on a PostgreSQL backend
     #[instrument(level = "trace")]

src/driver/sqlx_sqlite.rs

@@ -36,6 +36,7 @@ impl std::fmt::Debug for SqlxSqlitePoolConnection {
 
 impl SqlxSqliteConnector {
     /// Check if the URI provided corresponds to `sqlite:` for a SQLite database
+    #[cfg(feature = "mock")]
     pub fn accepts(string: &str) -> bool {
         string.starts_with("sqlite:") && string.parse::<SqliteConnectOptions>().is_ok()
     }
@@ -72,16 +73,6 @@ impl SqlxSqliteConnector {
     }
 }
 
-impl SqlxSqliteConnector {
-    /// Instantiate a sqlx pool connection to a [DatabaseConnection]
-    pub fn from_sqlx_sqlite_pool(pool: SqlitePool) -> DatabaseConnection {
-        DatabaseConnection::SqlxSqlitePoolConnection(SqlxSqlitePoolConnection {
-            pool,
-            metric_callback: None,
-        })
-    }
-}
-
 impl SqlxSqlitePoolConnection {
     /// Execute a [Statement] on a SQLite backend
     #[instrument(level = "trace")]

src/lib.rs

@@ -345,7 +345,6 @@ pub mod tests_cfg;
 mod util;
 
 pub use database::*;
-pub use driver::*;
 pub use entity::*;
 pub use error::*;
 pub use executor::*;

src/query/combine.rs

@@ -2,7 +2,6 @@ use crate::{
     ColumnTrait, EntityTrait, IdenStatic, Iterable, QueryTrait, Select, SelectTwo, SelectTwoMany,
 };
 use core::marker::PhantomData;
-pub use sea_query::JoinType;
 use sea_query::{Alias, ColumnRef, Iden, Order, SeaRc, SelectExpr, SelectStatement, SimpleExpr};
 
 macro_rules! select_def {

src/query/mod.rs

@@ -15,7 +15,6 @@ pub use combine::{SelectA, SelectB};
 pub use delete::*;
 pub use helper::*;
 pub use insert::*;
-pub use join::*;
 #[cfg(feature = "with-json")]
 pub use json::*;
 pub use loader::*;

src/query/select.rs

@@ -1,7 +1,6 @@
 use crate::{ColumnTrait, EntityTrait, Iterable, QueryFilter, QueryOrder, QuerySelect, QueryTrait};
 use core::fmt::Debug;
 use core::marker::PhantomData;
-pub use sea_query::JoinType;
 use sea_query::{Expr, IntoColumnRef, SelectStatement, SimpleExpr};
 
 /// Defines a structure to perform select operations