Struct sea_query::expr::Expr [−][src]
pub struct Expr { /* fields omitted */ }
Expand description
Helper to build a SimpleExpr
.
Implementations
impl Expr
[src]
impl Expr
[src]pub fn col<T>(n: T) -> Self where
T: IntoColumnRef,
[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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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 not_like(self, v: &str) -> SimpleExpr
[src]
pub fn is_null(self) -> SimpleExpr
[src]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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 not_in_subquery(self, sel: SelectStatement) -> SimpleExpr
[src]
pub fn not_in_subquery(self, sel: SelectStatement) -> SimpleExpr
[src]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 arg<T>(self, arg: T) -> SimpleExpr where
T: Into<SimpleExpr>,
[src]
T: Into<SimpleExpr>,
pub fn args<T, I>(self, args: I) -> SimpleExpr where
T: Into<SimpleExpr>,
I: IntoIterator<Item = T>,
[src]
T: Into<SimpleExpr>,
I: IntoIterator<Item = T>,
pub fn into_simple_expr(self) -> SimpleExpr
[src]
pub fn into_simple_expr(self) -> SimpleExpr
[src]Into::<SimpleExpr>::into()
when type inference is impossible
Trait Implementations
impl Into<SelectExpr> for Expr
[src]
impl Into<SelectExpr> for Expr
[src]fn into(self) -> SelectExpr
[src]
fn into(self) -> SelectExpr
[src]Performs the conversion.
impl Into<SimpleExpr> for Expr
[src]
impl Into<SimpleExpr> for Expr
[src]fn into(self) -> SimpleExpr
[src]
fn into(self) -> SimpleExpr
[src]Performs the conversion.
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> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<T> Same<T> for T
impl<T> Same<T> for T
type Output = T
type Output = T
Should always be Self
impl<T> ToOwned for T where
T: Clone,
[src]
impl<T> ToOwned for T where
T: Clone,
[src]type Owned = T
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn to_owned(&self) -> T
[src]Creates owned data from borrowed data, usually by cloning. Read more
pub fn clone_into(&self, target: &mut T)
[src]
pub fn clone_into(&self, target: &mut T)
[src]🔬 This is a nightly-only experimental API. (toowned_clone_into
)
recently added
Uses borrowed data to replace owned data, usually by cloning. Read more
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,