Enum sea_orm_migration::prelude::SimpleExpr
source · pub enum SimpleExpr {
Show 14 variants
Column(ColumnRef),
Tuple(Vec<SimpleExpr>),
Unary(UnOper, Box<SimpleExpr>),
FunctionCall(FunctionCall),
Binary(Box<SimpleExpr>, BinOper, Box<SimpleExpr>),
SubQuery(Option<SubQueryOper>, Box<SubQueryStatement>),
Value(Value),
Values(Vec<Value>),
Custom(String),
CustomWithExpr(String, Vec<SimpleExpr>),
Keyword(Keyword),
AsEnum(SeaRc<dyn Iden>, Box<SimpleExpr>),
Case(Box<CaseStatement>),
Constant(Value),
}
Expand description
Represents a Simple Expression in SQL.
SimpleExpr
is a node in the expression tree and can represent identifiers, function calls,
various operators and sub-queries.
Variants§
Column(ColumnRef)
Tuple(Vec<SimpleExpr>)
Unary(UnOper, Box<SimpleExpr>)
FunctionCall(FunctionCall)
Binary(Box<SimpleExpr>, BinOper, Box<SimpleExpr>)
SubQuery(Option<SubQueryOper>, Box<SubQueryStatement>)
Value(Value)
Values(Vec<Value>)
Custom(String)
CustomWithExpr(String, Vec<SimpleExpr>)
Keyword(Keyword)
AsEnum(SeaRc<dyn Iden>, Box<SimpleExpr>)
Case(Box<CaseStatement>)
Constant(Value)
Implementations§
source§impl SimpleExpr
impl SimpleExpr
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()
.column(Char::SizeW)
.from(Char::Table)
.and_where(Expr::col(Char::SizeW).eq(1).not())
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `size_w` FROM `character` WHERE NOT `size_w` = 1"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "size_w" FROM "character" WHERE NOT "size_w" = 1"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "size_w" FROM "character" WHERE NOT "size_w" = 1"#
);
sourcepub fn and(self, right: SimpleExpr) -> SimpleExpr
pub fn and(self, right: SimpleExpr) -> SimpleExpr
Express a logical AND
operation.
§Examples
use sea_query::{*, tests_cfg::*};
let query = Query::select()
.columns([Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.cond_where(any![
Expr::col(Char::SizeW).eq(1).and(Expr::col(Char::SizeH).eq(2)),
Expr::col(Char::SizeW).eq(3).and(Expr::col(Char::SizeH).eq(4)),
])
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE (`size_w` = 1 AND `size_h` = 2) OR (`size_w` = 3 AND `size_h` = 4)"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE ("size_w" = 1 AND "size_h" = 2) OR ("size_w" = 3 AND "size_h" = 4)"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE ("size_w" = 1 AND "size_h" = 2) OR ("size_w" = 3 AND "size_h" = 4)"#
);
sourcepub fn or(self, right: SimpleExpr) -> SimpleExpr
pub fn or(self, right: SimpleExpr) -> SimpleExpr
Express a logical OR
operation.
§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).or(Expr::col(Char::SizeH).eq(2)))
.and_where(Expr::col(Char::SizeW).eq(3).or(Expr::col(Char::SizeH).eq(4)))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE (`size_w` = 1 OR `size_h` = 2) AND (`size_w` = 3 OR `size_h` = 4)"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE ("size_w" = 1 OR "size_h" = 2) AND ("size_w" = 3 OR "size_h" = 4)"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE ("size_w" = 1 OR "size_h" = 2) AND ("size_w" = 3 OR "size_h" = 4)"#
);
sourcepub fn eq<V>(self, v: V) -> SimpleExprwhere
V: Into<SimpleExpr>,
pub fn eq<V>(self, v: V) -> SimpleExprwhere
V: Into<SimpleExpr>,
Express an equal (=
) expression.
§Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns([Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::value("What!").eq("Nothing"))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 'What!' = 'Nothing'"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 'What!' = 'Nothing'"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 'What!' = 'Nothing'"#
);
sourcepub fn ne<V>(self, v: V) -> SimpleExprwhere
V: Into<SimpleExpr>,
pub fn ne<V>(self, v: V) -> SimpleExprwhere
V: Into<SimpleExpr>,
Express a not equal (<>
) expression.
§Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.columns([Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.and_where(Expr::value("Morning").ne("Good"))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE 'Morning' <> 'Good'"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 'Morning' <> 'Good'"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 'Morning' <> 'Good'"#
);
sourcepub fn add<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
pub fn add<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
Perform addition with another SimpleExpr
.
§Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.expr(
Expr::col(Char::SizeW)
.max()
.add(Expr::col(Char::SizeH).max()),
)
.from(Char::Table)
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT MAX(`size_w`) + MAX(`size_h`) FROM `character`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT MAX("size_w") + MAX("size_h") FROM "character""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT MAX("size_w") + MAX("size_h") FROM "character""#
);
sourcepub fn mul<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
pub fn mul<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
Perform multiplication with another SimpleExpr
.
§Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.expr(
Expr::col(Char::SizeW)
.max()
.mul(Expr::col(Char::SizeH).max()),
)
.from(Char::Table)
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT MAX(`size_w`) * MAX(`size_h`) FROM `character`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT MAX("size_w") * MAX("size_h") FROM "character""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT MAX("size_w") * MAX("size_h") FROM "character""#
);
sourcepub fn div<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
pub fn div<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
Perform division with another SimpleExpr
.
§Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.expr(
Expr::col(Char::SizeW)
.max()
.div(Expr::col(Char::SizeH).max()),
)
.from(Char::Table)
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT MAX(`size_w`) / MAX(`size_h`) FROM `character`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT MAX("size_w") / MAX("size_h") FROM "character""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT MAX("size_w") / MAX("size_h") FROM "character""#
);
sourcepub fn sub<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
pub fn sub<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
Perform subtraction with another SimpleExpr
.
§Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.expr(
Expr::col(Char::SizeW)
.max()
.sub(Expr::col(Char::SizeW).min()),
)
.from(Char::Table)
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT MAX(`size_w`) - MIN(`size_w`) FROM `character`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT MAX("size_w") - MIN("size_w") FROM "character""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT MAX("size_w") - MIN("size_w") FROM "character""#
);
sourcepub fn cast_as<T>(self, type_name: T) -> SimpleExprwhere
T: IntoIden,
pub fn cast_as<T>(self, type_name: T) -> SimpleExprwhere
T: IntoIden,
Express a CAST AS
expression.
§Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.expr(Expr::value("1").cast_as(Alias::new("integer")))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT CAST('1' AS integer)"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT CAST('1' AS integer)"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT CAST('1' AS integer)"#
);
sourcepub fn binary<O, T>(self, op: O, right: T) -> SimpleExpr
pub fn binary<O, T>(self, op: O, right: T) -> SimpleExpr
Create any binary operation
§Examples
use sea_query::{*, tests_cfg::*};
let query = Query::select()
.columns([Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.cond_where(all![
Expr::value(10).binary(BinOper::SmallerThan, Expr::col(Char::SizeW)),
Expr::value(20).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 10 < `size_w` AND 20 > `size_h`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 10 < "size_w" AND 20 > "size_h""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE 10 < "size_w" AND 20 > "size_h""#
);
sourcepub fn like<L>(self, like: L) -> SimpleExprwhere
L: IntoLikeExpr,
pub fn like<L>(self, like: L) -> SimpleExprwhere
L: IntoLikeExpr,
Express a LIKE
expression.
§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::Table, Char::FontId)).cast_as(Alias::new("TEXT")).like("a%"))
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE CAST(`character`.`font_id` AS TEXT) LIKE 'a%'"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE CAST("character"."font_id" AS TEXT) LIKE 'a%'"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE CAST("character"."font_id" AS TEXT) LIKE 'a%'"#
);
sourcepub fn not_like<L>(self, like: L) -> SimpleExprwhere
L: IntoLikeExpr,
pub fn not_like<L>(self, like: L) -> SimpleExprwhere
L: IntoLikeExpr,
Express a NOT LIKE
expression
Trait Implementations§
source§impl Clone for SimpleExpr
impl Clone for SimpleExpr
source§fn clone(&self) -> SimpleExpr
fn clone(&self) -> SimpleExpr
Returns a copy of the value. Read more
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from
source
. Read moresource§impl Debug for SimpleExpr
impl Debug for SimpleExpr
source§impl From<ColumnRef> for SimpleExpr
impl From<ColumnRef> for SimpleExpr
source§fn from(col: ColumnRef) -> SimpleExpr
fn from(col: ColumnRef) -> SimpleExpr
Converts to this type from the input type.
source§impl From<Expr> for SimpleExpr
impl From<Expr> for SimpleExpr
source§fn from(src: Expr) -> SimpleExpr
fn from(src: Expr) -> SimpleExpr
Convert into SimpleExpr
source§impl From<FunctionCall> for SimpleExpr
impl From<FunctionCall> for SimpleExpr
source§fn from(func: FunctionCall) -> SimpleExpr
fn from(func: FunctionCall) -> SimpleExpr
Converts to this type from the input type.
source§impl From<Keyword> for SimpleExpr
impl From<Keyword> for SimpleExpr
source§fn from(k: Keyword) -> SimpleExpr
fn from(k: Keyword) -> SimpleExpr
Converts to this type from the input type.
source§impl From<SimpleExpr> for ConditionExpression
impl From<SimpleExpr> for ConditionExpression
source§fn from(condition: SimpleExpr) -> ConditionExpression
fn from(condition: SimpleExpr) -> ConditionExpression
Converts to this type from the input type.
source§impl<T> From<T> for SimpleExpr
impl<T> From<T> for SimpleExpr
source§fn from(v: T) -> SimpleExpr
fn from(v: T) -> SimpleExpr
Converts to this type from the input type.
source§impl Into<SimpleExpr> for CaseStatement
impl Into<SimpleExpr> for CaseStatement
source§fn into(self) -> SimpleExpr
fn into(self) -> SimpleExpr
Converts this type into the (usually inferred) input type.
source§impl IntoCondition for SimpleExpr
impl IntoCondition for SimpleExpr
fn into_condition(self) -> Condition
source§impl IntoSimpleExpr for SimpleExpr
impl IntoSimpleExpr for SimpleExpr
source§fn into_simple_expr(self) -> SimpleExpr
fn into_simple_expr(self) -> SimpleExpr
Method to perform the conversion
source§impl PartialEq for SimpleExpr
impl PartialEq for SimpleExpr
source§fn eq(&self, other: &SimpleExpr) -> bool
fn eq(&self, other: &SimpleExpr) -> bool
This method tests for
self
and other
values to be equal, and is used
by ==
.source§impl PgExpr for SimpleExpr
impl PgExpr for SimpleExpr
source§fn concatenate<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
fn concatenate<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
Express an postgres concatenate (
||
) expression. Read moresource§fn concat<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
fn concat<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
Alias of
PgExpr::concatenate
source§fn matches<T>(self, expr: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
fn matches<T>(self, expr: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
Express an postgres fulltext search matches (
@@
) expression. Read moresource§fn contains<T>(self, expr: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
fn contains<T>(self, expr: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
Express an postgres fulltext search contains (
@>
) expression. Read moresource§fn contained<T>(self, expr: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
fn contained<T>(self, expr: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
Express an postgres fulltext search contained (
<@
) expression. Read moresource§fn ilike<L>(self, like: L) -> SimpleExprwhere
L: IntoLikeExpr,
fn ilike<L>(self, like: L) -> SimpleExprwhere
L: IntoLikeExpr,
Express a
ILIKE
expression. Read moresource§fn not_ilike<L>(self, like: L) -> SimpleExprwhere
L: IntoLikeExpr,
fn not_ilike<L>(self, like: L) -> SimpleExprwhere
L: IntoLikeExpr,
Express a
NOT ILIKE
expressionsource§fn get_json_field<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
fn get_json_field<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
Express a postgres retrieves JSON field as JSON value (
->
). Read moresource§fn cast_json_field<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
fn cast_json_field<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
Express a postgres retrieves JSON field and casts it to an appropriate SQL type (
->>
). Read moresource§impl SqliteExpr for SimpleExpr
impl SqliteExpr for SimpleExpr
source§fn glob<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
fn glob<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
Express an sqlite
GLOB
operator. Read moresource§fn matches<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
fn matches<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
Express an sqlite
MATCH
operator. Read moresource§fn get_json_field<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
fn get_json_field<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
Express an sqlite retrieves JSON field as JSON value (
->
). Read moresource§fn cast_json_field<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
fn cast_json_field<T>(self, right: T) -> SimpleExprwhere
T: Into<SimpleExpr>,
Express an sqlite retrieves JSON field and casts it to an appropriate SQL type (
->>
). Read moreimpl StructuralPartialEq for SimpleExpr
Auto Trait Implementations§
impl Freeze for SimpleExpr
impl !RefUnwindSafe for SimpleExpr
impl Send for SimpleExpr
impl Sync for SimpleExpr
impl Unpin for SimpleExpr
impl !UnwindSafe for SimpleExpr
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more