Trait block_tools::db::use_diesel::query_dsl::QueryDsl[−][src]

pub trait QueryDsl {
    pub fn distinct(self) -> Self::Output
    where
        Self: DistinctDsl,
    { ... }

    pub fn distinct_on<Expr>(self, expr: Expr) -> Self::Output
    where
        Self: DistinctOnDsl<Expr>,
    { ... }

    pub fn select<Selection>(self, selection: Selection) -> Self::Output
    where
        Self: SelectDsl<Selection>,
        Selection: Expression,
    { ... }

    pub fn count(self) -> Self::Output
    where
        Self: SelectDsl<CountStar>,
    { ... }

    pub fn inner_join<Rhs>(self, rhs: Rhs) -> Self::Output
    where
        Self: JoinWithImplicitOnClause<Rhs, Inner>,
    { ... }

    pub fn left_outer_join<Rhs>(self, rhs: Rhs) -> Self::Output
    where
        Self: JoinWithImplicitOnClause<Rhs, LeftOuter>,
    { ... }

    pub fn left_join<Rhs>(self, rhs: Rhs) -> Self::Output
    where
        Self: JoinWithImplicitOnClause<Rhs, LeftOuter>,
    { ... }

    pub fn filter<Predicate>(self, predicate: Predicate) -> Self::Output
    where
        Self: FilterDsl<Predicate>,
    { ... }

    pub fn or_filter<Predicate>(self, predicate: Predicate) -> Self::Output
    where
        Self: OrFilterDsl<Predicate>,
    { ... }

    pub fn find<PK>(self, id: PK) -> Self::Output
    where
        Self: FindDsl<PK>,
    { ... }

    pub fn order<Expr>(self, expr: Expr) -> Self::Output
    where
        Self: OrderDsl<Expr>,
        Expr: Expression,
    { ... }

    pub fn order_by<Expr>(self, expr: Expr) -> Self::Output
    where
        Self: OrderDsl<Expr>,
        Expr: Expression,
    { ... }

    pub fn then_order_by<Order>(self, order: Order) -> Self::Output
    where
        Self: ThenOrderDsl<Order>,
    { ... }

    pub fn limit(self, limit: i64) -> Self::Output
    where
        Self: LimitDsl,
    { ... }

    pub fn offset(self, offset: i64) -> Self::Output
    where
        Self: OffsetDsl,
    { ... }

    pub fn for_update(self) -> Self::Output
    where
        Self: ForUpdateDsl,
    { ... }

    pub fn for_no_key_update(self) -> Self::Output
    where
        Self: LockingDsl<ForNoKeyUpdate>,
    { ... }

    pub fn for_share(self) -> Self::Output
    where
        Self: LockingDsl<ForShare>,
    { ... }

    pub fn for_key_share(self) -> Self::Output
    where
        Self: LockingDsl<ForKeyShare>,
    { ... }

    pub fn skip_locked(self) -> Self::Output
    where
        Self: ModifyLockDsl<SkipLocked>,
    { ... }

    pub fn no_wait(self) -> Self::Output
    where
        Self: ModifyLockDsl<NoWait>,
    { ... }

    pub fn into_boxed<'a, DB>(self) -> Self::Output
    where
        Self: BoxedDsl<'a, DB>,
        DB: Backend,
    { ... }

    pub fn single_value(self) -> Self::Output
    where
        Self: SingleValueDsl,
    { ... }

    pub fn nullable(self) -> Self::Output
    where
        Self: SelectNullableDsl,
    { ... }
}

Methods used to construct select statements.

Provided methods

pub fn distinct(self) -> Self::Output where
    Self: DistinctDsl, [src]

Adds the DISTINCT keyword to a query.

This method will override any previous distinct clause that was present. For example, on PostgreSQL, foo.distinct_on(bar).distinct() will create the same query as foo.distinct().

Example

diesel::insert_into(users)
    .values(&vec![name.eq("Sean"); 3])
    .execute(&connection)?;
let names = users.select(name).load::<String>(&connection)?;
let distinct_names = users.select(name).distinct().load::<String>(&connection)?;

assert_eq!(vec!["Sean"; 3], names);
assert_eq!(vec!["Sean"; 1], distinct_names);

pub fn distinct_on<Expr>(self, expr: Expr) -> Self::Output where
    Self: DistinctOnDsl<Expr>, [src]

