Struct sea_query::expr::Expr[−][src]

pub struct Expr { /* fields omitted */ }

Helper to build a SimpleExpr.

Implementations

impl Expr[src]

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

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, [src]

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>, [src]

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[src]

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>, [src]

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[src]

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>, [src]

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"#
);

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

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>, [src]

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, [src]

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>, [src]

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>, [src]

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>, [src]

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>, [src]

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>, [src]

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>, [src]

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>, [src]

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>, [src]

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>, [src]

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>, [src]

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[src]

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 is_null(self) -> SimpleExpr[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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>, [src]

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>, [src]

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>, [src]

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[src]

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 arg<T>(self, arg: T) -> SimpleExpr where
    T: Into<SimpleExpr>, [src]

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

pub fn into_simple_expr(self) -> SimpleExpr[src]

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

Trait Implementations

impl Clone for Expr[src]

impl Debug for Expr[src]

impl Default for Expr[src]

impl Into<SelectExpr> for Expr[src]

impl Into<SimpleExpr> for Expr[src]

Auto Trait Implementations

impl !RefUnwindSafe for Expr

impl !Send for Expr

impl !Sync for Expr

impl Unpin for Expr

impl !UnwindSafe for Expr

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<V, T> VZip<V> for T where
    V: MultiLane<T>,