Struct sea_query::expr::Expr

pub struct Expr { /* fields omitted */ }

Helper to build a SimpleExpr.

Implementations

impl Expr

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

Express the target column without table prefix.

Examples

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

let query = Query::select()
    .columns(vec![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(vec![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 tbl<T, C>(t: T, c: C) -> Self where
    T: IntoIden,
    C: IntoIden, 

Express the target column with table prefix.

Examples

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

let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::tbl(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 val<V>(v: V) -> Self where
    V: Into<Value>, 

Express a Value, returning a Expr.

Examples

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

let query = Query::select()
    .columns(vec![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(expr: SimpleExpr) -> Self

Wrap a SimpleExpr and perform some operation on it.

Examples

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

let query = Query::select()
    .columns(vec![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) -> SimpleExpr where
    V: Into<Value>, 

Express a Value, returning a SimpleExpr.

Examples

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

let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::value(1).into())
    .and_where(Expr::value(2.5).into())
    .and_where(Expr::value("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 cust(s: &str) -> SimpleExpr

Express any custom expression in &str.

Examples

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

let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::cust("1 = 1").into())
    .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) -> SimpleExpr where
    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(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col(Char::Id).eq(1))
    .and_where(Expr::cust_with_values("6 = ? * ?", vec![2, 3]).into())
    .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(PostgresQueryBuilder),
    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()
    .expr(Expr::cust_with_values("6 = ? * ?", vec![2, 3]))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT 6 = 2 * 3"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    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("? ?? ?", vec!["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 @?? (?::JSONPATH)", vec!["hello"]))
    .to_owned();

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

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

Express an equal (=) expression.

Examples

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

let query = Query::select()
    .columns(vec![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) -> SimpleExpr where
    V: Into<Value>, 

Express a not equal (<>) expression.

Examples

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

let query = Query::select()
    .columns(vec![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<T, C>(self, t: T, c: C) -> SimpleExpr where
    T: IntoIden,
    C: IntoIden, 

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(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::tbl(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) -> SimpleExpr where
    V: Into<Value>, 

Express a greater than (>) expression.

Examples

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

let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::tbl(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) -> SimpleExpr where
    V: Into<Value>, 

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

Examples

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

let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::tbl(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) -> SimpleExpr where
    V: Into<Value>, 

Express a less than (<) expression.

Examples

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

let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::tbl(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) -> SimpleExpr where
    V: Into<Value>, 

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

Examples

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

let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::tbl(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) -> SimpleExpr where
    V: Into<Value>, 

Express an arithmetic addition operation.

Examples

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

let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::val(1).add(1).equals(Expr::value(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) -> SimpleExpr where
    V: Into<Value>, 

Express an arithmetic subtraction operation.

Examples

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

let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::val(1).sub(1).equals(Expr::value(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) -> SimpleExpr where
    V: Into<Value>, 

Express an arithmetic multiplication operation.

Examples

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

let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::val(1).mul(1).equals(Expr::value(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) -> SimpleExpr where
    V: Into<Value>, 

Express an arithmetic division operation.

Examples

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

let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::val(1).div(1).equals(Expr::value(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) -> SimpleExpr where
    V: Into<Value>, 

Express a BETWEEN expression.

Examples

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

let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::tbl(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) -> SimpleExpr where
    V: Into<Value>, 

Express a NOT BETWEEN expression.

Examples

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

let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::tbl(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(self, v: &str) -> SimpleExpr

Express a LIKE expression.

Examples

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

let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::tbl(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\'%'"#
);

pub fn not_like(self, v: &str) -> SimpleExpr

pub fn is_null(self) -> SimpleExpr

Express a IS NULL expression.

Examples

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

let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::tbl(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_not_null(self) -> SimpleExpr

Express a IS NOT NULL expression.

Examples

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

let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::tbl(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 not(self) -> SimpleExpr

Negates an expression with NOT.

Examples

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

let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::expr(Expr::tbl(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::tbl(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::tbl(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::tbl(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::tbl(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) -> SimpleExpr where
    V: Into<Value>, 

Express a IF NULL function.

Examples

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

let query = Query::select()
    .expr(Expr::tbl(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) -> SimpleExpr where
    V: Into<Value>,
    I: IntoIterator<Item = V>, 

Express a IN expression.

Examples

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

let query = Query::select()
    .columns(vec![Char::Id])
    .from(Char::Table)
    .and_where(Expr::tbl(Char::Table, Char::SizeW).is_in(vec![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(vec![Char::Id])
    .from(Char::Table)
    .and_where(Expr::tbl(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 is_not_in<V, I>(self, v: I) -> SimpleExpr where
    V: Into<Value>,
    I: IntoIterator<Item = V>, 

Express a NOT IN expression.

Examples

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

let query = Query::select()
    .columns(vec![Char::Id])
    .from(Char::Table)
    .and_where(Expr::tbl(Char::Table, Char::SizeW).is_not_in(vec![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(vec![Char::Id])
    .from(Char::Table)
    .and_where(Expr::tbl(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(vec![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(vec![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 matches<T>(self, expr: T) -> SimpleExpr where
    T: Into<SimpleExpr>, 

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

Examples

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

let query = Query::select()
    .columns(vec![Font::Name, Font::Variant, Font::Language])
    .from(Font::Table)
    .and_where(Expr::val("a & b").matches(Expr::val("a b")))
    .and_where(Expr::col(Font::Name).matches(Expr::val("a b")))
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "name", "variant", "language" FROM "font" WHERE 'a & b' @@ 'a b' AND "name" @@ 'a b'"#
);

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

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

Examples

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

let query = Query::select()
    .columns(vec![Font::Name, Font::Variant, Font::Language])
    .from(Font::Table)
    .and_where(Expr::val("a & b").contains(Expr::val("a b")))
    .and_where(Expr::col(Font::Name).contains(Expr::val("a b")))
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "name", "variant", "language" FROM "font" WHERE 'a & b' @> 'a b' AND "name" @> 'a b'"#
);

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

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

Examples

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

let query = Query::select()
    .columns(vec![Font::Name, Font::Variant, Font::Language])
    .from(Font::Table)
    .and_where(Expr::val("a & b").contained(Expr::val("a b")))
    .and_where(Expr::col(Font::Name).contained(Expr::val("a b")))
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "name", "variant", "language" FROM "font" WHERE 'a & b' <@ 'a b' AND "name" <@ 'a b'"#
);

pub fn concatenate<T>(self, expr: T) -> SimpleExpr where
    T: Into<SimpleExpr>, 

Express an postgres concatenate (||) expression.

Examples

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

let query = Query::select()
    .columns(vec![Font::Name, Font::Variant, Font::Language])
    .from(Font::Table)
    .and_where(Expr::val("a").concatenate(Expr::val("b")))
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "name", "variant", "language" FROM "font" WHERE 'a' || 'b'"#
);

pub fn arg<T>(self, arg: T) -> SimpleExpr where
    T: Into<SimpleExpr>, 

pub fn args<T, I>(self, args: I) -> SimpleExpr where
    T: Into<SimpleExpr>,
    I: IntoIterator<Item = T>, 

pub fn into_simple_expr(self) -> SimpleExpr

Into::<SimpleExpr>::into() when type inference is impossible

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 Default for Expr

fn default() -> Expr

Returns the “default value” for a type.

impl Into<SelectExpr> for Expr

fn into(self) -> SelectExpr

Performs the conversion.

impl Into<SimpleExpr> for Expr

fn into(self) -> SimpleExpr

Convert into SimpleExpr. Will panic if this Expr is missing an operand