Trait diesel::expression_methods::ExpressionMethods

source · [−]
pub trait ExpressionMethods: Expression + Sized {

Show 15 methods    fn eq<T: AsExpression<Self::SqlType>>(
        self, 
        other: T
    ) -> Eq<Self, T::Expression> { ... }

    fn ne<T: AsExpression<Self::SqlType>>(
        self, 
        other: T
    ) -> NotEq<Self, T::Expression> { ... }

    fn eq_any<T>(self, values: T) -> In<Self, T::InExpression>
    where
        T: AsInExpression<Self::SqlType>,
    { ... }

    fn ne_any<T>(self, values: T) -> NotIn<Self, T::InExpression>
    where
        T: AsInExpression<Self::SqlType>,
    { ... }

    fn ne_all<T>(self, values: T) -> NotIn<Self, T::InExpression>
    where
        T: AsInExpression<Self::SqlType>,
    { ... }

    fn is_null(self) -> IsNull<Self> { ... }

    fn is_not_null(self) -> IsNotNull<Self> { ... }

    fn gt<T: AsExpression<Self::SqlType>>(
        self, 
        other: T
    ) -> Gt<Self, T::Expression> { ... }

    fn ge<T: AsExpression<Self::SqlType>>(
        self, 
        other: T
    ) -> GtEq<Self, T::Expression> { ... }

    fn lt<T: AsExpression<Self::SqlType>>(
        self, 
        other: T
    ) -> Lt<Self, T::Expression> { ... }

    fn le<T: AsExpression<Self::SqlType>>(
        self, 
        other: T
    ) -> LtEq<Self, T::Expression> { ... }

    fn between<T, U>(
        self, 
        lower: T, 
        upper: U
    ) -> Between<Self, And<T::Expression, U::Expression>>
    where
        T: AsExpression<Self::SqlType>,
        U: AsExpression<Self::SqlType>,
    { ... }

    fn not_between<T, U>(
        self, 
        lower: T, 
        upper: U
    ) -> NotBetween<Self, And<T::Expression, U::Expression>>
    where
        T: AsExpression<Self::SqlType>,
        U: AsExpression<Self::SqlType>,
    { ... }

    fn desc(self) -> Desc<Self> { ... }

    fn asc(self) -> Asc<Self> { ... }

}
Expand description

Methods present on all expressions, except tuples

Provided methods

Creates a SQL = expression.

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

Creates a SQL != expression.

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

Creates a SQL IN statement.

Queries using this method will not be placed in the prepared statement 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.select(id).filter(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.select(id).filter(name.eq_any(Vec::<String>::new()));
assert_eq!(Ok(vec![]), data.load::<i32>(&connection));
👎 Deprecated since 1.2.0:

use ne_all instead

Deprecated alias for ne_all

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

let data = users.select(id).filter(name.ne_any(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_any(Vec::<String>::new()));
assert_eq!(Ok(vec![1, 2, 3]), data.load(&connection));

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

Creates a SQL IS NULL expression.

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

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

Creates a SQL > expression.

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

Creates a SQL >= expression.

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

Creates a SQL < expression.

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

Creates a SQL <= expression.

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

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

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

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

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<BoxableExpression<users, DB, SqlType=()>> =
    if order == "name" {
        Box::new(name.desc())
    } else {
        Box::new(id.asc())
    };

Implementors