Try our Chrome extension
Easily add the current web-page from your browser directly into your changedetection.io tool, more great features coming soon!
Chrome Webstore
Changedetection.io needs your support!
You can help us by supporting changedetection.io on these platforms;
- Rate us at AlternativeTo.net
- Star us on GitHub
- Follow us at Twitter/X
- G2 Software reviews
- Check us out on LinkedIn
- And tell your friends and colleagues :)
The more popular changedetection.io is, the more time we can dedicate to adding amazing features!
Many thanks :)
changedetection.io team
Not yet seconds ago
False
Not yet seconds ago
Triggered text Ignored text Blocked text
20 hours ago
Skip to content
Navigation Menu
Sign in Appearance settings
* Platform
+ AI CODE CREATION
o GitHub Copilot Write better code with AI
o GitHub Copilot app Direct agents from issue to merge
o MCP Registry Integrate external tools
+ DEVELOPER WORKFLOWS
o Actions Automate any workflow
o Codespaces Instant dev environments
o Issues Plan and track work
o Code Review Manage code changes
o Code Quality Enforce quality at merge
+ APPLICATION SECURITY
o GitHub Advanced Security Find and fix vulnerabilities
o Code security Secure your code as you build
o Secret protection Stop leaks before they start
+ EXPLORE
o Why GitHub
o Documentation
o Blog
o Changelog
o Marketplace
View all features
* Solutions
+ BY COMPANY SIZE
o Enterprises
o Small and medium teams
o Startups
o Nonprofits
+ BY USE CASE
o App Modernization
o DevSecOps
o DevOps
o CI/CD
o View all use cases
+ BY INDUSTRY
o Healthcare
o Financial services
o Manufacturing
o Government
o View all industries
View all solutions
* Resources
+ EXPLORE BY TOPIC
o AI
o Software Development
o DevOps
o Security
o View all topics
+ EXPLORE BY TYPE
o Customer stories
o Events & webinars
o Ebooks & reports
o Business insights
o GitHub Skills
+ SUPPORT & SERVICES
o Documentation
o Customer support
o Community forum
o Trust center
o Partners
View all resources
* Open Source
+ COMMUNITY
o GitHub Sponsors Fund open source developers
+ PROGRAMS
o Security Lab
o Maintainer Community
o Accelerator
o GitHub Stars
o Archive Program
+ REPOSITORIES
o Topics
o Trending
o Collections
* Enterprise
+ ENTERPRISE SOLUTIONS
o Enterprise platform AI-powered developer platform
+ AVAILABLE ADD-ONS
o GitHub Advanced Security Enterprise-grade security features
o Copilot for Business Enterprise-grade AI features
o Premium Support Enterprise-grade 24/7 support
* Pricing
Type / to search
Sign in
Sign up Appearance settings
You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session. Dismiss alert
Uh oh!
There was an error while loading. Please reload this page.
SeaQL / sea-orm Public
* Uh oh!
There was an error while loading. Please reload this page.
* Notifications You must be signed in to change notification settings
* Fork 722
* Star 9.9k
* Code
* Issues 161
* Pull requests 63
* Discussions
* Actions
* Security and quality 0
* Insights
Additional navigation options
* Code
* Issues
* Pull requests
* Discussions
* Actions
* Security and quality
* Insights
master
Branches Tags
Go to file
Code
Open more actions menu
Folders and files
Name Name Last commit message Last commit date
Latest commit
History
3,722 Commits
3,722 Commits
.github .github
build-tools build-tools
changelog changelog
docs docs
examples examples
issues issues
sea-orm-arrow sea-orm-arrow
sea-orm-cli sea-orm-cli
sea-orm-codegen sea-orm-codegen
sea-orm-macros sea-orm-macros
sea-orm-migration sea-orm-migration
sea-orm-rocket sea-orm-rocket
sea-orm-sync sea-orm-sync
src src
tests tests
.gitattributes .gitattributes
.gitignore .gitignore
.rustfmt.toml .rustfmt.toml
.taplo.toml .taplo.toml
CHANGELOG.md CHANGELOG.md
CLAUDE.md CLAUDE.md
COMMUNITY.md COMMUNITY.md
CONTRIBUTING.md CONTRIBUTING.md
Cargo.toml Cargo.toml
DEVELOPMENT.md DEVELOPMENT.md
LICENSE-APACHE LICENSE-APACHE
LICENSE-MIT LICENSE-MIT
README-zh.md README-zh.md
README.md README.md
VERSIONS.md VERSIONS.md
View all files
Repository files navigation
*
* README
* Code of conduct
* Contributing
* Apache-2.0 license
* MIT license
More items
SeaORM is a powerful ORM for building web services in Rust
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
Join our Discord server to chat with others!
* Documentation
Integration examples:
* Actix Example
* Axum Example
* GraphQL Example
* jsonrpsee Example
* Loco Example / Loco REST Starter
* Poem Example
* Rocket Example / Rocket OpenAPI Example
* Salvo Example
* Tonic Example
* Seaography Example (Bakery) / Seaography Example (Sakila)
If you want a simple, clean example that fits in a single file that demonstrates the best of SeaORM, you can try:
* Quickstart
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.
* Change Log
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.
* A Sneak Peek at SeaORM 2.0
* SeaORM 2.0: A closer look
* Role Based Access Control in SeaORM 2.0
* Seaography 2.0: A Powerful and Extensible GraphQL Framework
* SeaORM 2.0: New Entity Format
* SeaORM 2.0: Entity First Workflow
* SeaORM 2.0: Strongly-Typed Column
* What's new in SeaORM Pro 2.0
* SeaORM 2.0: Nested ActiveModel
* A walk-through of SeaORM 2.0
* How we made SeaORM synchronous
* SeaORM 2.0 Migration Guide
* SeaORM now supports Arrow & Parquet
* SeaORM 2.0 with SQL Server Support
If you make extensive use of SeaQuery, we recommend checking out our blog post on SeaQuery 1.0 release:
* The road to SeaQuery 1.0
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?
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
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.
🦀 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.
About
🐚 A powerful relational ORM for Rust
www.sea-ql.org/SeaORM/
Topics
databasehacktoberfestlocomariadbmysqlormpostgresrustsqlsqlitesqlxtokio
Resources
Readme
Apache-2.0, MIT licenses found
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Custom properties
Stars
9.9k stars
Watchers
38 watching
Forks
722 forks
Report repository
Releases
Sponsor this project
Used by
Contributors
Languages
Footer
© 2026 GitHub, Inc.
Footer navigation
* Terms
* Privacy
* Security
* Status
* Community
* Docs
* Contact
* Manage cookies
* Do not share my personal information
You can’t perform that action at this time.
For now, Differences are performed on text, not graphically, only the latest screenshot is available.
Screenshot requires a Content Fetcher ( Sockpuppetbrowser, selenium, etc ) that supports screenshots.