Adds the DISTINCT ON clause to a query.

Example

diesel::insert_into(animals)
    .values(&vec![
        (species.eq("dog"), name.eq(Some("Jack")), legs.eq(4)),
        (species.eq("dog"), name.eq(None), legs.eq(4)),
        (species.eq("spider"), name.eq(None), legs.eq(8)),
    ])
    .execute(&connection)
    .unwrap();
let all_animals = animals.select((species, name, legs)).load(&connection);
let distinct_animals = animals.select((species, name, legs)).distinct_on(species).load(&connection);

assert_eq!(Ok(vec![Animal::new("dog", Some("Jack"), 4),
                   Animal::new("dog", None, 4),
                   Animal::new("spider", None, 8)]), all_animals);
assert_eq!(Ok(vec![Animal::new("dog", Some("Jack"), 4),
                   Animal::new("spider", None, 8)]), distinct_animals);

pub fn select<Selection>(self, selection: Selection) -> Self::Output where
    Self: SelectDsl<Selection>,
    Selection: Expression, [src]

Adds a SELECT clause to the query.

If there was already a select clause present, it will be overridden. For example, foo.select(bar).select(baz) will produce the same query as foo.select(baz).

By default, the select clause will be roughly equivalent to SELECT * (however, Diesel will list all columns to ensure that they are in the order we expect).

select has slightly stricter bounds on its arguments than other methods. In particular, when used with a left outer join, .nullable must be called on columns that come from the right side of a join. It can be called on the column itself, or on an expression containing that column. title.nullable(), lower(title).nullable(), and (id, title).nullable() would all be valid.

Examples

// By default, all columns will be selected
let all_users = users.load::<(i32, String)>(&connection)?;
assert_eq!(vec![(1, String::from("Sean")), (2, String::from("Tess"))], all_users);

let all_names = users.select(name).load::<String>(&connection)?;
assert_eq!(vec!["Sean", "Tess"], all_names);

When used with a left join

let join = users::table.left_join(posts::table);

// By default, all columns from both tables are selected
let all_data = join.load::<(User, Option<Post>)>(&connection)?;
let expected_data = vec![
    (User::new(1, "Sean"), Some(Post::new(post_id, 1, "Sean's Post"))),
    (User::new(2, "Tess"), None),
];
assert_eq!(expected_data, all_data);

// Since `posts` is on the right side of a left join, `.nullable` is
// needed.
let names_and_titles = join.select((users::name, posts::title.nullable()))
    .load::<(String, Option<String>)>(&connection)?;
let expected_data = vec![
    (String::from("Sean"), Some(String::from("Sean's Post"))),
    (String::from("Tess"), None),
];
assert_eq!(expected_data, names_and_titles);

pub fn count(self) -> Self::Output where
    Self: SelectDsl<CountStar>, [src]

Get the count of a query. This is equivalent to .select(count_star())

Example

let count = users.count().get_result(&connection);
assert_eq!(Ok(2), count);

pub fn inner_join<Rhs>(self, rhs: Rhs) -> Self::Output where
    Self: JoinWithImplicitOnClause<Rhs, Inner>, [src]

Join two tables using a SQL INNER JOIN.

If you have invoked joinable! for the two tables, you can pass that table directly. Otherwise you will need to use .on to specify the ON clause.

You can join to as many tables as you'd like in a query, with the restriction that no table can appear in the query more than once. The reason for this restriction is that one of the appearances would require aliasing, and we do not currently have a fleshed out story for dealing with table aliases.

You will also need to call allow_tables_to_appear_in_same_query!. If you are using infer_schema! or diesel print-schema, this will have been generated for you. See the documentation for allow_tables_to_appear_in_same_query! for details.

Diesel expects multi-table joins to be semantically grouped based on the relationships. For example, users.inner_join(posts.inner_join(comments)) is not the same as users.inner_join(posts).inner_join(comments). The first would deserialize into (User, (Post, Comment)) and generate the following SQL:

SELECT * FROM users
    INNER JOIN posts ON posts.user_id = users.id
    INNER JOIN comments ON comments.post_id = posts.id

While the second query would deserialize into (User, Post, Comment) and generate the following SQL:

SELECT * FROM users
    INNER JOIN posts ON posts.user_id = users.id
    INNER JOIN comments ON comments.user_id = users.id

Examples

