Struct sea_orm_migration::prelude::expr::Expr

pub struct Expr { /* private fields */ }

Helper to build a SimpleExpr.

Implementations

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn into_simple_expr(self) -> SimpleExpr

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

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Expr

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Expr

fn default() -> Expr

Returns the “default value” for a type.

impl From<Expr> for SimpleExpr

fn from(src: Expr) -> SimpleExpr

Convert into SimpleExpr. Will panic if this Expr is missing an operand

impl From<Expr> for SelectExpr

fn from(src: Expr) -> SelectExpr

Converts to this type from the input type.