Crate sea_orm

source ·
Expand description


🐚 An async & dynamic ORM for Rust

crate docs build status


SeaORM is a relational ORM to help you build web services in Rust with the familiarity of dynamic languages.

Getting Started

GitHub stars If you like what we do, consider starring, commenting, sharing and contributing!

Discord Join our Discord server to chat with others in the SeaQL community!

Integration examples


  1. Async

    Relying on SQLx, SeaORM is a new library with async support from day 1.

  2. Dynamic

    Built upon SeaQuery, SeaORM allows you to build complex queries without ‘fighting the ORM’.

  3. Testable

    Use mock connections to write unit tests for your logic.

  4. Service Oriented

    Quickly build services that join, filter, sort and paginate data in APIs.

A quick taste of SeaORM


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

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

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

impl Related<super::fruit::Entity> for Entity {
    fn to() -> RelationDef {


// find all models
let cakes: Vec<cake::Model> = Cake::find().all(db).await?;

// find and filter
let chocolate: Vec<cake::Model> = Cake::find()

// 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>)> =


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()),

// insert one
let pear = pear.insert(db).await?;

// insert many
Fruit::insert_many([apple, pear]).exec(db).await?;


use sea_orm::sea_query::{Expr, Value};

let pear: Option<fruit::Model> = Fruit::find_by_id(1).one(db).await?;
let mut pear: fruit::ActiveModel = pear.unwrap().into(); = Set("Sweet pear".to_owned());

// update one
let pear: fruit::Model = pear.update(db).await?;

// update many: UPDATE "fruit" SET "cake_id" = NULL WHERE "fruit"."name" LIKE '%Apple%'
    .col_expr(fruit::Column::CakeId, Expr::value(Value::Int(None)))


let banana = fruit::ActiveModel {
    id: NotSet,
    name: Set("Banana".to_owned()),

// create, because primary key `id` is `NotSet`
let mut banana =; = Set("Banana Mongo".to_owned());

// update, because primary key `id` is `Set`
let banana =;


// delete one
let orange: Option<fruit::Model> = Fruit::find_by_id(1).one(db).await?;
let orange: fruit::Model = orange.unwrap();

// or simply
let orange: Option<fruit::Model> = Fruit::find_by_id(1).one(db).await?;
let orange: fruit::Model = orange.unwrap();

// delete many: DELETE FROM "fruit" WHERE "fruit"."name" LIKE 'Orange'

Learn More

  1. Design
  2. Architecture
  3. Release Model
  4. Change Log

Who’s using SeaORM?

The following products are powered by SeaORM:

A lightweight web security auditing toolkit

The enterprise ready webhooks service

A personal search engine

SeaORM is the foundation of:

For more projects, see Built with SeaORM.


Licensed under either of

at your option.


Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

SeaORM is a community driven project. We welcome you to participate, contribute and together help build Rust’s future.

A big shout out to our contributors:



A friend of Ferris, Terres the hermit crab is the official mascot of SeaORM. His hobby is collecting shells.




  • Module for the Entity type and operations
  • Error types for all database operations
  • Holds types and methods to perform metric collection
  • Holds types and methods to perform queries
  • Holds types that defines the schemas of an Entity




  • Access mode
  • The type of database backend for real world databases. This is enabled by feature flags as specified in the crate documentation
  • Handle a database connection depending on the backend enabled by the feature flags. This creates a database pool.
  • Isolation level
  • Defines errors for handling transaction failures
  • An error from trying to get a row from a Model
  • Value variants



Type Definitions

Derive Macros

  • A derive macro to implement sea_orm::ActiveEnum trait for enums.
  • The DeriveActiveModel derive macro will implement ActiveModelTrait for ActiveModel which provides setters and getters for all active values in the active model.
  • Models that a user can override
  • The DeriveColumn derive macro will implement [ColumnTrait] for Columns. It defines the identifier of each column by implementing Iden and IdenStatic. The EnumIter is also derived, allowing iteration over all enum variants.
  • Derive a column if column names are not in snake-case
  • Create an Entity
  • This derive macro is the ‘almighty’ macro which automatically generates Entity, Column, and PrimaryKey from a given Model.
  • Derive into an active model
  • The DeriveMigrationName derive macro will implement sea_orm_migration::MigrationName for a migration.
  • The DeriveModel derive macro will implement ModelTrait for Model, which provides setters and getters for all attributes in the mod It also implements FromQueryResult to convert a query result into the corresponding Model.
  • The DerivePrimaryKey derive macro will implement [PrimaryKeyToColumn] for PrimaryKey which defines tedious mappings between primary keys and columns. The [EnumIter] is also derived, allowing iteration over all enum variants.
  • The DeriveRelation derive macro will implement RelationTrait for Relation.
  • Creates a new type that iterates of the variants of an enum.
  • Convert a query result into the corresponding Model.