With implicit ON clause

joinable!(posts -> users (user_id));
allow_tables_to_appear_in_same_query!(users, posts);

let data = users.inner_join(posts)
    .select((name, title))
    .load(&connection);

let expected_data = vec![
    (String::from("Sean"), String::from("My first post")),
    (String::from("Sean"), String::from("About Rust")),
    (String::from("Tess"), String::from("My first post too")),
];
assert_eq!(Ok(expected_data), data);

With explicit ON clause

allow_tables_to_appear_in_same_query!(users, posts);

diesel::insert_into(posts)
    .values(&vec![
        (user_id.eq(1), title.eq("Sean's post")),
        (user_id.eq(2), title.eq("Sean is a jerk")),
    ])
    .execute(&connection)
    .unwrap();

let data = users
    .inner_join(posts.on(title.like(name.concat("%"))))
    .select((name, title))
    .load(&connection);
let expected_data = vec![
    (String::from("Sean"), String::from("Sean's post")),
    (String::from("Sean"), String::from("Sean is a jerk")),
];
assert_eq!(Ok(expected_data), data);

pub fn left_outer_join<Rhs>(self, rhs: Rhs) -> Self::Output where
    Self: JoinWithImplicitOnClause<Rhs, LeftOuter>, [src]

Join two tables using a SQL LEFT OUTER JOIN.

Behaves similarly to inner_join, but will produce a left join instead. See inner_join for usage examples.

pub fn left_join<Rhs>(self, rhs: Rhs) -> Self::Output where
    Self: JoinWithImplicitOnClause<Rhs, LeftOuter>, [src]

Alias for left_outer_join.

pub fn filter<Predicate>(self, predicate: Predicate) -> Self::Output where
    Self: FilterDsl<Predicate>, [src]

Adds to the WHERE clause of a query.

If there is already a WHERE clause, the result will be old AND new.

Example:

let seans_id = users.filter(name.eq("Sean")).select(id)
    .first(&connection);
assert_eq!(Ok(1), seans_id);
let tess_id = users.filter(name.eq("Tess")).select(id)
    .first(&connection);
assert_eq!(Ok(2), tess_id);

pub fn or_filter<Predicate>(self, predicate: Predicate) -> Self::Output where
    Self: OrFilterDsl<Predicate>, [src]

Adds to the WHERE clause of a query using OR

If there is already a WHERE clause, the result will be (old OR new). Calling foo.filter(bar).or_filter(baz) is identical to foo.filter(bar.or(baz)). However, the second form is much harder to do dynamically.

Example:

diesel::insert_into(animals)
    .values(&vec![
        (species.eq("cat"), legs.eq(4), name.eq("Sinatra")),
        (species.eq("dog"), legs.eq(3), name.eq("Fido")),
        (species.eq("spider"), legs.eq(8), name.eq("Charlotte")),
    ])
    .execute(&connection)?;

let good_animals = animals
    .filter(name.eq("Fido"))
    .or_filter(legs.eq(4))
    .select(name)
    .get_results::<Option<String>>(&connection)?;
let expected = vec![
    Some(String::from("Sinatra")),
    Some(String::from("Fido")),
];
assert_eq!(expected, good_animals);

pub fn find<PK>(self, id: PK) -> Self::Output where
    Self: FindDsl<PK>, [src]

Attempts to find a single record from the given table by primary key.

Example

let sean = (1, "Sean".to_string());
let tess = (2, "Tess".to_string());
assert_eq!(Ok(sean), users.find(1).first(&connection));
assert_eq!(Ok(tess), users.find(2).first(&connection));
assert_eq!(Err::<(i32, String), _>(NotFound), users.find(3).first(&connection));

pub fn order<Expr>(self, expr: Expr) -> Self::Output where
    Self: OrderDsl<Expr>,
    Expr: Expression, [src]

Sets the order clause of a query.

If there was already a order clause, it will be overridden. See also: .desc() and .asc()

Ordering by multiple columns can be achieved by passing a tuple of those columns. To construct an order clause of an unknown number of columns, see QueryDsl::then_order_by

Examples

diesel::insert_into(users)
    .values(&vec![
        name.eq("Saul"),
        name.eq("Steve"),
        name.eq("Stan"),
    ])
    .execute(&connection)?;

let ordered_names = users.select(name)
    .order(name.desc())
    .load::<String>(&connection)?;
