cargo fmt

sea-orm-codegen/src/entity/writer.rs

@@ -116,9 +116,7 @@ impl EntityWriter {
             Self::gen_impl_relation_trait(entity),
         ];
         code_blocks.extend(Self::gen_impl_related(entity));
-        code_blocks.extend(vec![
-            Self::gen_impl_active_model_behavior(),
-        ]);
+        code_blocks.extend(vec![Self::gen_impl_active_model_behavior()]);
         code_blocks
     }
 

src/database/mock.rs

@@ -79,11 +79,7 @@ impl MockDatabaseTrait for MockDatabase {
         }
     }
 
-    fn query(
-        &mut self,
-        counter: usize,
-        statement: Statement,
-    ) -> Result<Vec<QueryResult>, DbErr> {
+    fn query(&mut self, counter: usize, statement: Statement) -> Result<Vec<QueryResult>, DbErr> {
         self.transaction_log.push(Transaction::one(statement));
         if counter < self.query_results.len() {
             Ok(std::mem::take(&mut self.query_results[counter])

src/database/mod.rs

@@ -29,6 +29,9 @@ impl Database {
         if crate::MockDatabaseConnector::accepts(string) {
             return crate::MockDatabaseConnector::connect(string).await;
         }
-        Err(DbErr::Conn(format!("The connection string '{}' has no supporting driver.", string)))
+        Err(DbErr::Conn(format!(
+            "The connection string '{}' has no supporting driver.",
+            string
+        )))
     }
 }

src/driver/sqlx_mysql.rs

@@ -49,7 +49,9 @@ impl SqlxMySqlPoolConnection {
                 Err(err) => Err(sqlx_error_to_exec_err(err)),
             }
         } else {
-            Err(DbErr::Exec("Failed to acquire connection from pool.".to_owned()))
+            Err(DbErr::Exec(
+                "Failed to acquire connection from pool.".to_owned(),
+            ))
         }
     }
 
@@ -66,7 +68,9 @@ impl SqlxMySqlPoolConnection {
                 },
             }
         } else {
-            Err(DbErr::Query("Failed to acquire connection from pool.".to_owned()))
+            Err(DbErr::Query(
+                "Failed to acquire connection from pool.".to_owned(),
+            ))
         }
     }
 
@@ -80,7 +84,9 @@ impl SqlxMySqlPoolConnection {
                 Err(err) => Err(sqlx_error_to_query_err(err)),
             }
         } else {
-            Err(DbErr::Query("Failed to acquire connection from pool.".to_owned()))
+            Err(DbErr::Query(
+                "Failed to acquire connection from pool.".to_owned(),
+            ))
         }
     }
 }

src/driver/sqlx_sqlite.rs

@@ -49,7 +49,9 @@ impl SqlxSqlitePoolConnection {
                 Err(err) => Err(sqlx_error_to_exec_err(err)),
             }
         } else {
-            Err(DbErr::Exec("Failed to acquire connection from pool.".to_owned()))
+            Err(DbErr::Exec(
+                "Failed to acquire connection from pool.".to_owned(),
+            ))
         }
     }
 
@@ -66,7 +68,9 @@ impl SqlxSqlitePoolConnection {
                 },
             }
         } else {
-            Err(DbErr::Query("Failed to acquire connection from pool.".to_owned()))
+            Err(DbErr::Query(
+                "Failed to acquire connection from pool.".to_owned(),
+            ))
         }
     }
 
@@ -80,7 +84,9 @@ impl SqlxSqlitePoolConnection {
                 Err(err) => Err(sqlx_error_to_query_err(err)),
             }
         } else {
-            Err(DbErr::Query("Failed to acquire connection from pool.".to_owned()))
+            Err(DbErr::Query(
+                "Failed to acquire connection from pool.".to_owned(),
+            ))
         }
     }
 }

src/entity/active_model.rs

