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

pub struct Expr { /* fields omitted */ }

Building block of a expression.

Expr representing the most fundamental concept in the expression including concept like table column with and without table name prefix and any custom expression in string. Also common operations or functions can be applied to the table column, such as equal, not equal, not_null and many others. Please reference below for more details.

Implementations

impl Expr[src]

pub fn col<T: 'static>(n: T) -> Self where
    T: Iden, [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).into())
    .to_owned();
 
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `size_w`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "size_w""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `size_w`"#
);

pub fn col_dyn(n: Rc<dyn Iden>) -> Self[src]

Express the target column without table prefix, a variation of Expr::col which takes a Rc<dyn Iden>.

Examples

use sea_query::{*, tests_cfg::*};
use std::rc::Rc;
 
let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col_dyn(Rc::new(Char::SizeW)).into())
    .to_owned();
 
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `size_w`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "size_w""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `size_w`"#
);

pub fn tbl<T: 'static, C: 'static>(t: T, c: C) -> Self where
    T: Iden,
    C: Iden, [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).into())
    .to_owned();
 
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w`"#
);

pub fn tbl_dyn(t: Rc<dyn Iden>, c: Rc<dyn Iden>) -> Self[src]

Express the target column with table prefix, a variation of Expr::tbl which takes two Rc<dyn Iden>.

Examples

use sea_query::{*, tests_cfg::*};
use std::rc::Rc;
 
let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::tbl_dyn(Rc::new(Char::Table), Rc::new(Char::SizeW)).into())
    .to_owned();
 
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w`"#
);

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("<Any-Custom-Expression>").into())
    .to_owned();
 
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE <Any-Custom-Expression>"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE <Any-Custom-Expression>"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE <Any-Custom-Expression>"#
);

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

Express a 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 equals<T: 'static, C: 'static>(self, t: T, c: C) -> SimpleExpr where
    T: Iden,
    C: Iden, [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 equals_dyn(self, t: Rc<dyn Iden>, c: Rc<dyn Iden>) -> SimpleExpr[src]

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

A variation of Expr::equals which takes two Rc<dyn Iden>.

Examples

use sea_query::{*, tests_cfg::*};
use std::rc::Rc;
 
let query = Query::select()
    .columns(vec![Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::tbl(Char::Table, Char::FontId).equals_dyn(Rc::new(Font::Table), Rc::new(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 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(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 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(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 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(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 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(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]

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::expr(Expr::tbl(Char::Table, Char::SizeW).is_not_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 NOT NULL"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE NOT "character"."size_w" IS NOT NULL"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE NOT `character`.`size_w` IS NOT NULL"#
);

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

Express a max 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).max())
    .to_owned();
 
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE MAX(`character`.`size_w`)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE MAX("character"."size_w")"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE MAX(`character`.`size_w`)"#
);

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

Express a min 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).min())
    .to_owned();
 
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE MIN(`character`.`size_w`)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE MIN("character"."size_w")"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE MIN(`character`.`size_w`)"#
);

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

Express a sum 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).sum())
    .to_owned();
 
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE SUM(`character`.`size_w`)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE SUM("character"."size_w")"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE SUM(`character`.`size_w`)"#
);

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

Express a count 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).count())
    .to_owned();
 
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE COUNT(`character`.`size_w`)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE COUNT("character"."size_w")"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE COUNT(`character`.`size_w`)"#
);

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

Express a if 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).if_null(0))
    .to_owned();
 
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE IFNULL(`character`.`size_w`, 0)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE COALESCE("character"."size_w", 0)"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE IFNULL(`character`.`size_w`, 0)"#
);

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

Express a is in 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_in(vec![1, 2, 3]))
    .to_owned();
 
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` IN (1, 2, 3)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" IN (1, 2, 3)"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` IN (1, 2, 3)"#
);

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

Express a is not 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_in(vec![1, 2, 3]))
    .to_owned();
 
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` NOT IN (1, 2, 3)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" NOT IN (1, 2, 3)"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` NOT IN (1, 2, 3)"#
);

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

Trait Implementations

impl Clone for Expr[src]

impl Into<SimpleExpr> for Expr[src]

Auto Trait Implementations

impl !RefUnwindSafe for Expr[src]

impl !Send for Expr[src]

impl !Sync for Expr[src]

impl Unpin for Expr[src]

impl !UnwindSafe for Expr[src]

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> 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.