use quote::{format_ident, quote};
use crate::{
emit::{leading, parameter},
interface::InterfaceModel,
model::DatabaseKind,
union,
};
const ID_FIELD: &str = "id";
impl InterfaceModel {
pub(crate) fn sql_databases(&self) -> Vec<DatabaseKind> {
self
.databases()
.into_iter()
.filter(|kind| kind.is_sql())
.collect()
}
pub(crate) fn projects(&self) -> bool {
!self.sql_databases().is_empty() && self.stored().next().is_some()
}
pub(crate) fn projection(&self) -> proc_macro2::TokenStream {
if !self.projects() {
return quote!();
}
let kind = self.kind_vocabulary();
let address = self.address_sum();
let key = self.key_sum();
let rows = self
.sql_databases()
.into_iter()
.map(|database| self.row(database));
quote! {
#kind
#address
#key
#(#rows)*
}
}
fn address_sum(&self) -> proc_macro2::TokenStream {
let vis = &self.vis;
let interface = &self.name;
let name = super::default_id_name(interface);
let vocabulary = super::default_kind_name(interface);
let identifiable = self.framework(&["transform"], "Identifiable");
let variants = self.members.iter().map(|member| {
let variant = &member.ident;
let ty = &member.ty;
let doc = leading(&format!(
"A row of [`{}`]'s table, at that member's own id.",
quote!(#ty)
));
quote! {
#[doc = #doc]
#variant(<#ty as #identifiable>::Id),
}
});
let kinds = self.members.iter().map(|member| {
let variant = &member.ident;
quote!(Self::#variant(_) => #vocabulary::#variant,)
});
let doc = leading(&format!(
"The ADDRESS of one row of [`{interface}`] — which member, and that member's own id.\n\nA SUM rather than one type, because the members need not agree about what an id IS: a member keyed by an integer and one keyed by text are one interface, and neither has to be widened to the other."
));
let kind_doc = leading(
"Which member this address is of.\n\nThe same fact the row's discriminant column carries, read back off the address — so the pair cannot disagree.",
);
quote! {
#[doc = #doc]
#[derive(::core::fmt::Debug, ::core::clone::Clone, ::core::cmp::PartialEq)]
#vis enum #name {
#(#variants)*
}
impl #name {
#[doc = #kind_doc]
#[inline]
#[must_use]
#vis const fn kind(&self) -> #vocabulary {
match self {
#(#kinds)*
}
}
}
}
}
fn key_sum(&self) -> proc_macro2::TokenStream {
let vis = &self.vis;
let interface = &self.name;
let name = super::default_key_name(interface);
let vocabulary = super::default_kind_name(interface);
let transformer = self.framework(&["transform"], "Transformer");
let variants = self.members.iter().map(|member| {
let variant = &member.ident;
let ty = &member.ty;
let doc = leading(&format!(
"A hit on [`{}`], at that member's own whole key.",
quote!(#ty)
));
quote! {
#[doc = #doc]
#variant(<#ty as #transformer>::Key),
}
});
let kinds = self.members.iter().map(|member| {
let variant = &member.ident;
quote!(Self::#variant(_) => #vocabulary::#variant,)
});
let doc = leading(&format!(
"The KEY of one hit of [`{interface}`] — which member, and that member's own whole key.\n\n\
The address one associated type over, and the two are the entity binding's own \
decomposition read here: a row is REACHED by an id, which the projection carries, and a hit \
is HANDED BACK under a key, which is this. What will answer with it is a search that crosses \
the members, so nothing decodes one out of a row and nothing spends one yet. It is minted \
now because it is that search's premise, and a premise settled when its consumer lands is a \
premise settled twice."
));
let kind_doc = leading(
"Which member this key is of.\n\nThe same fact the address answers about a row, read off the \
key instead — so a hit's two halves cannot name different members.",
);
quote! {
#[doc = #doc]
#[derive(::core::fmt::Debug, ::core::clone::Clone, ::core::cmp::PartialEq)]
#vis enum #name {
#(#variants)*
}
impl #name {
#[doc = #kind_doc]
#[inline]
#[must_use]
#vis const fn kind(&self) -> #vocabulary {
match self {
#(#kinds)*
}
}
}
}
}
fn kind_vocabulary(&self) -> proc_macro2::TokenStream {
let vis = &self.vis;
let interface = &self.name;
let name = super::default_kind_name(interface);
let capability = self.framework(&["interface"], "InterfaceKind");
let variants = self.members.iter().map(|member| {
let variant = &member.ident;
let ty = &member.ty;
let doc = leading(&format!("A row read out of [`{}`]'s table.", quote!(#ty)));
quote! {
#[doc = #doc]
#variant,
}
});
let all = self.members.iter().map(|member| {
let variant = &member.ident;
quote!(Self::#variant,)
});
let words = self.members.iter().map(|member| {
let variant = &member.ident;
let word = union::word(&member.ident).to_string();
quote!(Self::#variant => #word,)
});
let interface_name = interface.to_string();
let doc = leading(&format!(
"Which member of [`{interface}`] a row came from.\n\nOne variant per member, carrying \
nothing: what a discriminant answers is WHICH, and the row beside it carries the columns. \
Its ordering is deliberately absent — the statement sorts by the projected WORD, so the \
comparison every party makes goes through `as_str` rather than through a derive that would \
run in declaration order."
));
let as_str_doc = leading("The word this member's arm projects, and the word a cursor freezes.");
quote! {
#[doc = #doc]
#[derive(
::core::fmt::Debug,
::core::clone::Clone,
::core::marker::Copy,
::core::cmp::PartialEq,
::core::cmp::Eq,
::core::hash::Hash
)]
#vis enum #name {
#(#variants)*
}
#[automatically_derived]
impl #capability for #name {
const INTERFACE: &'static ::core::primitive::str = #interface_name;
const ALL: &'static [Self] = &[#(#all)*];
#[doc = #as_str_doc]
#[inline]
fn as_str(self) -> &'static ::core::primitive::str {
match self {
#(#words)*
}
}
}
}
}
fn row(&self, kind: DatabaseKind) -> proc_macro2::TokenStream {
let vis = &self.vis;
let interface = &self.name;
let name = super::default_row_name(interface, kind);
let vocabulary = super::default_kind_name(interface);
let address = super::default_id_name(interface);
let discriminant = format_ident!("{}", self.kind_word(kind));
let id = format_ident!("{ID_FIELD}");
let fields = self.projected().map(|field| {
let column = &field.name;
let ty = field.pinned(kind);
quote!(#column: #ty,)
});
let accessors = self.projected().map(|field| {
let column = &field.name;
let ty = field.pinned(kind);
let doc = leading(&format!(
"The `{column}` column, in the form this database stores it."
));
quote! {
#[doc = #doc]
#[inline]
#[must_use]
#vis const fn #column(&self) -> &#ty {
&self.#column
}
}
});
let what = what(kind);
let doc = leading(&format!(
"The {what} projection every member of [`{interface}`] is read INTO.\n\nThe interface's own \
row: one field per shared column, at the type this database pins it to, and the member the \
row came from. It is not any member's row — a member's row is that member's whole table, \
where this is the promise the interface made over all of them."
));
let kind_doc = leading("Which member this row came from.");
let id_doc = leading(
"This row's ADDRESS — the member it came from, at that member's own id. Borrowed, because a \
member's id need not be `Copy`: the sum is as cheap to hand back as its widest variant and no \
cheaper.",
);
let decode = self.decode(kind);
quote! {
#[doc = #doc]
#[derive(::core::fmt::Debug, ::core::clone::Clone, ::core::cmp::PartialEq)]
#vis struct #name {
#discriminant: #vocabulary,
#id: #address,
#(#fields)*
}
impl #name {
#[doc = #kind_doc]
#[inline]
#[must_use]
#vis const fn #discriminant(&self) -> #vocabulary {
self.#discriminant
}
#[doc = #id_doc]
#[inline]
#[must_use]
#vis const fn #id(&self) -> &#address {
&self.#id
}
#(#accessors)*
}
#decode
}
}
fn decode(&self, kind: DatabaseKind) -> proc_macro2::TokenStream {
let interface = &self.name;
let name = super::default_row_name(interface, kind);
let vocabulary = super::default_kind_name(interface);
let address = super::default_id_name(interface);
let discriminant = format_ident!("{}", self.kind_word(kind));
let id = format_ident!("{ID_FIELD}");
let from_row = self.framework(&["sqlx"], "FromRow");
let row_trait = self.framework(&["sqlx"], "Row");
let column_index = self.framework(&["sqlx"], "ColumnIndex");
let decode = self.framework(&["sqlx"], "Decode");
let column_type = self.framework(&["sqlx"], "Type");
let result = self.framework(&["sqlx"], "Result");
let sqlx_error = self.framework(&["sqlx"], "Error");
let capability = self.framework(&["interface"], "InterfaceKind");
let identifiable = self.framework(&["transform"], "Identifiable");
let alias = self.kind_word(kind);
let id_alias = self.framework(&["interface"], "ID");
let row_parameter = parameter("ROW");
let bounds = self.projected().flat_map(|field| {
let ty = field.pinned(kind);
[
quote!(#ty: #decode<'a, #row_parameter::Database>),
quote!(#ty: #column_type<#row_parameter::Database>),
]
});
let addresses = self.members.iter().flat_map(|member| {
let ty = &member.ty;
[
quote!(<#ty as #identifiable>::Id: #decode<'a, #row_parameter::Database>),
quote!(<#ty as #identifiable>::Id: #column_type<#row_parameter::Database>),
]
});
let raised = self.members.iter().map(|member| {
let variant = &member.ident;
quote!(#vocabulary::#variant => #address::#variant(__row.try_get(__ingraph_id)?),)
});
let reads = self.projected().map(|field| {
let column = &field.name;
let ty = field.pinned(kind);
let external = field.name.to_string();
quote!(let #column: #ty = __row.try_get(#external)?;)
});
let fields = self.projected().map(|field| &field.name);
let doc = leading(&format!(
"Read a [`{name}`] back out of a union's row, each column under the INTERFACE's own name."
));
quote! {
#[automatically_derived]
impl<'a, #row_parameter: #row_trait> #from_row<'a, #row_parameter> for #name
where
&'a ::core::primitive::str: #column_index<#row_parameter>,
::std::string::String: #decode<'a, #row_parameter::Database>
+ #column_type<#row_parameter::Database>,
#(#bounds,)*
#(#addresses,)*
{
#[doc = #doc]
fn from_row(__row: &'a #row_parameter) -> #result<Self> {
let __ingraph_alias: &::core::primitive::str = #alias;
let __ingraph_kind: ::std::string::String = __row.try_get(__ingraph_alias)?;
let #discriminant = <#vocabulary as #capability>::parse(&__ingraph_kind)
.map_err(|__ingraph_unknown| #sqlx_error::ColumnDecode {
index: ::std::borrow::ToOwned::to_owned(__ingraph_alias),
source: ::std::boxed::Box::new(__ingraph_unknown),
})?;
let __ingraph_id: &::core::primitive::str = #id_alias.as_str();
let #id = match #discriminant {
#(#raised)*
};
#(#reads)*
::core::result::Result::Ok(Self { #discriminant, #id, #(#fields,)* })
}
}
}
}
}
pub(crate) const fn what(kind: DatabaseKind) -> &'static str {
match kind {
DatabaseKind::Sqlite => "SQLite",
DatabaseKind::Postgres => "PostgreSQL",
DatabaseKind::Mysql => "MySQL",
DatabaseKind::Mongo => "MongoDB",
}
}