🔱 A dynamic query builder for MySQL, Postgres and SQLite

[](https://crates.io/crates/sea-query) [](https://docs.rs/sea-query) [](https://github.com/SeaQL/sea-query/actions/workflows/rust.yml)

SeaQuery

SeaQuery is a query builder to help you construct dynamic SQL queries in Rust. You can construct expressions, queries and schema as abstract syntax trees using an ergonomic API. We support MySQL, Postgres and SQLite behind a common interface that aligns their behaviour where appropriate.

We provide integration for SQLx, postgres and rusqlite. See examples for usage.

SeaQuery is the foundation of SeaORM, an async & dynamic ORM for Rust.

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

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

Install

```toml

Cargo.toml

[dependencies] sea-query = "0" ```

SeaQuery is very lightweight, all dependencies are optional (except inherent).

Feature flags

Macro: derive attr

Async support: thread-safe (use Arc inplace of Rc)

SQL engine: backend-mysql, backend-postgres, backend-sqlite

Type support: with-chrono, with-time, with-json, with-rust_decimal, with-bigdecimal, with-uuid, with-ipnetwork, with-mac_address, postgres-array, postgres-interval

Usage

Table of Content

1. Basics

   1. Iden
   2. Expression
   3. Condition
   4. Statement Builders

2. Query Statement

   1. Query Select
   2. Query Insert
   3. Query Update
   4. Query Delete

3. Advanced

   1. Aggregate Functions
   2. Casting
   3. Custom Function

4. Schema Statement

   1. Table Create
   2. Table Alter
   3. Table Drop
   4. Table Rename
   5. Table Truncate
   6. Foreign Key Create
   7. Foreign Key Drop
   8. Index Create
   9. Index Drop

Motivation

Why would you want to use a dynamic query builder?

1. Parameter bindings

One of the headaches when using raw SQL is parameter binding. With SeaQuery you can:

rust assert_eq!( Query::select() .column(Glyph::Image) .from(Glyph::Table) .and_where(Expr::col(Glyph::Image).like("A")) .and_where(Expr::col(Glyph::Id).is_in([1, 2, 3])) .build(PostgresQueryBuilder), ( r#"SELECT "image" FROM "glyph" WHERE "image" LIKE $1 AND "id" IN ($2, $3, $4)"# .to_owned(), Values(vec![ Value::String(Some(Box::new("A".to_owned()))), Value::Int(Some(1)), Value::Int(Some(2)), Value::Int(Some(3)) ]) ) );

1. Dynamic query

You can construct the query at runtime based on user inputs:

rust Query::select() .column(Char::Character) .from(Char::Table) .conditions( // some runtime condition true, // if condition is true then add the following condition |q| { q.and_where(Expr::col(Char::Id).eq(1)); }, // otherwise leave it as is |q| {}, );

Iden

Iden is a trait for identifiers used in any query statement.

Commonly implemented by Enum where each Enum represents a table found in a database, and its variants include table name and column name.

[Iden::unquoted()] must be implemented to provide a mapping between Enum variants and its corresponding string value.

```rust use sea_query::*;

// For example Character table with column id, character, font_size... pub enum Character { Table, Id, FontId, FontSize, }

// Mapping between Enum variant and its corresponding string value impl Iden for Character { fn unquoted(&self, s: &mut dyn std::fmt::Write) { write!( s, "{}", match self { Self::Table => "character", Self::Id => "id", Self::FontId => "fontid", Self::FontSize => "fontsize", } ) .unwrap(); } } ```

If you're okay with running another procedural macro, you can activate the derive or attr feature on the crate to save you some boilerplate. For more usage information, look at the derive examples or the attribute examples.

```rust

[cfg(feature = "derive")]

use sea_query::Iden;

// This will implement Iden exactly as shown above

[derive(Iden)]

enum Character { Table, } asserteq!(Character::Table.tostring(), "character");

// You can also derive a unit struct

[derive(Iden)]

struct Glyph; asserteq!(Glyph.tostring(), "glyph"); ```

```rust

[cfg(feature = "attr")]

use seaquery::{enumdef, Iden};

[enum_def]

struct Character { pub foo: u64, }

// It generates the following along with Iden impl enum CharacterIden { Table, Foo, }

asserteq!(CharacterIden::Table.tostring(), "character"); asserteq!(CharacterIden::Foo.tostring(), "foo"); ```

Expression

Use [Expr] to construct select, join, where and having expression in query.

rust assert_eq!( Query::select() .column(Char::Character) .from(Char::Table) .and_where( Expr::expr(Expr::col(Char::SizeW).add(1)) .mul(2) .eq(Expr::expr(Expr::col(Char::SizeH).div(2)).sub(1)) ) .and_where( Expr::col(Char::SizeW).in_subquery( Query::select() .expr(Expr::cust_with_values("ln($1 ^ $2)", [2.4, 1.2])) .take() ) ) .and_where( Expr::col(Char::Character) .like("D") .and(Expr::col(Char::Character).like("E")) ) .to_string(PostgresQueryBuilder), [ r#"SELECT "character" FROM "character""#, r#"WHERE ("size_w" + 1) * 2 = ("size_h" / 2) - 1"#, r#"AND "size_w" IN (SELECT ln(2.4 ^ 1.2))"#, r#"AND (("character" LIKE 'D') AND ("character" LIKE 'E'))"#, ] .join(" ") );

Condition

If you have complex conditions to express, you can use the [Condition] builder, usable for [ConditionalStatement::cond_where] and [SelectStatement::cond_having].

rust assert_eq!( Query::select() .column(Glyph::Id) .from(Glyph::Table) .cond_where( Cond::any() .add( Cond::all() .add(Expr::col(Glyph::Aspect).is_null()) .add(Expr::col(Glyph::Image).is_null()) ) .add( Cond::all() .add(Expr::col(Glyph::Aspect).is_in([3, 4])) .add(Expr::col(Glyph::Image).like("A%")) ) ) .to_string(PostgresQueryBuilder), [ r#"SELECT "id" FROM "glyph""#, r#"WHERE"#, r#"("aspect" IS NULL AND "image" IS NULL)"#, r#"OR"#, r#"("aspect" IN (3, 4) AND "image" LIKE 'A%')"#, ] .join(" ") );

There is also the [any!] and [all!] macro at your convenience:

rust Query::select().cond_where(any![ Expr::col(Glyph::Aspect).is_in([3, 4]), all![ Expr::col(Glyph::Aspect).is_null(), Expr::col(Glyph::Image).like("A%") ] ]);

Statement Builders

Statements are divided into 2 categories: Query and Schema, and to be serialized into SQL with [QueryStatementBuilder] and [SchemaStatementBuilder] respectively.

Schema statement has the following interface:

rust fn build<T: SchemaBuilder>(&self, schema_builder: T) -> String;

Query statement has the following interfaces:

```rust fn build(&self, query_builder: T) -> (String, Values);

fn tostring(&self, querybuilder: T) -> String; ```

build builds a SQL statement as string and parameters to be passed to the database driver through the binary protocol. This is the preferred way as it has less overhead and is more secure.

to_string builds a SQL statement as string with parameters injected. This is good for testing and debugging.

Query Select

```rust let query = Query::select() .column(Char::Character) .column((Font::Table, Font::Name)) .from(Char::Table) .leftjoin(Font::Table, Expr::col((Char::Table, Char::FontId)).equals((Font::Table, Font::Id))) .andwhere(Expr::col(Char::SizeW).isin([3, 4])) .andwhere(Expr::col(Char::Character).like("A%")) .to_owned();

asserteq!( query.tostring(MysqlQueryBuilder), r#"SELECT character, font.name FROM character LEFT JOIN font ON character.font_id = font.id WHERE size_w IN (3, 4) AND character LIKE 'A%'"# ); asserteq!( query.tostring(PostgresQueryBuilder), r#"SELECT "character", "font"."name" FROM "character" LEFT JOIN "font" ON "character"."fontid" = "font"."id" WHERE "sizew" IN (3, 4) AND "character" LIKE 'A%'"# ); asserteq!( query.tostring(SqliteQueryBuilder), r#"SELECT "character", "font"."name" FROM "character" LEFT JOIN "font" ON "character"."fontid" = "font"."id" WHERE "sizew" IN (3, 4) AND "character" LIKE 'A%'"# ); ```

Query Insert

```rust let query = Query::insert() .intotable(Glyph::Table) .columns([Glyph::Aspect, Glyph::Image]) .valuespanic([5.15.into(), "12A".into()]) .valuespanic([4.21.into(), "123".into()]) .toowned();

asserteq!( query.tostring(MysqlQueryBuilder), r#"INSERT INTO glyph (aspect, image) VALUES (5.15, '12A'), (4.21, '123')"# ); asserteq!( query.tostring(PostgresQueryBuilder), r#"INSERT INTO "glyph" ("aspect", "image") VALUES (5.15, '12A'), (4.21, '123')"# ); asserteq!( query.tostring(SqliteQueryBuilder), r#"INSERT INTO "glyph" ("aspect", "image") VALUES (5.15, '12A'), (4.21, '123')"# ); ```

Query Update

```rust let query = Query::update() .table(Glyph::Table) .values([(Glyph::Aspect, 1.23.into()), (Glyph::Image, "123".into())]) .andwhere(Expr::col(Glyph::Id).eq(1)) .toowned();

asserteq!( query.tostring(MysqlQueryBuilder), r#"UPDATE glyph SET aspect = 1.23, image = '123' WHERE id = 1"# ); asserteq!( query.tostring(PostgresQueryBuilder), r#"UPDATE "glyph" SET "aspect" = 1.23, "image" = '123' WHERE "id" = 1"# ); asserteq!( query.tostring(SqliteQueryBuilder), r#"UPDATE "glyph" SET "aspect" = 1.23, "image" = '123' WHERE "id" = 1"# ); ```

Query Delete

```rust let query = Query::delete() .fromtable(Glyph::Table) .condwhere( Cond::any() .add(Expr::col(Glyph::Id).lt(1)) .add(Expr::col(Glyph::Id).gt(10)), ) .to_owned();

asserteq!( query.tostring(MysqlQueryBuilder), r#"DELETE FROM glyph WHERE id < 1 OR id > 10"# ); asserteq!( query.tostring(PostgresQueryBuilder), r#"DELETE FROM "glyph" WHERE "id" < 1 OR "id" > 10"# ); asserteq!( query.tostring(SqliteQueryBuilder), r#"DELETE FROM "glyph" WHERE "id" < 1 OR "id" > 10"# ); ```

Aggregate Functions

max, min, sum, avg, count etc

rust let query = Query::select() .expr(Func::sum(Expr::col((Char::Table, Char::SizeH)))) .from(Char::Table) .to_owned(); assert_eq!( query.to_string(MysqlQueryBuilder), r#"SELECT SUM(`character`.`size_h`) FROM `character`"# ); assert_eq!( query.to_string(PostgresQueryBuilder), r#"SELECT SUM("character"."size_h") FROM "character""# ); assert_eq!( query.to_string(SqliteQueryBuilder), r#"SELECT SUM("character"."size_h") FROM "character""# );

Casting

```rust let query = Query::select() .expr(Func::castas("hello", Alias::new("MyType"))) .toowned();

asserteq!( query.tostring(MysqlQueryBuilder), r#"SELECT CAST('hello' AS MyType)"# ); asserteq!( query.tostring(PostgresQueryBuilder), r#"SELECT CAST('hello' AS MyType)"# ); asserteq!( query.tostring(SqliteQueryBuilder), r#"SELECT CAST('hello' AS MyType)"# ); ```

Custom Function

```rust struct MyFunction;

impl Iden for MyFunction { fn unquoted(&self, s: &mut dyn Write) { write!(s, "MY_FUNCTION").unwrap(); } }

let query = Query::select() .expr(Func::cust(MyFunction).arg(Expr::val("hello"))) .to_owned();

asserteq!( query.tostring(MysqlQueryBuilder), r#"SELECT MYFUNCTION('hello')"# ); asserteq!( query.tostring(PostgresQueryBuilder), r#"SELECT MYFUNCTION('hello')"# ); asserteq!( query.tostring(SqliteQueryBuilder), r#"SELECT MY_FUNCTION('hello')"# ); ```

Table Create

```rust let table = Table::create() .table(Char::Table) .ifnotexists() .col(ColumnDef::new(Char::Id).integer().notnull().autoincrement().primarykey()) .col(ColumnDef::new(Char::FontSize).integer().notnull()) .col(ColumnDef::new(Char::Character).string().notnull()) .col(ColumnDef::new(Char::SizeW).integer().notnull()) .col(ColumnDef::new(Char::SizeH).integer().notnull()) .col(ColumnDef::new(Char::FontId).integer().default(Value::Int(None))) .foreignkey( ForeignKey::create() .name("FK2e303c3a712662f1fc2a4d0aad6") .from(Char::Table, Char::FontId) .to(Font::Table, Font::Id) .ondelete(ForeignKeyAction::Cascade) .onupdate(ForeignKeyAction::Cascade) ) .toowned();

asserteq!( table.tostring(MysqlQueryBuilder), [ r#"CREATE TABLE IF NOT EXISTS character ("#, r#"id int NOT NULL AUTOINCREMENT PRIMARY KEY,"#, r#"font_size int NOT NULL,"#, r#"character varchar(255) NOT NULL,"#, r#"size_w int NOT NULL,"#, r#"size_h int NOT NULL,"#, r#"font_id int DEFAULT NULL,"#, r#"CONSTRAINT FK_2e303c3a712662f1fc2a4d0aad6"#, r#"FOREIGN KEY (font_id) REFERENCES font (id)"#, r#"ON DELETE CASCADE ON UPDATE CASCADE"#, r#")"#, ].join(" ") ); asserteq!( table.tostring(PostgresQueryBuilder), [ r#"CREATE TABLE IF NOT EXISTS "character" ("#, r#""id" serial NOT NULL PRIMARY KEY,"#, r#""fontsize" integer NOT NULL,"#, r#""character" varchar NOT NULL,"#, r#""sizew" integer NOT NULL,"#, r#""sizeh" integer NOT NULL,"#, r#""fontid" integer DEFAULT NULL,"#, r#"CONSTRAINT "FK2e303c3a712662f1fc2a4d0aad6""#, r#"FOREIGN KEY ("fontid") REFERENCES "font" ("id")"#, r#"ON DELETE CASCADE ON UPDATE CASCADE"#, r#")"#, ].join(" ") ); asserteq!( table.tostring(SqliteQueryBuilder), [ r#"CREATE TABLE IF NOT EXISTS "character" ("#, r#""id" integer NOT NULL PRIMARY KEY AUTOINCREMENT,"#, r#""fontsize" integer NOT NULL,"#, r#""character" text NOT NULL,"#, r#""sizew" integer NOT NULL,"#, r#""sizeh" integer NOT NULL,"#, r#""fontid" integer DEFAULT NULL,"#, r#"FOREIGN KEY ("fontid") REFERENCES "font" ("id") ON DELETE CASCADE ON UPDATE CASCADE"#, r#")"#, ].join(" ") ); ```

Table Alter

```rust let table = Table::alter() .table(Font::Table) .addcolumn( ColumnDef::new(Alias::new("newcol")) .integer() .notnull() .default(100), ) .toowned();

asserteq!( table.tostring(MysqlQueryBuilder), r#"ALTER TABLE font ADD COLUMN new_col int NOT NULL DEFAULT 100"# ); asserteq!( table.tostring(PostgresQueryBuilder), r#"ALTER TABLE "font" ADD COLUMN "newcol" integer NOT NULL DEFAULT 100"# ); asserteq!( table.tostring(SqliteQueryBuilder), r#"ALTER TABLE "font" ADD COLUMN "newcol" integer NOT NULL DEFAULT 100"#, ); ```

Table Drop

```rust let table = Table::drop() .table(Glyph::Table) .table(Char::Table) .to_owned();

asserteq!( table.tostring(MysqlQueryBuilder), r#"DROP TABLE glyph, character"# ); asserteq!( table.tostring(PostgresQueryBuilder), r#"DROP TABLE "glyph", "character""# ); asserteq!( table.tostring(SqliteQueryBuilder), r#"DROP TABLE "glyph", "character""# ); ```

Table Rename

```rust let table = Table::rename() .table(Font::Table, Alias::new("fontnew")) .toowned();

asserteq!( table.tostring(MysqlQueryBuilder), r#"RENAME TABLE font TO font_new"# ); asserteq!( table.tostring(PostgresQueryBuilder), r#"ALTER TABLE "font" RENAME TO "fontnew""# ); asserteq!( table.tostring(SqliteQueryBuilder), r#"ALTER TABLE "font" RENAME TO "fontnew""# ); ```

Table Truncate

```rust let table = Table::truncate().table(Font::Table).to_owned();

asserteq!( table.tostring(MysqlQueryBuilder), r#"TRUNCATE TABLE font"# ); asserteq!( table.tostring(PostgresQueryBuilder), r#"TRUNCATE TABLE "font""# ); // Sqlite does not support the TRUNCATE statement ```

Foreign Key Create

```rust let foreignkey = ForeignKey::create() .name("FKcharacterfont") .from(Char::Table, Char::FontId) .to(Font::Table, Font::Id) .ondelete(ForeignKeyAction::Cascade) .onupdate(ForeignKeyAction::Cascade) .toowned();

asserteq!( foreignkey.tostring(MysqlQueryBuilder), [ r#"ALTER TABLE character"#, r#"ADD CONSTRAINT FK_character_font"#, r#"FOREIGN KEY (font_id) REFERENCES font (id)"#, r#"ON DELETE CASCADE ON UPDATE CASCADE"#, ] .join(" ") ); asserteq!( foreignkey.tostring(PostgresQueryBuilder), [ r#"ALTER TABLE "character" ADD CONSTRAINT "FKcharacterfont""#, r#"FOREIGN KEY ("font_id") REFERENCES "font" ("id")"#, r#"ON DELETE CASCADE ON UPDATE CASCADE"#, ] .join(" ") ); // Sqlite does not support modification of foreign key constraints to existing tables ```

Foreign Key Drop

```rust let foreignkey = ForeignKey::drop() .name("FKcharacterfont") .table(Char::Table) .toowned();

asserteq!( foreignkey.tostring(MysqlQueryBuilder), r#"ALTER TABLE character DROP FOREIGN KEY FK_character_font"# ); asserteq!( foreignkey.tostring(PostgresQueryBuilder), r#"ALTER TABLE "character" DROP CONSTRAINT "FKcharacterfont""# ); // Sqlite does not support modification of foreign key constraints to existing tables ```

Index Create

```rust let index = Index::create() .name("idx-glyph-aspect") .table(Glyph::Table) .col(Glyph::Aspect) .to_owned();

asserteq!( index.tostring(MysqlQueryBuilder), r#"CREATE INDEX idx-glyph-aspect ON glyph (aspect)"# ); asserteq!( index.tostring(PostgresQueryBuilder), r#"CREATE INDEX "idx-glyph-aspect" ON "glyph" ("aspect")"# ); asserteq!( index.tostring(SqliteQueryBuilder), r#"CREATE INDEX "idx-glyph-aspect" ON "glyph" ("aspect")"# ); ```

Index Drop

```rust let index = Index::drop() .name("idx-glyph-aspect") .table(Glyph::Table) .to_owned();

asserteq!( index.tostring(MysqlQueryBuilder), r#"DROP INDEX idx-glyph-aspect ON glyph"# ); asserteq!( index.tostring(PostgresQueryBuilder), r#"DROP INDEX "idx-glyph-aspect""# ); asserteq!( index.tostring(SqliteQueryBuilder), r#"DROP INDEX "idx-glyph-aspect""# ); ```

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.

SeaQuery is a community driven project. We welcome you to participate, contribute and together build for Rust's future.

A big shout out to our contributors: