Struct sea_query::expr::Expr

pub struct Expr { /* private fields */ }

Helper to build a SimpleExpr.

Implementations

impl Expr

pub fn asterisk() -> Self

Express the asterisk without table prefix.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .expr(Expr::asterisk())
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT * FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT * FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT * FROM "character""#
);

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::SizeW)).eq(1))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` = 1"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" = 1"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" = 1"#
);

pub fn col<T>(n: T) -> Selfwhere
    T: IntoColumnRef,

Express the target column without table prefix.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col(Char::SizeW).eq(1))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `size_w` = 1"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "size_w" = 1"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "size_w" = 1"#
);

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::SizeW)).eq(1))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` = 1"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" = 1"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" = 1"#
);

pub fn tuple<I>(n: I) -> Selfwhere
    I: IntoIterator<Item = SimpleExpr>,

Wraps tuple of SimpleExpr, can be used for tuple comparison

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(
        Expr::tuple([Expr::col(Char::SizeW).into(), Expr::value(100)])
            .lt(Expr::tuple([Expr::value(500), Expr::value(100)])))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE (`size_w`, 100) < (500, 100)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE ("size_w", 100) < (500, 100)"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE ("size_w", 100) < (500, 100)"#
);

pub fn table_asterisk<T>(t: T) -> Selfwhere
    T: IntoIden,

