Trait diesel::expression_methods::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>where
Self::SqlType: SqlType,
T: AsExpression<Self::SqlType>,
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);
sourcefn ne<T>(self, other: T) -> NotEq<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>,
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>where
Self::SqlType: SqlType,
T: AsInExpression<Self::SqlType>,
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));
sourcefn ne_all<T>(self, values: T) -> NeAny<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>,
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>where
Self::SqlType: SqlType,
T: AsExpression<Self::SqlType>,
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);
sourcefn ge<T>(self, other: T) -> GtEq<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>,
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>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>,
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>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>,
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>where
Self::SqlType: SqlType,
T: AsExpression<Self::SqlType>,
U: 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>,
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>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>,
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())
};