[][src]Trait diesel::expression_methods::ExpressionMethods

pub trait ExpressionMethods: Expression + Sized {
    fn eq<T>(self, other: T) -> Eq<Self, T>
    where
        Self::SqlType: SqlType,
        T: AsExpression<Self::SqlType>
, { ... }
fn ne<T>(self, other: T) -> NotEq<Self, T>
    where
        Self::SqlType: SqlType,
        T: AsExpression<Self::SqlType>
, { ... }
fn eq_any<T>(self, values: T) -> EqAny<Self, T>
    where
        Self::SqlType: SqlType,
        T: AsInExpression<Self::SqlType>
, { ... }
fn ne_all<T>(self, values: T) -> NeAny<Self, T>
    where
        Self::SqlType: SqlType,
        T: AsInExpression<Self::SqlType>
, { ... }
fn is_null(self) -> IsNull<Self> { ... }
fn is_not_null(self) -> IsNotNull<Self> { ... }
fn gt<T>(self, other: T) -> Gt<Self, T>
    where
        Self::SqlType: SqlType,
        T: AsExpression<Self::SqlType>
, { ... }
fn ge<T>(self, other: T) -> GtEq<Self, T>
    where
        Self::SqlType: SqlType,
        T: AsExpression<Self::SqlType>
, { ... }
fn lt<T>(self, other: T) -> Lt<Self, T>
    where
        Self::SqlType: SqlType,
        T: AsExpression<Self::SqlType>
, { ... }
fn le<T>(self, other: T) -> LtEq<Self, T>
    where
        Self::SqlType: SqlType,
        T: AsExpression<Self::SqlType>
, { ... }
fn between<T, U>(self, lower: T, upper: U) -> Between<Self, T, U>
    where
        Self::SqlType: SqlType,
        T: AsExpression<Self::SqlType>,
        U: AsExpression<Self::SqlType>
, { ... }
fn not_between<T, U>(self, lower: T, upper: U) -> NotBetween<Self, T, U>
    where
        Self::SqlType: SqlType,
        T: AsExpression<Self::SqlType>,
        U: AsExpression<Self::SqlType>
, { ... }
fn desc(self) -> Desc<Self> { ... }
fn asc(self) -> Asc<Self> { ... } }

Methods present on all expressions, except tuples

Provided methods

fn eq<T>(self, other: T) -> Eq<Self, T> where
    Self::SqlType: SqlType,
    T: AsExpression<Self::SqlType>, 

Creates a SQL = expression.

Example

let data = users.select(id).filter(name.eq("Sean"));
assert_eq!(Ok(1), data.first(&connection));

fn ne<T>(self, other: T) -> NotEq<Self, T> where
    Self::SqlType: SqlType,
    T: AsExpression<Self::SqlType>, 

Creates a SQL != expression.

Example

let data = users.select(id).filter(name.ne("Sean"));
assert_eq!(Ok(2), data.first(&connection));

fn eq_any<T>(self, values: T) -> EqAny<Self, T> where
    Self::SqlType: SqlType,
    T: AsInExpression<Self::SqlType>, 

Creates a SQL IN statement.

Queries using this method will not typically be placed in the prepared statement cache. However, in cases when a subquery is passed to the method, that query will use the cache (assuming the subquery itself is safe to cache). On PostgreSQL, you should use eq(any()) instead. This method may change in the future to automatically perform = ANY on PostgreSQL.

Example

let data = users::table.select(users::id).filter(users::name.eq_any(vec!["Sean", "Jim"]));
assert_eq!(Ok(vec![1, 3]), data.load(&connection));

// Calling `eq_any` with an empty array is the same as doing `WHERE 1=0`
let data = users::table.select(users::id).filter(users::name.eq_any(Vec::<String>::new()));
assert_eq!(Ok(vec![]), data.load::<i32>(&connection));

// Calling `eq_any` with a subquery is the same as using
// `WHERE {column} IN {subquery}`.

let subquery = users::table.filter(users::name.eq("Sean")).select(users::id).into_boxed();
let data = posts::table.select(posts::id).filter(posts::user_id.eq_any(subquery));
assert_eq!(Ok(vec![1, 2]), data.load::<i32>(&connection));

fn ne_all<T>(self, values: T) -> NeAny<Self, T> where
    Self::SqlType: SqlType,
    T: AsInExpression<Self::SqlType>, 

