sea-orm

🐚 An async & dynamic ORM for Rust

8,753

607

8,753

196

View on GitHub

Top Related Projects

diesel

13,520

A safe, extensible ORM and Query Builder for Rust

prisma

43,929

Next-generation ORM for Node.js & TypeScript | PostgreSQL, MySQL, MariaDB, SQL Server, SQLite, MongoDB and CockroachDB

sqlx

15,733

🧰 The Rust SQL Toolkit. An async, pure Rust SQL crate featuring compile-time checked queries without a DSL. Supports PostgreSQL, MySQL, and SQLite.

refinery

1,542

Powerful SQL migration toolkit for Rust.

Quick Overview

SeaORM is an async, dynamic, and lightweight Object-Relational Mapping (ORM) library for Rust. It provides a high-level abstraction for database operations, supporting multiple database backends and offering features like query building, migrations, and connection pooling.

Pros

Asynchronous by design, providing efficient database operations
Supports multiple database backends (MySQL, PostgreSQL, SQLite)
Offers both active record and data mapper patterns
Provides a powerful query builder and migration system

Cons

Learning curve for developers new to Rust or ORMs
Limited documentation compared to more established ORMs
May have performance overhead compared to raw SQL in some cases
Still relatively young, with potential for breaking changes in future versions

Code Examples

Defining an entity:

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

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

#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
pub enum Relation {}

impl ActiveModelBehavior for ActiveModel {}

Performing a simple query:

use sea_orm::{DatabaseConnection, EntityTrait};

async fn find_post_by_id(db: &DatabaseConnection, id: i32) -> Result<Option<post::Model>, DbErr> {
    post::Entity::find_by_id(id).one(db).await
}

Inserting a new record:

use sea_orm::{ActiveModelTrait, Set};

async fn create_post(db: &DatabaseConnection, title: &str, text: &str) -> Result<post::Model, DbErr> {
    let new_post = post::ActiveModel {
        title: Set(title.to_owned()),
        text: Set(text.to_owned()),
        ..Default::default()
    };
    new_post.insert(db).await
}

Getting Started

To start using SeaORM, add it to your Cargo.toml:

[dependencies]
sea-orm = { version = "0.12", features = [ "sqlx-postgres", "runtime-tokio-native-tls", "macros" ] }

Then, in your Rust code:

use sea_orm::{Database, DbErr};

#[tokio::main]
async fn main() -> Result<(), DbErr> {
    let db = Database::connect("postgres://username:password@localhost/database").await?;
    // Use the database connection for queries
    Ok(())
}

This sets up a basic connection to a PostgreSQL database. Adjust the connection string and features as needed for your specific database backend.

Competitor Comparisons

diesel

13,520

A safe, extensible ORM and Query Builder for Rust

Pros of Diesel

More mature and battle-tested, with a larger community and ecosystem
Offers compile-time checking of SQL queries, reducing runtime errors
Provides a powerful query builder with type-safe expressions

Cons of Diesel

Steeper learning curve due to its macro-heavy approach
Limited support for async operations, primarily focused on synchronous APIs
Requires manual schema definition and migration management

Code Comparison

Diesel query example:

let results = users
    .filter(published.eq(true))
    .limit(5)
    .load::<Post>(&mut conn)?;

Sea-ORM query example:

let results = Post::find()
    .filter(post::Column::Published.eq(true))
    .limit(5)
    .all(&db).await?;

Both Diesel and Sea-ORM are Rust ORMs for database operations. Diesel is more established and offers strong compile-time guarantees, while Sea-ORM provides a more familiar ActiveRecord-like API with built-in async support. Diesel's query syntax is more concise, but Sea-ORM's approach may be more intuitive for developers coming from other ORMs. The choice between them often depends on specific project requirements and developer preferences.

prisma

43,929

Next-generation ORM for Node.js & TypeScript | PostgreSQL, MySQL, MariaDB, SQL Server, SQLite, MongoDB and CockroachDB

Pros of Prisma

More mature and widely adopted, with a larger community and ecosystem
Supports multiple programming languages (JavaScript, TypeScript, Go)
Offers a powerful migration system and schema versioning

Cons of Prisma

Requires a separate schema file, which can lead to duplication
Less flexible for complex queries and raw SQL operations
Steeper learning curve for developers familiar with traditional ORMs

Code Comparison

Prisma:

