Trait rocket_db_pools::diesel::prelude::CombineDsl

pub trait CombineDsl {
    type Query: Query;

    // Required methods
    fn union<Rhs>(
        self,
        rhs: Rhs
    ) -> CombinationClause<Union, Distinct, Self::Query, <Rhs as AsQuery>::Query>
       where Rhs: AsQuery<SqlType = <Self::Query as Query>::SqlType>;
    fn union_all<Rhs>(
        self,
        rhs: Rhs
    ) -> CombinationClause<Union, All, Self::Query, <Rhs as AsQuery>::Query>
       where Rhs: AsQuery<SqlType = <Self::Query as Query>::SqlType>;
    fn intersect<Rhs>(
        self,
        rhs: Rhs
    ) -> CombinationClause<Intersect, Distinct, Self::Query, <Rhs as AsQuery>::Query>
       where Rhs: AsQuery<SqlType = <Self::Query as Query>::SqlType>;
    fn intersect_all<Rhs>(
        self,
        rhs: Rhs
    ) -> CombinationClause<Intersect, All, Self::Query, <Rhs as AsQuery>::Query>
       where Rhs: AsQuery<SqlType = <Self::Query as Query>::SqlType>;
    fn except<Rhs>(
        self,
        rhs: Rhs
    ) -> CombinationClause<Except, Distinct, Self::Query, <Rhs as AsQuery>::Query>
       where Rhs: AsQuery<SqlType = <Self::Query as Query>::SqlType>;
    fn except_all<Rhs>(
        self,
        rhs: Rhs
    ) -> CombinationClause<Except, All, Self::Query, <Rhs as AsQuery>::Query>
       where Rhs: AsQuery<SqlType = <Self::Query as Query>::SqlType>;
}

Extension trait to combine queries using a combinator like UNION, INTERSECT or EXPECT with or without ALL rule for duplicates

Required Associated Types

type Query: Query

What kind of query does this type represent?

Required Methods

fn union<Rhs>( self, rhs: Rhs ) -> CombinationClause<Union, Distinct, Self::Query, <Rhs as AsQuery>::Query>

where Rhs: AsQuery<SqlType = <Self::Query as Query>::SqlType>,

Combine two queries using a SQL UNION

Examples

let data = users.select(user_name.nullable())
    .union(animals.select(animal_name).filter(animal_name.is_not_null()))
    .load(connection);

let expected_data = vec![
    Some(String::from("Jack")),
    Some(String::from("Sean")),
    Some(String::from("Tess")),
];
assert_eq!(Ok(expected_data), data);

fn union_all<Rhs>( self, rhs: Rhs ) -> CombinationClause<Union, All, Self::Query, <Rhs as AsQuery>::Query>

where Rhs: AsQuery<SqlType = <Self::Query as Query>::SqlType>,

Combine two queries using a SQL UNION ALL

fn intersect<Rhs>( self, rhs: Rhs ) -> CombinationClause<Intersect, Distinct, Self::Query, <Rhs as AsQuery>::Query>

where Rhs: AsQuery<SqlType = <Self::Query as Query>::SqlType>,

Combine two queries using a SQL INTERSECT

fn intersect_all<Rhs>( self, rhs: Rhs ) -> CombinationClause<Intersect, All, Self::Query, <Rhs as AsQuery>::Query>

where Rhs: AsQuery<SqlType = <Self::Query as Query>::SqlType>,

Combine two queries using a SQL INTERSECT ALL

fn except<Rhs>( self, rhs: Rhs ) -> CombinationClause<Except, Distinct, Self::Query, <Rhs as AsQuery>::Query>

where Rhs: AsQuery<SqlType = <Self::Query as Query>::SqlType>,

Combine two queries using a SQL EXCEPT

fn except_all<Rhs>( self, rhs: Rhs ) -> CombinationClause<Except, All, Self::Query, <Rhs as AsQuery>::Query>

where Rhs: AsQuery<SqlType = <Self::Query as Query>::SqlType>,

Combine two queries using a SQL EXCEPT ALL

Object Safety

This trait is not object safe.

Implementors

impl<'a, ST, QS, DB, GB> CombineDsl for BoxedSelectStatement<'a, ST, QS, DB, GB>

where BoxedSelectStatement<'a, ST, QS, DB, GB>: Query,

type Query = BoxedSelectStatement<'a, ST, QS, DB, GB>

impl<F, S, D, W, O, LOf, G, H, LC> CombineDsl for SelectStatement<F, S, D, W, O, LOf, G, H, LC>

where SelectStatement<F, S, D, W, O, LOf, G, H, LC>: Query,

type Query = SelectStatement<F, S, D, W, O, LOf, G, H, LC>

impl<S> CombineDsl for Alias<S>

where S: AliasSource, <S as AliasSource>::Target: Table, Alias<S>: AsQuery,

type Query = <Alias<S> as AsQuery>::Query

impl<T> CombineDsl for T

where T: Table,

type Query = <T as AsQuery>::Query