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", so this trait is not object safe.

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