const user = await prisma.user.create({
  data: {
    name: 'Alice',
    email: 'alice@example.com',
  },
})

Sea-ORM:

let user = User::insert(ActiveModel {
    name: Set("Alice".to_owned()),
    email: Set("alice@example.com".to_owned()),
    ..Default::default()
})
.exec(db)
.await?;

Both ORMs provide a clean and intuitive API for database operations. Prisma uses a more declarative approach, while Sea-ORM follows Rust's idiomatic patterns.

Sea-ORM is specifically designed for Rust, offering better integration with the language's features and ecosystem. It provides more fine-grained control over database operations and is generally more performant due to Rust's zero-cost abstractions.

Prisma, on the other hand, offers a more unified experience across different programming languages and has a larger set of features and integrations available out-of-the-box.

sqlx

15,733

🧰 The Rust SQL Toolkit. An async, pure Rust SQL crate featuring compile-time checked queries without a DSL. Supports PostgreSQL, MySQL, and SQLite.

Pros of sqlx

Lower-level API, offering more control and flexibility
Supports both synchronous and asynchronous operations
Lighter weight and potentially faster for simple queries

Cons of sqlx

Requires more manual work for complex queries and relationships
Less abstraction, which can lead to more boilerplate code
Limited ORM-like features compared to Sea-ORM

Code Comparison

sqlx:

let users = sqlx::query!("SELECT * FROM users WHERE active = ?", true)
    .fetch_all(&pool)
    .await?;

Sea-ORM:

let users = User::find()
    .filter(user::Column::Active.eq(true))
    .all(&db)
    .await?;

Summary

sqlx is a lower-level database library that provides more direct control over SQL queries and database operations. It's suitable for developers who prefer writing raw SQL and want fine-grained control over their database interactions.

Sea-ORM, on the other hand, is a full-featured ORM that provides a higher level of abstraction. It offers more convenience for complex queries and relationships but may have a steeper learning curve and potentially more overhead for simple operations.

The choice between the two depends on the project's requirements, the developer's preferences, and the complexity of the database interactions needed in the application.

rbatis

2,390

Compile Time Async Dynamic SQL ORM

Pros of rbatis

Written in Rust, offering better performance and memory safety
Supports multiple databases including MySQL, PostgreSQL, and SQLite
Provides both ORM and SQL builder functionalities

Cons of rbatis

Less mature ecosystem compared to Sea-ORM
Documentation may be less comprehensive or up-to-date
Smaller community and fewer third-party integrations

Code Comparison

rbatis:

#[crud_table]
#[derive(Clone, Debug)]
pub struct User {
    pub id: Option<u64>,
    pub name: Option<String>,
    pub age: Option<i32>,
}

let rb = Rbatis::new();
rb.link("mysql://localhost:3306/test").await?;
let user = User::select_by_column(&rb, "id", 1).await?;

Sea-ORM:

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

let db = Database::connect("mysql://localhost:3306/test").await?;
let user = Users::find_by_id(1).one(&db).await?;

Both ORMs provide similar functionality for defining models and querying databases. rbatis uses attributes like #[crud_table], while Sea-ORM uses #[sea_orm(...)]. The syntax for connecting to databases and performing queries is slightly different, but both aim to provide a type-safe and ergonomic API for database operations in Rust.

refinery

1,542

Powerful SQL migration toolkit for Rust.

Pros of refinery

Focused solely on database migrations, providing a lightweight and specialized solution
Supports both embedded and CLI-based migration management
Offers a simple and intuitive API for defining and running migrations

Cons of refinery

Limited to migration functionality, lacking ORM features
Smaller community and ecosystem compared to Sea-ORM
Less comprehensive documentation and fewer examples available

Code Comparison

refinery:

use refinery::embed_migrations;

embed_migrations!("./migrations");

fn main() {
    let mut conn = establish_connection();
    embedded_migrations::run(&mut conn).unwrap();
}

Sea-ORM:

use sea_orm_migration::prelude::*;

#[async_std::main]
async fn main() {
    let db = Database::connect("database_url").await?;
    Migrator::up(&db, None).await?;
}

Sea-ORM is a full-featured ORM with migration support, while refinery focuses exclusively on migrations. Sea-ORM offers a more comprehensive solution for database interactions, including entity management and query building. refinery, being more specialized, provides a simpler API for migration-specific tasks.

