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() -> Self

👎Deprecated since 0.29.0: Please use the [Asterisk]

pub fn col<T>(n: T) -> Self

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) -> Self

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) -> Self

where I: IntoIterator<Item = Self>,

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) -> Self

where T: IntoIden,

👎Deprecated since 0.29.0: Please use the [Asterisk]

pub fn val<V>(v: V) -> Self

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) -> Self

where T: Into<Self>,

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) -> Self

where V: Into<Self>,

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) -> Self

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) -> Self

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) -> Self

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

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) -> Self

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) -> Self

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) -> Self

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) -> Self

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) -> Self

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) -> Self

Express a ALL sub-query expression.

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

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

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() -> Self

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() -> Self

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() -> Self

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() -> Self

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() -> Self

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) -> Self

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 Debug for Expr

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

Formats the value using the given formatter.

impl From<Builder> for Expr

Available on crate feature backend-postgres only.

fn from(builder: Builder) -> Self

Converts to this type from the input type.

impl From<Builder> for Expr

Available on crate feature backend-postgres only.

fn from(builder: Builder) -> Self

Converts to this type from the input type.

impl From<Builder> for Expr

Available on crate feature backend-postgres only.

fn from(value: Builder) -> Self

Converts to this type from the input type.

impl From<Builder> for Expr

Available on crate feature backend-postgres only.

fn from(builder: Builder) -> Self

Converts to this type from the input type.

impl From<ColumnRef> for Expr

fn from(col: ColumnRef) -> Self

Converts to this type from the input type.

impl From<Condition> for Expr

fn from(cond: Condition) -> Self

Converts to this type from the input type.

impl From<DeleteStatement> for Expr

fn from(v: DeleteStatement) -> Self

Converts to this type from the input type.

impl From<Expr> for Condition

fn from(expr: Expr) -> Self

Converts to this type from the input type.

impl From<Expr> for IndexColumn

fn from(value: Expr) -> Self

Converts to this type from the input type.

impl From<FunctionCall> for Expr

fn from(func: FunctionCall) -> Self

Converts to this type from the input type.

impl From<InsertStatement> for Expr

fn from(v: InsertStatement) -> Self

Converts to this type from the input type.

impl From<Keyword> for Expr

fn from(k: Keyword) -> Self

Converts to this type from the input type.

impl From<LikeExpr> for Expr

fn from(like: LikeExpr) -> Self

Converts to this type from the input type.

impl From<SelectStatement> for Expr

fn from(v: SelectStatement) -> Self

Converts to this type from the input type.

impl From<SubQueryStatement> for Expr

fn from(v: SubQueryStatement) -> Self

Converts to this type from the input type.

impl<T> From<T> for Expr

where T: Into<Value>,

fn from(v: T) -> Self

Converts to this type from the input type.

impl From<TypeRef> for Expr

fn from(type_name: TypeRef) -> Self

Converts to this type from the input type.

impl From<UpdateStatement> for Expr

fn from(v: UpdateStatement) -> Self

Converts to this type from the input type.

impl From<Vec<Value>> for Expr

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

Converts to this type from the input type.

impl From<WithQuery> for Expr

fn from(v: WithQuery) -> Self

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