Struct sea_query::expr::Expr [−][src]
Helper to build a SimpleExpr
.
Implementations
impl Expr
[src]
pub fn col<T>(n: T) -> Self where
T: IntoColumnRef,
[src]
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,
[src]
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>,
[src]
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
[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]
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
[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>(s: &str, v: Vec<V>) -> SimpleExpr where
V: Into<Value>,
[src]
V: Into<Value>,
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]
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>,
[src]
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,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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
[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]
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>(self, v: Vec<V>) -> SimpleExpr where
V: Into<Value>,
[src]
V: Into<Value>,
Express a 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]
V: Into<Value>,
Express a NOT 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_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)"# );
pub fn arg<T>(self, arg: T) -> SimpleExpr where
T: Into<SimpleExpr>,
[src]
T: Into<SimpleExpr>,
pub fn args<T>(self, args: Vec<T>) -> SimpleExpr where
T: Into<SimpleExpr>,
[src]
T: Into<SimpleExpr>,
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]
fn into(self) -> SelectExpr
[src]
impl Into<SimpleExpr> for Expr
[src]
fn into(self) -> SimpleExpr
[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]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,