Creates a SQL NOT IN statement.

Queries using this method will not be placed in the prepared statement cache. On PostgreSQL, you should use ne(all()) instead. This method may change in the future to automatically perform != ALL on PostgreSQL.

Example

let data = users.select(id).filter(name.ne_all(vec!["Sean", "Jim"]));
assert_eq!(Ok(vec![2]), data.load(&connection));

let data = users.select(id).filter(name.ne_all(vec!["Tess"]));
assert_eq!(Ok(vec![1, 3]), data.load(&connection));

// Calling `ne_any` with an empty array is the same as doing `WHERE 1=1`
let data = users.select(id).filter(name.ne_all(Vec::<String>::new()));
assert_eq!(Ok(vec![1, 2, 3]), data.load(&connection));

fn is_null(self) -> IsNull<Self>

Creates a SQL IS NULL expression.

Example

let data = animals
    .select(species)
    .filter(name.is_null())
    .first::<String>(&connection)?;
assert_eq!("spider", data);

fn is_not_null(self) -> IsNotNull<Self>

Creates a SQL IS NOT NULL expression.

Example

let data = animals
    .select(species)
    .filter(name.is_not_null())
    .first::<String>(&connection)?;
assert_eq!("dog", data);

fn gt<T>(self, other: T) -> Gt<Self, T> where
    Self::SqlType: SqlType,
    T: AsExpression<Self::SqlType>, 

Creates a SQL > expression.

Example

let data = users
    .select(name)
    .filter(id.gt(1))
    .first::<String>(&connection)?;
assert_eq!("Tess", data);

fn ge<T>(self, other: T) -> GtEq<Self, T> where
    Self::SqlType: SqlType,
    T: AsExpression<Self::SqlType>, 

Creates a SQL >= expression.

Example

let data = users
    .select(name)
    .filter(id.ge(2))
    .first::<String>(&connection)?;
assert_eq!("Tess", data);

fn lt<T>(self, other: T) -> Lt<Self, T> where
    Self::SqlType: SqlType,
    T: AsExpression<Self::SqlType>, 

Creates a SQL < expression.

Example

let data = users
    .select(name)
    .filter(id.lt(2))
    .first::<String>(&connection)?;
assert_eq!("Sean", data);

fn le<T>(self, other: T) -> LtEq<Self, T> where
    Self::SqlType: SqlType,
    T: AsExpression<Self::SqlType>, 

Creates a SQL <= expression.

Example

let data = users
    .select(name)
    .filter(id.le(2))
    .first::<String>(&connection)?;
assert_eq!("Sean", data);

fn between<T, U>(self, lower: T, upper: U) -> Between<Self, T, U> where
    Self::SqlType: SqlType,
    T: AsExpression<Self::SqlType>,
    U: AsExpression<Self::SqlType>, 

Creates a SQL BETWEEN expression using the given lower and upper bounds.

Example

let data = animals
    .select(species)
    .filter(legs.between(2, 6))
    .first(&connection);
assert_eq!(Ok("dog".to_string()), data);

fn not_between<T, U>(self, lower: T, upper: U) -> NotBetween<Self, T, U> where
    Self::SqlType: SqlType,
    T: AsExpression<Self::SqlType>,
    U: AsExpression<Self::SqlType>, 

Creates a SQL NOT BETWEEN expression using the given lower and upper bounds.

Example

let data = animals
    .select(species)
    .filter(legs.not_between(2, 6))
    .first::<String>(&connection)?;
assert_eq!("spider", data);

fn desc(self) -> Desc<Self>

Creates a SQL DESC expression, representing this expression in descending order.

Example

let names = users
    .select(name)
    .order(name.desc())
    .load::<String>(&connection)?;
assert_eq!(vec!["Tess", "Sean"], names);

fn asc(self) -> Asc<Self>

Creates a SQL ASC expression, representing this expression in ascending order.

This is the same as leaving the direction unspecified. It is useful if you need to provide an unknown ordering, and need to box the return value of a function.

Example

let ordering: Box<dyn BoxableExpression<users, DB, SqlType = NotSelectable>> =
    if order == "name" {
        Box::new(name.desc())
    } else {
        Box::new(id.asc())
    };
Loading content...

Implementors

impl<T> ExpressionMethods for T where
    T: Expression,
    T::SqlType: SingleValue
[src]

Loading content...