Entity Structure

Let's look at a simple Cake entity.

use sea_orm::entity::prelude::*;

#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
#[sea_orm(table_name = "cake")]
pub struct Model {
    #[sea_orm(primary_key)]
    pub id: i32,
    pub name: String,
}

#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
pub enum Relation {
    #[sea_orm(has_many = "super::fruit::Entity")]
    Fruit,
}

impl ActiveModelBehavior for ActiveModel {}

Entity

The DeriveEntityModel macro does all the heavy lifting of defining an Entity with associating Model, Column and PrimaryKey.

Table Name

The table_name attribute specifies the corresponding table in the database. Optionally, you can also specify the database schema or database name by schema_name.

#[sea_orm(table_name = "cake", schema_name = "public")]
pub struct Model { ... }

Column

Column Name

All column names are assumed to be in snake-case. You can override the column name by specifying the column_name attribute.

#[sea_orm(column_name = "name")]
pub name: String

Column Type

The column type will be derived automatically with the following mapping:

For the mappings of Rust primitive data types.

Rust type	Database Type (ColumnType)
String	Char
String	String
i8	TinyInteger
u8	TinyUnsigned
i16	SmallInteger
u16	SmallUnsigned
i32	Integer
u32	Unsigned
i64	BigInteger
u64	BigUnsigned
f32	Float
f64	Double
bool	Boolean
Vec<u8>	Binary

For the mappings of Rust non-primitive data types. You can check entity/prelude.rs for all of the reexported types.

Rust type	Database Type (ColumnType)
Date: chrono::NaiveDate TimeDate: time::Date	Date
Time: chrono::NaiveTime TimeTime: time::Time	Time
DateTime: chrono::NaiveDateTime TimeDateTime: time::PrimitiveDateTime	DateTime
DateTimeLocal: chrono::DateTime<Local> DateTimeUtc: chrono::DateTime<Utc>	Timestamp
DateTimeWithTimeZone: chrono::DateTime<FixedOffset> TimeDateTimeWithTimeZone: time::OffsetDateTime	TimestampWithTimeZone
Uuid: uuid::Uuid	Uuid
Json: serde_json::Value	Json
Decimal: rust_decimal::Decimal	Decimal

You can override the default mappings between a Rust type and ColumnType by the column_type attribute.

#[sea_orm(column_type = "Text")]
pub name: String

Additional Properties

You can add additional properties default_value, unique, indexed and nullable to a column.

If you specified a custom column_type for an optional attribute, you must also specify nullable.

#[sea_orm(column_type = "Text", default_value = "Sam", unique, indexed, nullable)]
pub name: Option<String>

Ignore Attribute

If you want to ignore a particular model attribute such that it maps to no database column, you can use the ignore annotation.

#[sea_orm(ignore)]
pub ignore_me: String

Primary Key

Use the primary_key attribute to mark a column as the primary key.

#[sea_orm(primary_key)]
pub id: i32

Auto Increment

By default, auto_increment is implied for primary_key column. Override it by specifying false.

#[sea_orm(primary_key, auto_increment = false)]
pub id: i32

Composite Key

This is usually the case in junction tables, where a two-column tuple is used as the primary key. Simply annotate multiple columns to define a composite primary key. By default, auto_increment is false for composite key.

pub struct Model {
    #[sea_orm(primary_key)]
    pub cake_id: i32,
    #[sea_orm(primary_key)]
    pub fruit_id: i32,
}

Relation

The DeriveRelation macro is a simple wrapper to impl the RelationTrait.

#[derive(DeriveRelation)]
pub enum Relation {
    #[sea_orm(has_many = "super::fruit::Entity")]
    Fruit,
}

expands into

impl RelationTrait for Relation {
    fn def(&self) -> RelationDef {
        match self {
            Self::Fruit => Entity::has_many(super::fruit::Entity).into(),
        }
    }
}

Learn more about relations in the next section.