Docs

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<R>(&self, _: R) -> Select<R>
     where
         R: EntityTrait,
-        Self::Entity: Related<R> {
+        Self::Entity: Related<R>,
+    {
         <Self::Entity as Related<R>>::find_related().belongs_to(self)
     }
 }

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::Model> = Cake::find().all(db).await?;
+//!
+//! // find and filter
+//! let chocolate: Vec<cake::Model> = Cake::find()
+//!     .filter(cake::Column::Name.contains("chocolate"))
+//!     .all(db)
+//!     .await?;
+//!
+//! // find one model
+//! let cheese: Option<cake::Model> = Cake::find_by_id(1).one(db).await?;
+//! let cheese: cake::Model = cheese.unwrap();
+//!
+//! // find related models (lazy)
+//! let fruits: Vec<fruit::Model> = cheese.find_related(Fruit).all(db).await?;
+//!
+//! // find related models (eager)
+//! let cake_with_fruits: Vec<(cake::Model, Vec<fruit::Model>)> = 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::Model> = Fruit::find_by_id(1).one(db).await?;
+//! # Ok(())
+//! # }
+//! #
+//! # async fn function2(db: &DbConn) -> Result<(), ExecErr> {
+//! # let pear: Option<fruit::Model> = 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::Model> = Fruit::find_by_id(1).one(db).await?;
+//! # Ok(())
+//! # }
+//! #
+//! # async fn function2(db: &DbConn) -> Result<(), ExecErr> {
+//! # let orange: Option<fruit::Model> = 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;

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`",

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;