Trait sea_orm::entity::prelude::EntityTrait [−][src]
pub trait EntityTrait: EntityName {
type Model: ModelTrait<Entity = Self> + FromQueryResult;
type Column: ColumnTrait;
type Relation: RelationTrait;
type PrimaryKey: PrimaryKeyTrait + PrimaryKeyToColumn<Column = Self::Column>;
fn belongs_to<R>(related: R) -> RelationBuilder<Self, R>
where
R: EntityTrait,
{ ... }
fn has_one<R>(_: R) -> RelationBuilder<Self, R>
where
R: EntityTrait + Related<Self>,
{ ... }
fn has_many<R>(_: R) -> RelationBuilder<Self, R>
where
R: EntityTrait + Related<Self>,
{ ... }
fn find() -> Select<Self> { ... }
fn find_by_id(
values: <Self::PrimaryKey as PrimaryKeyTrait>::ValueType
) -> Select<Self> { ... }
fn insert<A>(model: A) -> Insert<A>
where
A: ActiveModelTrait<Entity = Self>,
{ ... }
fn insert_many<A, I>(models: I) -> Insert<A>
where
A: ActiveModelTrait<Entity = Self>,
I: IntoIterator<Item = A>,
{ ... }
fn update<A>(model: A) -> UpdateOne<A>
where
A: ActiveModelTrait<Entity = Self>,
{ ... }
fn update_many() -> UpdateMany<Self> { ... }
fn delete<A>(model: A) -> DeleteOne<A>
where
A: ActiveModelTrait<Entity = Self>,
{ ... }
fn delete_many() -> DeleteMany<Self> { ... }
}
Expand description
An Entity implementing EntityTrait
represents a table in a database.
This trait provides an API for you to inspect it’s properties
- Column (implemented
ColumnTrait
) - Relation (implemented
RelationTrait
) - Primary Key (implemented
PrimaryKeyTrait
andPrimaryKeyToColumn
)
This trait also provides an API for CRUD actions
- Select:
find
,find_*
- Insert:
insert
,insert_*
- Update:
update
,update_*
- Delete:
delete
,delete_*
Associated Types
type Model: ModelTrait<Entity = Self> + FromQueryResult
type Column: ColumnTrait
type Relation: RelationTrait
type PrimaryKey: PrimaryKeyTrait + PrimaryKeyToColumn<Column = Self::Column>
Provided methods
fn belongs_to<R>(related: R) -> RelationBuilder<Self, R> where
R: EntityTrait,
fn belongs_to<R>(related: R) -> RelationBuilder<Self, R> where
R: EntityTrait,
Check if the relation belongs to an Entity
fn has_one<R>(_: R) -> RelationBuilder<Self, R> where
R: EntityTrait + Related<Self>,
fn has_one<R>(_: R) -> RelationBuilder<Self, R> where
R: EntityTrait + Related<Self>,
Check if the entity has at least one relation
fn has_many<R>(_: R) -> RelationBuilder<Self, R> where
R: EntityTrait + Related<Self>,
fn has_many<R>(_: R) -> RelationBuilder<Self, R> where
R: EntityTrait + Related<Self>,
Check if the Entity has many relations
Construct select statement to find one / all models
- To select columns, join tables and group by expressions, see
QuerySelect
- To apply where conditions / filters, see
QueryFilter
- To apply order by expressions, see
QueryOrder
Example
use sea_orm::{entity::*, query::*, tests_cfg::cake};
assert_eq!(
cake::Entity::find().one(&db).await?,
Some(cake::Model {
id: 1,
name: "New York Cheese".to_owned(),
})
);
assert_eq!(
cake::Entity::find().all(&db).await?,
vec![
cake::Model {
id: 1,
name: "New York Cheese".to_owned(),
},
cake::Model {
id: 2,
name: "Chocolate Forest".to_owned(),
},
]
);
assert_eq!(
db.into_transaction_log(),
vec![
Transaction::from_sql_and_values(
DbBackend::Postgres,
r#"SELECT "cake"."id", "cake"."name" FROM "cake" LIMIT $1"#,
vec![1u64.into()]
),
Transaction::from_sql_and_values(
DbBackend::Postgres,
r#"SELECT "cake"."id", "cake"."name" FROM "cake""#,
vec![]
),
]
);
fn find_by_id(
values: <Self::PrimaryKey as PrimaryKeyTrait>::ValueType
) -> Select<Self>
fn find_by_id(
values: <Self::PrimaryKey as PrimaryKeyTrait>::ValueType
) -> Select<Self>
Find a model by primary key
Example
use sea_orm::{entity::*, query::*, tests_cfg::cake};
assert_eq!(
cake::Entity::find_by_id(11).all(&db).await?,
vec![cake::Model {
id: 11,
name: "Sponge Cake".to_owned(),
}]
);
assert_eq!(
db.into_transaction_log(),
vec![Transaction::from_sql_and_values(
DbBackend::Postgres,
r#"SELECT "cake"."id", "cake"."name" FROM "cake" WHERE "cake"."id" = $1"#,
vec![11i32.into()]
)]
);
Find by composite key
use sea_orm::{entity::*, query::*, tests_cfg::cake_filling};
assert_eq!(
cake_filling::Entity::find_by_id((2, 3)).all(&db).await?,
vec![cake_filling::Model {
cake_id: 2,
filling_id: 3,
}]
);
assert_eq!(
db.into_transaction_log(),
vec![Transaction::from_sql_and_values(
DbBackend::Postgres,
[
r#"SELECT "cake_filling"."cake_id", "cake_filling"."filling_id" FROM "cake_filling""#,
r#"WHERE "cake_filling"."cake_id" = $1 AND "cake_filling"."filling_id" = $2"#,
].join(" ").as_str(),
vec![2i32.into(), 3i32.into()]
)]);
fn insert<A>(model: A) -> Insert<A> where
A: ActiveModelTrait<Entity = Self>,
fn insert<A>(model: A) -> Insert<A> where
A: ActiveModelTrait<Entity = Self>,
Insert an model into database
Example (Postgres)
use sea_orm::{entity::*, query::*, tests_cfg::cake};
let apple = cake::ActiveModel {
name: Set("Apple Pie".to_owned()),
..Default::default()
};
let insert_result = cake::Entity::insert(apple).exec(&db).await?;
assert_eq!(dbg!(insert_result.last_insert_id), 15);
assert_eq!(
db.into_transaction_log(),
vec![Transaction::from_sql_and_values(
DbBackend::Postgres,
r#"INSERT INTO "cake" ("name") VALUES ($1) RETURNING "id""#,
vec!["Apple Pie".into()]
)]
);
Example (MySQL)
use sea_orm::{entity::*, query::*, tests_cfg::cake};
let apple = cake::ActiveModel {
name: Set("Apple Pie".to_owned()),
..Default::default()
};
let insert_result = cake::Entity::insert(apple).exec(&db).await?;
assert_eq!(insert_result.last_insert_id, 15);
assert_eq!(
db.into_transaction_log(),
vec![Transaction::from_sql_and_values(
DbBackend::MySql,
r#"INSERT INTO `cake` (`name`) VALUES (?)"#,
vec!["Apple Pie".into()]
)]
);
fn insert_many<A, I>(models: I) -> Insert<A> where
A: ActiveModelTrait<Entity = Self>,
I: IntoIterator<Item = A>,
fn insert_many<A, I>(models: I) -> Insert<A> where
A: ActiveModelTrait<Entity = Self>,
I: IntoIterator<Item = A>,
Insert many models into database
Example (Postgres)
use sea_orm::{entity::*, query::*, tests_cfg::cake};
let apple = cake::ActiveModel {
name: Set("Apple Pie".to_owned()),
..Default::default()
};
let orange = cake::ActiveModel {
name: Set("Orange Scone".to_owned()),
..Default::default()
};
let insert_result = cake::Entity::insert_many(vec![apple, orange])
.exec(&db)
.await?;
assert_eq!(insert_result.last_insert_id, 28);
assert_eq!(
db.into_transaction_log(),
vec![Transaction::from_sql_and_values(
DbBackend::Postgres,
r#"INSERT INTO "cake" ("name") VALUES ($1), ($2) RETURNING "id""#,
vec!["Apple Pie".into(), "Orange Scone".into()]
)]
);
Example (MySQL)
use sea_orm::{entity::*, query::*, tests_cfg::cake};
let apple = cake::ActiveModel {
name: Set("Apple Pie".to_owned()),
..Default::default()
};
let orange = cake::ActiveModel {
name: Set("Orange Scone".to_owned()),
..Default::default()
};
let insert_result = cake::Entity::insert_many(vec![apple, orange])
.exec(&db)
.await?;
assert_eq!(insert_result.last_insert_id, 28);
assert_eq!(
db.into_transaction_log(),
vec![Transaction::from_sql_and_values(
DbBackend::MySql,
r#"INSERT INTO `cake` (`name`) VALUES (?), (?)"#,
vec!["Apple Pie".into(), "Orange Scone".into()]
)]
);
fn update<A>(model: A) -> UpdateOne<A> where
A: ActiveModelTrait<Entity = Self>,
fn update<A>(model: A) -> UpdateOne<A> where
A: ActiveModelTrait<Entity = Self>,
Update an model in database
- To apply where conditions / filters, see
QueryFilter
Example (Postgres)
use sea_orm::{entity::*, query::*, tests_cfg::fruit};
let orange = fruit::ActiveModel {
id: Set(1),
name: Set("Orange".to_owned()),
..Default::default()
};
assert_eq!(
fruit::Entity::update(orange.clone())
.filter(fruit::Column::Name.contains("orange"))
.exec(&db)
.await?,
fruit::Model {
id: 1,
name: "Orange".to_owned(),
cake_id: None,
}
);
assert_eq!(
db.into_transaction_log(),
vec![Transaction::from_sql_and_values(
DbBackend::Postgres,
r#"UPDATE "fruit" SET "name" = $1 WHERE "fruit"."id" = $2 AND "fruit"."name" LIKE $3 RETURNING "id", "name", "cake_id""#,
vec!["Orange".into(), 1i32.into(), "%orange%".into()]
)]);
Example (MySQL)
use sea_orm::{entity::*, query::*, tests_cfg::fruit};
let orange = fruit::ActiveModel {
id: Set(1),
name: Set("Orange".to_owned()),
..Default::default()
};
assert_eq!(
fruit::Entity::update(orange.clone())
.filter(fruit::Column::Name.contains("orange"))
.exec(&db)
.await?,
fruit::Model {
id: 1,
name: "Orange".to_owned(),
cake_id: None,
}
);
assert_eq!(
db.into_transaction_log(),
vec![
Transaction::from_sql_and_values(
DbBackend::MySql,
r#"UPDATE `fruit` SET `name` = ? WHERE `fruit`.`id` = ? AND `fruit`.`name` LIKE ?"#,
vec!["Orange".into(), 1i32.into(), "%orange%".into()]
),
Transaction::from_sql_and_values(
DbBackend::MySql,
r#"SELECT `fruit`.`id`, `fruit`.`name`, `fruit`.`cake_id` FROM `fruit` WHERE `fruit`.`id` = ? LIMIT ?"#,
vec![1i32.into(), 1u64.into()]
)]);
fn update_many() -> UpdateMany<Self>
fn update_many() -> UpdateMany<Self>
Update many models in database
- To apply where conditions / filters, see
QueryFilter
Example
use sea_orm::{
entity::*,
query::*,
sea_query::{Expr, Value},
tests_cfg::fruit,
};
let update_result = fruit::Entity::update_many()
.col_expr(fruit::Column::CakeId, Expr::value(Value::Int(None)))
.filter(fruit::Column::Name.contains("Apple"))
.exec(&db)
.await?;
assert_eq!(update_result.rows_affected, 5);
assert_eq!(
db.into_transaction_log(),
vec![Transaction::from_sql_and_values(
DbBackend::Postgres,
r#"UPDATE "fruit" SET "cake_id" = $1 WHERE "fruit"."name" LIKE $2"#,
vec![Value::Int(None), "%Apple%".into()]
)]
);
fn delete<A>(model: A) -> DeleteOne<A> where
A: ActiveModelTrait<Entity = Self>,
fn delete<A>(model: A) -> DeleteOne<A> where
A: ActiveModelTrait<Entity = Self>,
Delete an model from database
- To apply where conditions / filters, see
QueryFilter
Example
use sea_orm::{entity::*, query::*, tests_cfg::fruit};
let orange = fruit::ActiveModel {
id: Set(3),
..Default::default()
};
let delete_result = fruit::Entity::delete(orange).exec(&db).await?;
assert_eq!(delete_result.rows_affected, 1);
assert_eq!(
db.into_transaction_log(),
vec![Transaction::from_sql_and_values(
DbBackend::Postgres,
r#"DELETE FROM "fruit" WHERE "fruit"."id" = $1"#,
vec![3i32.into()]
)]
);
fn delete_many() -> DeleteMany<Self>
fn delete_many() -> DeleteMany<Self>
Delete many models from database
- To apply where conditions / filters, see
QueryFilter
Example
use sea_orm::{entity::*, query::*, tests_cfg::fruit};
let delete_result = fruit::Entity::delete_many()
.filter(fruit::Column::Name.contains("Apple"))
.exec(&db)
.await?;
assert_eq!(delete_result.rows_affected, 5);
assert_eq!(
db.into_transaction_log(),
vec![Transaction::from_sql_and_values(
DbBackend::Postgres,
r#"DELETE FROM "fruit" WHERE "fruit"."name" LIKE $1"#,
vec!["%Apple%".into()]
)]
);