Trait diesel::prelude::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§
sourcefn eq<T>(self, other: T) -> Eq<Self, T>
fn eq<T>(self, other: T) -> Eq<Self, T>
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);
sourcefn ne<T>(self, other: T) -> NotEq<Self, T>
fn ne<T>(self, other: T) -> NotEq<Self, T>
Creates a SQL !=
expression.
§Example
let data = users.select(id).filter(name.ne("Sean"));
assert_eq!(Ok(2), data.first(connection));
sourcefn eq_any<T>(self, values: T) -> EqAny<Self, T>
fn eq_any<T>(self, values: T) -> EqAny<Self, T>
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));
sourcefn ne_all<T>(self, values: T) -> NeAny<Self, T>
fn ne_all<T>(self, values: T) -> NeAny<Self, T>
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));
sourcefn is_null(self) -> IsNull<Self>
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);
sourcefn is_not_null(self) -> IsNotNull<Self>
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);
sourcefn gt<T>(self, other: T) -> Gt<Self, T>
fn gt<T>(self, other: T) -> Gt<Self, T>
Creates a SQL >
expression.
§Example
let data = users
.select(name)
.filter(id.gt(1))
.first::<String>(connection)?;
assert_eq!("Tess", data);
sourcefn ge<T>(self, other: T) -> GtEq<Self, T>
fn ge<T>(self, other: T) -> GtEq<Self, T>
Creates a SQL >=
expression.
§Example
let data = users
.select(name)
.filter(id.ge(2))
.first::<String>(connection)?;
assert_eq!("Tess", data);
sourcefn lt<T>(self, other: T) -> Lt<Self, T>
fn lt<T>(self, other: T) -> Lt<Self, T>
Creates a SQL <
expression.
§Example
let data = users
.select(name)
.filter(id.lt(2))
.first::<String>(connection)?;
assert_eq!("Sean", data);
sourcefn le<T>(self, other: T) -> LtEq<Self, T>
fn le<T>(self, other: T) -> LtEq<Self, T>
Creates a SQL <=
expression.
§Example
let data = users
.select(name)
.filter(id.le(2))
.first::<String>(connection)?;
assert_eq!("Sean", data);
sourcefn between<T, U>(self, lower: T, upper: U) -> Between<Self, T, U>
fn between<T, U>(self, lower: T, upper: U) -> Between<Self, T, U>
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);
sourcefn not_between<T, U>(self, lower: T, upper: U) -> NotBetween<Self, T, U>
fn not_between<T, U>(self, lower: T, upper: U) -> NotBetween<Self, T, U>
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);
sourcefn desc(self) -> Desc<Self>
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);
sourcefn asc(self) -> Asc<Self>
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())
};