Sea-ORM has a larger community, more extensive documentation, and a wider range of features. However, refinery's lightweight nature may be preferable for projects that only require migration functionality without the overhead of a full ORM.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

SeaORM

ð An async & dynamic ORM for Rust

SeaORM

ä¸æææ¡£

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

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

Please help us with maintaining SeaORM by completing the SeaQL Community Survey 2025!

Join our Discord server to chat with other members of the SeaQL community!

Getting Started

Integration examples:

Features

Async

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

Built upon SeaQuery, SeaORM allows you to build complex dynamic queries.
Service Oriented

Quickly build services that join, filter, sort and paginate data in REST, GraphQL and gRPC APIs.
Production Ready

SeaORM is feature-rich, well-tested and used in production by companies and startups.

A quick taste of SeaORM

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

Entity

You don't have to write this by hand! Entity files can be generated from an existing database with sea-orm-cli.

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 Related<super::fruit::Entity> for Entity {
    fn to() -> RelationDef {
        Relation::Fruit.def()
    }
}

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 fruits: Vec<fruit::Model> = cheese.find_related(Fruit).all(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_fruits: Vec<(cake::Model, Vec<fruit::Model>)> = Cake::find()
    .find_with_related(Fruit) // 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 fruit::Column::CakeId;
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(CakeId, Expr::col(CakeId).add(Expr::val(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?;

Ergonomic Raw SQL

Let SeaORM handle 90% of all the transactional queries. When your query is too complex to express, SeaORM still offer convenience in writing raw SQL.

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.

let item = Item { id: 2 }; // nested parameter access

let cake: Option<cake::Model> = Cake::find()
    .from_raw_sql(raw_sql!(
        Sqlite,
        r#"SELECT "id", "name" FROM "cake" WHERE id = {item.id}"#
    ))
    .one(db)
    .await?;

#[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 will be 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
Custom GraphQL endpoints (new in 2.0)
Role Based Access Control (new in 2.0)

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 SeaORM's underlying query builder, we recommend checking out our blog post on SeaQuery 1.0 release:

The road to SeaQuery 1.0

It doesn't mean that SeaORM is 'done', we've designed an architecture to allow us to deliver new features without major breaking changes.

Change Log

License

Licensed under either of

Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

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!

Who's using SeaORM?

SeaORM is trusted by companies and startups for both internal tools and publicâfacing applications, thanks to its ergonomics and the familiarity it brings from dynamic languages. Built on async Rust, it combines high performance and a strong type system without sacrificing developer productivity.

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

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

Sponsorship

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

Gold Sponsors

QDX pioneers quantum dynamics-powered drug discovery, leveraging AI and supercomputing to accelerate molecular modeling. We're immensely grateful to QDX for sponsoring the development of SeaORM, the SQL toolkit that powers their data engineering workflows.

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.

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. Stick them on your laptop, notebook, or any gadget to show off your love for Rust!

Sticker Pack Contents:

Logo of SeaQL projects: SeaQL, SeaORM, SeaQuery, Seaography, FireDBG
Mascot of SeaQL: Terres the Hermit Crab
Mascot of Rust: Ferris the Crab
The Rustacean word

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

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

Top Related Projects

Quick Overview

Pros

Cons

Code Examples

Getting Started

Competitor Comparisons

Pros of Diesel

Cons of Diesel

Code Comparison

Pros of Prisma

Cons of Prisma

Code Comparison

Pros of sqlx

Cons of sqlx

Code Comparison

Summary

Pros of rbatis

Cons of rbatis

Code Comparison

Pros of refinery

Cons of refinery

Code Comparison

Convert designs to code with AI

README

SeaORM

ð An async & dynamic ORM for Rust

SeaORM

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

Getting Started

Features

A quick taste of SeaORM

Entity

Select

Nested Select

Insert

Insert (advanced)

Update

Save

Delete

Ergonomic Raw SQL

ð§­ Seaography: instant GraphQL API

ð¥ï¸ SeaORM Pro: Professional Admin Panel

SQL Server Support

Releases

License

Contribution

Who's using SeaORM?

Sponsorship

Gold Sponsors

Silver Sponsors

Mascot

Rustacean Sticker Pack ð¦

Top Related Projects

Convert designs to code with AI

ð An async & dynamic ORM for Rust

ð§ Seaography: instant GraphQL API

ð¥ï¸ SeaORM Pro: Professional Admin Panel

Rustacean Sticker Pack ð¦