🐚 A powerful relational ORM for Rust
Repo SeaQL/sea-orm, read from GitHub 1 h ago. SeaQL has not joined Take My Repo.
SeaQL/sea-orm is a public repo on GitHub by SeaQL. 🐚 A powerful relational ORM for Rust. It declares the Apache-2.0 license on GitHub. It is written mainly in Rust, has 9,981 stars and last changed on 2026-11-16. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-22.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
Support us with a ⭐ !
Model complex relationships 1-1, 1-N, M-N, and even self-referential in a high-level, conceptual way.
Inspired by popular ORMs in the Ruby, Python, and Node.js ecosystem, SeaORM offers a developer experience that feels instantly recognizable.
SeaORM is a batteries-included ORM with filters, pagination, and nested queries to accelerate building REST, GraphQL, and gRPC APIs.
With 250k+ weekly downloads, SeaORM is production-ready, trusted by startups and enterprises worldwide.
SeaORM's default features do not enable TLS. To select a TLS backend for SQLx, you need to add a SQLx dependency with the desired TLS feature.
For example, to use sqlx-postgres with tokio and AWS-LC:
[dependencies]
sea-orm = { version = "2", features = ["sqlx-postgres", "runtime-tokio"] }
sqlx = { version = "0.9", features = ["tls-rustls-aws-lc-rs"] }
When using sea-orm-cli as a dependency, its defaults enable runtime-tokio-native-tls. To select another TLS backend, you need to disable the default features:
[dependencies]
sea-orm-cli = { version = "2", default-features = false, features = [
"codegen",
"sqlx-postgres",
"runtime-tokio",
] }
sqlx = { version = "0.9", features = ["tls-rustls-aws-lc-rs"] }
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.
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>,
}
}
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(),
}]),
}]),
};
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?;
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;
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?;
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.
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?;
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?;
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);
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);
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?;
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?;
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?;
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 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 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:
Read the Getting Started guide to learn more.

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.
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:
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.
We invite you to participate, contribute and together help build Rust's future.
A big shout out to our contributors!
Here is a short list of awesome open source software built with SeaORM. Feel free to submit yours!
| Project | GitHub | Tagline |
|---|---|---|
| Zed | A high-performance, multiplayer code editor | |
| Servo | The Servo Parallel Browser Engine Project | |
| OpenObserve | Open-source observability platform | |
| RisingWave | Stream processing and management platform | |
| Warpgate | Smart SSH bastion that works with any SSH client | |
| LLDAP | A light LDAP server for user management | |
| Svix | The enterprise ready webhooks service | |
| Ryot | The only self hosted tracker you will ever need | |
| OctoBase | A light-weight, scalable, offline collaborative data backend | |
| System Initiative | DevOps Automation Platform |
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.
We're grateful to our silver sponsor: JetBrains, for sponsoring our IDE.
|
|
A friend of Ferris, Terres the hermit crab is the official mascot of SeaORM. His hobby is collecting shells.
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:
Support SeaQL and get a Sticker Pack! All proceeds contributes directly to the ongoing development of SeaQL projects.
SeaQL/sea-orm is a public repo on GitHub by SeaQL. 🐚 A powerful relational ORM for Rust.
It declares the Apache-2.0 license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-11-16. GitHub counts 226 open issues and pull requests. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
Java 面试 & 后端通用面试指南,覆盖计算机基础、数据库、分布式、高并发、系统设计与 AI 应用开发
Persistent Context Across Sessions for Every Agent – Captures everything your agent does during sessions, compresses it with AI, and injects relevant context back into future sessions. Works with Claude Code, OpenClaw, Codex, Gemini, Hermes, Copilot, OpenCode + More
The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.
Stop renting your intelligence. Own it with AnythingLLM. Everything you need for a powerful local-first agent experience

mall项目是一套电商系统,包括前台商城系统及后台管理系统,基于Spring Boot+MyBatis实现,采用Docker容器化部署。 前台商城系统包含首页门户、商品推荐、商品搜索、商品展示、购物车、订单流程、会员中心、客户服务、帮助中心等模块。 后台管理系统包含商品管理、订单管理、会员管理、促销管理、运营管理、内容管理、统计报表、财务管理、权限管理、设置等模块。
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/SeaQL/sea-ormTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.