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

pub trait ExpressionMethods: Expression + Sized {
    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 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: AsExpression<Self::SqlType>>(
        self, 
        other: Range<T>
    ) -> Between<Self, And<T::Expression, T::Expression>> { ... }
    fn not_between<T: AsExpression<Self::SqlType>>(
        self, 
        other: Range<T>
    ) -> NotBetween<Self, And<T::Expression, T::Expression>> { ... }
    fn desc(self) -> Desc<Self> { ... }
    fn asc(self) -> Asc<Self> { ... }
    fn nullable(self) -> Nullable<Self> { ... }
}

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

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(any()) instead. This method may change in the future to automatically perform != ANY on PostgreSQL.

Example

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 IS NULL expression.

Creates a SQL IS NOT NULL expression.

Creates a SQL > expression.

Example

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

Creates a SQL >= expression.

Example

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

Creates a SQL < expression.

Example

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

Creates a SQL <= expression.

Example

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

Creates a SQL BETWEEN expression using the given range.

Creates a SQL NOT BETWEEN expression using the given range.

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

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

Converts this potentially non-null expression into one which is treated as nullable. This method has no impact on the generated SQL, and is only used to allow certain comparisons that would otherwise fail to compile.

Example

table! {
    users {
        id -> Integer,
        name -> VarChar,
    }
}

table! {
    posts {
        id -> Integer,
        user_id -> Integer,
        author_name -> Nullable<VarChar>,
    }
}

fn main() {
    use self::users::dsl::*;
    use self::posts::dsl::{posts, author_name};
    let connection = establish_connection();

    let data = users.inner_join(posts)
        .filter(name.nullable().eq(author_name))
        .select(name)
        .load::<String>(&connection);
    println!("{:?}", data);
}

Implementors