caisin/sea-orm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cargo fmt

Browse Source
This commit is contained in:
Chris Tsang 2021-07-11 22:08:37 +08:00
parent 883bd1605d
commit 6ff5a32b7a
14 changed files with 230 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
sea-orm-codegen/src/entity/writer.rs
View File

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

6
src/database/mock.rs
View File

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

5
src/database/mod.rs
View File

@ -29,6 +29,9 @@ impl Database {
if crate::MockDatabaseConnector::accepts(string) { if crate::MockDatabaseConnector::accepts(string) {
return crate::MockDatabaseConnector::connect(string).await; 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
)))
} }
} }

12
src/driver/sqlx_mysql.rs
View File

@ -49,7 +49,9 @@ impl SqlxMySqlPoolConnection {
Err(err) => Err(sqlx_error_to_exec_err(err)), Err(err) => Err(sqlx_error_to_exec_err(err)),
} }
} else { } 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 { } 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)), Err(err) => Err(sqlx_error_to_query_err(err)),
} }
} else { } else {
Err(DbErr::Query("Failed to acquire connection from pool.".to_owned())) Err(DbErr::Query(
"Failed to acquire connection from pool.".to_owned(),
))
} }
} }
} }

12
src/driver/sqlx_sqlite.rs
View File

@ -49,7 +49,9 @@ impl SqlxSqlitePoolConnection {
Err(err) => Err(sqlx_error_to_exec_err(err)), Err(err) => Err(sqlx_error_to_exec_err(err)),
} }
} else { } 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 { } 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)), Err(err) => Err(sqlx_error_to_query_err(err)),
} }
} else { } else {
Err(DbErr::Query("Failed to acquire connection from pool.".to_owned())) Err(DbErr::Query(
"Failed to acquire connection from pool.".to_owned(),
))
} }
} }
} }

6
src/entity/active_model.rs
View File

@ -227,7 +227,11 @@ where
let model: Option<E::Model> = found?; let model: Option<E::Model> = found?;
match model { match model {
Some(model) => Ok(model.into_active_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 { } else {
Ok(A::default()) Ok(A::default())

2
src/entity/model.rs
View File

@ -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; pub use sea_query::Value;
use std::fmt::Debug; use std::fmt::Debug;

5
src/executor/delete.rs
View File

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

5
src/executor/insert.rs
View File

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

19
src/executor/query.rs
View File

@ -56,12 +56,14 @@ macro_rules! try_getable_all {
#[cfg(feature = "sqlx-mysql")] #[cfg(feature = "sqlx-mysql")]
QueryResultRow::SqlxMySql(row) => { QueryResultRow::SqlxMySql(row) => {
use sqlx::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")] #[cfg(feature = "sqlx-sqlite")]
QueryResultRow::SqlxSqlite(row) => { QueryResultRow::SqlxSqlite(row) => {
use sqlx::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")] #[cfg(feature = "mock")]
QueryResultRow::Mock(row) => Ok(row.try_get(column.as_str())?), QueryResultRow::Mock(row) => Ok(row.try_get(column.as_str())?),
@ -109,7 +111,8 @@ macro_rules! try_getable_mysql {
#[cfg(feature = "sqlx-mysql")] #[cfg(feature = "sqlx-mysql")]
QueryResultRow::SqlxMySql(row) => { QueryResultRow::SqlxMySql(row) => {
use sqlx::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")] #[cfg(feature = "sqlx-sqlite")]
QueryResultRow::SqlxSqlite(_) => { QueryResultRow::SqlxSqlite(_) => {
@ -172,14 +175,18 @@ impl TryGetable for Decimal {
#[cfg(feature = "sqlx-mysql")] #[cfg(feature = "sqlx-mysql")]
QueryResultRow::SqlxMySql(row) => { QueryResultRow::SqlxMySql(row) => {
use sqlx::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")] #[cfg(feature = "sqlx-sqlite")]
QueryResultRow::SqlxSqlite(row) => { QueryResultRow::SqlxSqlite(row) => {
use sqlx::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; 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")] #[cfg(feature = "mock")]
QueryResultRow::Mock(row) => Ok(row.try_get(column.as_str())?), QueryResultRow::Mock(row) => Ok(row.try_get(column.as_str())?),

10
src/executor/update.rs
View File

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

2
src/lib.rs
View File

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

2
src/query/json.rs
View File

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

352
tests/schema/mod.rs
View File

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