pub struct Expr { /* private fields */ }
Expand description
Helper to build a SimpleExpr
.
Implementations
sourceimpl Expr
impl Expr
sourcepub fn asterisk() -> Expr
pub fn asterisk() -> Expr
Express the asterisk without table prefix.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.expr(Expr::asterisk())
.from(Char::Table)
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT * FROM `character`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT * FROM "character""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT * FROM "character""#
);
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"#
);
sourcepub fn col<T>(n: T) -> Expr where
T: IntoColumnRef,
pub fn col<T>(n: T) -> Expr where
T: IntoColumnRef,
Express the target column without table prefix.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::col(Char::SizeW).eq(1))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `size_w` = 1"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "size_w" = 1"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "size_w" = 1"#
);
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::col((Char::Table, Char::SizeW)).eq(1))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` = 1"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" = 1"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" = 1"#
);
sourcepub fn tuple<I>(n: I) -> Expr where
I: IntoIterator<Item = SimpleExpr>,
pub fn tuple<I>(n: I) -> Expr where
I: IntoIterator<Item = SimpleExpr>,
Wraps tuple of SimpleExpr
, can be used for tuple comparison
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(
Expr::tuple([Expr::col(Char::SizeW).into_simple_expr(), Expr::value(100)])
.less_than(Expr::tuple([Expr::value(500), Expr::value(100)])))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE (`size_w`, 100) < (500, 100)"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE ("size_w", 100) < (500, 100)"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE ("size_w", 100) < (500, 100)"#
);
sourcepub fn table_asterisk<T>(t: T) -> Expr where
T: IntoIden,
pub fn table_asterisk<T>(t: T) -> Expr where
T: IntoIden,
Express the asterisk with table prefix.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.expr(Expr::asterisk())
.from(Char::Table)
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT * FROM `character`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT * FROM "character""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT * FROM "character""#
);
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.expr(Expr::table_asterisk(Char::Table))
.column((Font::Table, Font::Name))
.from(Char::Table)
.inner_join(Font::Table, Expr::tbl(Char::Table, Char::FontId).equals(Font::Table, Font::Id))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`.*, `font`.`name` FROM `character` INNER JOIN `font` ON `character`.`font_id` = `font`.`id`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character".*, "font"."name" FROM "character" INNER JOIN "font" ON "character"."font_id" = "font"."id""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character".*, "font"."name" FROM "character" INNER JOIN "font" ON "character"."font_id" = "font"."id""#
);
sourcepub fn tbl<T, C>(t: T, c: C) -> Expr where
T: IntoIden,
C: IntoIden,
pub fn tbl<T, C>(t: T, c: C) -> Expr where
T: IntoIden,
C: IntoIden,
Express the target column with table prefix.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::tbl(Char::Table, Char::SizeW).eq(1))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` = 1"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" = 1"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" = 1"#
);
sourcepub fn val<V>(v: V) -> Expr where
V: Into<Value>,
pub fn val<V>(v: V) -> Expr where
V: Into<Value>,
Express a Value
, returning a Expr
.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::val(1).into())
.and_where(Expr::val(2.5).into())
.and_where(Expr::val("3").into())
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 1 AND 2.5 AND '3'"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 AND 2.5 AND '3'"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 AND 2.5 AND '3'"#
);
sourcepub fn expr(expr: SimpleExpr) -> Expr
pub fn expr(expr: SimpleExpr) -> Expr
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"#
);
sourcepub fn value<V>(v: V) -> SimpleExpr where
V: Into<Value>,
pub fn value<V>(v: V) -> SimpleExpr where
V: Into<Value>,
Express a Value
, returning a SimpleExpr
.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::value(1).into())
.and_where(Expr::value(2.5).into())
.and_where(Expr::value("3").into())
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 1 AND 2.5 AND '3'"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 AND 2.5 AND '3'"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 AND 2.5 AND '3'"#
);
sourcepub fn cust(s: &str) -> SimpleExpr
pub fn cust(s: &str) -> SimpleExpr
Express any custom expression in &str
.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::cust("1 = 1").into())
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 1 = 1"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 = 1"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 = 1"#
);
sourcepub fn cust_with_values<V, I>(s: &str, v: I) -> SimpleExpr where
V: Into<Value>,
I: IntoIterator<Item = V>,
pub fn cust_with_values<V, I>(s: &str, v: I) -> SimpleExpr where
V: Into<Value>,
I: IntoIterator<Item = V>,
Express any custom expression with Value
. Use this if your expression needs variables.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::col(Char::Id).eq(1))
.and_where(Expr::cust_with_values("6 = ? * ?", vec![2, 3]).into())
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `id` = 1 AND 6 = 2 * 3"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "id" = 1 AND 6 = 2 * 3"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "id" = 1 AND 6 = 2 * 3"#
);
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.expr(Expr::cust_with_values("6 = ? * ?", vec![2, 3]))
.to_owned();
assert_eq!(query.to_string(MysqlQueryBuilder), r#"SELECT 6 = 2 * 3"#);
assert_eq!(query.to_string(PostgresQueryBuilder), r#"SELECT 6 = 2 * 3"#);
assert_eq!(query.to_string(SqliteQueryBuilder), r#"SELECT 6 = 2 * 3"#);
Postgres only: use ??
to escape ?
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.expr(Expr::cust_with_values("? ?? ?", vec!["a", "b"]))
.to_owned();
assert_eq!(query.to_string(PostgresQueryBuilder), r#"SELECT 'a' ? 'b'"#);
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.expr(Expr::cust_with_values(
"data @?? (?::JSONPATH)",
vec!["hello"],
))
.to_owned();
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT data @? ('hello'::JSONPATH)"#
);
sourcepub fn eq<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
pub fn eq<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
Express an equal (=
) expression.
Examples
use sea_query::{*, tests_cfg::*};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::val("What!").eq("Nothing"))
.and_where(Expr::col(Char::Id).eq(1))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 'What!' = 'Nothing' AND `id` = 1"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 'What!' = 'Nothing' AND "id" = 1"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 'What!' = 'Nothing' AND "id" = 1"#
);
sourcepub fn ne<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
pub fn ne<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
Express a not equal (<>
) expression.
Examples
use sea_query::{*, tests_cfg::*};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::val("Morning").ne("Good"))
.and_where(Expr::col(Char::Id).ne(1))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 'Morning' <> 'Good' AND `id` <> 1"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 'Morning' <> 'Good' AND "id" <> 1"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 'Morning' <> 'Good' AND "id" <> 1"#
);
sourcepub fn equals<T, C>(self, t: T, c: C) -> SimpleExpr where
T: IntoIden,
C: IntoIden,
pub fn equals<T, C>(self, t: T, c: C) -> SimpleExpr where
T: IntoIden,
C: IntoIden,
Express a equal expression between two table columns, you will mainly use this to relate identical value between two table columns.
Examples
use sea_query::{*, tests_cfg::*};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::tbl(Char::Table, Char::FontId).equals(Font::Table, Font::Id))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`font_id` = `font`.`id`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."font_id" = "font"."id""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."font_id" = "font"."id""#
);
sourcepub fn gt<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
pub fn gt<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
Express a greater than (>
) expression.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::tbl(Char::Table, Char::SizeW).gt(2))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` > 2"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" > 2"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" > 2"#
);
sourcepub fn greater_than<T>(self, expr: T) -> SimpleExpr where
T: Into<SimpleExpr>,
pub fn greater_than<T>(self, expr: T) -> SimpleExpr where
T: Into<SimpleExpr>,
Express a greater than (>
) expression to another 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)
.greater_than(Expr::tbl(Char::Table, Char::SizeH))
)
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` > `character`.`size_h`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" > "character"."size_h""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" > "character"."size_h""#
);
sourcepub fn gte<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
pub fn gte<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
Express a greater than or equal (>=
) expression.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::tbl(Char::Table, Char::SizeW).gte(2))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` >= 2"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" >= 2"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" >= 2"#
);
sourcepub fn greater_or_equal<T>(self, expr: T) -> SimpleExpr where
T: Into<SimpleExpr>,
pub fn greater_or_equal<T>(self, expr: T) -> SimpleExpr where
T: Into<SimpleExpr>,
Express a greater than or equal (>=
) expression to another 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)
.greater_or_equal(Expr::tbl(Char::Table, Char::SizeH))
)
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` >= `character`.`size_h`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" >= "character"."size_h""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" >= "character"."size_h""#
);
sourcepub fn lt<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
pub fn lt<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
Express a less than (<
) expression.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::tbl(Char::Table, Char::SizeW).lt(2))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` < 2"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" < 2"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" < 2"#
);
sourcepub fn less_than<T>(self, expr: T) -> SimpleExpr where
T: Into<SimpleExpr>,
pub fn less_than<T>(self, expr: T) -> SimpleExpr where
T: Into<SimpleExpr>,
Express a less than (<
) expression to another 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)
.less_than(Expr::tbl(Char::Table, Char::SizeH))
)
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` < `character`.`size_h`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" < "character"."size_h""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" < "character"."size_h""#
);
sourcepub fn lte<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
pub fn lte<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
Express a less than or equal (<=
) expression.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::tbl(Char::Table, Char::SizeW).lte(2))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` <= 2"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" <= 2"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" <= 2"#
);
sourcepub fn less_or_equal<T>(self, expr: T) -> SimpleExpr where
T: Into<SimpleExpr>,
pub fn less_or_equal<T>(self, expr: T) -> SimpleExpr where
T: Into<SimpleExpr>,
Express a less than or equal (<=
) expression to another 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)
.less_or_equal(Expr::tbl(Char::Table, Char::SizeH))
)
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` <= `character`.`size_h`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" <= "character"."size_h""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" <= "character"."size_h""#
);
sourcepub fn add<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
pub fn add<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
Express an arithmetic addition operation.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::val(1).add(1).equals(Expr::value(2)))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 1 + 1 = 2"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 + 1 = 2"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 + 1 = 2"#
);
sourcepub fn sub<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
pub fn sub<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
Express an arithmetic subtraction operation.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::val(1).sub(1).equals(Expr::value(2)))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 1 - 1 = 2"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 - 1 = 2"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 - 1 = 2"#
);
sourcepub fn mul<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
pub fn mul<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
Express an arithmetic multiplication operation.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::val(1).mul(1).equals(Expr::value(2)))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 1 * 1 = 2"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 * 1 = 2"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 * 1 = 2"#
);
sourcepub fn div<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
pub fn div<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
Express an arithmetic division operation.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::val(1).div(1).equals(Expr::value(2)))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 1 / 1 = 2"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 / 1 = 2"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 1 / 1 = 2"#
);
sourcepub fn between<V>(self, a: V, b: V) -> SimpleExpr where
V: Into<Value>,
pub fn between<V>(self, a: V, b: V) -> SimpleExpr where
V: Into<Value>,
Express a BETWEEN
expression.
Examples
use sea_query::{*, tests_cfg::*};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::tbl(Char::Table, Char::SizeW).between(1, 10))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` BETWEEN 1 AND 10"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" BETWEEN 1 AND 10"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" BETWEEN 1 AND 10"#
);
sourcepub fn not_between<V>(self, a: V, b: V) -> SimpleExpr where
V: Into<Value>,
pub fn not_between<V>(self, a: V, b: V) -> SimpleExpr where
V: Into<Value>,
Express a NOT BETWEEN
expression.
Examples
use sea_query::{*, tests_cfg::*};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::tbl(Char::Table, Char::SizeW).not_between(1, 10))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` NOT BETWEEN 1 AND 10"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" NOT BETWEEN 1 AND 10"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" NOT BETWEEN 1 AND 10"#
);
sourcepub fn like(self, v: &str) -> SimpleExpr
pub fn like(self, v: &str) -> SimpleExpr
Express a LIKE
expression.
Examples
use sea_query::{*, tests_cfg::*};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::tbl(Char::Table, Char::Character).like("Ours'%"))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`character` LIKE 'Ours\'%'"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."character" LIKE E'Ours\'%'"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."character" LIKE 'Ours\'%'"#
);
pub fn not_like(self, v: &str) -> SimpleExpr
sourcepub fn is_null(self) -> SimpleExpr
pub fn is_null(self) -> SimpleExpr
Express a IS NULL
expression.
Examples
use sea_query::{*, tests_cfg::*};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::tbl(Char::Table, Char::SizeW).is_null())
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` IS NULL"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" IS NULL"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" IS NULL"#
);
sourcepub fn is_not_null(self) -> SimpleExpr
pub fn is_not_null(self) -> SimpleExpr
Express a IS NOT NULL
expression.
Examples
use sea_query::{*, tests_cfg::*};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::tbl(Char::Table, Char::SizeW).is_not_null())
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `character`.`size_w` IS NOT NULL"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" IS NOT NULL"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."size_w" IS NOT NULL"#
);
sourcepub fn binary<T>(self, operation: BinOper, right: T) -> SimpleExpr where
T: Into<SimpleExpr>,
pub fn binary<T>(self, operation: BinOper, right: T) -> SimpleExpr where
T: Into<SimpleExpr>,
Create any binary operation
Examples
use sea_query::{*, tests_cfg::*};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.cond_where(all![
Expr::col(Char::SizeW).binary(BinOper::SmallerThan, Expr::value(10)),
Expr::col(Char::SizeW).binary(BinOper::GreaterThan, Expr::col(Char::SizeH))
])
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `size_w` < 10 AND `size_w` > `size_h`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "size_w" < 10 AND "size_w" > "size_h""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "size_w" < 10 AND "size_w" > "size_h""#
);
sourcepub fn not(self) -> SimpleExpr
pub fn not(self) -> SimpleExpr
Negates an expression with NOT
.
Examples
use sea_query::{*, tests_cfg::*};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::expr(Expr::tbl(Char::Table, Char::SizeW).is_null()).not())
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE NOT `character`.`size_w` IS NULL"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE NOT "character"."size_w" IS NULL"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE NOT "character"."size_w" IS NULL"#
);
sourcepub fn max(self) -> SimpleExpr
pub fn max(self) -> SimpleExpr
Express a MAX
function.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.expr(Expr::tbl(Char::Table, Char::SizeW).max())
.from(Char::Table)
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT MAX(`character`.`size_w`) FROM `character`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT MAX("character"."size_w") FROM "character""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT MAX("character"."size_w") FROM "character""#
);
sourcepub fn min(self) -> SimpleExpr
pub fn min(self) -> SimpleExpr
Express a MIN
function.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.expr(Expr::tbl(Char::Table, Char::SizeW).min())
.from(Char::Table)
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT MIN(`character`.`size_w`) FROM `character`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT MIN("character"."size_w") FROM "character""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT MIN("character"."size_w") FROM "character""#
);
sourcepub fn sum(self) -> SimpleExpr
pub fn sum(self) -> SimpleExpr
Express a SUM
function.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.expr(Expr::tbl(Char::Table, Char::SizeW).sum())
.from(Char::Table)
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT SUM(`character`.`size_w`) FROM `character`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT SUM("character"."size_w") FROM "character""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT SUM("character"."size_w") FROM "character""#
);
sourcepub fn count(self) -> SimpleExpr
pub fn count(self) -> SimpleExpr
Express a COUNT
function.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.expr(Expr::tbl(Char::Table, Char::SizeW).count())
.from(Char::Table)
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT COUNT(`character`.`size_w`) FROM `character`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT COUNT("character"."size_w") FROM "character""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT COUNT("character"."size_w") FROM "character""#
);
sourcepub fn if_null<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
pub fn if_null<V>(self, v: V) -> SimpleExpr where
V: Into<Value>,
Express a IF NULL
function.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.expr(Expr::tbl(Char::Table, Char::SizeW).if_null(0))
.from(Char::Table)
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT IFNULL(`character`.`size_w`, 0) FROM `character`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT COALESCE("character"."size_w", 0) FROM "character""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT IFNULL("character"."size_w", 0) FROM "character""#
);
sourcepub fn is_in<V, I>(self, v: I) -> SimpleExpr where
V: Into<Value>,
I: IntoIterator<Item = V>,
pub fn is_in<V, I>(self, v: I) -> SimpleExpr where
V: Into<Value>,
I: IntoIterator<Item = V>,
Express a IN
expression.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Id])
.from(Char::Table)
.and_where(Expr::tbl(Char::Table, Char::SizeW).is_in(vec![1, 2, 3]))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `id` FROM `character` WHERE `character`.`size_w` IN (1, 2, 3)"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "id" FROM "character" WHERE "character"."size_w" IN (1, 2, 3)"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "id" FROM "character" WHERE "character"."size_w" IN (1, 2, 3)"#
);
Empty value list
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Id])
.from(Char::Table)
.and_where(Expr::tbl(Char::Table, Char::SizeW).is_in(Vec::<u8>::new()))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `id` FROM `character` WHERE 1 = 2"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "id" FROM "character" WHERE 1 = 2"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "id" FROM "character" WHERE 1 = 2"#
);
sourcepub fn is_not_in<V, I>(self, v: I) -> SimpleExpr where
V: Into<Value>,
I: IntoIterator<Item = V>,
pub fn is_not_in<V, I>(self, v: I) -> SimpleExpr where
V: Into<Value>,
I: IntoIterator<Item = V>,
Express a NOT IN
expression.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Id])
.from(Char::Table)
.and_where(Expr::tbl(Char::Table, Char::SizeW).is_not_in(vec![1, 2, 3]))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `id` FROM `character` WHERE `character`.`size_w` NOT IN (1, 2, 3)"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "id" FROM "character" WHERE "character"."size_w" NOT IN (1, 2, 3)"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "id" FROM "character" WHERE "character"."size_w" NOT IN (1, 2, 3)"#
);
Empty value list
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Char::Id])
.from(Char::Table)
.and_where(Expr::tbl(Char::Table, Char::SizeW).is_not_in(Vec::<u8>::new()))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `id` FROM `character` WHERE 1 = 1"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "id" FROM "character" WHERE 1 = 1"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "id" FROM "character" WHERE 1 = 1"#
);
sourcepub fn in_subquery(self, sel: SelectStatement) -> SimpleExpr
pub fn in_subquery(self, sel: SelectStatement) -> SimpleExpr
Express a IN
sub-query expression.
Examples
use sea_query::{*, tests_cfg::*};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::col(Char::SizeW).in_subquery(
Query::select()
.expr(Expr::cust("3 + 2 * 2"))
.take()
))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `size_w` IN (SELECT 3 + 2 * 2)"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "size_w" IN (SELECT 3 + 2 * 2)"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "size_w" IN (SELECT 3 + 2 * 2)"#
);
sourcepub fn not_in_subquery(self, sel: SelectStatement) -> SimpleExpr
pub fn not_in_subquery(self, sel: SelectStatement) -> SimpleExpr
Express a NOT IN
sub-query expression.
Examples
use sea_query::{*, tests_cfg::*};
let query = Query::select()
.columns(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::col(Char::SizeW).not_in_subquery(
Query::select()
.expr(Expr::cust("3 + 2 * 2"))
.take()
))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE `size_w` NOT IN (SELECT 3 + 2 * 2)"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "size_w" NOT IN (SELECT 3 + 2 * 2)"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "size_w" NOT IN (SELECT 3 + 2 * 2)"#
);
sourcepub fn matches<T>(self, expr: T) -> SimpleExpr where
T: Into<SimpleExpr>,
pub fn matches<T>(self, expr: T) -> SimpleExpr where
T: Into<SimpleExpr>,
Express an postgres fulltext search matches (@@
) expression.
Examples
use sea_query::{*, tests_cfg::*};
let query = Query::select()
.columns(vec![Font::Name, Font::Variant, Font::Language])
.from(Font::Table)
.and_where(Expr::val("a & b").matches(Expr::val("a b")))
.and_where(Expr::col(Font::Name).matches(Expr::val("a b")))
.to_owned();
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "name", "variant", "language" FROM "font" WHERE 'a & b' @@ 'a b' AND "name" @@ 'a b'"#
);
sourcepub fn contains<T>(self, expr: T) -> SimpleExpr where
T: Into<SimpleExpr>,
pub fn contains<T>(self, expr: T) -> SimpleExpr where
T: Into<SimpleExpr>,
Express an postgres fulltext search contains (@>
) expression.
Examples
use sea_query::{*, tests_cfg::*};
let query = Query::select()
.columns(vec![Font::Name, Font::Variant, Font::Language])
.from(Font::Table)
.and_where(Expr::val("a & b").contains(Expr::val("a b")))
.and_where(Expr::col(Font::Name).contains(Expr::val("a b")))
.to_owned();
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "name", "variant", "language" FROM "font" WHERE 'a & b' @> 'a b' AND "name" @> 'a b'"#
);
sourcepub fn contained<T>(self, expr: T) -> SimpleExpr where
T: Into<SimpleExpr>,
pub fn contained<T>(self, expr: T) -> SimpleExpr where
T: Into<SimpleExpr>,
Express an postgres fulltext search contained (<@
) expression.
Examples
use sea_query::{*, tests_cfg::*};
let query = Query::select()
.columns(vec![Font::Name, Font::Variant, Font::Language])
.from(Font::Table)
.and_where(Expr::val("a & b").contained(Expr::val("a b")))
.and_where(Expr::col(Font::Name).contained(Expr::val("a b")))
.to_owned();
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "name", "variant", "language" FROM "font" WHERE 'a & b' <@ 'a b' AND "name" <@ 'a b'"#
);
sourcepub fn concatenate<T>(self, expr: T) -> SimpleExpr where
T: Into<SimpleExpr>,
pub fn concatenate<T>(self, expr: T) -> SimpleExpr where
T: Into<SimpleExpr>,
Express an postgres concatenate (||
) expression.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns(vec![Font::Name, Font::Variant, Font::Language])
.from(Font::Table)
.and_where(Expr::val("a").concatenate(Expr::val("b")))
.and_where(Expr::val("c").concat(Expr::val("d")))
.to_owned();
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "name", "variant", "language" FROM "font" WHERE 'a' || 'b' AND 'c' || 'd'"#
);
sourcepub fn concat<T>(self, expr: T) -> SimpleExpr where
T: Into<SimpleExpr>,
pub fn concat<T>(self, expr: T) -> SimpleExpr where
T: Into<SimpleExpr>,
Alias of Expr::concatenate
pub fn arg<T>(self, arg: T) -> SimpleExpr where
T: Into<SimpleExpr>,
pub fn args<T, I>(self, args: I) -> SimpleExpr where
T: Into<SimpleExpr>,
I: IntoIterator<Item = T>,
sourcepub fn as_enum<T>(self, type_name: T) -> SimpleExpr where
T: IntoIden,
pub fn as_enum<T>(self, type_name: T) -> SimpleExpr where
T: IntoIden,
Express a AS enum
expression.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.expr(Expr::col(Char::FontSize).as_enum(Alias::new("text")))
.from(Char::Table)
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `font_size` FROM `character`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT CAST("font_size" AS text) FROM "character""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "font_size" FROM "character""#
);
let query = Query::insert()
.into_table(Char::Table)
.columns(vec![Char::FontSize])
.exprs_panic(vec![Expr::val("large").as_enum(Alias::new("FontSizeEnum"))])
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"INSERT INTO `character` (`font_size`) VALUES ('large')"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"INSERT INTO "character" ("font_size") VALUES (CAST('large' AS FontSizeEnum))"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"INSERT INTO "character" ("font_size") VALUES ('large')"#
);
sourcepub fn into_simple_expr(self) -> SimpleExpr
pub fn into_simple_expr(self) -> SimpleExpr
Into::<SimpleExpr>::into()
when type inference is impossible
Trait Implementations
sourceimpl From<Expr> for SimpleExpr
impl From<Expr> for SimpleExpr
sourcefn from(src: Expr) -> SimpleExpr
fn from(src: Expr) -> SimpleExpr
Convert into SimpleExpr. Will panic if this Expr is missing an operand
sourceimpl From<Expr> for SelectExpr
impl From<Expr> for SelectExpr
sourcefn from(src: Expr) -> SelectExpr
fn from(src: Expr) -> SelectExpr
Converts to this type from the input type.
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
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
sourcefn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)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>,
fn vzip(self) -> V
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
T: Future, type Output = <T as Future>::Output;
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
fn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more