Express the asterisk with table prefix.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .expr(Expr::asterisk())
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT * FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT * FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT * FROM "character""#
);

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .expr(Expr::table_asterisk(Char::Table))
    .column((Font::Table, Font::Name))
    .from(Char::Table)
    .inner_join(Font::Table, Expr::col((Char::Table, Char::FontId)).equals((Font::Table, Font::Id)))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`.*, `font`.`name` FROM `character` INNER JOIN `font` ON `character`.`font_id` = `font`.`id`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character".*, "font"."name" FROM "character" INNER JOIN "font" ON "character"."font_id" = "font"."id""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character".*, "font"."name" FROM "character" INNER JOIN "font" ON "character"."font_id" = "font"."id""#
);

pub fn tbl<T, C>(t: T, c: C) -> Selfwhere
    T: IntoIden,
    C: IntoIden,

👎Deprecated since 0.28.0: Please use the [Expr::col]

pub fn val<V>(v: V) -> Selfwhere
    V: Into<Value>,

Express a Value, returning a Expr.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::val(1).into())
    .and_where(Expr::val(2.5).into())
    .and_where(Expr::val("3").into())
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 1 AND 2.5 AND '3'"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 AND 2.5 AND '3'"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 AND 2.5 AND '3'"#
);

pub fn expr<T>(expr: T) -> Selfwhere
    T: Into<SimpleExpr>,

Wrap a SimpleExpr and perform some operation on it.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::expr(Expr::col(Char::SizeW).if_null(0)).gt(2))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE IFNULL(`size_w`, 0) > 2"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE COALESCE("size_w", 0) > 2"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE IFNULL("size_w", 0) > 2"#
);

pub fn value<V>(v: V) -> SimpleExprwhere
    V: Into<SimpleExpr>,

Express a Value, returning a SimpleExpr.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::value(1))
    .and_where(Expr::value(2.5))
    .and_where(Expr::value("3"))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 1 AND 2.5 AND '3'"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 AND 2.5 AND '3'"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 AND 2.5 AND '3'"#
);

pub fn cust(s: &str) -> SimpleExpr

Express any custom expression in &str.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::cust("1 = 1"))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 1 = 1"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 = 1"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 = 1"#
);

pub fn cust_with_values<V, I>(s: &str, v: I) -> SimpleExprwhere
    V: Into<Value>,
    I: IntoIterator<Item = V>,

Express any custom expression with Value. Use this if your expression needs variables.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col(Char::Id).eq(1))
    .and_where(Expr::cust_with_values("6 = ? * ?", [2, 3]))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `id` = 1 AND 6 = 2 * 3"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "id" = 1 AND 6 = 2 * 3"#
);

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col(Char::Id).eq(1))
    .and_where(Expr::cust_with_values("6 = $2 * $1", [3, 2]))
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "id" = 1 AND 6 = 2 * 3"#
);

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .expr(Expr::cust_with_values("6 = ? * ?", [2, 3]))
    .to_owned();

assert_eq!(query.to_string(MysqlQueryBuilder), r#"SELECT 6 = 2 * 3"#);
assert_eq!(query.to_string(SqliteQueryBuilder), r#"SELECT 6 = 2 * 3"#);

Postgres only: use $$ to escape $

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .expr(Expr::cust_with_values("$1 $$ $2", ["a", "b"]))
    .to_owned();

assert_eq!(query.to_string(PostgresQueryBuilder), r#"SELECT 'a' $ 'b'"#);

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .expr(Expr::cust_with_values("data @? ($1::JSONPATH)", ["hello"]))
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT data @? ('hello'::JSONPATH)"#
);

pub fn cust_with_expr<T>(s: &str, expr: T) -> SimpleExprwhere
    T: Into<SimpleExpr>,

Express any custom expression with SimpleExpr. Use this if your expression needs other expression.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .expr(Expr::cust_with_expr("data @? ($1::JSONPATH)", "hello"))
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT data @? ('hello'::JSONPATH)"#
);

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .expr(Expr::cust_with_expr(
        "json_agg(DISTINCT $1)",
        Expr::col(Char::Character),
    ))
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT json_agg(DISTINCT "character")"#
);

pub fn cust_with_exprs<I>(s: &str, v: I) -> SimpleExprwhere
    I: IntoIterator<Item = SimpleExpr>,

Express any custom expression with SimpleExpr. Use this if your expression needs other expressions.

pub fn eq<V>(self, v: V) -> SimpleExprwhere
    V: Into<SimpleExpr>,

Express an equal (=) expression.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::val("What!").eq("Nothing"))
    .and_where(Expr::col(Char::Id).eq(1))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 'What!' = 'Nothing' AND `id` = 1"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 'What!' = 'Nothing' AND "id" = 1"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 'What!' = 'Nothing' AND "id" = 1"#
);

pub fn ne<V>(self, v: V) -> SimpleExprwhere
    V: Into<SimpleExpr>,

Express a not equal (<>) expression.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::val("Morning").ne("Good"))
    .and_where(Expr::col(Char::Id).ne(1))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 'Morning' <> 'Good' AND `id` <> 1"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 'Morning' <> 'Good' AND "id" <> 1"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 'Morning' <> 'Good' AND "id" <> 1"#
);

pub fn equals<C>(self, col: C) -> SimpleExprwhere
    C: IntoColumnRef,

Express a equal expression between two table columns, you will mainly use this to relate identical value between two table columns.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::FontId)).equals((Font::Table, Font::Id)))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`font_id` = `font`.`id`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."font_id" = "font"."id""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."font_id" = "font"."id""#
);

pub fn not_equals<C>(self, col: C) -> SimpleExprwhere
    C: IntoColumnRef,

Express a not equal expression between two table columns, you will mainly use this to relate identical value between two table columns.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::FontId)).equals((Font::Table, Font::Id)))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`font_id` = `font`.`id`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."font_id" = "font"."id""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."font_id" = "font"."id""#
);

pub fn gt<V>(self, v: V) -> SimpleExprwhere
    V: Into<SimpleExpr>,

Express a greater than (>) expression.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::SizeW)).gt(2))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` > 2"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" > 2"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" > 2"#
);

pub fn gte<V>(self, v: V) -> SimpleExprwhere
    V: Into<SimpleExpr>,

Express a greater than or equal (>=) expression.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::SizeW)).gte(2))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` >= 2"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" >= 2"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" >= 2"#
);

pub fn lt<V>(self, v: V) -> SimpleExprwhere
    V: Into<SimpleExpr>,

Express a less than (<) expression.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::SizeW)).lt(2))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` < 2"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" < 2"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" < 2"#
);

pub fn lte<V>(self, v: V) -> SimpleExprwhere
    V: Into<SimpleExpr>,

