Enum starfish_core::migrator::prelude::sea_orm::sea_query::SimpleExpr
source · [−]pub enum SimpleExpr {
Column(ColumnRef),
Tuple(Vec<SimpleExpr, Global>),
Unary(UnOper, Box<SimpleExpr, Global>),
FunctionCall(Function, Vec<SimpleExpr, Global>),
Binary(Box<SimpleExpr, Global>, BinOper, Box<SimpleExpr, Global>),
SubQuery(Box<SubQueryStatement, Global>),
Value(Value),
Values(Vec<Value, Global>),
Custom(String),
CustomWithValues(String, Vec<Value, Global>),
Keyword(Keyword),
AsEnum(Arc<dyn Iden + 'static>, Box<SimpleExpr, Global>),
}
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, Global>)
Unary(UnOper, Box<SimpleExpr, Global>)
FunctionCall(Function, Vec<SimpleExpr, Global>)
Binary(Box<SimpleExpr, Global>, BinOper, Box<SimpleExpr, Global>)
SubQuery(Box<SubQueryStatement, Global>)
Value(Value)
Values(Vec<Value, Global>)
Custom(String)
CustomWithValues(String, Vec<Value, Global>)
Keyword(Keyword)
AsEnum(Arc<dyn Iden + 'static>, Box<SimpleExpr, Global>)
Implementations
sourceimpl SimpleExpr
impl SimpleExpr
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(vec![Char::Character, Char::SizeW, Char::SizeH])
.from(Char::Table)
.or_where(Expr::col(Char::SizeW).eq(1).and(Expr::col(Char::SizeH).eq(2)))
.or_where(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(vec![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 equals<T>(self, right: T) -> SimpleExpr where
T: Into<SimpleExpr>,
pub fn equals<T>(self, right: T) -> SimpleExpr where
T: Into<SimpleExpr>,
Compares with another SimpleExpr
for equality.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.column(Char::Character)
.from(Char::Table)
.and_where(
Expr::col(Char::SizeW)
.mul(2)
.equals(Expr::col(Char::SizeH).mul(3)),
)
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character` FROM `character` WHERE `size_w` * 2 = `size_h` * 3"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character" FROM "character" WHERE "size_w" * 2 = "size_h" * 3"#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character" FROM "character" WHERE "size_w" * 2 = "size_h" * 3"#
);
sourcepub fn not_equals<T>(self, right: T) -> SimpleExpr where
T: Into<SimpleExpr>,
pub fn not_equals<T>(self, right: T) -> SimpleExpr where
T: Into<SimpleExpr>,
Compares with another SimpleExpr
for inequality.
Examples
use sea_query::{tests_cfg::*, *};
let query = Query::select()
.column(Char::Character)
.from(Char::Table)
.and_where(
Expr::col(Char::SizeW)
.mul(2)
.not_equals(Expr::col(Char::SizeH)),
)
.to_owned();
assert_eq!(
query.to_string(MysqlQueryBuilder),
r#"SELECT `character` FROM `character` WHERE `size_w` * 2 <> `size_h`"#
);
assert_eq!(
query.to_string(PostgresQueryBuilder),
r#"SELECT "character" FROM "character" WHERE "size_w" * 2 <> "size_h""#
);
assert_eq!(
query.to_string(SqliteQueryBuilder),
r#"SELECT "character" FROM "character" WHERE "size_w" * 2 <> "size_h""#
);
sourcepub fn add<T>(self, right: T) -> SimpleExpr where
T: Into<SimpleExpr>,
pub fn add<T>(self, right: T) -> SimpleExpr where
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 sub<T>(self, right: T) -> SimpleExpr where
T: Into<SimpleExpr>,
pub fn sub<T>(self, right: T) -> SimpleExpr where
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 concatenate<T>(self, right: T) -> SimpleExpr where
T: Into<SimpleExpr>,
pub fn concatenate<T>(self, right: 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"))
.concat(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' || 'c' || 'd'"#
);
sourcepub fn concat<T>(self, right: T) -> SimpleExpr where
T: Into<SimpleExpr>,
pub fn concat<T>(self, right: T) -> SimpleExpr where
T: Into<SimpleExpr>,
Alias of SimpleExpr::concatenate
sourcepub fn cast_as<T>(self, type_name: T) -> SimpleExpr where
T: IntoIden,
pub fn cast_as<T>(self, type_name: T) -> SimpleExpr where
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)"#
);
Trait Implementations
sourceimpl Clone for SimpleExpr
impl Clone for SimpleExpr
sourcefn clone(&self) -> SimpleExpr
fn clone(&self) -> SimpleExpr
Returns a copy of the value. Read more
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
sourceimpl Debug for SimpleExpr
impl Debug for SimpleExpr
sourceimpl From<Expr> for SimpleExpr
impl From<Expr> for SimpleExpr
sourcefn from(src: Expr) -> SimpleExpr
fn from(src: Expr) -> SimpleExpr
Convert into SimpleExpr. Will panic if this Expr is missing an operand
sourceimpl From<SimpleExpr> for ConditionExpression
impl From<SimpleExpr> for ConditionExpression
sourcefn from(condition: SimpleExpr) -> ConditionExpression
fn from(condition: SimpleExpr) -> ConditionExpression
Converts to this type from the input type.
sourceimpl Into<SelectExpr> for SimpleExpr
impl Into<SelectExpr> for SimpleExpr
sourcefn into(self) -> SelectExpr
fn into(self) -> SelectExpr
Converts this type into the (usually inferred) input type.
sourceimpl IntoCondition for SimpleExpr
impl IntoCondition for SimpleExpr
fn into_condition(self) -> Condition
sourceimpl IntoSimpleExpr for SimpleExpr
impl IntoSimpleExpr for SimpleExpr
sourcefn into_simple_expr(self) -> SimpleExpr
fn into_simple_expr(self) -> SimpleExpr
Method to perform the conversion
Auto Trait Implementations
impl !RefUnwindSafe for SimpleExpr
impl Send for SimpleExpr
impl Sync for SimpleExpr
impl Unpin for SimpleExpr
impl !UnwindSafe for SimpleExpr
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
sourcefn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
fn vzip(self) -> V
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
T: Future, type Output = <T as Future>::Output;
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
fn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more