[opensourcedex]

sea-orm is a free, open source databases project written in Rust and released under Apache-2.0. It has 9,946 GitHub stars, 745 forks and 234 open issues, and was last pushed 3 days ago. On this registry it ranks #83 of 206 tracked projects in Databases, with 5 head-to-head comparisons available. It gained 38 stars over the last 30 tracked days.

What is sea-orm?

SeaORM is an Apache-2.0 relational ORM for the Rust ecosystem that maps relational databases onto typed Rust entities, and it is built for Rust developers creating web services and APIs that want structured, type-checked database access instead of hand-written query strings.

What it is

SeaORM lives in the Rust ecosystem and is distributed as the sea-orm crate on crates.io. It is a relational ORM: tables become Rust structs, columns become fields, and foreign keys become typed navigation properties. It models 1-1, 1-N, and M-N relationships, and also self-referential ones, at a high, conceptual level. The README describes it as a batteries-included ORM with filters, pagination, and nested queries, positioned to accelerate REST, GraphQL, and gRPC APIs. Backend support covers Postgres, MySQL, MariaDB, and SQLite, running on the tokio async runtime.

The concrete problem it solves is the manual work of talking to a relational database from Rust. Without an ORM, a service author writes SQL by hand and maps result rows onto structs, tracking column names, joins, and foreign keys separately from the type system. SeaORM replaces that with generated entity files and a query API. The sea-orm-cli tool generates entity modules from an existing database, and the README demonstrates the dense output produced with --entity-format dense, new in 2.0. Relationships declared on the entity, such as #[sea_orm(has_one)], #[sea_orm(has_many)], #[sea_orm(belongs_to)], and #[sea_orm(has_many, via = "post_tag")] for a junction table, drive the loader.

Key capabilities

  • Advanced relations covering 1-1, 1-N, M-N, and self-referential links, declared directly on entity structs.
  • Entity file generation from an existing database with sea-orm-cli, including the dense format enabled by --entity-format dense.
  • A Smart Entity Loader that uses a join for 1-1 relations and a data loader for 1-N relations, eliminating the N+1 problem during nested queries.
  • Query ergonomics such as .filter_by_id(42), shorthand for .filter(user::COLUMN.id.eq(42)), and .with(profile::Entity) for eager loading.
  • Filters, pagination, and nested queries aimed at building REST, GraphQL, and gRPC APIs.
  • Working integration examples for Actix, Axum, Rocket, Poem, Salvo, Tonic, jsonrpsee, and Loco, plus Seaography GraphQL examples.

Who uses it and how

  • Startups and enterprises building Rust web services, which the README cites as its production user base.
  • Teams provisioning at volume through crates.io, where the crate records more than 250k weekly downloads.
  • Loco applications, using the dedicated Loco example and the Loco REST Starter as a project template.
  • GraphQL and RPC services, demonstrated by the Seaography Bakery and Sakila examples, the Tonic gRPC example, and the jsonrpsee example.
  • Developers evaluating the library quickly, using the quickstart example designed to fit in a single file.

Getting started

Add the sea-orm crate from crates.io as a dependency, and use sea-orm-cli to generate entity files from an existing database. Documentation lives at sea-ql.org/SeaORM, with runnable integration examples and a single-file quickstart in the repository.

How it compares

Within the Rust data-access space, SeaORM sits alongside sqlx, which appears in the project's topic list; SeaORM offers a higher-level entity and relation model over the same database backends. Its developer experience is explicitly modelled on the popular ORMs of the Ruby, Python, and Node.js ecosystems, so developers arriving from those languages will find familiar concepts. No paid products are listed as being replaced here, so no licence or cost comparison is drawn.

When to use it โ€” and when not to

SeaORM is a library rather than a hosted service, so there is nothing to operate on its behalf, but a self-hoster still runs the underlying Postgres, MySQL, MariaDB, or SQLite database. Teams that want raw SQL control, or that work outside Rust, should not pick it. The project carries 234 open issues at the time of writing, and the README provided here stays high level, deferring most detail to external documentation.

project readme (upstream, from github) โ€” read inline
SeaORM

SeaORM is a powerful ORM for building web services in Rust

crate build status GitHub stars
Support us with a โญ !

๐Ÿš SeaORM

ไธญๆ–‡ๆ–‡ๆกฃ

Advanced Relations

Model complex relationships 1-1, 1-N, M-N, and even self-referential in a high-level, conceptual way.

Familiar Concepts

Inspired by popular ORMs in the Ruby, Python, and Node.js ecosystem, SeaORM offers a developer experience that feels instantly recognizable.

