Struct SetOp 

pub struct SetOp<D, Output> { /* private fields */ }

A chain of SELECTs combined by set operators, all decoding to the first branch’s Output — which is also where SQL itself takes the combined result’s column names from. ORDER BY here is necessarily by ordinal position (ORDER BY 1, 1-indexed) rather than a typed column — the branches can have entirely different Scopes, so there is no single scope left to check a column reference against once they’re combined; ordinal position is the only reference SQL itself allows in this position.

Implementations

impl<D: Dialect, L> SetOp<D, Row<L>>

pub fn order_by_column<K, Idx>(self, _key: K, dir: SortDir) -> Self

where K: LookupKey, L: Field<K::Key, Idx>, Idx: Position,

ORDER BY naming the column instead of counting to it: the position is row::Field’s index, which the row already carries. A column the combined result doesn’t select is a compile error, which is the whole reason no ORDER BY <n> is spellable here. Callable multiple times like Select::order_by, each call appending a key.

impl<D: Dialect, V: SingleColumn> SetOp<D, V>

A set operation whose branches select one un-tupled column: its output is a bare value, so there is one position and nothing to name.

pub fn order_by(self, dir: SortDir) -> Self

impl<D: Dialect, Output> SetOp<D, Output>

pub fn union<ScopeB, SelB, IdxB>(self, other: &Select<D, ScopeB, SelB>) -> Self

where SelB: Selection<ScopeB, IdxB>, SelB::Output: SameShape<Output>,

Appends another branch via UNION (duplicates across branches are removed, same as plain SQL UNION).

pub fn union_all<ScopeB, SelB, IdxB>( self, other: &Select<D, ScopeB, SelB>, ) -> Self

where SelB: Selection<ScopeB, IdxB>, SelB::Output: SameShape<Output>,

Appends another branch via UNION ALL (no deduplication — cheaper than UNION when the branches are already known disjoint, or when duplicates are meaningful).

pub fn intersect<ScopeB, SelB, IdxB>( self, other: &Select<D, ScopeB, SelB>, ) -> Self

where SelB: Selection<ScopeB, IdxB>, SelB::Output: SameShape<Output>,

Appends another branch via INTERSECT (rows present in both).

pub fn except<ScopeB, SelB, IdxB>(self, other: &Select<D, ScopeB, SelB>) -> Self

where SelB: Selection<ScopeB, IdxB>, SelB::Output: SameShape<Output>,

Appends another branch via EXCEPT (rows in the accumulated result so far, minus rows in other).

pub fn limit(self, n: impl IntoRowCount) -> Self

pub fn offset(self, n: impl IntoRowCount) -> Self

pub fn count_sql(&self, _dialect: D) -> (String, Vec<Value>)

How many rows the combination returns, its own ORDER BY/paging dropped. The branches keep theirs: a UNION of two LIMITed queries is a different set from a UNION of the whole ones.

pub fn to_sql(&self, _dialect: D) -> (String, Vec<Value>)