diesel::expression_methods

Trait ExpressionMethods

source 
pub trait ExpressionMethods: Expression + Sized {

Show 14 methods    // Provided methods
    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> { ... }

}
Expand description

Methods present on all expressions, except tuples

Provided Methods§

source

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

Creates a SQL = expression.

Note that this function follows SQL semantics around None/null values, so eq(None) will never match. Use is_null instead.

To get behavior that is more like the Rust = operator you can also use the postgres-specific is_not_distinct_from .

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

Matching against None follows SQL semantics:

let data = animals
    .select(species)
    .filter(name.eq::<Option<String>>(None))
    .first::<String>(connection);
assert_eq!(Err(diesel::NotFound), data);

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

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

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, this method automatically performs a = ANY() query.

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

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, this method automatically performs a != ALL() query.

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

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

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

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

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

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

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

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

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

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

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

Object Safety§

This trait is not object safe.

Implementors§