Trait CombineDsl 

pub trait CombineDsl {
    type Query: Query;

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

Extension trait to combine queries using a combinator like UNION, INTERSECT or EXCEPT 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) -> Union<Self, Rhs>

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) -> UnionAll<Self, Rhs>

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

Combine two queries using a SQL UNION ALL

fn intersect<Rhs>(self, rhs: Rhs) -> Intersect<Self, Rhs>

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

Combine two queries using a SQL INTERSECT

fn intersect_all<Rhs>(self, rhs: Rhs) -> IntersectAll<Self, Rhs>

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

Combine two queries using a SQL INTERSECT ALL

fn except<Rhs>(self, rhs: Rhs) -> Except<Self, Rhs>

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

Combine two queries using a SQL EXCEPT

fn except_all<Rhs>(self, rhs: Rhs) -> ExceptAll<Self, Rhs>

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

Combine two queries using a SQL EXCEPT ALL

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

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

where Self: Query,

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

impl<S> CombineDsl for Alias<S>

where S: AliasSource, S::Target: Table, Self: AsQuery,

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

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

where Self: Query,

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

impl<T: Table> CombineDsl for T

type Query = <T as AsQuery>::Query