@@ -227,7 +227,11 @@ where
         let model: Option<E::Model> = found?;
         match model {
             Some(model) => Ok(model.into_active_model()),
-            None => Err(DbErr::Exec(format!("Failed to find inserted item: {} {}", E::default().to_string(), res.last_insert_id))),
+            None => Err(DbErr::Exec(format!(
+                "Failed to find inserted item: {} {}",
+                E::default().to_string(),
+                res.last_insert_id
+            ))),
         }
     } else {
         Ok(A::default())

src/entity/model.rs

@@ -1,4 +1,4 @@
-use crate::{EntityTrait, DbErr, QueryFilter, QueryResult, Related, Select};
+use crate::{DbErr, EntityTrait, QueryFilter, QueryResult, Related, Select};
 pub use sea_query::Value;
 use std::fmt::Debug;
 

src/executor/delete.rs

@@ -62,10 +62,7 @@ async fn exec_delete_only(
 }
 
 // Only Statement impl Send
-async fn exec_delete(
-    statement: Statement,
-    db: &DatabaseConnection,
-) -> Result<DeleteResult, DbErr> {
+async fn exec_delete(statement: Statement, db: &DatabaseConnection) -> Result<DeleteResult, DbErr> {
     let result = db.execute(statement).await?;
     Ok(DeleteResult {
         rows_affected: result.rows_affected(),

src/executor/insert.rs

@@ -40,10 +40,7 @@ impl Inserter {
 }
 
 // Only Statement impl Send
-async fn exec_insert(
-    statement: Statement,
-    db: &DatabaseConnection,
-) -> Result<InsertResult, DbErr> {
+async fn exec_insert(statement: Statement, db: &DatabaseConnection) -> Result<InsertResult, DbErr> {
     let result = db.execute(statement).await?;
     // TODO: Postgres instead use query_one + returning clause
     Ok(InsertResult {

src/executor/query.rs

@@ -56,12 +56,14 @@ macro_rules! try_getable_all {
                     #[cfg(feature = "sqlx-mysql")]
                     QueryResultRow::SqlxMySql(row) => {
                         use sqlx::Row;
-                        row.try_get(column.as_str()).map_err(crate::sqlx_error_to_query_err)
+                        row.try_get(column.as_str())
+                            .map_err(crate::sqlx_error_to_query_err)
                     }
                     #[cfg(feature = "sqlx-sqlite")]
                     QueryResultRow::SqlxSqlite(row) => {
                         use sqlx::Row;
-                        row.try_get(column.as_str()).map_err(crate::sqlx_error_to_query_err)
+                        row.try_get(column.as_str())
+                            .map_err(crate::sqlx_error_to_query_err)
                     }
                     #[cfg(feature = "mock")]
                     QueryResultRow::Mock(row) => Ok(row.try_get(column.as_str())?),
@@ -109,7 +111,8 @@ macro_rules! try_getable_mysql {
                     #[cfg(feature = "sqlx-mysql")]
                     QueryResultRow::SqlxMySql(row) => {
                         use sqlx::Row;
-                        row.try_get(column.as_str()).map_err(crate::sqlx_error_to_query_err)
+                        row.try_get(column.as_str())
+                            .map_err(crate::sqlx_error_to_query_err)
                     }
                     #[cfg(feature = "sqlx-sqlite")]
                     QueryResultRow::SqlxSqlite(_) => {
@@ -172,14 +175,18 @@ impl TryGetable for Decimal {
             #[cfg(feature = "sqlx-mysql")]
             QueryResultRow::SqlxMySql(row) => {
                 use sqlx::Row;
-                row.try_get(column.as_str()).map_err(crate::sqlx_error_to_query_err)
+                row.try_get(column.as_str())
+                    .map_err(crate::sqlx_error_to_query_err)
             }
             #[cfg(feature = "sqlx-sqlite")]
             QueryResultRow::SqlxSqlite(row) => {
                 use sqlx::Row;
-                let val: f64 = row.try_get(column.as_str()).map_err(crate::sqlx_error_to_query_err)?;
+                let val: f64 = row
+                    .try_get(column.as_str())
+                    .map_err(crate::sqlx_error_to_query_err)?;
                 use rust_decimal::prelude::FromPrimitive;
-                Decimal::from_f64(val).ok_or_else(|| DbErr::Query("Failed to convert f64 into Decimal".to_owned()))
+                Decimal::from_f64(val)
+                    .ok_or_else(|| DbErr::Query("Failed to convert f64 into Decimal".to_owned()))
             }
             #[cfg(feature = "mock")]
             QueryResultRow::Mock(row) => Ok(row.try_get(column.as_str())?),

src/executor/update.rs

@@ -18,10 +18,7 @@ impl<'a, A: 'a> UpdateOne<A>
 where
     A: ActiveModelTrait,
 {
-    pub fn exec(
-        self,
-        db: &'a DatabaseConnection,
-    ) -> impl Future<Output = Result<A, DbErr>> + 'a {
+    pub fn exec(self, db: &'a DatabaseConnection) -> impl Future<Output = Result<A, DbErr>> + 'a {
         // so that self is dropped before entering await
         exec_update_and_return_original(self.query, self.model, db)
     }
@@ -74,10 +71,7 @@ where
 }
 
 // Only Statement impl Send
-async fn exec_update(
-    statement: Statement,
-    db: &DatabaseConnection,
-) -> Result<UpdateResult, DbErr> {
+async fn exec_update(statement: Statement, db: &DatabaseConnection) -> Result<UpdateResult, DbErr> {
     let result = db.execute(statement).await?;
     Ok(UpdateResult {
         rows_affected: result.rows_affected(),

src/lib.rs

@@ -215,5 +215,5 @@ pub use sea_orm_macros::{
 };
 pub use sea_query;
 pub use sea_query::Iden;
-pub use strum::EnumIter;
 pub use strum;
+pub use strum::EnumIter;

src/query/json.rs

@@ -1,4 +1,4 @@
-use crate::{FromQueryResult, DbErr, QueryResult, QueryResultRow};
+use crate::{DbErr, FromQueryResult, QueryResult, QueryResultRow};
 use serde_json::Map;
 pub use serde_json::Value as JsonValue;
 

tests/schema/mod.rs

@@ -4,208 +4,208 @@ use sea_query::{ColumnDef, ForeignKey, ForeignKeyAction, Index, TableCreateState
 pub use super::bakery_chain::*;
 
 async fn create_table(db: &DbConn, stmt: &TableCreateStatement) -> Result<ExecResult, DbErr> {
-  let builder = db.get_schema_builder_backend();
-  db.execute(builder.build(stmt)).await
+    let builder = db.get_schema_builder_backend();
+    db.execute(builder.build(stmt)).await
 }
 
 pub async fn create_bakery_table(db: &DbConn) -> Result<ExecResult, DbErr> {
-  let stmt = sea_query::Table::create()
-    .table(bakery::Entity)
-    .if_not_exists()
-    .col(
-      ColumnDef::new(bakery::Column::Id)
-        .integer()
-        .not_null()
-        .auto_increment()
-        .primary_key(),
-    )
-    .col(ColumnDef::new(bakery::Column::Name).string())
-    .col(ColumnDef::new(bakery::Column::ProfitMargin).float())
-    .to_owned();
+    let stmt = sea_query::Table::create()
+        .table(bakery::Entity)
+        .if_not_exists()
+        .col(
+            ColumnDef::new(bakery::Column::Id)
+                .integer()
+                .not_null()
+                .auto_increment()
+                .primary_key(),
+        )
+        .col(ColumnDef::new(bakery::Column::Name).string())
+        .col(ColumnDef::new(bakery::Column::ProfitMargin).float())
+        .to_owned();
 
-  create_table(db, &stmt).await
+    create_table(db, &stmt).await
 }
 
 pub async fn create_baker_table(db: &DbConn) -> Result<ExecResult, DbErr> {
-  let stmt = sea_query::Table::create()
-    .table(baker::Entity)
-    .if_not_exists()
-    .col(
-      ColumnDef::new(baker::Column::Id)
-        .integer()
-        .not_null()
-        .auto_increment()
-        .primary_key(),
-    )
-    .col(ColumnDef::new(baker::Column::Name).string())
-    .col(ColumnDef::new(baker::Column::BakeryId).integer())
-    .foreign_key(
-      ForeignKey::create()
-        .name("FK_baker_bakery")
-        .from(baker::Entity, baker::Column::BakeryId)
-        .to(bakery::Entity, bakery::Column::Id)
-        .on_delete(ForeignKeyAction::Cascade)
-        .on_update(ForeignKeyAction::Cascade),
-    )
-    .to_owned();
+    let stmt = sea_query::Table::create()
+        .table(baker::Entity)
+        .if_not_exists()
+        .col(
+            ColumnDef::new(baker::Column::Id)
+                .integer()
+                .not_null()
+                .auto_increment()
+                .primary_key(),
+        )
+        .col(ColumnDef::new(baker::Column::Name).string())
+        .col(ColumnDef::new(baker::Column::BakeryId).integer())
+        .foreign_key(
+            ForeignKey::create()
+                .name("FK_baker_bakery")
+                .from(baker::Entity, baker::Column::BakeryId)
+                .to(bakery::Entity, bakery::Column::Id)
+                .on_delete(ForeignKeyAction::Cascade)
+                .on_update(ForeignKeyAction::Cascade),
+        )
+        .to_owned();
 
-  create_table(db, &stmt).await
+    create_table(db, &stmt).await
 }
 
 pub async fn create_customer_table(db: &DbConn) -> Result<ExecResult, DbErr> {
-  let stmt = sea_query::Table::create()
-    .table(customer::Entity)
-    .if_not_exists()
-    .col(
-      ColumnDef::new(customer::Column::Id)
-        .integer()
-        .not_null()
-        .auto_increment()
-        .primary_key(),
-    )
-    .col(ColumnDef::new(customer::Column::Name).string())
-    .col(ColumnDef::new(customer::Column::Notes).text())
-    .to_owned();
+    let stmt = sea_query::Table::create()
+        .table(customer::Entity)
+        .if_not_exists()
+        .col(
+            ColumnDef::new(customer::Column::Id)
+                .integer()
+                .not_null()
+                .auto_increment()
+                .primary_key(),
+        )
+        .col(ColumnDef::new(customer::Column::Name).string())
+        .col(ColumnDef::new(customer::Column::Notes).text())
+        .to_owned();
 
-  create_table(db, &stmt).await
+    create_table(db, &stmt).await
 }
 
 pub async fn create_order_table(db: &DbConn) -> Result<ExecResult, DbErr> {
-  let stmt = sea_query::Table::create()
-    .table(order::Entity)
-    .if_not_exists()
-    .col(
-      ColumnDef::new(order::Column::Id)
-        .integer()
-        .not_null()
-        .auto_increment()
-        .primary_key(),
-    )
-    .col(ColumnDef::new(order::Column::Total).float())
-    .col(ColumnDef::new(order::Column::BakeryId).integer().not_null())
-    .col(
-      ColumnDef::new(order::Column::CustomerId)
-        .integer()
-        .not_null(),
-    )
-    .col(
-      ColumnDef::new(order::Column::PlacedAt)
-        .date_time()
-        .not_null(),
-    )
-    .foreign_key(
-      ForeignKey::create()
-        .name("FK_order_bakery")
-        .from(order::Entity, order::Column::BakeryId)
-        .to(bakery::Entity, bakery::Column::Id)
-        .on_delete(ForeignKeyAction::Cascade)
-        .on_update(ForeignKeyAction::Cascade),
-    )
-    .foreign_key(
-      ForeignKey::create()
-        .name("FK_order_customer")
-        .from(order::Entity, order::Column::CustomerId)
-        .to(customer::Entity, customer::Column::Id)
-        .on_delete(ForeignKeyAction::Cascade)
-        .on_update(ForeignKeyAction::Cascade),
-    )
-    .to_owned();
+    let stmt = sea_query::Table::create()
+        .table(order::Entity)
+        .if_not_exists()
+        .col(
+            ColumnDef::new(order::Column::Id)
+                .integer()
+                .not_null()
+                .auto_increment()
+                .primary_key(),
+        )
+        .col(ColumnDef::new(order::Column::Total).float())
+        .col(ColumnDef::new(order::Column::BakeryId).integer().not_null())
+        .col(
+            ColumnDef::new(order::Column::CustomerId)
+                .integer()
+                .not_null(),
+        )
+        .col(
+            ColumnDef::new(order::Column::PlacedAt)
+                .date_time()
+                .not_null(),
+        )
+        .foreign_key(
+            ForeignKey::create()
+                .name("FK_order_bakery")
+                .from(order::Entity, order::Column::BakeryId)
+                .to(bakery::Entity, bakery::Column::Id)
+                .on_delete(ForeignKeyAction::Cascade)
+                .on_update(ForeignKeyAction::Cascade),
+        )
+        .foreign_key(
+            ForeignKey::create()
+                .name("FK_order_customer")
+                .from(order::Entity, order::Column::CustomerId)
+                .to(customer::Entity, customer::Column::Id)
+                .on_delete(ForeignKeyAction::Cascade)
+                .on_update(ForeignKeyAction::Cascade),
+        )
+        .to_owned();
 
-  create_table(db, &stmt).await
+    create_table(db, &stmt).await
 }
 
 pub async fn create_lineitem_table(db: &DbConn) -> Result<ExecResult, DbErr> {
-  let stmt = sea_query::Table::create()
-    .table(lineitem::Entity)
-    .if_not_exists()
-    .col(
-      ColumnDef::new(lineitem::Column::Id)
-        .integer()
-        .not_null()
-        .auto_increment()
-        .primary_key(),
-    )
-    .col(ColumnDef::new(lineitem::Column::Price).decimal())
-    .col(ColumnDef::new(lineitem::Column::Quantity).integer())
-    .col(
-      ColumnDef::new(lineitem::Column::OrderId)
-        .integer()
-        .not_null(),
-    )
-    .col(
-      ColumnDef::new(lineitem::Column::CakeId)
-        .integer()
-        .not_null(),
-    )
-    .foreign_key(
-      ForeignKey::create()
-        .name("FK_lineitem_order")
-        .from(lineitem::Entity, lineitem::Column::OrderId)
-        .to(order::Entity, order::Column::Id)
-        .on_delete(ForeignKeyAction::Cascade)
-        .on_update(ForeignKeyAction::Cascade),
-    )
-    .foreign_key(
-      ForeignKey::create()
-        .name("FK_lineitem_cake")
-        .from(lineitem::Entity, lineitem::Column::CakeId)
-        .to(cake::Entity, cake::Column::Id)
-        .on_delete(ForeignKeyAction::Cascade)
-        .on_update(ForeignKeyAction::Cascade),
-    )
-    .to_owned();
+    let stmt = sea_query::Table::create()
+        .table(lineitem::Entity)
+        .if_not_exists()
+        .col(
+            ColumnDef::new(lineitem::Column::Id)
+                .integer()
+                .not_null()
+                .auto_increment()
+                .primary_key(),
+        )
+        .col(ColumnDef::new(lineitem::Column::Price).decimal())
+        .col(ColumnDef::new(lineitem::Column::Quantity).integer())
+        .col(
+            ColumnDef::new(lineitem::Column::OrderId)
+                .integer()
+                .not_null(),
+        )
+        .col(
+            ColumnDef::new(lineitem::Column::CakeId)
+                .integer()
+                .not_null(),
+        )
+        .foreign_key(
+            ForeignKey::create()
+                .name("FK_lineitem_order")
+                .from(lineitem::Entity, lineitem::Column::OrderId)
+                .to(order::Entity, order::Column::Id)
+                .on_delete(ForeignKeyAction::Cascade)
+                .on_update(ForeignKeyAction::Cascade),
+        )
+        .foreign_key(
+            ForeignKey::create()
+                .name("FK_lineitem_cake")
+                .from(lineitem::Entity, lineitem::Column::CakeId)
+                .to(cake::Entity, cake::Column::Id)
+                .on_delete(ForeignKeyAction::Cascade)
+                .on_update(ForeignKeyAction::Cascade),
+        )
+        .to_owned();
 
-  create_table(db, &stmt).await
+    create_table(db, &stmt).await
 }
 
 pub async fn create_cakes_bakers_table(db: &DbConn) -> Result<ExecResult, DbErr> {
-  let stmt = sea_query::Table::create()
-    .table(cakes_bakers::Entity)
-    .if_not_exists()
-    .col(
-      ColumnDef::new(cakes_bakers::Column::CakeId)
-        .integer()
-        .not_null(),
-    )
-    .col(
-      ColumnDef::new(cakes_bakers::Column::BakerId)
-        .integer()
-        .not_null(),
-    )
-    .primary_key(
-      Index::create()
-        .col(cakes_bakers::Column::CakeId)
-        .col(cakes_bakers::Column::BakerId),
-    )
-    .to_owned();
+    let stmt = sea_query::Table::create()
+        .table(cakes_bakers::Entity)
+        .if_not_exists()
+        .col(
+            ColumnDef::new(cakes_bakers::Column::CakeId)
+                .integer()
+                .not_null(),
+        )
+        .col(
+            ColumnDef::new(cakes_bakers::Column::BakerId)
+                .integer()
+                .not_null(),
+        )
+        .primary_key(
+            Index::create()
+                .col(cakes_bakers::Column::CakeId)
+                .col(cakes_bakers::Column::BakerId),
+        )
+        .to_owned();
 
-  create_table(db, &stmt).await
+    create_table(db, &stmt).await
 }
 
 pub async fn create_cake_table(db: &DbConn) -> Result<ExecResult, DbErr> {
-  let stmt = sea_query::Table::create()
-    .table(cake::Entity)
-    .if_not_exists()
-    .col(
-      ColumnDef::new(cake::Column::Id)
-        .integer()
-        .not_null()
-        .auto_increment()
-        .primary_key(),
-    )
-    .col(ColumnDef::new(cake::Column::Name).string())
-    .col(ColumnDef::new(cake::Column::Price).float())
-    .col(ColumnDef::new(cake::Column::BakeryId).integer().not_null())
-    .foreign_key(
-      ForeignKey::create()
-        .name("FK_cake_bakery")
-        .from(cake::Entity, cake::Column::BakeryId)
-        .to(bakery::Entity, bakery::Column::Id)
-        .on_delete(ForeignKeyAction::Cascade)
-        .on_update(ForeignKeyAction::Cascade),
-    )
-    .col(ColumnDef::new(cake::Column::GlutenFree).boolean())
-    .to_owned();
+    let stmt = sea_query::Table::create()
+        .table(cake::Entity)
+        .if_not_exists()
+        .col(
+            ColumnDef::new(cake::Column::Id)
+                .integer()
+                .not_null()
+                .auto_increment()
+                .primary_key(),
+        )
+        .col(ColumnDef::new(cake::Column::Name).string())
+        .col(ColumnDef::new(cake::Column::Price).float())
+        .col(ColumnDef::new(cake::Column::BakeryId).integer().not_null())
+        .foreign_key(
+            ForeignKey::create()
+                .name("FK_cake_bakery")
+                .from(cake::Entity, cake::Column::BakeryId)
+                .to(bakery::Entity, bakery::Column::Id)
+                .on_delete(ForeignKeyAction::Cascade)
+                .on_update(ForeignKeyAction::Cascade),
+        )
+        .col(ColumnDef::new(cake::Column::GlutenFree).boolean())
+        .to_owned();
 
-  create_table(db, &stmt).await
+    create_table(db, &stmt).await
 }