Feature Rich

SeaORM is a batteries-included ORM with filters, pagination, and nested queries to accelerate building REST, GraphQL, and gRPC APIs.

Production Ready

With 250k+ weekly downloads, SeaORM is production-ready, trusted by startups and enterprises worldwide.

Getting Started

Discord Join our Discord server to chat with others!

Integration examples:

If you want a simple, clean example that fits in a single file that demonstrates the best of SeaORM, you can try:

Let's have a quick walk through of the unique features of SeaORM.

Expressive Entity format

You don't have to write this by hand! Entity files can be generated from an existing database using sea-orm-cli, following is generated with --entity-format dense (new in 2.0).

mod user {
    use sea_orm::entity::prelude::*;

    #[sea_orm::model]
    #[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
    #[sea_orm(table_name = "user")]
    pub struct Model {
        #[sea_orm(primary_key)]
        pub id: i32,
        pub name: String,
        #[sea_orm(unique)]
        pub email: String,
        #[sea_orm(has_one)]
        pub profile: HasOne<super::profile::Entity>,
        #[sea_orm(has_many)]
        pub posts: HasMany<super::post::Entity>,
    }
}
mod post {
    use sea_orm::entity::prelude::*;

    #[sea_orm::model]
    #[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
    #[sea_orm(table_name = "post")]
    pub struct Model {
        #[sea_orm(primary_key)]
        pub id: i32,
        pub user_id: i32,
        pub title: String,
        #[sea_orm(belongs_to, from = "user_id", to = "id")]
        pub author: BelongsTo<super::user::Entity>,
        #[sea_orm(has_many, via = "post_tag")] // M-N relation with junction
        pub tags: HasMany<super::tag::Entity>,
    }
}

Smart Entity Loader

The Entity Loader intelligently uses join for 1-1 and data loader for 1-N relations, eliminating the N+1 problem even when performing nested queries.

// join paths:
// user -> profile
// user -> post
//         post -> post_tag -> tag
let smart_user = user::Entity::load()
    .filter_by_id(42) // shorthand for .filter(user::COLUMN.id.eq(42))
    .with(profile::Entity) // 1-1 uses join
    .with((post::Entity, tag::Entity)) // 1-N uses data loader
    .one(db)
    .await?
    .unwrap();

// 3 queries are executed under the hood:
// 1. SELECT FROM user JOIN profile WHERE id = $
// 2. SELECT FROM post WHERE user_id IN (..)
// 3. SELECT FROM tag JOIN post_tag WHERE post_id IN (..)

smart_user
    == user::ModelEx {
        id: 42,
        name: "Bob".into(),
        email: "bob@sea-ql.org".into(),
        profile: HasOne::loaded(Some(profile::ModelEx {
            picture: "image.jpg".into(),
        })),
        posts: HasMany::Loaded(vec![post::ModelEx {
            title: "Nice weather".into(),
            tags: HasMany::Loaded(vec![tag::ModelEx {
                tag: "sunny".into(),
            }]),
        }]),
    };

ActiveModel: nested persistence made simple

Persist an entire object graph: user, profile (1-1), posts (1-N), and tags (M-N) in a single operation using a fluent builder API. SeaORM automatically determines the dependencies and inserts or deletes objects in the correct order. This requires the SeaORM 2.0 dense entity format.

// this creates the nested object as shown above:
let user = user::ActiveModel::builder()
    .set_name("Bob")
    .set_email("bob@sea-ql.org")
    .set_profile(profile::ActiveModel::builder().set_picture("image.jpg"))
    .add_post(
        post::ActiveModel::builder()
            .set_title("Nice weather")
            .add_tag(tag::ActiveModel::builder().set_tag("sunny")),
    )
    .save(db)
    .await?;

Schema first or Entity first? Your choice

SeaORM provides a powerful migration system that lets you create tables, modify schemas, and seed data with ease.

With SeaORM 2.0, you also get a first-class Entity First Workflow: simply define new entities or add columns to existing ones, and SeaORM will automatically detect the changes and create the new tables, columns, unique keys, and foreign keys.

// SeaORM resolves foreign key dependencies and creates the tables in topological order.
// Requires the `entity-registry` and `schema-sync` feature flags.
db.get_schema_registry("my_crate::entity::*").sync(db).await;

Ergonomic Raw SQL

Let SeaORM handle 95% of your transactional queries. For the remaining cases that are too complex to express, SeaORM still offers convenient support for writing raw SQL.

let user = Item { name: "Bob" }; // nested parameter access
let ids = [2, 3, 4]; // expanded by the `..` operator