assert_eq!(vec!["Steve", "Stan", "Saul"], ordered_names);

diesel::insert_into(users).values(name.eq("Stan")).execute(&connection)?;

let data = users.select((name, id))
    .order((name.asc(), id.desc()))
    .load(&connection)?;
let expected_data = vec![
    (String::from("Saul"), 3),
    (String::from("Stan"), 6),
    (String::from("Stan"), 5),
    (String::from("Steve"), 4),
];
assert_eq!(expected_data, data);

pub fn order_by<Expr>(self, expr: Expr) -> Self::Output where
    Self: OrderDsl<Expr>,
    Expr: Expression, [src]

Alias for order

pub fn then_order_by<Order>(self, order: Order) -> Self::Output where
    Self: ThenOrderDsl<Order>, [src]

Appends to the ORDER BY clause of this SQL query.

Unlike .order, this method will append rather than replace. In other words, .order_by(foo).order_by(bar) is equivalent to .order_by(bar). In contrast, .order_by(foo).then_order_by(bar) is equivalent to .order((foo, bar)). This method is only present on boxed queries.

Examples

diesel::insert_into(users)
    .values(&vec![
        name.eq("Saul"),
        name.eq("Steve"),
        name.eq("Stan"),
        name.eq("Stan"),
    ])
    .execute(&connection)?;

let data = users.select((name, id))
    .order_by(name.asc())
    .then_order_by(id.desc())
    .load(&connection)?;
let expected_data = vec![
    (String::from("Saul"), 3),
    (String::from("Stan"), 6),
    (String::from("Stan"), 5),
    (String::from("Steve"), 4),
];
assert_eq!(expected_data, data);

pub fn limit(self, limit: i64) -> Self::Output where
    Self: LimitDsl, [src]

Sets the limit clause of the query.

If there was already a limit clause, it will be overridden.

Example

// Using a limit
let limited = users.select(name)
    .order(id)
    .limit(1)
    .load::<String>(&connection)?;

// Without a limit
let no_limit = users.select(name)
    .order(id)
    .load::<String>(&connection)?;

assert_eq!(vec!["Sean"], limited);
assert_eq!(vec!["Sean", "Bastien", "Pascal"], no_limit);

pub fn offset(self, offset: i64) -> Self::Output where
    Self: OffsetDsl, [src]

Sets the offset clause of the query.

If there was already a offset clause, it will be overridden.

Example

// Using an offset
let offset = users.select(name)
    .order(id)
    .limit(2)
    .offset(1)
    .load::<String>(&connection)?;

// No Offset
let no_offset = users.select(name)
    .order(id)
    .limit(2)
    .load::<String>(&connection)?;

assert_eq!(vec!["Bastien", "Pascal"], offset);
assert_eq!(vec!["Sean", "Bastien"], no_offset);

pub fn for_update(self) -> Self::Output where
    Self: ForUpdateDsl, [src]

Adds FOR UPDATE to the end of the select statement.

This method is only available for MySQL and PostgreSQL. SQLite does not provide any form of row locking.

Additionally, .for_update cannot be used on queries with a distinct clause, group by clause, having clause, or any unions. Queries with a FOR UPDATE clause cannot be boxed.

Example

ⓘ
// Executes `SELECT * FROM users FOR UPDATE`
users.for_update().load(&connection)

pub fn for_no_key_update(self) -> Self::Output where
    Self: LockingDsl<ForNoKeyUpdate>, [src]

Adds FOR NO KEY UPDATE to the end of the select statement.

This method is only available for PostgreSQL. SQLite does not provide any form of row locking, and MySQL does not support anything finer than row-level locking.

Additionally, .for_no_key_update cannot be used on queries with a distinct clause, group by clause, having clause, or any unions. Queries with a FOR NO KEY UPDATE clause cannot be boxed.

Example

ⓘ
// Executes `SELECT * FROM users FOR NO KEY UPDATE`
users.for_no_key_update().load(&connection)

pub fn for_share(self) -> Self::Output where
    Self: LockingDsl<ForShare>, [src]

Adds FOR SHARE to the end of the select statement.

This method is only available for MySQL and PostgreSQL. SQLite does not provide any form of row locking.

Additionally, .for_share cannot be used on queries with a distinct clause, group by clause, having clause, or any unions. Queries with a FOR SHARE clause cannot be boxed.

