From 0a215f75ed075ae930da8faa700e3017a22527e8 Mon Sep 17 00:00:00 2001 From: Chris Tsang Date: Mon, 28 Jun 2021 02:10:46 +0800 Subject: [PATCH] Docs --- src/entity/model.rs | 5 +- src/lib.rs | 125 +++++++++++++++++++++++++++++++++++++++++++ src/query/join.rs | 7 ++- src/tests_cfg/mod.rs | 5 ++ 4 files changed, 138 insertions(+), 4 deletions(-) diff --git a/src/entity/model.rs b/src/entity/model.rs index 4419218a..6161538b 100644 --- a/src/entity/model.rs +++ b/src/entity/model.rs @@ -1,4 +1,4 @@ -use crate::{Select, EntityTrait, Related, QueryFilter, QueryResult, TypeErr}; +use crate::{EntityTrait, QueryFilter, QueryResult, Related, Select, TypeErr}; pub use sea_query::Value; use std::fmt::Debug; @@ -12,7 +12,8 @@ pub trait ModelTrait: Clone + Debug { fn find_related(&self, _: R) -> Select where R: EntityTrait, - Self::Entity: Related { + Self::Entity: Related, + { >::find_related().belongs_to(self) } } diff --git a/src/lib.rs b/src/lib.rs index 273479d1..dc7720ff 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,3 +1,128 @@ +//! # Select +//! ``` +//! # use sea_orm::{DbConn, entity::*, query::*, tests_cfg::*}; +//! # async fn function(db: &DbConn) -> Result<(), QueryErr> { +//! # +//! // find all models +//! let cakes: Vec = Cake::find().all(db).await?; +//! +//! // find and filter +//! let chocolate: Vec = Cake::find() +//! .filter(cake::Column::Name.contains("chocolate")) +//! .all(db) +//! .await?; +//! +//! // find one model +//! let cheese: Option = Cake::find_by_id(1).one(db).await?; +//! let cheese: cake::Model = cheese.unwrap(); +//! +//! // find related models (lazy) +//! let fruits: Vec = cheese.find_related(Fruit).all(db).await?; +//! +//! // find related models (eager) +//! let cake_with_fruits: Vec<(cake::Model, Vec)> = Cake::find() +//! .left_join_and_select_with(Fruit) +//! .all(db) +//! .await?; +//! +//! # Ok(()) +//! # } +//! ``` +//! # Insert +//! ``` +//! # use sea_orm::{DbConn, entity::*, query::*, tests_cfg::*}; +//! # async fn function(db: &DbConn) -> Result<(), ExecErr> { +//! # +//! let apple = fruit::ActiveModel { +//! name: Set("Apple".to_owned()), +//! ..Default::default() // no need to set primary key +//! }; +//! +//! let pear = fruit::ActiveModel { +//! name: Set("Pear".to_owned()), +//! ..Default::default() +//! }; +//! +//! // insert one +//! let res: InsertResult = Fruit::insert(pear).exec(db).await?; +//! +//! println!("InsertResult: {}", res.last_insert_id); +//! # +//! # Ok(()) +//! # } +//! # +//! # async fn function2(db: &DbConn) -> Result<(), ExecErr> { +//! # let apple = fruit::ActiveModel { +//! # name: Set("Apple".to_owned()), +//! # ..Default::default() // no need to set primary key +//! # }; +//! # +//! # let pear = fruit::ActiveModel { +//! # name: Set("Pear".to_owned()), +//! # ..Default::default() +//! # }; +//! +//! // insert many +//! Fruit::insert_many(vec![apple, pear]).exec(db).await?; +//! # +//! # Ok(()) +//! # } +//! ``` +//! # Update +//! ``` +//! # use sea_orm::{DbConn, entity::*, query::*, tests_cfg::*}; +//! # +//! use sea_orm::sea_query::{Expr, Value}; +//! +//! # async fn function(db: &DbConn) -> Result<(), QueryErr> { +//! let pear: Option = Fruit::find_by_id(1).one(db).await?; +//! # Ok(()) +//! # } +//! # +//! # async fn function2(db: &DbConn) -> Result<(), ExecErr> { +//! # let pear: Option = Fruit::find_by_id(1).one(db).await.unwrap(); +//! +//! let mut pear: fruit::ActiveModel = pear.unwrap().into(); +//! pear.name = Set("Sweet pear".to_owned()); +//! +//! // update one +//! let pear: fruit::ActiveModel = Fruit::update(pear).exec(db).await?; +//! +//! // update many: UPDATE "fruit" SET "cake_id" = NULL WHERE "fruit"."name" LIKE '%Apple%' +//! Fruit::update_many() +//! .col_expr(fruit::Column::CakeId, Expr::value(Value::Null)) +//! .filter(fruit::Column::Name.contains("Apple")) +//! .exec(db) +//! .await?; +//! +//! # Ok(()) +//! # } +//! ``` +//! # Delete +//! ``` +//! # use sea_orm::{DbConn, entity::*, query::*, tests_cfg::*}; +//! # +//! # async fn function(db: &DbConn) -> Result<(), QueryErr> { +//! let orange: Option = Fruit::find_by_id(1).one(db).await?; +//! # Ok(()) +//! # } +//! # +//! # async fn function2(db: &DbConn) -> Result<(), ExecErr> { +//! # let orange: Option = Fruit::find_by_id(1).one(db).await.unwrap(); +//! let orange: fruit::ActiveModel = orange.unwrap().into(); +//! +//! // delete one +//! fruit::Entity::delete(orange).exec(db).await?; +//! +//! // delete many: DELETE FROM "fruit" WHERE "fruit"."name" LIKE 'Orange' +//! fruit::Entity::delete_many() +//! .filter(fruit::Column::Name.contains("Orange")) +//! .exec(db) +//! .await?; +//! +//! # Ok(()) +//! # } +//! ``` mod database; mod driver; pub mod entity; diff --git a/src/query/join.rs b/src/query/join.rs index f15dcfe6..e3dc6dfb 100644 --- a/src/query/join.rs +++ b/src/query/join.rs @@ -62,7 +62,7 @@ where #[cfg(test)] mod tests { use crate::tests_cfg::{cake, filling, fruit}; - use crate::{ColumnTrait, EntityTrait, QueryFilter, QueryTrait, ModelTrait}; + use crate::{ColumnTrait, EntityTrait, ModelTrait, QueryFilter, QueryTrait}; use sea_query::MysqlQueryBuilder; #[test] @@ -139,7 +139,10 @@ mod tests { }; assert_eq!( - cake_model.find_related(fruit::Entity).build(MysqlQueryBuilder).to_string(), + cake_model + .find_related(fruit::Entity) + .build(MysqlQueryBuilder) + .to_string(), [ "SELECT `fruit`.`id`, `fruit`.`name`, `fruit`.`cake_id` FROM `fruit`", "INNER JOIN `cake` ON `cake`.`id` = `fruit`.`cake_id`", diff --git a/src/tests_cfg/mod.rs b/src/tests_cfg/mod.rs index e39a16f3..ca9b8a68 100644 --- a/src/tests_cfg/mod.rs +++ b/src/tests_cfg/mod.rs @@ -4,3 +4,8 @@ pub mod cake; pub mod cake_filling; pub mod filling; pub mod fruit; + +pub use cake::Entity as Cake; +pub use cake_filling::Entity as CakeFilling; +pub use filling::Entity as Filling; +pub use fruit::Entity as Fruit;