Enum sea_query::expr::SimpleExpr[][src]

pub enum SimpleExpr {
    Column(Rc<dyn Iden>),
    TableColumn(Rc<dyn Iden>, Rc<dyn Iden>),
    Unary(UnOperBox<SimpleExpr>),
    FunctionCall(FunctionVec<SimpleExpr>),
    Binary(Box<SimpleExpr>, BinOperBox<SimpleExpr>),
    SubQuery(Box<SelectStatement>),
    Value(Value),
    Values(Vec<Value>),
    Custom(String),
}

Expression used in query, including all supported expression variants.

SimpleExpr represent various kinds of expression can be used in query. Two SimpleExpr can be chain together with method defined below, such as logical AND, logical OR, arithmetic ADD ...etc. Please reference below for more details.

Variants

Column(Rc<dyn Iden>)
TableColumn(Rc<dyn Iden>, Rc<dyn Iden>)
FunctionCall(FunctionVec<SimpleExpr>)
SubQuery(Box<SelectStatement>)
Value(Value)
Values(Vec<Value>)
Custom(String)

Implementations

impl SimpleExpr[src]

pub fn and(self, right: SimpleExpr) -> Self[src]

Express a logical and expression.

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

pub fn or(self, right: SimpleExpr) -> Self[src]

Express a logical or 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).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))"#
);

pub fn equals(self, right: SimpleExpr) -> Self[src]

Express a logical 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::col(Char::SizeW).max().equals(Expr::col(Char::SizeH).max()))
    .to_owned();
 
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE MAX(`size_w`) = MAX(`size_h`)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE MAX("size_w") = MAX("size_h")"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE MAX(`size_w`) = MAX(`size_h`)"#
);

pub fn not_equals(self, right: SimpleExpr) -> Self[src]

Express a logical 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::col(Char::SizeW).max().not_equals(Expr::col(Char::SizeH).max()))
    .to_owned();
 
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE MAX(`size_w`) <> MAX(`size_h`)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE MAX("size_w") <> MAX("size_h")"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE MAX(`size_w`) <> MAX(`size_h`)"#
);

pub fn add(self, right: SimpleExpr) -> Self[src]

Express a arithmetic addition 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).max().add(Expr::col(Char::SizeH).max()))
    .to_owned();
 
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE MAX(`size_w`) + MAX(`size_h`)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE MAX("size_w") + MAX("size_h")"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE MAX(`size_w`) + MAX(`size_h`)"#
);

pub fn sub(self, right: SimpleExpr) -> Self[src]

Express a arithmetic subtraction 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).max().sub(Expr::col(Char::SizeH).max()))
    .to_owned();
 
assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE MAX(`size_w`) - MAX(`size_h`)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE MAX("size_w") - MAX("size_h")"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT `character`, `size_w`, `size_h` FROM `character` WHERE MAX(`size_w`) - MAX(`size_h`)"#
);

Trait Implementations

impl Clone for SimpleExpr[src]

impl Into<SelectExpr> for SimpleExpr[src]

impl Into<SimpleExpr> for Expr[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.