Example

ⓘ
// Executes `SELECT * FROM users FOR SHARE`
users.for_share().load(&connection)

pub fn for_key_share(self) -> Self::Output where
    Self: LockingDsl<ForKeyShare>, [src]

Adds FOR KEY SHARE to the end of the select statement.

This method is only available for PostgreSQL. SQLite does not provide any form of row locking, and MySQL does not support anything finer than row-level locking.

Additionally, .for_key_share cannot be used on queries with a distinct clause, group by clause, having clause, or any unions. Queries with a FOR KEY SHARE clause cannot be boxed.

Example

ⓘ
// Executes `SELECT * FROM users FOR KEY SHARE`
users.for_key_share().load(&connection)

pub fn skip_locked(self) -> Self::Output where
    Self: ModifyLockDsl<SkipLocked>, [src]

Adds SKIP LOCKED to the end of a FOR UPDATE clause.

This modifier is only supported in PostgreSQL 9.5+ and MySQL 8+.

Example

ⓘ
// Executes `SELECT * FROM users FOR UPDATE SKIP LOCKED`
users.for_update().skip_locked().load(&connection)

pub fn no_wait(self) -> Self::Output where
    Self: ModifyLockDsl<NoWait>, [src]

Adds NOWAIT to the end of a FOR UPDATE clause.

This modifier is only supported in PostgreSQL 9.5+ and MySQL 8+.

Example

ⓘ
// Executes `SELECT * FROM users FOR UPDATE NOWAIT`
users.for_update().no_wait().load(&connection)

pub fn into_boxed<'a, DB>(self) -> Self::Output where
    Self: BoxedDsl<'a, DB>,
    DB: Backend, [src]

Boxes the pieces of a query into a single type.

This is useful for cases where you want to conditionally modify a query, but need the type to remain the same. The backend must be specified as part of this. It is not possible to box a query and have it be useable on multiple backends.

A boxed query will incur a minor performance penalty, as the query builder can no longer be inlined by the compiler. For most applications this cost will be minimal.

Example

let mut query = users::table.into_boxed();
if let Some(name) = params.get("name") {
    query = query.filter(users::name.eq(name));
}
let users = query.load(&connection);

Diesel queries also have a similar problem to Iterator, where returning them from a function requires exposing the implementation of that function. The helper_types module exists to help with this, but you might want to hide the return type or have it conditionally change. Boxing can achieve both.

Example

fn users_by_name<'a>(name: &'a str) -> users::BoxedQuery<'a, DB> {
    users::table.filter(users::name.eq(name)).into_boxed()
}

assert_eq!(Ok(1), users_by_name("Sean").select(users::id).first(&connection));
assert_eq!(Ok(2), users_by_name("Tess").select(users::id).first(&connection));

pub fn single_value(self) -> Self::Output where
    Self: SingleValueDsl, [src]

Wraps this select statement in parenthesis, allowing it to be used as an expression.

SQL allows queries such as foo = (SELECT ...), as long as the subselect returns only a single column, and 0 or 1 rows. This method indicates that you expect the query to only return a single value (this will be enforced by adding LIMIT 1).

The SQL type of this will always be Nullable, as the query returns NULL if the table is empty or it otherwise returns 0 rows.

Example

insert_into(posts::table)
    .values(posts::user_id.eq(1))
    .execute(&connection)?;
let last_post = posts::table
    .order(posts::id.desc());
let most_recently_active_user = users.select(name)
    .filter(id.nullable().eq(last_post.select(posts::user_id).single_value()))
    .first::<String>(&connection)?;
assert_eq!("Sean", most_recently_active_user);

pub fn nullable(self) -> Self::Output where
    Self: SelectNullableDsl, [src]

Coerce the SQL type of the select clause to it's nullable equivalent.

This is use full for writing queries that contain subselects on non null fields comparing them to nullable fields.

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

table! {
    posts {
        id -> Integer,
        by_user -> Nullable<Text>,
    }
}

posts::table.filter(
   posts::by_user.eq_any(users::table.select(users::name).nullable())
).load(&connection)?;
Loading content...

Implementors

impl<'a, ST, QS, DB> QueryDsl for BoxedSelectStatement<'a, ST, QS, DB>[src]

impl<T> QueryDsl for T where
    T: Table, [src]

Loading content...