Express a less than or equal (<=) expression.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::SizeW)).lte(2))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` <= 2"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" <= 2"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" <= 2"#
);

pub fn add<V>(self, v: V) -> SimpleExprwhere
    V: Into<SimpleExpr>,

Express an arithmetic addition operation.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::val(1).add(1).eq(2))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 1 + 1 = 2"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 + 1 = 2"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 + 1 = 2"#
);

pub fn sub<V>(self, v: V) -> SimpleExprwhere
    V: Into<SimpleExpr>,

Express an arithmetic subtraction operation.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::val(1).sub(1).eq(2))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 1 - 1 = 2"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 - 1 = 2"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 - 1 = 2"#
);

pub fn mul<V>(self, v: V) -> SimpleExprwhere
    V: Into<SimpleExpr>,

Express an arithmetic multiplication operation.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::val(1).mul(1).eq(2))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 1 * 1 = 2"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 * 1 = 2"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 * 1 = 2"#
);

pub fn div<V>(self, v: V) -> SimpleExprwhere
    V: Into<SimpleExpr>,

Express an arithmetic division operation.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::val(1).div(1).eq(2))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 1 / 1 = 2"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 / 1 = 2"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 / 1 = 2"#
);

pub fn modulo<V>(self, v: V) -> SimpleExprwhere
    V: Into<SimpleExpr>,

Express an arithmetic modulo operation.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::val(1).modulo(1).eq(2))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 1 % 1 = 2"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 % 1 = 2"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 % 1 = 2"#
);

pub fn left_shift<V>(self, v: V) -> SimpleExprwhere
    V: Into<SimpleExpr>,

Express a bitwise left shift.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::val(1).left_shift(1).eq(2))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 1 << 1 = 2"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 << 1 = 2"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 << 1 = 2"#
);

pub fn right_shift<V>(self, v: V) -> SimpleExprwhere
    V: Into<SimpleExpr>,

Express a bitwise right shift.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::val(1).right_shift(1).eq(2))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 1 >> 1 = 2"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 >> 1 = 2"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 >> 1 = 2"#
);

pub fn between<V>(self, a: V, b: V) -> SimpleExprwhere
    V: Into<SimpleExpr>,

Express a BETWEEN expression.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::SizeW)).between(1, 10))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` BETWEEN 1 AND 10"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" BETWEEN 1 AND 10"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" BETWEEN 1 AND 10"#
);

pub fn not_between<V>(self, a: V, b: V) -> SimpleExprwhere
    V: Into<SimpleExpr>,

Express a NOT BETWEEN expression.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::SizeW)).not_between(1, 10))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` NOT BETWEEN 1 AND 10"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" NOT BETWEEN 1 AND 10"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" NOT BETWEEN 1 AND 10"#
);

pub fn like<L: IntoLikeExpr>(self, like: L) -> SimpleExpr

Express a LIKE expression.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::Character)).like("Ours'%"))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`character` LIKE 'Ours\'%'"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."character" LIKE E'Ours\'%'"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."character" LIKE 'Ours''%'"#
);

Like with ESCAPE

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::Character)).like(LikeExpr::str(r"|_Our|_").escape('|')))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`character` LIKE '|_Our|_' ESCAPE '|'"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."character" LIKE '|_Our|_' ESCAPE '|'"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."character" LIKE '|_Our|_' ESCAPE '|'"#
);

pub fn not_like<L: IntoLikeExpr>(self, like: L) -> SimpleExpr

Express a NOT LIKE expression

pub fn is_null(self) -> SimpleExpr

Express a IS NULL expression.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::SizeW)).is_null())
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` IS NULL"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" IS NULL"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" IS NULL"#
);

pub fn is<V>(self, v: V) -> SimpleExprwhere
    V: Into<SimpleExpr>,

Express a IS expression.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::Ascii)).is(true))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`ascii` IS TRUE"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."ascii" IS TRUE"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."ascii" IS TRUE"#
);

pub fn is_not_null(self) -> SimpleExpr