let user: Option<user::Model> = user::Entity::find()
    .from_raw_sql(raw_sql!(
        Sqlite,
        r#"SELECT "id", "name" FROM "user"
           WHERE "name" LIKE {user.name}
           AND "id" in ({..ids})
        "#
    ))
    .one(db)
    .await?;

Synchronous Support

sea-orm-sync provides the full SeaORM API without requiring an async runtime, making it ideal for lightweight CLI programs with SQLite.

See the quickstart example for usage.

Basics

Select

SeaORM models 1-N and M-N relationships at the Entity level, letting you traverse many-to-many links through a junction table in a single call.

// 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 fruit: Option<fruit::Model> = cheese.find_related(Fruit).one(db).await?;

// find related models (eager): for 1-1 relations
let cake_with_fruit: Vec<(cake::Model, Option<fruit::Model>)> =
    Cake::find().find_also_related(Fruit).all(db).await?;

// find related models (eager): works for both 1-N and M-N relations
let cake_with_fillings: Vec<(cake::Model, Vec<filling::Model>)> = Cake::find()
    .find_with_related(Filling) // for M-N relations, two joins are performed
    .all(db) // rows are automatically consolidated by left entity
    .await?;

Nested Select

Partial models prevent overfetching by letting you querying only the fields you need; it also makes writing deeply nested relational queries simple.

use sea_orm::DerivePartialModel;

#[derive(DerivePartialModel)]
#[sea_orm(entity = "cake::Entity")]
struct CakeWithFruit {
    id: i32,
    name: String,
    #[sea_orm(nested)]
    fruit: Option<fruit::Model>, // this can be a regular or another partial model
}

let cakes: Vec<CakeWithFruit> = Cake::find()
    .left_join(fruit::Entity) // no need to specify join condition
    .into_partial_model() // only the columns in the partial model will be selected
    .all(db)
    .await?;

Insert

SeaORM's ActiveModel lets you work directly with Rust data structures and persist them through a simple API. It's easy to insert large batches of rows from different data sources.

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: Active Record style
let apple = apple.insert(db).await?;
apple.id == 1;

// insert one: repository style
let result = Fruit::insert(apple).exec(db).await?;
result.last_insert_id == 1;

// insert many returning last insert id
let result = Fruit::insert_many([apple, pear]).exec(db).await?;
result.last_insert_id == Some(2);

Insert (advanced)

You can take advantage of database specific features to perform upsert and idempotent insert.

// insert many with returning (if supported by database)
let models: Vec<fruit::Model> = Fruit::insert_many([apple, pear])
    .exec_with_returning(db)
    .await?;
models[0]
    == fruit::Model {
        id: 1, // database assigned value
        name: "Apple".to_owned(),
        cake_id: None,
    };

// insert with ON CONFLICT on primary key do nothing, with MySQL specific polyfill
let result = Fruit::insert_many([apple, pear])
    .on_conflict_do_nothing()
    .exec(db)
    .await?;

matches!(result, TryInsertResult::Conflicted);

Update

ActiveModel avoids race conditions by updating only the fields you've changed, never overwriting untouched columns. You can also craft complex bulk update queries with a fluent query building API.

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

pear.name = Set("Sweet pear".to_owned()); // update value of a single field

// update one: only changed columns will be updated
let pear: fruit::Model = pear.update(db).await?;

// update many: UPDATE "fruit" SET "cake_id" = "cake_id" + 2
//               WHERE "fruit"."name" LIKE '%Apple%'
Fruit::update_many()
    .col_expr(fruit::COLUMN.cake_id, fruit::COLUMN.cake_id.add(2))
    .filter(fruit::COLUMN.name.contains("Apple"))
    .exec(db)
    .await?;

Save

You can perform "insert or update" operation with ActiveModel, making it easy to compose transactional operations.

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

// create, because primary key `id` is `NotSet`
let mut banana = banana.save(db).await?;

banana.id == Unchanged(2);
banana.name = Set("Banana Mongo".to_owned());

// update, because primary key `id` is present
let banana = banana.save(db).await?;

Delete

The same ActiveModel API consistent with insert and update.

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

// delete one: repository style
let orange = fruit::ActiveModel {
    id: Set(2),
    ..Default::default()
};
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?;

Raw SQL Query

The raw_sql! macro is like the format! macro but without the risk of SQL injection. It supports nested parameter interpolation, array and tuple expansion, and even repeating group, offering great flexibility in crafting complex queries.

#[derive(FromQueryResult)]
struct CakeWithBakery {
    name: String,
    #[sea_orm(nested)]
    bakery: Option<Bakery>,
}

