Enum Expr 

#[non_exhaustive]
pub enum Expr {
    Column(ColumnRef),
    Tuple(Vec<Expr>),
    Unary(UnOper, Box<Expr>),
    FunctionCall(FunctionCall),
    Binary(Box<Expr>, BinOper, Box<Expr>),
    SubQuery(Option<SubQueryOper>, Box<SubQueryStatement>),
    Value(Value),
    Values(Vec<Value>),
    Custom(Cow<'static, str>),
    CustomWithExpr(Cow<'static, str>, Vec<Expr>),
    Keyword(Keyword),
    AsEnum(DynIden, Box<Expr>),
    Case(Box<CaseStatement>),
    Constant(Value),
    TypeName(TypeRef),
}

An arbitrary, dynamically-typed SQL expression.

It can be used in select fields, where clauses and many other places.

More concreterly, under the hood Exprs can be:

• Rust values
• SQL identifiers
• SQL function calls
• various operators and sub-queries

If something is not supported here, look into BinOper::Custom, Func::cust, or Expr::cust* as a workaround, and consider reporting your issue.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Column(ColumnRef)

Tuple(Vec<Expr>)

Unary(UnOper, Box<Expr>)

FunctionCall(FunctionCall)

Binary(Box<Expr>, BinOper, Box<Expr>)

SubQuery(Option<SubQueryOper>, Box<SubQueryStatement>)

Value(Value)

Values(Vec<Value>)

Custom(Cow<'static, str>)

CustomWithExpr(Cow<'static, str>, Vec<Expr>)

Keyword(Keyword)

AsEnum(DynIden, Box<Expr>)

Case(Box<CaseStatement>)

Constant(Value)

TypeName(TypeRef)

Implementations

impl Expr

pub fn asterisk() -> Expr

👎Deprecated since 0.29.0: Please use the [Asterisk]

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([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([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 column<T>(n: T) -> Expr

where T: IntoColumnRef,

Express the target column without table prefix, returning a Expr.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::column(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([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::column((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 = Expr>,

Wraps tuple of Expr, can be used for tuple comparison

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(
        Expr::tuple([Expr::col(Char::SizeW).into(), Expr::value(100)])
            .lt(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,

👎Deprecated since 0.29.0: Please use the [Asterisk]

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([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<T>(expr: T) -> Expr

where T: Into<Expr>,

Wrap an expression to perform some operation on it later.

Since sea_query 0.32.0 (sea_orm 1.1.1), this is not necessary in most cases!

Some SQL operations used to be defined only as inherent methods on Expr. Thus, to use them, you needed to manually convert from other types to Expr. But now these operations are also defined as ExprTrait methods that can be called directly on any expression type,

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    // This is the old style, when `Expr::expr` was necessary:
    .and_where(Expr::expr(Expr::col(Char::SizeW).if_null(0)).gt(2))
    .to_owned();

// But since 0.32.0, this compiles too:
let _ = Expr::col(Char::SizeW).if_null(0).gt(2);

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

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .column(Char::Character)
    .from(Char::Table)
    // This is the old style, when `Expr::expr` was necessary:
    .and_where(Expr::expr(Func::lower(Expr::col(Char::Character))).is_in(["a", "b"]))
    .to_owned();

// But since 0.32.0, this compiles too:
let _ = Func::lower(Expr::col(Char::Character)).is_in(["a", "b"]);

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character` FROM `character` WHERE LOWER(`character`) IN ('a', 'b')"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character" FROM "character" WHERE LOWER("character") IN ('a', 'b')"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character" FROM "character" WHERE LOWER("character") IN ('a', 'b')"#
);

pub fn value<V>(v: V) -> Expr

where V: Into<Expr>,

Express a Value, returning a Expr.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::value(1))
    .and_where(Expr::value(2.5))
    .and_where(Expr::value("3"))
    .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<T>(s: T) -> Expr

where T: Into<Cow<'static, str>>,

Express any custom expression in &str.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::cust("1 = 1"))
    .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<T, V, I>(s: T, v: I) -> Expr

where T: Into<Cow<'static, str>>, 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([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col(Char::Id).eq(1))
    .and_where(Expr::cust_with_values("6 = ? * ?", [2, 3]))
    .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(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()
    .columns([Char::Character, Char::SizeW, Char::SizeH])
    .from(Char::Table)
    .and_where(Expr::col(Char::Id).eq(1))
    .and_where(Expr::cust_with_values("6 = $2 * $1", [3, 2]))
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    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 = ? * ?", [2, 3]))
    .to_owned();

assert_eq!(query.to_string(MysqlQueryBuilder), 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("$1 $$ $2", ["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 @? ($1::JSONPATH)", ["hello"]))
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT data @? ('hello'::JSONPATH)"#
);

pub fn cust_with_expr<T, E>(s: T, expr: E) -> Expr

where T: Into<Cow<'static, str>>, E: Into<Expr>,

Express any custom expression with Expr. Use this if your expression needs other expression.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .expr(Expr::val(1).add(2))
    .expr(Expr::cust_with_expr("data @? ($1::JSONPATH)", "hello"))
    .to_owned();
let (sql, values) = query.build(PostgresQueryBuilder);

assert_eq!(sql, r#"SELECT $1 + $2, data @? ($3::JSONPATH)"#);
assert_eq!(
    values,
    Values(vec![1i32.into(), 2i32.into(), "hello".into()])
);

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .expr(Expr::cust_with_expr(
        "json_agg(DISTINCT $1)",
        Expr::col(Char::Character),
    ))
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT json_agg(DISTINCT "character")"#
);

pub fn cust_with_exprs<T, I>(s: T, v: I) -> Expr

where T: Into<Cow<'static, str>>, I: IntoIterator<Item = Expr>,

Express any custom expression with Expr. Use this if your expression needs other expressions.

pub fn exists(sel: SelectStatement) -> Expr

Express a EXISTS sub-query expression.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .expr_as(Expr::exists(Query::select().column(Char::Id).from(Char::Table).take()), "character_exists")
    .expr_as(Expr::exists(Query::select().column(Glyph::Id).from(Glyph::Table).take()), "glyph_exists")
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT EXISTS(SELECT `id` FROM `character`) AS `character_exists`, EXISTS(SELECT `id` FROM `glyph`) AS `glyph_exists`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT EXISTS(SELECT "id" FROM "character") AS "character_exists", EXISTS(SELECT "id" FROM "glyph") AS "glyph_exists""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT EXISTS(SELECT "id" FROM "character") AS "character_exists", EXISTS(SELECT "id" FROM "glyph") AS "glyph_exists""#
);

pub fn not_exists(sel: SelectStatement) -> Expr

Express a NOT EXISTS sub-query expression.

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .expr_as(Expr::not_exists(Query::select().column(Char::Id).from(Char::Table).take()), "character_exists")
    .expr_as(Expr::not_exists(Query::select().column(Glyph::Id).from(Glyph::Table).take()), "glyph_exists")
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT NOT EXISTS(SELECT `id` FROM `character`) AS `character_exists`, NOT EXISTS(SELECT `id` FROM `glyph`) AS `glyph_exists`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT NOT EXISTS(SELECT "id" FROM "character") AS "character_exists", NOT EXISTS(SELECT "id" FROM "glyph") AS "glyph_exists""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT NOT EXISTS(SELECT "id" FROM "character") AS "character_exists", NOT EXISTS(SELECT "id" FROM "glyph") AS "glyph_exists""#
);

pub fn any(sel: SelectStatement) -> Expr

Express a ANY sub-query expression.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .column(Char::Id)
    .from(Char::Table)
    .and_where(Expr::col(Char::Id).eq(Expr::any(
        Query::select().column(Char::Id).from(Char::Table).take(),
    )))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `id` FROM `character` WHERE `id` = ANY(SELECT `id` FROM `character`)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "id" FROM "character" WHERE "id" = ANY(SELECT "id" FROM "character")"#
);

pub fn some(sel: SelectStatement) -> Expr

Express a SOME sub-query expression.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .column(Char::Id)
    .from(Char::Table)
    .and_where(Expr::col(Char::Id).ne(Expr::some(
        Query::select().column(Char::Id).from(Char::Table).take(),
    )))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `id` FROM `character` WHERE `id` <> SOME(SELECT `id` FROM `character`)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "id" FROM "character" WHERE "id" <> SOME(SELECT "id" FROM "character")"#
);

pub fn all(sel: SelectStatement) -> Expr

Express a ALL sub-query expression.

pub fn case<C, T>(cond: C, then: T) -> CaseStatement

where C: IntoCondition, T: Into<Expr>,

Adds new CASE WHEN to existing case statement.

Examples

use sea_query::{*, tests_cfg::*};

let query = Query::select()
    .expr_as(
        Expr::case(
                Expr::col((Glyph::Table, Glyph::Aspect)).is_in([2, 4]),
                true
             )
            .finally(false),
         "is_even"
    )
    .from(Glyph::Table)
    .to_owned();

assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT (CASE WHEN ("glyph"."aspect" IN (2, 4)) THEN TRUE ELSE FALSE END) AS "is_even" FROM "glyph""#
);

pub fn null() -> Expr

Keyword NULL.

Examples

use sea_query::*;

let query = Query::select().expr(Expr::null()).to_owned();

assert_eq!(query.to_string(MysqlQueryBuilder), r#"SELECT NULL"#);
assert_eq!(query.to_string(PostgresQueryBuilder), r#"SELECT NULL"#);
assert_eq!(query.to_string(SqliteQueryBuilder), r#"SELECT NULL"#);

pub fn current_date() -> Expr

Keyword CURRENT_DATE.

Examples

use sea_query::*;

let query = Query::select().expr(Expr::current_date()).to_owned();

assert_eq!(query.to_string(MysqlQueryBuilder), r#"SELECT CURRENT_DATE"#);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT CURRENT_DATE"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT CURRENT_DATE"#
);

pub fn current_time() -> Expr

Keyword CURRENT_TIMESTAMP.

Examples

use sea_query::*;

let query = Query::select().expr(Expr::current_time()).to_owned();

assert_eq!(query.to_string(MysqlQueryBuilder), r#"SELECT CURRENT_TIME"#);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT CURRENT_TIME"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT CURRENT_TIME"#
);

pub fn current_timestamp() -> Expr

Keyword CURRENT_TIMESTAMP.

Examples

use sea_query::{Expr, MysqlQueryBuilder, PostgresQueryBuilder, Query, SqliteQueryBuilder};

let query = Query::select().expr(Expr::current_timestamp()).to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT CURRENT_TIMESTAMP"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT CURRENT_TIMESTAMP"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT CURRENT_TIMESTAMP"#
);

pub fn keyword_default() -> Expr

Keyword DEFAULT.

SQLite does not support VALUES ​​(DEFAULT).

Examples

use sea_query::{
    Expr, MysqlQueryBuilder, PostgresQueryBuilder, Query, SqliteQueryBuilder, tests_cfg::*,
};

let query = Query::insert()
    .columns([Char::Id])
    .values_panic([Expr::keyword_default()])
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"INSERT (`id`) VALUES (DEFAULT)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"INSERT ("id") VALUES (DEFAULT)"#
);

pub fn custom_keyword<T>(i: T) -> Expr

where T: IntoIden,

Custom keyword.

Examples

use sea_query::*;

let query = Query::select()
    .expr(Expr::custom_keyword("test"))
    .to_owned();

assert_eq!(query.to_string(MysqlQueryBuilder), r#"SELECT test"#);
assert_eq!(query.to_string(PostgresQueryBuilder), r#"SELECT test"#);
assert_eq!(query.to_string(SqliteQueryBuilder), r#"SELECT test"#);

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ColumnAsExpr for Expr

fn into_column_as_expr(self) -> Expr

Casting ActiveEnum as TEXT in select expression, otherwise same as IntoSimpleExpr::into_simple_expr

impl Debug for Expr

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

Formats the value using the given formatter.

impl From<Builder> for Expr

fn from(builder: Builder) -> Expr

Converts to this type from the input type.

impl From<Builder> for Expr

fn from(builder: Builder) -> Expr

Converts to this type from the input type.

impl From<Builder> for Expr

fn from(value: Builder) -> Expr

Converts to this type from the input type.

impl From<Builder> for Expr

fn from(builder: Builder) -> Expr

Converts to this type from the input type.

impl From<ColumnRef> for Expr

fn from(col: ColumnRef) -> Expr

Converts to this type from the input type.

impl From<Condition> for Expr

fn from(cond: Condition) -> Expr

Converts to this type from the input type.

impl From<ConditionExpression> for Expr

fn from(ce: ConditionExpression) -> Expr

Converts to this type from the input type.

impl From<DeleteStatement> for Expr

fn from(v: DeleteStatement) -> Expr

Converts to this type from the input type.

impl From<Expr> for Condition

fn from(expr: Expr) -> Condition

Converts to this type from the input type.

impl From<Expr> for IndexColumn

fn from(value: Expr) -> IndexColumn

Converts to this type from the input type.

impl From<FunctionCall> for Expr

fn from(func: FunctionCall) -> Expr

Converts to this type from the input type.

impl From<InsertStatement> for Expr

fn from(v: InsertStatement) -> Expr

Converts to this type from the input type.

impl From<Keyword> for Expr

fn from(k: Keyword) -> Expr

Converts to this type from the input type.

impl From<LikeExpr> for Expr

fn from(like: LikeExpr) -> Expr

Converts to this type from the input type.

impl From<SelectStatement> for Expr

fn from(v: SelectStatement) -> Expr

Converts to this type from the input type.

impl From<SubQueryStatement> for Expr

fn from(v: SubQueryStatement) -> Expr

Converts to this type from the input type.

impl<T> From<T> for Expr

where T: Into<Value>,

fn from(v: T) -> Expr

Converts to this type from the input type.

impl From<TypeRef> for Expr

fn from(type_name: TypeRef) -> Expr

Converts to this type from the input type.

impl From<UpdateStatement> for Expr

fn from(v: UpdateStatement) -> Expr

Converts to this type from the input type.

impl From<Vec<Value>> for Expr

fn from(v: Vec<Value>) -> Expr

Converts to this type from the input type.

impl From<WithQuery> for Expr

fn from(v: WithQuery) -> Expr

Converts to this type from the input type.

impl Into<Expr> for CaseStatement

fn into(self) -> Expr

Converts this type into the (usually inferred) input type.

impl IntoSimpleExpr for Expr

fn into_simple_expr(self) -> Expr

Method to perform the conversion

impl PartialEq for Expr

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Expr