qbrs_core/select/
selection.rs

1//! What a `.select(..)` list decodes to once a row comes back.
2
3use crate::expr::{Column, ColumnKey, ExprKind, Keyed, LabelKey, Labeled, SqlType};
4use crate::render::SelectItem;
5use std::marker::PhantomData;
6
7use crate::row::{Named, Row, RowCons, RowKey, RowNil};
8use crate::scope::{Find, Superset, Table, WrapNullable};
9
10/// Sealed for the reason `InsertRow` is: these traits pair a type-level
11/// claim (`Fields`/`Output`) with the runtime list of `SelectItem`s that is
12/// supposed to match it, and only the impls in this crate keep the two in
13/// step. A hand-written one could select a row that decodes transposed —
14/// the failure `row::SameShape` and column-keyed rows exist to stop.
15mod private {
16    /// Carries the trait's own parameters, for the reason `scope::proof`
17    /// explains: `Self` can be an honest `Column<C>` while the free `Idx`
18    /// is the caller's own type, so a seal on `Self` alone admits the
19    /// forgery — and a private proof *type* is reachable by projection.
20    pub trait Sealed<Scope, Idx> {}
21}
22
23/// `AllColumns`/`CteShape` are emitted in the schema's own crate, so their
24/// seal has to be nameable there — a separate trait, because sharing
25/// `private::Sealed` would hand out the one line that unseals `Selection`
26/// too, and a hand-written `Selection` is exactly what the seal is for.
27#[doc(hidden)]
28pub trait SelectableSealed {}
29
30impl<C, Scope, Idx> private::Sealed<Scope, Idx> for Column<C>
31where
32    C: crate::expr::ColumnKey,
33    Scope: Find<C::Table, Idx>,
34{
35}
36
37impl<K, Req, S: SqlType, Scope, Idx> private::Sealed<Scope, Idx> for Keyed<K, Req, S> where
38    Scope: Superset<Req, Idx>
39{
40}
41
42impl<K, Inner, Scope, Idx> private::Sealed<Scope, Idx> for Labeled<K, Inner> where
43    Inner: RowField<Scope, Idx>
44{
45}
46
47impl<T: AllColumns, Scope, Idx> private::Sealed<Scope, Idx> for All<T> where
48    T::Columns: ColumnList<Scope, Idx>
49{
50}
51
52/// What a single un-tupled selection decodes to: a bare native value, or
53/// its `Option`. Sealed by construction — the impls come from the same
54/// `sql_leaf_type!` that declares the types — and used to give a
55/// one-column set operation an `ORDER BY` with no position to state.
56pub trait SingleColumn {}
57
58/// One *field* of a resulting `Row`: the key its value is filed under, and
59/// the Rust type it decodes to. A selection list is a chain of
60/// `SelectionPart`s, one of which — `All` — carries many of these at once.
61///
62/// Parameterized by `Scope` so a bare column's `Value` is `Option<T>` when —
63/// and only when — that column's table is nullable in *this* query, via
64/// `scope::Find::Nullability` + `WrapNullable`. Nullability is therefore
65/// derived from join shape rather than asserted with a manual `.nullable()`.
66///
67/// Scope membership is proven as a side effect of this trait type-checking
68/// at all, through the `Find`/`Superset` bounds below — so callers need no
69/// separate check.
70#[diagnostic::on_unimplemented(
71    message = "`{Self}` can't be a field of this query's rows",
72    label = "a column, an aggregate, a window function, a `sql!` fragment, or a labelled one of those can be",
73    note = "an expression the builder inferred a type for — a comparison, an `is_null`, a `LIKE` — has to state what it decodes to with `.decodes_as::<..>()`, since that inference can contradict the join; a `sql!` fragment already states it"
74)]
75pub trait RowField<Scope, Idx>: RowKey + private::Sealed<Scope, Idx> {
76    type Value;
77    /// This field's SQL type — the marker `Value` has already resolved away
78    /// to a native Rust type. A single-column subquery (`Select::contains`)
79    /// needs this to compare its selected column against an outer
80    /// expression with `expr::Comparable`, which a native `Value` can't do.
81    type Sql: SqlType;
82    fn item(&self) -> SelectItem;
83}
84
85impl<C: ColumnKey, Scope, Idx> RowField<Scope, Idx> for Column<C>
86where
87    Scope: Find<C::Table, Idx>,
88    C::Sql: WrapNullable<<Scope as Find<C::Table, Idx>>::Nullability>,
89    <C::Sql as WrapNullable<<Scope as Find<C::Table, Idx>>::Nullability>>::Output: SqlType,
90{
91    type Value = <<C::Sql as WrapNullable<
92        <Scope as Find<C::Table, Idx>>::Nullability,
93    >>::Output as SqlType>::Native;
94    type Sql = <C::Sql as WrapNullable<<Scope as Find<C::Table, Idx>>::Nullability>>::Output;
95    fn item(&self) -> SelectItem {
96        SelectItem::bare(ExprKind::Column {
97            table: <C::Table as Table>::NAME,
98            name: C::NAME,
99        })
100    }
101}
102
103impl<K, Req, S: SqlType, Scope, Idx> RowField<Scope, Idx> for Keyed<K, Req, S>
104where
105    Scope: Superset<Req, Idx>,
106{
107    type Value = S::Native;
108    type Sql = S;
109    fn item(&self) -> SelectItem {
110        SelectItem::bare(self.kind.clone())
111    }
112}
113
114/// A label renames whatever it wraps and changes nothing else, so this is
115/// one impl rather than one per selectable: the inner value decides the
116/// scope check and the decoded type, the label decides the `AS` and the row
117/// key.
118impl<K: LabelKey, Inner: RowField<Scope, Idx>, Scope, Idx> RowField<Scope, Idx>
119    for Labeled<K, Inner>
120{
121    type Value = Inner::Value;
122    type Sql = Inner::Sql;
123    fn item(&self) -> SelectItem {
124        SelectItem::labeled(self.inner.item().kind, <K as Named>::NAME)
125    }
126}
127
128/// A whole `SELECT` list. A tuple decodes to a `row::Row` keyed by each
129/// element's `RowField::Key`; a single un-tupled element decodes to its bare
130/// value, since there is nothing to key it against.
131#[diagnostic::on_unimplemented(
132    message = "`{Self}` isn't a valid selection list here",
133    label = "a selection is a column, an aggregate, a window function, a `sql!` fragment, a labelled one of those, `<table>::All`, or a tuple of up to 32 of them",
134    note = "every element has to be in scope — `.from(..)`/`.join(..)` the tables it names — and an expression the builder inferred a type for has to state its decoded type with `.decodes_as::<..>()`"
135)]
136pub trait Selection<Scope, Idx>: private::Sealed<Scope, Idx> {
137    type Output;
138    fn items(&self) -> Vec<SelectItem>;
139}
140
141macro_rules! scalar_selection {
142    (impl[$($generics:tt)*] $ty:ty) => {
143        impl<$($generics)*, Scope, Idx> Selection<Scope, Idx> for $ty
144        where
145            $ty: RowField<Scope, Idx>,
146        {
147                    type Output = <$ty as RowField<Scope, Idx>>::Value;
148            fn items(&self) -> Vec<SelectItem> {
149                vec![RowField::item(self)]
150            }
151        }
152    };
153}
154
155/// One element of a selection list. A column or an expression contributes
156/// one field; `All` contributes a whole table's worth. `Fields<Tail>` is
157/// what it puts in front of whatever the rest of the list contributes, so a
158/// list is assembled by nesting rather than by concatenating afterwards.
159#[diagnostic::on_unimplemented(
160    message = "`{Self}` can't be part of a selection list",
161    label = "a column, an aggregate, a window function, a `sql!` fragment, a labelled one of those, or `<table>::All` can be",
162    note = "an expression the builder inferred a type for — a comparison, an `is_null`, a `LIKE` — has to state what it decodes to with `.decodes_as::<..>()`, since that inference can contradict the join"
163)]
164pub trait SelectionPart<Scope, Idx>: private::Sealed<Scope, Idx> {
165    type Fields<Tail>;
166    fn push_items(&self, out: &mut Vec<SelectItem>);
167}
168
169macro_rules! field_part {
170    (impl[$($generics:tt)*] $ty:ty) => {
171        impl<$($generics)*, Scope, Idx> SelectionPart<Scope, Idx> for $ty
172        where
173            $ty: RowField<Scope, Idx>,
174        {
175                    type Fields<Tail> = RowCons<
176                <$ty as RowKey>::Key,
177                <$ty as RowField<Scope, Idx>>::Value,
178                Tail,
179            >;
180            fn push_items(&self, out: &mut Vec<SelectItem>) {
181                out.push(RowField::item(self));
182            }
183        }
184    };
185}
186/// Everything selectable on its own: as a whole list of one, and as one
187/// part of a longer list. Stated once, since a selectable that is one and
188/// not the other has never been a thing.
189macro_rules! selectable {
190    (impl[$($generics:tt)*] $ty:ty) => {
191        scalar_selection!(impl[$($generics)*] $ty);
192        field_part!(impl[$($generics)*] $ty);
193    };
194}
195selectable!(impl[C: ColumnKey] Column<C>);
196selectable!(impl[K, Req, S: SqlType] Keyed<K, Req, S>);
197selectable!(impl[K, Inner] Labeled<K, Inner>);
198
199/// Every column of one table, in declaration order — `select(users::All)`.
200/// The table's own `#[derive(Table)]` supplies the chain through
201/// `AllColumns`, so a selection list and the schema cannot drift apart, and
202/// a whole table counts as one element of a tuple however many columns it
203/// has.
204pub struct All<T>(PhantomData<fn() -> T>);
205
206impl<T> All<T> {
207    pub const fn new() -> Self {
208        All(PhantomData)
209    }
210}
211
212impl<T> Clone for All<T> {
213    fn clone(&self) -> Self {
214        *self
215    }
216}
217impl<T> Copy for All<T> {}
218
219impl<T> Default for All<T> {
220    fn default() -> Self {
221        All::new()
222    }
223}
224
225/// What `#[derive(Table)]` emits so `All<Table>` knows the table's columns
226/// and what each of them decodes to in a given scope.
227pub trait AllColumns: SelectableSealed {
228    /// The table's columns as a type-level list, `Cons<Column<C>, ..>`.
229    /// The row and the rendered items are both computed from it here, so a
230    /// hand-written impl can name a different set of columns but can never
231    /// make the two disagree — which is what a schema's own crate could do
232    /// while this trait stated the row and pushed the items separately.
233    type Columns;
234}
235
236/// The list `AllColumns` names, walked once for the row's fields and once
237/// for the items. Implemented for `Nil` and `Cons<Column<C>, Tail>` only,
238/// and only here — sealed, because this trait *is* the pairing `AllColumns`
239/// was split up to remove: it states the row and pushes the items
240/// separately, so a hand-written impl could transpose them. Nothing outside
241/// this crate implements it, so an ordinary private supertrait is enough;
242/// no `Proof` is needed.
243mod column_list {
244    pub trait Sealed {}
245    impl Sealed for crate::scope::Nil {}
246    impl<C: crate::expr::ColumnKey, Tail> Sealed for crate::scope::Cons<crate::expr::Column<C>, Tail> {}
247}
248
249pub trait ColumnList<Scope, Idx>: column_list::Sealed {
250    type Fields<Tail>;
251    fn push_items(out: &mut Vec<SelectItem>);
252}
253
254impl<Scope, Idx> ColumnList<Scope, Idx> for crate::scope::Nil {
255    type Fields<Tail> = Tail;
256    fn push_items(_out: &mut Vec<SelectItem>) {}
257}
258
259impl<C: ColumnKey, Tail, Scope, Idx> ColumnList<Scope, Idx> for crate::scope::Cons<Column<C>, Tail>
260where
261    Column<C>: RowField<Scope, Idx>,
262    Tail: ColumnList<Scope, Idx>,
263{
264    type Fields<T> = RowCons<C, <Column<C> as RowField<Scope, Idx>>::Value, Tail::Fields<T>>;
265    fn push_items(out: &mut Vec<SelectItem>) {
266        out.push(RowField::item(&Column::<C>::new()));
267        Tail::push_items(out);
268    }
269}
270
271impl<T: AllColumns, Scope, Idx> SelectionPart<Scope, Idx> for All<T>
272where
273    T::Columns: ColumnList<Scope, Idx>,
274{
275    type Fields<Tail> = <T::Columns as ColumnList<Scope, Idx>>::Fields<Tail>;
276    fn push_items(&self, out: &mut Vec<SelectItem>) {
277        <T::Columns as ColumnList<Scope, Idx>>::push_items(out);
278    }
279}
280
281impl<T: AllColumns, Scope, Idx> Selection<Scope, Idx> for All<T>
282where
283    T::Columns: ColumnList<Scope, Idx>,
284{
285    type Output = Row<<T::Columns as ColumnList<Scope, Idx>>::Fields<RowNil>>;
286    fn items(&self) -> Vec<SelectItem> {
287        let mut out = Vec::new();
288        <T::Columns as ColumnList<Scope, Idx>>::push_items(&mut out);
289        out
290    }
291}
292
293macro_rules! row_chain {
294    ($n:ident $i:ident) => {
295        <$n as SelectionPart<Scope, $i>>::Fields<RowNil>
296    };
297    ($n:ident $i:ident, $($rest:tt)*) => {
298        <$n as SelectionPart<Scope, $i>>::Fields<row_chain!($($rest)*)>
299    };
300}
301
302macro_rules! tuple_selection {
303    ($($n:ident $i:ident),+) => {
304        impl<Scope, $($n,)+ $($i,)+> private::Sealed<Scope, ($($i,)+)> for ($($n,)+)
305        where
306            $($n: SelectionPart<Scope, $i>,)+
307        {
308        }
309
310        #[allow(non_snake_case)]
311        impl<Scope, $($n,)+ $($i,)+> Selection<Scope, ($($i,)+)> for ($($n,)+)
312        where
313            $($n: SelectionPart<Scope, $i>,)+
314        {
315                    type Output = Row<row_chain!($($n $i),+)>;
316            fn items(&self) -> Vec<SelectItem> {
317                let ($($n,)+) = self;
318                let mut out = Vec::new();
319                $(SelectionPart::push_items($n, &mut out);)+
320                out
321            }
322        }
323    };
324}
325tuple_selection!(A IA);
326tuple_selection!(A IA, B IB);
327tuple_selection!(A IA, B IB, C IC);
328tuple_selection!(A IA, B IB, C IC, D ID);
329tuple_selection!(A IA, B IB, C IC, D ID, E IE);
330tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF);
331tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG);
332tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH);
333tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II);
334tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ);
335tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK);
336tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL);
337tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM);
338tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM, N IN);
339tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM, N IN, O IO);
340tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM, N IN, O IO, P IP);
341tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM, N IN, O IO, P IP, Q IQ);
342tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM, N IN, O IO, P IP, Q IQ, R IR);
343tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM, N IN, O IO, P IP, Q IQ, R IR, S IS);
344tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM, N IN, O IO, P IP, Q IQ, R IR, S IS, T IT);
345tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM, N IN, O IO, P IP, Q IQ, R IR, S IS, T IT, U IU);
346tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM, N IN, O IO, P IP, Q IQ, R IR, S IS, T IT, U IU, V IV);
347tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM, N IN, O IO, P IP, Q IQ, R IR, S IS, T IT, U IU, V IV, W IW);
348tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM, N IN, O IO, P IP, Q IQ, R IR, S IS, T IT, U IU, V IV, W IW, X IX);
349tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM, N IN, O IO, P IP, Q IQ, R IR, S IS, T IT, U IU, V IV, W IW, X IX, Y IY);
350tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM, N IN, O IO, P IP, Q IQ, R IR, S IS, T IT, U IU, V IV, W IW, X IX, Y IY, Z IZ);
351tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM, N IN, O IO, P IP, Q IQ, R IR, S IS, T IT, U IU, V IV, W IW, X IX, Y IY, Z IZ, AA IAA);
352tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM, N IN, O IO, P IP, Q IQ, R IR, S IS, T IT, U IU, V IV, W IW, X IX, Y IY, Z IZ, AA IAA, BB IBB);
353tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM, N IN, O IO, P IP, Q IQ, R IR, S IS, T IT, U IU, V IV, W IW, X IX, Y IY, Z IZ, AA IAA, BB IBB, CC ICC);
354tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM, N IN, O IO, P IP, Q IQ, R IR, S IS, T IT, U IU, V IV, W IW, X IX, Y IY, Z IZ, AA IAA, BB IBB, CC ICC, DD IDD);
355tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM, N IN, O IO, P IP, Q IQ, R IR, S IS, T IT, U IU, V IV, W IW, X IX, Y IY, Z IZ, AA IAA, BB IBB, CC ICC, DD IDD, EE IEE);
356tuple_selection!(A IA, B IB, C IC, D ID, E IE, F IF, G IG, H IH, I II, J IJ, K IK, L IL, M IM, N IN, O IO, P IP, Q IQ, R IR, S IS, T IT, U IU, V IV, W IW, X IX, Y IY, Z IZ, AA IAA, BB IBB, CC ICC, DD IDD, EE IEE, FF IFF);
qbrs_core/select/selection.rs

qbrs_core/select/
selection.rs