#[derive(FromQueryResult)]
struct Bakery {
    #[sea_orm(alias = "bakery_name")]
    name: String,
}

let cake_ids = [2, 3, 4]; // expanded by the `..` operator

// can use many APIs with raw SQL, including nested select
let cake: Option<CakeWithBakery> = CakeWithBakery::find_by_statement(raw_sql!(
    Sqlite,
    r#"SELECT "cake"."name", "bakery"."name" AS "bakery_name"
       FROM "cake"
       LEFT JOIN "bakery" ON "cake"."bakery_id" = "bakery"."id"
       WHERE "cake"."id" IN ({..cake_ids})"#
))
.one(db)
.await?;

๐Ÿงญ Seaography: instant GraphQL API

Seaography is a GraphQL framework built for SeaORM. Seaography allows you to build GraphQL resolvers quickly. With just a few commands, you can launch a fullly-featured GraphQL server from SeaORM entities, complete with filter, pagination, relational queries and mutations!

Look at the Seaography Example to learn more.

๐Ÿ–ฅ๏ธ SeaORM Pro: Professional Admin Panel

SeaORM Pro is an admin panel solution allowing you to quickly and easily launch an admin panel for your application - frontend development skills not required, but certainly nice to have!

SeaORM Pro has been updated to support the latest features in SeaORM 2.0.

Features:

  • Full CRUD
  • Built on React + GraphQL
  • Built-in GraphQL resolver
  • Customize the UI with TOML config
  • Role Based Access Control (new in 2.0)

Read the Getting Started guide to learn more.

SQL Server Support

SQL Server for SeaORM offers the same SeaORM API for MSSQL. We ported all test cases and examples, complemented by MSSQL specific documentation. If you are building enterprise software, you can request commercial access. It is currently based on SeaORM 1.0, but we will offer free upgrade to existing users when SeaORM 2.0 is finalized.

Releases

SeaORM 2.0 has reached its release candidate phase. We'd love for you to try it out and help shape the final release by sharing your feedback.

SeaORM 2.0 is shaping up to be our most significant release yet - with a few breaking changes, plenty of enhancements, and a clear focus on developer experience.

If you make extensive use of SeaQuery, we recommend checking out our blog post on SeaQuery 1.0 release:

License

Licensed under either of

at your option.

Contribution

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.

We invite you to participate, contribute and together help build Rust's future.

A big shout out to our contributors!

Contributors

Who's using SeaORM?

Here is a short list of awesome open source software built with SeaORM. Feel free to submit yours!

Project GitHub Tagline
Zed GitHub stars A high-performance, multiplayer code editor
Servo GitHub stars The Servo Parallel Browser Engine Project
OpenObserve GitHub stars Open-source observability platform
RisingWave GitHub stars Stream processing and management platform
Warpgate GitHub stars Smart SSH bastion that works with any SSH client
LLDAP GitHub stars A light LDAP server for user management
Svix GitHub stars The enterprise ready webhooks service
Ryot GitHub stars The only self hosted tracker you will ever need
OctoBase GitHub stars A light-weight, scalable, offline collaborative data backend
System Initiative GitHub stars DevOps Automation Platform

Sponsorship

SeaQL.org is an independent open-source organization run by passionate developers. If you feel generous, a small donation via GitHub Sponsor will be greatly appreciated, and goes a long way towards sustaining the organization.

Silver Sponsors

We're grateful to our silver sponsors: Digital Ocean, for sponsoring our servers. And JetBrains, for sponsoring our IDE.

Mascot

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

Terres

๐Ÿฆ€ Rustacean Sticker Pack

The Rustacean Sticker Pack is the perfect way to express your passion for Rust. Our stickers are made with a premium water-resistant vinyl with a unique matte finish.

Sticker Pack Contents:

  • Logo of SeaQL projects: SeaQL, SeaORM, SeaQuery, Seaography
  • Mascots: Ferris the Crab x 3, Terres the Hermit Crab
  • The Rustacean wordmark

Support SeaQL and get a Sticker Pack! All proceeds contributes directly to the ongoing development of SeaQL projects.

Rustacean Sticker Pack by SeaQL

Frequently asked questions

Is sea-orm free to use?

sea-orm is open source under the Apache-2.0 licence. There is no licence fee and no seat count โ€” you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does sea-orm do?

๐Ÿš A powerful relational ORM for Rust

What is sea-orm written in?

sea-orm is primarily written in Rust. Its source is publicly available at https://github.com/SeaQL/sea-orm, and it has 9,946 GitHub stars.