Express a IS NOT NULL expression.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::SizeW)).is_not_null())
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` IS NOT NULL"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" IS NOT NULL"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" IS NOT NULL"#
);

pub fn is_not<V>(self, v: V) -> SimpleExprwhere
    V: Into<SimpleExpr>,

Express a IS NOT expression.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::Ascii)).is_not(true))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`ascii` IS NOT TRUE"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."ascii" IS NOT TRUE"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."ascii" IS NOT TRUE"#
);

pub fn binary<O, T>(self, op: O, right: T) -> SimpleExprwhere
    O: Into<BinOper>,
    T: Into<SimpleExpr>,

Create any binary operation

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .cond_where(all![
        Expr::col(Char::SizeW).binary(BinOper::SmallerThan, 10),
        Expr::col(Char::SizeW).binary(BinOper::GreaterThan, Expr::col(Char::SizeH))
    ])
    .to_owned();
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `size_w` < 10 AND `size_w` > `size_h`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "size_w" < 10 AND "size_w" > "size_h""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "size_w" < 10 AND "size_w" > "size_h""#
);

pub fn not(self) -> SimpleExpr

Negates an expression with NOT.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::expr(Expr::col((Char::Table, Char::SizeW)).is_null()).not())
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE NOT `character`.`size_w` IS NULL"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE NOT "character"."size_w" IS NULL"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE NOT "character"."size_w" IS NULL"#
);

pub fn max(self) -> SimpleExpr

Express a MAX function.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .expr(Expr::col((Char::Table, Char::SizeW)).max())
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT MAX(`character`.`size_w`) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT MAX("character"."size_w") FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT MAX("character"."size_w") FROM "character""#
);

pub fn min(self) -> SimpleExpr

Express a MIN function.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .expr(Expr::col((Char::Table, Char::SizeW)).min())
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT MIN(`character`.`size_w`) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT MIN("character"."size_w") FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT MIN("character"."size_w") FROM "character""#
);

pub fn sum(self) -> SimpleExpr

Express a SUM function.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .expr(Expr::col((Char::Table, Char::SizeW)).sum())
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT SUM(`character`.`size_w`) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT SUM("character"."size_w") FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT SUM("character"."size_w") FROM "character""#
);

pub fn count(self) -> SimpleExpr

Express a COUNT function.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .expr(Expr::col((Char::Table, Char::SizeW)).count())
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT COUNT(`character`.`size_w`) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT COUNT("character"."size_w") FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT COUNT("character"."size_w") FROM "character""#
);

pub fn if_null<V>(self, v: V) -> SimpleExprwhere
    V: Into<SimpleExpr>,

Express a IF NULL function.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .expr(Expr::col((Char::Table, Char::SizeW)).if_null(0))
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT IFNULL(`character`.`size_w`, 0) FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT COALESCE("character"."size_w", 0) FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT IFNULL("character"."size_w", 0) FROM "character""#
);

pub fn is_in<V, I>(self, v: I) -> SimpleExprwhere
    V: Into<SimpleExpr>,
    I: IntoIterator<Item = V>,

Express a IN expression.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Id])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::SizeW)).is_in([1, 2, 3]))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `id` FROM `character` WHERE `character`.`size_w` IN (1, 2, 3)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "id" FROM "character" WHERE "character"."size_w" IN (1, 2, 3)"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "id" FROM "character" WHERE "character"."size_w" IN (1, 2, 3)"#
);

Empty value list

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Id])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::SizeW)).is_in(Vec::<u8>::new()))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `id` FROM `character` WHERE 1 = 2"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "id" FROM "character" WHERE 1 = 2"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "id" FROM "character" WHERE 1 = 2"#
);

pub fn in_tuples<V, I>(self, v: I) -> SimpleExprwhere
    V: IntoValueTuple,
    I: IntoIterator<Item = V>,

Express a IN sub expression.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .columns([Char::Character, Char::FontId])
    .from(Char::Table)
    .and_where(
        Expr::tuple([
            Expr::col(Char::Character).into(),
            Expr::col(Char::FontId).into(),
        ])
        .in_tuples([(1, String::from("1")), (2, String::from("2"))])
    )
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `font_id` FROM `character` WHERE (`character`, `font_id`) IN ((1, '1'), (2, '2'))"#
);

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "font_id" FROM "character" WHERE ("character", "font_id") IN ((1, '1'), (2, '2'))"#
);

assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "font_id" FROM "character" WHERE ("character", "font_id") IN ((1, '1'), (2, '2'))"#
);

pub fn is_not_in<V, I>(self, v: I) -> SimpleExprwhere
    V: Into<SimpleExpr>,
    I: IntoIterator<Item = V>,

Express a NOT IN expression.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Id])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::SizeW)).is_not_in([1, 2, 3]))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `id` FROM `character` WHERE `character`.`size_w` NOT IN (1, 2, 3)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "id" FROM "character" WHERE "character"."size_w" NOT IN (1, 2, 3)"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "id" FROM "character" WHERE "character"."size_w" NOT IN (1, 2, 3)"#
);

Empty value list

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Id])
    .from(Char::Table)
    .and_where(Expr::col((Char::Table, Char::SizeW)).is_not_in(Vec::<u8>::new()))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `id` FROM `character` WHERE 1 = 1"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "id" FROM "character" WHERE 1 = 1"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "id" FROM "character" WHERE 1 = 1"#
);

pub fn in_subquery(self, sel: SelectStatement) -> SimpleExpr

Express a IN sub-query expression.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col(Char::SizeW).in_subquery(
        Query::select()
            .expr(Expr::cust("3 + 2 * 2"))
            .take()
    ))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `size_w` IN (SELECT 3 + 2 * 2)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "size_w" IN (SELECT 3 + 2 * 2)"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "size_w" IN (SELECT 3 + 2 * 2)"#
);

pub fn not_in_subquery(self, sel: SelectStatement) -> SimpleExpr

Express a NOT IN sub-query expression.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col(Char::SizeW).not_in_subquery(
        Query::select()
            .expr(Expr::cust("3 + 2 * 2"))
            .take()
    ))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `size_w` NOT IN (SELECT 3 + 2 * 2)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "size_w" NOT IN (SELECT 3 + 2 * 2)"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "size_w" NOT IN (SELECT 3 + 2 * 2)"#
);

pub fn exists(sel: SelectStatement) -> SimpleExpr

Express a EXISTS sub-query expression.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .expr_as(Expr::exists(Query::select().column(Char::Id).from(Char::Table).take()), Alias::new("character_exists"))
    .expr_as(Expr::exists(Query::select().column(Glyph::Id).from(Glyph::Table).take()), Alias::new("glyph_exists"))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT EXISTS(SELECT `id` FROM `character`) AS `character_exists`, EXISTS(SELECT `id` FROM `glyph`) AS `glyph_exists`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT EXISTS(SELECT "id" FROM "character") AS "character_exists", EXISTS(SELECT "id" FROM "glyph") AS "glyph_exists""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT EXISTS(SELECT "id" FROM "character") AS "character_exists", EXISTS(SELECT "id" FROM "glyph") AS "glyph_exists""#
);

pub fn any(sel: SelectStatement) -> SimpleExpr

Express a ANY sub-query expression.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .column(Char::Id)
    .from(Char::Table)
    .and_where(Expr::col(Char::Id).eq(Expr::any(
        Query::select().column(Char::Id).from(Char::Table).take(),
    )))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `id` FROM `character` WHERE `id` = ANY(SELECT `id` FROM `character`)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "id" FROM "character" WHERE "id" = ANY(SELECT "id" FROM "character")"#
);

pub fn some(sel: SelectStatement) -> SimpleExpr

Express a SOME sub-query expression.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .column(Char::Id)
    .from(Char::Table)
    .and_where(Expr::col(Char::Id).ne(Expr::some(
        Query::select().column(Char::Id).from(Char::Table).take(),
    )))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `id` FROM `character` WHERE `id` <> SOME(SELECT `id` FROM `character`)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "id" FROM "character" WHERE "id" <> SOME(SELECT "id" FROM "character")"#
);

pub fn all(sel: SelectStatement) -> SimpleExpr

Express a ALL sub-query expression.

pub fn as_enum<T>(self, type_name: T) -> SimpleExprwhere
    T: IntoIden,

Express a AS enum expression.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .expr(Expr::col(Char::FontSize).as_enum(Alias::new("text")))
    .from(Char::Table)
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `font_size` FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT CAST("font_size" AS text) FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "font_size" FROM "character""#
);

let query = Query::insert()
    .into_table(Char::Table)
    .columns([Char::FontSize])
    .values_panic([Expr::val("large").as_enum(Alias::new("FontSizeEnum"))])
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"INSERT INTO `character` (`font_size`) VALUES ('large')"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"INSERT INTO "character" ("font_size") VALUES (CAST('large' AS FontSizeEnum))"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"INSERT INTO "character" ("font_size") VALUES ('large')"#
);

pub fn case<C, T>(cond: C, then: T) -> CaseStatementwhere
    C: IntoCondition,
    T: Into<SimpleExpr>,

Adds new CASE WHEN to existing case statement.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .expr_as(
        Expr::case(
                Expr::col((Glyph::Table, Glyph::Aspect)).is_in([2, 4]),
                true
             )
            .finally(false),
         Alias::new("is_even")
    )
    .from(Glyph::Table)
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT (CASE WHEN ("glyph"."aspect" IN (2, 4)) THEN TRUE ELSE FALSE END) AS "is_even" FROM "glyph""#
);

pub fn cast_as<T>(self, type_name: T) -> SimpleExprwhere
    T: IntoIden,

Express a CAST AS expression.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .expr(Expr::val("1").cast_as(Alias::new("integer")))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT CAST('1' AS integer)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT CAST('1' AS integer)"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT CAST('1' AS integer)"#
);

pub fn current_date() -> Expr

Keyword CURRENT_TIMESTAMP.

Examples

use sea_query::*;

let query = Query::select().expr(Expr::current_date()).to_owned();

assert_eq!(query.to_string(MysqlQueryBuilder), r#"SELECT CURRENT_DATE"#);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT CURRENT_DATE"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT CURRENT_DATE"#
);

pub fn current_time() -> Expr

Keyword CURRENT_TIMESTAMP.

Examples

use sea_query::*;

let query = Query::select().expr(Expr::current_time()).to_owned();

assert_eq!(query.to_string(MysqlQueryBuilder), r#"SELECT CURRENT_TIME"#);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT CURRENT_TIME"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT CURRENT_TIME"#
);

pub fn current_timestamp() -> Expr

Keyword CURRENT_TIMESTAMP.

Examples

use sea_query::{Expr, MysqlQueryBuilder, PostgresQueryBuilder, Query, SqliteQueryBuilder};

let query = Query::select().expr(Expr::current_timestamp()).to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT CURRENT_TIMESTAMP"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT CURRENT_TIMESTAMP"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT CURRENT_TIMESTAMP"#
);

pub fn custom_keyword<T>(i: T) -> Exprwhere
    T: IntoIden,

Custom keyword.

Examples

use sea_query::*;

let query = Query::select()
    .expr(Expr::custom_keyword(Alias::new("test")))
    .to_owned();

assert_eq!(query.to_string(MysqlQueryBuilder), r#"SELECT test"#);
assert_eq!(query.to_string(PostgresQueryBuilder), r#"SELECT test"#);
assert_eq!(query.to_string(SqliteQueryBuilder), r#"SELECT test"#);

pub fn greater_than<T>(self, expr: T) -> SimpleExprwhere
    T: Into<SimpleExpr>,

👎Deprecated since 0.28.0: Please use the [Expr::gt]

pub fn greater_or_equal<T>(self, expr: T) -> SimpleExprwhere
    T: Into<SimpleExpr>,

👎Deprecated since 0.28.0: Please use the [Expr::gte]

pub fn less_than<T>(self, expr: T) -> SimpleExprwhere
    T: Into<SimpleExpr>,

👎Deprecated since 0.28.0: Please use the [Expr::lt]

pub fn less_or_equal<T>(self, expr: T) -> SimpleExprwhere
    T: Into<SimpleExpr>,

👎Deprecated since 0.28.0: Please use the [Expr::lte]

pub fn into_simple_expr(self) -> SimpleExpr

👎Deprecated since 0.28.0: Please use the [Into::<SimpleExpr>::into()]

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Expr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Expr> for SimpleExpr

fn from(src: Expr) -> Self

Convert into SimpleExpr

impl PgExpr for Expr

Available on crate feature backend-postgres only.

fn concatenate<T>(self, right: T) -> SimpleExprwhere
    T: Into<SimpleExpr>,

Express an postgres concatenate (||) expression.

fn concat<T>(self, right: T) -> SimpleExprwhere
    T: Into<SimpleExpr>,

Alias of PgExpr::concatenate

fn matches<T>(self, expr: T) -> SimpleExprwhere
    T: Into<SimpleExpr>,

Express an postgres fulltext search matches (@@) expression.

fn contains<T>(self, expr: T) -> SimpleExprwhere
    T: Into<SimpleExpr>,

Express an postgres fulltext search contains (@>) expression.

fn contained<T>(self, expr: T) -> SimpleExprwhere
    T: Into<SimpleExpr>,

Express an postgres fulltext search contained (<@) expression.

fn ilike<L>(self, like: L) -> SimpleExprwhere
    L: IntoLikeExpr,

Express a LIKE expression.

fn not_ilike<L>(self, like: L) -> SimpleExprwhere
    L: IntoLikeExpr,

Express a NOT ILIKE expression

impl SqliteExpr for Expr

Available on crate feature backend-sqlite only.

fn matches<T>(self, right: T) -> SimpleExprwhere
    T: Into<SimpleExpr>,

Express an sqlite MATCH operator.

fn get_json_field<T>(self, right: T) -> SimpleExprwhere
    T: Into<SimpleExpr>,

Express an sqlite retrieves JSON field as JSON value (->).

fn cast_json_field<T>(self, right: T) -> SimpleExprwhere
    T: Into<SimpleExpr>,

Express an sqlite retrieves JSON field and casts it to an appropriate SQL type (->>).