use quote::{format_ident, quote, quote_spanned};
use crate::model::{DatabaseBackend, Label, PersistColumn, RecordModel, TracingLevel};
fn sort_key_type() -> proc_macro2::TokenStream {
quote!(::std::vec::Vec<::core::primitive::u8>)
}
impl RecordModel {
pub(super) fn query(&self) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
let mut types = proc_macro2::TokenStream::new();
let mut impls = proc_macro2::TokenStream::new();
for database in self.queryable() {
types.extend(database.cursor_value(self));
impls.extend(database.cursor_value_impls(self));
impls.extend(database.bindings(self));
impls.extend(database.entry_points(self));
}
for database in self.describable() {
impls.extend(database.blueprint(self));
}
(types, impls)
}
pub(crate) fn queryable(&self) -> Vec<&DatabaseBackend> {
if self.id_column_stored().is_none() {
return Vec::new();
}
self
.persist
.iter()
.flat_map(|persist| &persist.backends)
.filter(|database| {
database.kind().is_sql() && !database.columns().is_empty() && database.raises(self)
})
.collect()
}
pub(crate) fn describable(&self) -> Vec<&DatabaseBackend> {
self
.queryable()
.into_iter()
.filter(|database| database.words_every_column(self))
.collect()
}
pub(crate) fn orderable(&self) -> bool {
self.persist.is_some()
}
}
impl DatabaseBackend {
fn raises(&self, model: &RecordModel) -> bool {
!matches!(self.into(), crate::model::Conversion::Default) || self.carries_every_field(model)
}
pub(crate) fn cursor_name(&self) -> syn::Ident {
format_ident!("{}Cursor", self.name())
}
pub(crate) fn paged_columns<'m>(
&self,
model: &'m RecordModel,
) -> Vec<(usize, &'m PersistColumn)> {
model
.ordered_columns()
.into_iter()
.filter(|(_, shared)| {
let Some(column) = self.stores(&shared.source) else {
return false;
};
!self.edge_stored(model, column) || self.mirrors(model, column)
})
.collect()
}
fn cursor_type(&self, model: &RecordModel, column: &PersistColumn) -> proc_macro2::TokenStream {
if self.mirrors(model, column) {
return sort_key_type();
}
if model.collects(&column.source) {
return self.row_field(model, column);
}
let ty = column.ty();
if !column.nullable {
return self.leaf_type(model, column, quote!(#ty));
}
let optional = model.framework(&["project"], "Optional");
self.leaf_type(model, column, quote!(<#ty as #optional>::Item))
}
fn leaf_type(
&self,
model: &RecordModel,
column: &PersistColumn,
ty: proc_macro2::TokenStream,
) -> proc_macro2::TokenStream {
if column.stored.is_some() {
return ty;
}
let leaves = model.framework(&["ordering"], "ToOrderLeaves");
let marker = self.leaf_marker(model, column, ty);
quote!(<#marker as #leaves>::Leaf)
}
fn leaf_marker(
&self,
model: &RecordModel,
column: &PersistColumn,
ty: proc_macro2::TokenStream,
) -> proc_macro2::TokenStream {
let Some(marker) = model.marker_of(&column.source) else {
let default_marker = model.framework(&["marker"], "DefaultMarker");
return quote!(<#ty as #default_marker>::Marker);
};
let held: syn::Type = syn::parse2(ty).expect("a column's own type parses as one");
marker.resolved(&model.krate, &held)
}
fn leaf_value(
&self,
model: &RecordModel,
column: &PersistColumn,
held: proc_macro2::TokenStream,
) -> proc_macro2::TokenStream {
if column.stored.is_some() {
return quote!(::core::option::Option::Some(::core::clone::Clone::clone(#held)));
}
let leaves = model.framework(&["ordering"], "ToOrderLeaves");
let ty = column.ty();
let ty = if column.nullable {
let optional = model.framework(&["project"], "Optional");
quote!(<#ty as #optional>::Item)
} else {
quote!(#ty)
};
let marker = self.leaf_marker(model, column, ty);
quote!(<#marker as #leaves>::leaf(#held, __ingraph_leaf))
}
fn cursor_value(&self, model: &RecordModel) -> proc_macro2::TokenStream {
let vis = &model.vis;
let name = self.cursor_name();
let record = &model.record;
let column_eq = model.framework(&["column"], "ColumnEq");
let variants = self.paged_columns(model).into_iter().map(|(_, shared)| {
let column = self
.stores(&shared.source)
.expect("`paged_columns` keeps only the columns this database stores");
let variant = shared.order_variant();
let ty = self.cursor_type(model, column);
let doc = super::leading(&format!("The `{}` column's value.", column.name));
let gate = model.gate(&column.source);
quote! {
#gate
#[doc = #doc]
#variant(#ty),
}
});
let arms = self.paged_columns(model).into_iter().map(|(_, shared)| {
let column = self
.stores(&shared.source)
.expect("`paged_columns` keeps only the columns this database stores");
let variant = shared.order_variant();
let ty = self.cursor_type(model, column);
let gate = model.gate(&column.source);
let at = column.source.span();
let compared = quote_spanned! {at=>
<#ty as #column_eq>::column_eq(__ingraph_this, __ingraph_that)
};
quote! {
#gate
(Self::#variant(__ingraph_this), Self::#variant(__ingraph_that)) => #compared,
}
});
let doc = super::leading(&format!(
"One slot of a cursor over a [`{record}`] as this database stores it — which column, and the \
value it held at the boundary row."
));
quote! {
#[doc = #doc]
#[derive(::core::fmt::Debug, ::core::clone::Clone)]
#vis enum #name {
#(#variants)*
}
#[automatically_derived]
impl ::core::cmp::PartialEq for #name {
#[inline]
fn eq(&self, __ingraph_other: &Self) -> ::core::primitive::bool {
match (self, __ingraph_other) {
#(#arms)*
#[allow(unreachable_patterns)]
_ => false,
}
}
}
}
}
fn cursor_value_impls(&self, model: &RecordModel) -> proc_macro2::TokenStream {
let name = self.cursor_name();
let cursor_value = model.framework(&["cursor"], "CursorValue");
let dialect_cursor = model.framework(&["cursor"], "DialectCursor");
let (module, item) = self.kind().dialect();
let backend = model.framework(module, item);
let carrier = model.framework(&["comparison", "sql"], "Carrier");
let database = model.framework(&["sqlx"], "Database");
let held = model.framework(&["sqlx"], "QueryBuilder");
let db = super::parameter("DB");
let columns = self.columns();
let ordered = self.paged_columns(model);
let writes = ordered.iter().enumerate().map(|(tag, (at, shared))| {
let variant = shared.order_variant();
let tag = u8::try_from(tag).unwrap_or(u8::MAX);
let ty = self.cursor_type(model, &columns[*at]);
let gate = model.gate(&columns[*at].source);
quote! {
#gate
Self::#variant(__ingraph_value) => {
__ingraph_out.push(#tag);
<#ty as #dialect_cursor<#backend>>::write_cursor_at(__ingraph_value, __ingraph_out);
}
}
});
let reads = ordered.iter().enumerate().map(|(tag, (at, shared))| {
let variant = shared.order_variant();
let tag = u8::try_from(tag).unwrap_or(u8::MAX);
let ty = self.cursor_type(model, &columns[*at]);
let gate = model.gate(&columns[*at].source);
quote! {
#gate
#tag => ::core::option::Option::map(
<#ty as #dialect_cursor<#backend>>::read_cursor_at(__ingraph_rest),
Self::#variant,
),
}
});
let binds = ordered.iter().map(|(at, shared)| {
let variant = shared.order_variant();
let gate = model.gate(&columns[*at].source);
quote!(#gate Self::#variant(__ingraph_value) => #carrier::push_bind(__ingraph_value, __ingraph_qb),)
});
let bounds = ordered.iter().map(|(at, _)| {
let ty = self.cursor_type(model, &columns[*at]);
quote!(#ty: #carrier<#db>,)
});
let write_doc = super::leading("Append this slot's tag and its value's own bytes.");
let read_doc = super::leading("The slot `bytes` holds, or `None` where they name no column.");
let bind_doc = super::leading("Bind this slot's value, in the type this database stores.");
quote! {
#[automatically_derived]
impl #cursor_value for #name {
#[doc = #write_doc]
fn write_cursor(&self, __ingraph_out: &mut ::std::vec::Vec<::core::primitive::u8>) {
match self {
#(#writes)*
}
}
#[doc = #read_doc]
fn read_cursor(__ingraph_bytes: &[::core::primitive::u8]) -> ::core::option::Option<Self> {
let (__ingraph_tag, __ingraph_rest) =
<[::core::primitive::u8]>::split_first(__ingraph_bytes)?;
match *__ingraph_tag {
#(#reads)*
_ => ::core::option::Option::None,
}
}
}
#[automatically_derived]
impl<#db> #carrier<#db> for #name
where
#db: #database,
#(#bounds)*
{
#[doc = #bind_doc]
fn push_bind(&self, __ingraph_qb: &mut #held<#db>) {
match self {
#(#binds)*
}
}
}
}
}
}
impl DatabaseBackend {
fn shaped(&self, model: &RecordModel) -> proc_macro2::TokenStream {
let db = super::parameter("DB");
let _ = db;
let column_kind = model.framework(&["column"], "ColumnKind");
let types = self
.columns()
.iter()
.filter(|column| !self.edge_stored(model, column))
.map(|column| self.row_field(model, column));
quote!(#(#types: #column_kind,)*)
}
pub(crate) fn column_shapes(&self, model: &RecordModel) -> Vec<proc_macro2::TokenStream> {
let column_name = model.framework(&["column"], "ColumnName");
let shape = model.framework(&["column"], "shape");
let flattened = model.framework(&["column"], "flattened");
self
.columns()
.iter()
.filter(|column| !self.edge_stored(model, column))
.map(|column| {
let ty = self.row_field(model, column);
let gate = model.gate(&column.source);
if column.flatten {
return quote!(#gate #flattened::<#ty>(),);
}
let declared = column.declared();
let stored = column.name.to_string();
let name = if declared == stored {
quote!(#column_name::new(#stored))
} else {
quote!(#column_name::renamed(#declared, #stored))
};
quote!(#gate #shape::<#ty>(#name),)
})
.collect()
}
pub(crate) fn column_fence(&self, model: &RecordModel) -> proc_macro2::TokenStream {
if !self.kind().is_sql() {
return proc_macro2::TokenStream::new();
}
let shapes = self.column_shapes(model);
if shapes.is_empty() {
return proc_macro2::TokenStream::new();
}
let column_shape = model.framework(&["column"], "ColumnShape");
let distinct = model.framework(&["column"], "distinct");
let row = self.name();
let selected: Vec<&PersistColumn> = self
.columns()
.iter()
.filter(|column| !self.edge_stored(model, column))
.collect();
let (places, at) = positions(model, &selected);
let checked = selected.iter().zip(&at).map(|(column, at)| {
let refusal = format!(
"`{row}` would render `{column}` into a column one of its own fields already renders. \
A `flatten`ed field lends NO name, so its type's segments join this row's own namespace \
— a segment called `x` renders `x` rather than `{column}_x` — and a value flattened \
beside a column of that name occupies it twice. Drop the `flatten` in this database's \
block, or rename whichever column it meets.",
column = column.name,
);
let gate = model.gate(&column.source);
quote!(#gate ::core::assert!(#distinct(__INGRAPH_COLUMNS__, #at), #refusal);)
});
quote! {
const _: () = {
const __INGRAPH_COLUMNS__: &[#column_shape] = &[#(#shapes)*];
#places
#(#checked)*
};
}
}
fn words_every_column(&self, model: &RecordModel) -> bool {
!self
.columns()
.iter()
.any(|column| model.collects(&column.source) && !self.edge_stored(model, column))
}
fn blueprint(&self, model: &RecordModel) -> proc_macro2::TokenStream {
let record = &model.record;
let row = self.name();
let backend = self.backend_type(model);
let describe = model.framework(&["schema"], "Describe");
let table = model.framework(&["schema"], "Table");
let edge_table = model.framework(&["schema"], "EdgeTable");
let edge_shape = model.framework(&["schema"], "EdgeShape");
let shadow = model.framework(&["schema"], "Shadow");
let stored_as = model.framework(&["column"], "StoredAs");
let column_kind = model.framework(&["column"], "ColumnKind");
let query = model.framework(&["query", "sql"], "SqlQuery");
let field_name = model.framework(&["field"], "FieldName");
let gate = model.framework(&["gate"], &self.kind().gate().to_string());
let held: Vec<&PersistColumn> = self
.columns()
.iter()
.filter(|column| !self.edge_stored(model, column))
.collect();
let words = held.iter().map(|column| {
let ty = self.row_field(model, column);
let gate = model.gate(&column.source);
let read = quote_spanned!(column.source.span()=> <#ty as #stored_as<#backend>>::WORDS);
quote!(#gate #read,)
});
let nulls = held.iter().map(|column| {
let gate = model.gate(&column.source);
let nullable = column.nullable;
quote!(#gate #nullable,)
});
let marked = |wanted: fn(&PersistColumn) -> bool, word: &'static str| {
let (mut checks, mut names) = (
proc_macro2::TokenStream::new(),
proc_macro2::TokenStream::new(),
);
for column in &held {
if !wanted(column) || model.collects(&column.source) {
continue;
}
let (gate, ty) = (model.gate(&column.source), self.row_field(model, column));
let name = self.external(model, column);
let refusal = format!(
"`{name}` is marked `{word}` and spans SEVERAL columns — the statement names a column \
directly, and a composite field's columns are its segments joined under its own name \
(`{name}_…`) rather than `{name}` itself. Move the word onto a single-column field, or \
give this one a `{db}(type = \"…\")` that is one column wide.",
db = self.kind().as_str(),
);
checks.extend(quote! {
#gate
const _: () = ::core::assert!(<#ty as #column_kind>::SEGMENTS.is_empty(), #refusal);
});
names.extend(quote!(#gate #field_name::new(#name),));
}
(checks, names)
};
let (index_checks, indexes) = marked(|column| column.indexed, "indexed");
let (unique_checks, uniques) = marked(|column| column.unique, "unique");
let composite = model.framework(&["schema"], "CompositeUnique");
let composites = self.composite_uniques().iter().map(|constraint| {
let (mut gates, mut names) = (
proc_macro2::TokenStream::new(),
proc_macro2::TokenStream::new(),
);
for entry in &constraint.entries {
if let Some(column) = held
.iter()
.find(|column| column.name.external() == entry.external())
{
gates.extend(model.gate(&column.source));
}
let name = entry.external();
names.extend(quote!(#field_name::new(#name),));
}
quote!(#gates #composite::new(&[#names]),)
});
let (mut elements, mut edges, mut shadows) = (
proc_macro2::TokenStream::new(),
proc_macro2::TokenStream::new(),
proc_macro2::TokenStream::new(),
);
for (at, column) in self.columns().iter().enumerate() {
if !self.edge_stored(model, column) {
continue;
}
let (gate, element) = (model.gate(&column.source), column.ty());
let name = self.external(model, column);
let word = format_ident!("__INGRAPH_ELEMENT_{at}__");
let shape = match model.shape_of(&column.source) {
Some(Label::Set) => quote!(#edge_shape::Set),
_ => quote!(#edge_shape::Sequence),
};
let refusal = format!(
"`{name}`'s element spans SEVERAL columns, and an edge table's element is declared at ONE \
word — a composite element's columns are named per leaf, which is a list this expansion \
cannot build in a `const`. Declare a `{db}(type = \"…\")` whose element is one column \
wide, or write this record's `Describe` by hand.",
db = self.kind().as_str(),
);
let read = quote_spanned!(column.source.span()=> <#element as #stored_as<#backend>>::WORDS);
elements.extend(quote! {
#gate
const #word: &'static ::core::primitive::str = {
const __INGRAPH_ELEMENT__: &[&'static ::core::primitive::str] = #read;
::core::assert!(<[_]>::len(__INGRAPH_ELEMENT__) == 1, #refusal);
__INGRAPH_ELEMENT__[0]
};
});
let seek = self
.seeks_by_value(model, column)
.then(|| quote!(.indexed()));
edges.extend(quote! {
#gate
#edge_table::new(&[#field_name::new(#name)], #shape, #word) #seek,
});
if !self.mirrors(model, column) {
continue;
}
let companion = self.sort_column(model, column);
shadows.extend(quote! {
#gate
#shadow::new(#field_name::new(#companion), &[#field_name::new(#name)]),
});
}
quote! {
#gate! {
#[automatically_derived]
impl #describe<#backend> for #record {
const BLUEPRINT: #table = {
#index_checks
#unique_checks
#elements
const __INGRAPH_WORDS__: &[&[&'static ::core::primitive::str]] = &[#(#words)*];
const __INGRAPH_NULLS__: &[::core::primitive::bool] = &[#(#nulls)*];
const __INGRAPH_INDEXES__: &[&'static #field_name] = &[#indexes];
const __INGRAPH_UNIQUES__: &[&'static #field_name] = &[#uniques];
const __INGRAPH_COMPOSITES__: &[#composite] = &[#(#composites)*];
const __INGRAPH_EDGES__: &[#edge_table] = &[#edges];
const __INGRAPH_SHADOWS__: &[#shadow] = &[#shadows];
#table::shaped(
<#row as #query<#backend>>::ADDRESS,
<#row as #query<#backend>>::COLUMNS,
__INGRAPH_WORDS__,
__INGRAPH_NULLS__,
)
.with_indexes(__INGRAPH_INDEXES__)
.with_uniques(__INGRAPH_UNIQUES__)
.with_composite_uniques(__INGRAPH_COMPOSITES__)
.with_edges(__INGRAPH_EDGES__)
.with_shadows(__INGRAPH_SHADOWS__)
};
}
}
}
}
fn bindings(&self, model: &RecordModel) -> proc_macro2::TokenStream {
let row = self.name();
let record = &model.record;
let cursor = self.cursor_name();
let comparison = self.comparison_name();
let db = super::parameter("DB");
let query = model.framework(&["query", "sql"], "SqlQuery");
let vocabulary = model.framework(&["transform"], "Record");
let crossing = model.framework(&["query", "sql"], "CrossingError");
let complex = model.framework(&["comparison"], "ComplexComparison");
let carrier = model.framework(&["comparison", "sql"], "Carrier");
let key_in = model.framework(&["comparison", "sql"], "SqlKeyIn");
let field_name = model.framework(&["field"], "FieldName");
let column_shape = model.framework(&["column"], "ColumnShape");
let shaped = self.shaped(model);
let address_ty = model.framework(&["comparison"], "RecordAddress");
let identifiable = model.framework(&["transform"], "Identifiable");
let database = model.framework(&["sqlx"], "Database");
let assumptions = self.assumptions(model);
let shared = model.stored_columns();
let id_at = model
.id_column_stored()
.expect("`RecordModel::queryable` refuses a database whose id is not stored");
let id_column = self
.stores(&shared[id_at].source)
.expect("an address step is a column of every database the record declares");
let id_name = id_column.name.to_string();
let id_value = {
let variant = shared[id_at].order_variant();
let value = id_column.from.apply(
quote!(::core::clone::Clone::clone(__ingraph_id)),
id_column.stored.is_some(),
);
quote!(#cursor::#variant(#value))
};
let id_read = {
let field = id_column.name.safe();
id_column.into.apply(
quote!(::core::clone::Clone::clone(&self.#field)),
id_column.stored.is_some(),
)
};
let selected = self.column_shapes(model);
let (plan, crossings, hydration) = self.collections(model, &[id_at]);
let table = model.table_name(self);
let alias = &self.storage().aliases;
let aliases = crate::alias::aliases(alias.prefix_in(&model.prefix), &table, alias.depth());
let raise = if self.reads_fallibly(model) {
quote! {
::core::result::Result::map_err(
<#record as ::core::convert::TryFrom<#row>>::try_from(self),
::core::convert::Into::into,
)
}
} else {
quote!(::core::result::Result::Ok(
<#record as ::core::convert::From<#row>>::from(self)
))
};
let bindings = quote! {
#[automatically_derived]
impl<#db> #query<#db> for #row
where
#db: #database,
#assumptions
#record: #vocabulary<#db, Comparison: #complex<#db>>,
#comparison<#db>: #complex<#db>,
#cursor: #carrier<#db>,
#shaped
#key_in<#cursor, #db, 1>: #complex<#db>,
#hydration
{
type Record = #record;
type Address = #key_in<#cursor, #db, 1>;
const ADDRESS: #address_ty = #address_ty::new(
#field_name::new(#table),
&[#field_name::new(#id_name)],
);
const ALIASES: &'static [&'static str] = &[#(#aliases),*];
const COLUMNS: &'static [#column_shape] = &[#(#selected)*];
#plan
fn addresses(
ids: &[<#record as #identifiable>::Id],
) -> ::core::result::Result<Self::Address, #crossing> {
let mut __ingraph_keys = ::std::vec::Vec::with_capacity(<[_]>::len(ids));
for __ingraph_id in ids {
::std::vec::Vec::push(&mut __ingraph_keys, [#id_value]);
}
::core::result::Result::Ok(#key_in::new([#id_name], __ingraph_keys))
}
fn id(&self) -> ::core::result::Result<<#record as #identifiable>::Id, #crossing> {
::core::result::Result::Ok(#id_read)
}
fn record(self) -> ::core::result::Result<#record, #crossing> {
#raise
}
}
#crossings
};
let mut emitted = bindings;
if model.orderable() {
emitted.extend(self.ordering(model, &hydration));
}
emitted.extend(self.writing(model, &hydration));
emitted
}
fn writing(
&self,
model: &RecordModel,
hydration: &proc_macro2::TokenStream,
) -> proc_macro2::TokenStream {
let row = self.name();
let record = &model.record;
let cursor = self.cursor_name();
let comparison = self.comparison_name();
let db = super::parameter("DB");
let write = model.framework(&["query", "sql"], "SqlWrite");
let vocabulary = model.framework(&["transform"], "Record");
let crossing = model.framework(&["query", "sql"], "CrossingError");
let complex = model.framework(&["comparison"], "ComplexComparison");
let carrier = model.framework(&["comparison", "sql"], "Carrier");
let key_in = model.framework(&["comparison", "sql"], "SqlKeyIn");
let database = model.framework(&["sqlx"], "Database");
let held = model.framework(&["sqlx"], "QueryBuilder");
let assumptions = self.assumptions(model);
let columns = self.columns();
let id_at = model
.id_column_stored()
.expect("`RecordModel::queryable` refuses a database whose id is not stored");
let (plan, crossings, bounds) = self.edge_writes(model);
let shaped = self.shaped(model);
let selected_types: Vec<proc_macro2::TokenStream> = columns
.iter()
.filter(|column| !self.edge_stored(model, column))
.map(|column| self.row_field(model, column))
.collect();
let selected: Vec<&PersistColumn> = columns
.iter()
.filter(|column| !self.edge_stored(model, column))
.collect();
let push = |column: &PersistColumn| {
let (field, ty) = (column.name.safe(), self.row_field(model, column));
quote!(<#ty as #carrier<#db>>::push_bind(&self.#field, __ingraph_qb))
};
let bind = self.dispatch(model, &selected, push);
let bind_address = self.dispatch(model, &[&columns[id_at]], push);
let project = if self.writes_fallibly() {
quote! {
::core::result::Result::map_err(
<#row as ::core::convert::TryFrom<#record>>::try_from(record),
::core::convert::Into::into,
)
}
} else {
quote!(::core::result::Result::Ok(
<#row as ::core::convert::From<#record>>::from(record)
))
};
let bind_doc = super::leading(
"Bind this row's `at`th column, in the order `SqlQuery::COLUMNS` names them — the values, \
where the engine writes every bracket and every comma around them.",
);
let address_doc = super::leading(
"Bind this row's `at`th address column. There is ONE, so the position is unread: the id is \
what names a row, and a framework-emitted table declares it `UNIQUE`.",
);
quote! {
#[automatically_derived]
impl<#db> #write<#db> for #row
where
#db: #database,
#assumptions
#record: #vocabulary<#db, Comparison: #complex<#db>>,
#comparison<#db>: #complex<#db>,
#cursor: #carrier<#db>,
#key_in<#cursor, #db, 1>: #complex<#db>,
#hydration
#(#selected_types: #carrier<#db>,)*
#shaped
#bounds
{
#plan
fn row(record: #record) -> ::core::result::Result<Self, #crossing> {
#project
}
#[doc = #bind_doc]
fn bind(&self, __ingraph_at: ::core::primitive::usize, __ingraph_qb: &mut #held<#db>) {
#bind
}
#[doc = #address_doc]
fn bind_address(
&self,
__ingraph_at: ::core::primitive::usize,
__ingraph_qb: &mut #held<#db>,
) {
#bind_address
}
}
#crossings
}
}
fn dispatch(
&self,
model: &RecordModel,
columns: &[&PersistColumn],
arm: impl Fn(&PersistColumn) -> proc_macro2::TokenStream,
) -> proc_macro2::TokenStream {
let width = columns.len();
let conditional = columns
.iter()
.any(|column| !model.gate(&column.source).is_empty());
if !conditional {
if width == 1 {
let only = columns
.first()
.map(|column| arm(column))
.unwrap_or_default();
return quote! {
let _ = __ingraph_at;
#only;
};
}
let arms = columns.iter().enumerate().map(|(at, column)| {
let arm = arm(column);
if at + 1 == width {
return quote!(_ => #arm,);
}
quote!(#at => #arm,)
});
return quote! {
match __ingraph_at {
#(#arms)*
}
};
}
let (places, at) = positions(model, columns);
let arms = columns.iter().zip(&at).map(|(column, at)| {
let (gate, arm) = (model.gate(&column.source), arm(column));
quote!(#gate #at => #arm,)
});
quote! {
#places
match __ingraph_at {
#(#arms)*
_ => {}
}
}
}
fn edge_writes(
&self,
model: &RecordModel,
) -> (
proc_macro2::TokenStream,
proc_macro2::TokenStream,
proc_macro2::TokenStream,
) {
let edges: Vec<&PersistColumn> = self
.columns()
.iter()
.filter(|column| self.edge_stored(model, column))
.collect();
if edges.is_empty() {
return Default::default();
}
let row = self.name();
let db = super::parameter("DB");
let edge_write = model.framework(&["query", "sql"], "EdgeWrite");
let edge_shape = model.framework(&["query", "sql"], "EdgeShape");
let field_name = model.framework(&["field"], "FieldName");
let carrier = model.framework(&["comparison", "sql"], "Carrier");
let database = model.framework(&["sqlx"], "Database");
let held = model.framework(&["sqlx"], "QueryBuilder");
let shadow_write = model.framework(&["query", "sql"], "ShadowWrite");
let sort_key = model.framework(&["sort"], "SortKey");
let collection_sort_key = model.framework(&["sort"], "collection_sort_key");
let bytes = sort_key_type();
let mut elements: Vec<&syn::Type> = Vec::new();
let mut sortable: Vec<&syn::Type> = Vec::new();
let mut crossings = proc_macro2::TokenStream::new();
let mut entries = proc_macro2::TokenStream::new();
let mut companions = proc_macro2::TokenStream::new();
for column in edges {
let field = column.name.safe();
let external = column.name.to_string();
let element = column.ty();
elements.push(element);
let shape = match model.shape_of(&column.source) {
Some(Label::Set) => quote!(#edge_shape::Set),
_ => quote!(#edge_shape::Sequence),
};
let kind = self.kind().as_str();
let count = format_ident!("__ingraph_count_{kind}_{field}");
let bind = format_ident!("__ingraph_element_{kind}_{field}");
let count_doc = super::leading(&format!(
"How many elements this row's `{external}` holds — the count the engine renders that many \
value rows for."
));
let bind_doc = super::leading(&format!(
"Bind this row's `at`th `{external}` element. The engine writes the parentheses, the commas \
and the ORDINAL beside it: a position is the plan's own counter, so an element's crossing \
states the value and nothing about where in the collection it sits."
));
let gate = model.gate(&column.source);
crossings.extend(quote! {
#gate
#[doc = #count_doc]
fn #count(__ingraph_row: &#row) -> ::core::primitive::usize {
::std::vec::Vec::len(&__ingraph_row.#field)
}
#gate
#[doc = #bind_doc]
fn #bind<#db>(
__ingraph_row: &#row,
__ingraph_at: ::core::primitive::usize,
__ingraph_qb: &mut #held<#db>,
)
where
#db: #database,
#element: #carrier<#db>,
{
<#element as #carrier<#db>>::push_bind(&__ingraph_row.#field[__ingraph_at], __ingraph_qb);
}
});
entries.extend(quote! {
#gate
#edge_write::new(
&[#field_name::new(#external)],
#shape,
#count,
#bind::<#db>,
),
});
if !self.mirrors(model, column) {
continue;
}
sortable.push(element);
let companion = self.sort_column(model, column);
let key = format_ident!("__ingraph_sort_{kind}_{field}");
let key_doc = super::leading(&format!(
"This row's `{external}`, as the ORDER-PRESERVING bytes `{companion}` holds. The engine \
writes the column and the placeholder; what the declaration owns is the value, and the \
value is the framework's own encoding of the collection this row carries."
));
crossings.extend(quote! {
#gate
#[doc = #key_doc]
fn #key<#db>(__ingraph_row: &#row, __ingraph_qb: &mut #held<#db>)
where
#db: #database,
#element: #sort_key,
#bytes: #carrier<#db>,
{
<#bytes as #carrier<#db>>::push_bind(
&#collection_sort_key(&__ingraph_row.#field),
__ingraph_qb,
);
}
});
companions.extend(quote! {
#gate
#shadow_write::new(#field_name::new(#companion), #key::<#db>),
});
}
let mut bounds = quote!(#(#elements: #carrier<#db>,)*);
let companion_plan = if sortable.is_empty() {
proc_macro2::TokenStream::new()
} else {
bounds.extend(quote!(#(#sortable: #sort_key,)* #bytes: #carrier<#db>,));
quote! {
const SHADOWS: &'static [#shadow_write<Self, #db>] = &[#companions];
}
};
let plan = quote! {
const EDGES: &'static [#edge_write<Self, #db>] = &[#entries];
#companion_plan
};
(plan, crossings, bounds)
}
fn collections(
&self,
model: &RecordModel,
key_at: &[usize],
) -> (
proc_macro2::TokenStream,
proc_macro2::TokenStream,
proc_macro2::TokenStream,
) {
let columns = self.columns();
let edges: Vec<&PersistColumn> = self
.columns()
.iter()
.filter(|column| self.edge_stored(model, column))
.collect();
if edges.is_empty() {
return Default::default();
}
let row = self.name();
let db = super::parameter("DB");
let edge_collection = model.framework(&["query", "sql"], "EdgeCollection");
let edge_shape = model.framework(&["query", "sql"], "EdgeShape");
let element_alias = model.framework(&["query", "sql"], "ELEMENT");
let distribute = model.framework(&["query", "sql"], "distribute");
let aggregated = model.framework(&["query", "sql"], "aggregated");
let field_name = model.framework(&["field"], "FieldName");
let carrier = model.framework(&["comparison", "sql"], "Carrier");
let database = model.framework(&["sqlx"], "Database");
let held = model.framework(&["sqlx"], "QueryBuilder");
let row_trait = model.framework(&["sqlx"], "Row");
let decode = model.framework(&["sqlx"], "Decode");
let column_type = model.framework(&["sqlx"], "Type");
let column_index = model.framework(&["sqlx"], "ColumnIndex");
let sqlx_error = model.framework(&["sqlx"], "Error");
let key_types: Vec<&syn::Type> = key_at.iter().map(|&at| columns[at].ty()).collect();
let key_fields: Vec<&syn::Ident> = key_at.iter().map(|&at| columns[at].name.safe()).collect();
let key_names: Vec<String> = key_at
.iter()
.map(|&at| columns[at].name.to_string())
.collect();
let binder = format_ident!("__ingraph_key_{}", self.kind().as_str());
let bind = if key_fields.len() == 1 {
let (field, ty) = (&key_fields[0], &key_types[0]);
quote! {
let _ = __ingraph_at;
<#ty as #carrier<#db>>::push_bind(&__ingraph_row.#field, __ingraph_qb);
}
} else {
let arms = key_fields.iter().zip(&key_types).enumerate().map(
|(position, (field, ty))| -> proc_macro2::TokenStream {
let bind = quote!(<#ty as #carrier<#db>>::push_bind(&__ingraph_row.#field, __ingraph_qb));
if position + 1 == key_fields.len() {
return quote!(_ => #bind,);
}
quote!(#position => #bind,)
},
);
quote! {
match __ingraph_at {
#(#arms)*
}
}
};
let binder_doc = super::leading(
"Bind one of this row's key columns, in the order `SqlQuery::ADDRESS` names them — the plan's \
half of a gather's membership, where the engine writes every bracket around it.",
);
let gathers = edges.iter().any(|column| !self.aggregates(model, column));
let mut crossings = if gathers {
quote! {
#[doc = #binder_doc]
fn #binder<#db>(
__ingraph_row: &#row,
__ingraph_at: ::core::primitive::usize,
__ingraph_qb: &mut #held<#db>,
)
where
#db: #database,
#(#key_types: #carrier<#db>,)*
{
#bind
}
}
} else {
proc_macro2::TokenStream::new()
};
let mut gathered_elements: Vec<&syn::Type> = Vec::new();
let mut aggregated_elements: Vec<&syn::Type> = Vec::new();
let mut entries = proc_macro2::TokenStream::new();
for column in edges {
let field = column.name.safe();
let external = column.name.to_string();
let element = column.ty();
let shape = match model.shape_of(&column.source) {
Some(Label::Set) => quote!(#edge_shape::Set),
_ => quote!(#edge_shape::Sequence),
};
let take = format_ident!(
"__ingraph_take_{}_{}",
self.kind().as_str(),
column.name.safe()
);
let gate = model.gate(&column.source);
if self.aggregates(model, column) {
aggregated_elements.push(element);
let take_doc = super::leading(&format!(
"Take the `{external}` array off the page row it rode in on — the plan's whole crossing \
for an aggregate, and one call. The ALIAS is the ENGINE's: several aggregates ride one \
statement, so the party that wrote the names is the party that hands them over."
));
crossings.extend(quote! {
#gate
#[doc = #take_doc]
fn #take<#db>(
__ingraph_row: &mut #row,
__ingraph_from: &<#db as #database>::Row,
__ingraph_alias: &::core::primitive::str,
) -> ::core::result::Result<(), #sqlx_error>
where
#db: #database,
for<'__ingraph_r> ::core::option::Option<::std::vec::Vec<#element>>:
#decode<'__ingraph_r, #db> + #column_type<#db>,
for<'__ingraph_a> &'__ingraph_a ::core::primitive::str:
#column_index<<#db as #database>::Row>,
{
__ingraph_row.#field = #aggregated::<#element, #db>(__ingraph_from, __ingraph_alias)?;
::core::result::Result::Ok(())
}
});
entries.extend(quote! {
#gate
#edge_collection::aggregate(
&[#field_name::new(#external)],
#shape,
#take::<#db>,
),
});
continue;
}
gathered_elements.push(element);
let take_doc = super::leading(&format!(
"Give every page row the `{external}` elements gathered for it — the plan's other half, \
which names the four types and nothing else: `distribute` owns the grouping and the \
collapse."
));
crossings.extend(quote! {
#gate
#[doc = #take_doc]
fn #take<#db>(
__ingraph_page: &mut [#row],
__ingraph_gathered: &[<#db as #database>::Row],
) -> ::core::result::Result<(), #sqlx_error>
where
#db: #database,
#(#key_types: ::core::clone::Clone + ::core::cmp::Eq + ::core::hash::Hash,)*
#(for<'__ingraph_r> #key_types: #decode<'__ingraph_r, #db> + #column_type<#db>,)*
for<'__ingraph_r> #element: #decode<'__ingraph_r, #db> + #column_type<#db>,
for<'__ingraph_a> &'__ingraph_a ::core::primitive::str:
#column_index<<#db as #database>::Row>,
{
let __ingraph_element: &::core::primitive::str =
::core::convert::AsRef::as_ref(#element_alias);
#distribute(
__ingraph_page,
__ingraph_gathered,
|__ingraph_row| (#(::core::clone::Clone::clone(&__ingraph_row.#key_fields),)*),
|__ingraph_row| ::core::result::Result::Ok((
#(#row_trait::try_get::<#key_types, _>(__ingraph_row, #key_names)?,)*
)),
|__ingraph_row| #row_trait::try_get::<#element, _>(__ingraph_row, __ingraph_element),
|__ingraph_row| &mut __ingraph_row.#field,
)
}
});
entries.extend(quote! {
#gate
#edge_collection::gather(
&[#field_name::new(#external)],
#shape,
#binder::<#db>,
#take::<#db>,
),
});
}
let membership = gathers.then(|| {
quote! {
#(#key_types: ::core::clone::Clone + ::core::cmp::Eq + ::core::hash::Hash,)*
#(#key_types: #carrier<#db>,)*
#(for<'__ingraph_r> #key_types: #decode<'__ingraph_r, #db> + #column_type<#db>,)*
}
});
let hydration = quote! {
#membership
#(for<'__ingraph_r> #gathered_elements: #decode<'__ingraph_r, #db> + #column_type<#db>,)*
#(
for<'__ingraph_r> ::core::option::Option<::std::vec::Vec<#aggregated_elements>>:
#decode<'__ingraph_r, #db> + #column_type<#db>,
)*
for<'__ingraph_a> &'__ingraph_a ::core::primitive::str:
#column_index<<#db as #database>::Row>,
};
let plan = quote! {
const COLLECTIONS: &'static [#edge_collection<Self, #db>] = &[#entries];
};
(plan, crossings, hydration)
}
fn ordering(
&self,
model: &RecordModel,
hydration: &proc_macro2::TokenStream,
) -> proc_macro2::TokenStream {
let row = self.name();
let record = &model.record;
let cursor = self.cursor_name();
let comparison = self.comparison_name();
let db = super::parameter("DB");
let ordering = model.framework(&["query", "sql"], "SqlOrdering");
let vocabulary = model.framework(&["transform"], "Record");
let complex = model.framework(&["comparison"], "ComplexComparison");
let carrier = model.framework(&["comparison", "sql"], "Carrier");
let key_in = model.framework(&["comparison", "sql"], "SqlKeyIn");
let order_term = model.framework(&["cursor"], "OrderTerm");
let optional = model.framework(&["project"], "Optional");
let database = model.framework(&["sqlx"], "Database");
let subjects = model.framework(&["comparison", "sql"], "TermColumns");
let order_subjects = model.framework(&["comparison", "sql"], "OrderSubjects");
let sqlx_error = model.framework(&["sqlx"], "Error");
let assumptions = self.assumptions(model);
let shaped = self.shaped(model);
let order_by = model.order_by.safe();
let term = self.kind().order_term();
let row_trait = model.framework(&["sqlx"], "Row");
let projected = model.ordered_columns().iter().any(|(_, shared)| {
self
.stores(&shared.source)
.is_some_and(|column| self.mirrors(model, column))
});
let (raw, alias) = if projected {
(quote!(__ingraph_raw), quote!(__ingraph_alias))
} else {
(quote!(_), quote!(_))
};
let leafed = model.ordered_columns().iter().any(|(_, shared)| {
self.stores(&shared.source).is_some_and(|column| {
column.stored.is_none()
&& !self.mirrors(model, column)
&& !self.edge_stored(model, column)
&& !model.collects(&column.source)
})
});
let leaf_param = if leafed {
quote!(__ingraph_leaf)
} else {
quote!(_)
};
let bytes = sort_key_type();
let boundary = projected.then(|| {
let decode = model.framework(&["sqlx"], "Decode");
let column_type = model.framework(&["sqlx"], "Type");
quote! {
for<'__ingraph_r> #bytes: #decode<'__ingraph_r, #db> + #column_type<#db>,
}
});
let values = model.ordered_columns().into_iter().map(|(_, shared)| {
let variant = shared.order_variant();
let gate = model.gate(&shared.source);
let Some(column) = self.stores(&shared.source) else {
return quote! {
#gate
#order_by::#variant(_) => ::core::result::Result::Ok(::core::option::Option::None),
};
};
let field = column.name.safe();
if self.mirrors(model, column) {
return quote! {
#gate
#order_by::#variant(_) => ::core::result::Result::map(
#row_trait::try_get::<#bytes, _>(__ingraph_raw, __ingraph_alias),
|__ingraph_key| ::core::option::Option::Some(#cursor::#variant(__ingraph_key)),
),
};
}
if self.edge_stored(model, column) {
return quote! {
#gate
#order_by::#variant(_) => ::core::result::Result::Ok(::core::option::Option::None),
};
}
if model.collects(&column.source) {
return quote! {
#gate
#order_by::#variant(_) => ::core::result::Result::Ok(::core::option::Option::Some(
#cursor::#variant(::core::clone::Clone::clone(&self.#field)),
)),
};
}
if column.nullable {
let leaf = self.leaf_value(model, column, quote!(__ingraph_value));
return quote! {
#gate
#order_by::#variant(_) => ::core::result::Result::Ok(::core::option::Option::map(
::core::option::Option::and_then(
#optional::as_option(&self.#field),
|__ingraph_value| #leaf,
),
#cursor::#variant,
)),
};
}
let leaf = self.leaf_value(model, column, quote!(&self.#field));
quote! {
#gate
#order_by::#variant(_) => ::core::result::Result::Ok(::core::option::Option::map(
#leaf,
#cursor::#variant,
)),
}
});
let value_doc = super::leading(
"The value this row holds at `order`'s column at LEVEL `leaf`, or `None` where it holds SQL \
`NULL` — a citizen that states a semantic sequence runs as one level per leaf and is asked \
once for each, through its own `OrderLeaves` vocabulary, while every other column has one \
level and answers with its field. A DERIVED leaf is recomputed at this call rather than \
carried, which is what keeps a boundary the value the statement sorted by. It is also `None` \
at an \
EDGE-STORED collection term with no companion, which is an order subject and not a cursor \
slot, so a page over one is refused before this is asked. An ARRAY-STORED collection IS a \
slot and answers with the whole list. A MIRRORED one answers with its COMPANION COLUMN's \
bytes, read off the RAW driver row under the alias the engine projected them: the statement \
ordered by the companion, so the boundary a page resumes at is what the statement compared, \
and never the sort key of the collection the gather put on this row afterwards. Every other \
term of this order is a COLUMN of the row, so the decoded row answers it and neither the raw \
row nor the alias is read.",
);
let subjects_doc =
super::leading("What each term of this order COMPARES: its own column, at every term.");
quote! {
#[automatically_derived]
impl<#db> #ordering<#db> for #row
where
#db: #database,
#assumptions
#record: #vocabulary<#db, Comparison: #complex<#db>>,
#comparison<#db>: #complex<#db>,
#cursor: #carrier<#db>,
#key_in<#cursor, #db, 1>: #complex<#db>,
#subjects: #order_subjects<#db>,
#boundary
#hydration
#shaped
{
type Order = #order_by;
type Value = #cursor;
type Subjects = #subjects;
#[inline]
fn complete(written: &[#order_by]) -> ::std::vec::Vec<#order_by> {
#order_by::complete(written)
}
#[inline]
fn term(order: #order_by) -> #order_term {
#order_by::#term(order)
}
#[doc = #subjects_doc]
#[inline]
fn subjects(_: &[#order_by]) -> #subjects {
#subjects
}
#[doc = #value_doc]
fn value(
&self,
order: #order_by,
#leaf_param: ::core::primitive::usize,
#raw: &<#db as #database>::Row,
#alias: &::core::primitive::str,
) -> ::core::result::Result<::core::option::Option<#cursor>, #sqlx_error> {
match order {
#(#values)*
}
}
}
}
}
fn entry_points(&self, model: &RecordModel) -> proc_macro2::TokenStream {
let vis = &model.vis;
let record = &model.record;
let row = self.name();
let kind = self.kind();
let db = super::parameter("DB");
let executor = super::parameter("EXEC");
let find_ty = model.framework(&["query", "sql"], "Find");
let query = model.framework(&["query", "sql"], "SqlQuery");
let dialect = model.framework(&["query", "sql"], "SqlDialect");
let snapshot_trait = model.framework(&["query", "sql"], "ReadSnapshot");
let error = model.framework(&["query", "sql"], "SqlQueryError");
let get = model.framework(&["query", "sql"], "get");
let identifiable = model.framework(&["transform"], "Identifiable");
let backend = model.framework(&["comparison"], "Backend");
let acquire = model.framework(&["sqlx"], "Acquire");
let from_row = model.framework(&["sqlx"], "FromRow");
let sqlx_executor = model.framework(&["sqlx"], "Executor");
let into_arguments = model.framework(&["sqlx"], "IntoArguments");
let database = model.framework(&["sqlx"], "Database");
let write = model.framework(&["query", "sql"], "SqlWrite");
let write_error = model.framework(&["query", "sql"], "SqlWriteError");
let write_transaction = model.framework(&["query", "sql"], "WriteTransaction");
let begin_write = model.framework(&["query", "sql"], "BeginWrite");
let upsert_clause = model.framework(&["query", "sql"], "Upsert");
let affected = model.framework(&["query", "sql"], "Affected");
let insert = model.framework(&["query", "sql"], "insert");
let upsert = model.framework(&["query", "sql"], "upsert");
let delete = model.framework(&["query", "sql"], "delete");
let delete_where = model.framework(&["query", "sql"], "delete_where");
let vocabulary = model.framework(&["transform"], "Record");
let complex = model.framework(&["comparison"], "ComplexComparison");
let carrier = model.framework(&["comparison", "sql"], "Carrier");
let (find, snapshot, get_name) = (kind.finder(), kind.snapshot_finder(), kind.getter());
let (insert_name, upsert_name) = (kind.inserter(), kind.upserter());
let (delete_name, purge_name) = (kind.deleter(), kind.purger());
let insert_doc = super::leading(&format!(
"Store this [`{record}`] in {} as a NEW row.\n\nAn address that already holds one is the \
dialect's own constraint violation, carried rather than translated — a caller that means \
*store this whatever was there* has [`{upsert_name}`](Self::{upsert_name}) and does not have \
to read an error to get it. The record crosses to its row through the declaration's own \
write legs, and a record whose collections are edge-stored is written in ONE transaction \
with them.",
kind.as_str()
));
let upsert_doc = super::leading(&format!(
"Store this [`{record}`] in {} at its address, REPLACING whatever was there.\n\nThe row is the \
dialect's keyed replace and every edge-stored collection is replaced as a SET — the old rows \
removed, the new ones written with the new collection's own ordinals, in the same \
transaction as the row. A collection that arrives shorter comes back shorter: the value \
handed over is the whole of it.",
kind.as_str()
));
let find_doc = super::leading(&format!(
"Query the [`{record}`]s stored in {} — the unordered lanes, the row ceiling, and the ordered \
page.",
kind.as_str()
));
let snapshot_doc = super::leading(&format!(
"[`{find}`](Self::{find}) inside a read transaction this dialect opens, so every statement of \
the call sees one state of the database."
));
let get_doc = super::leading(&format!(
"The [`{record}`] at `id` in {}, or `None` where no row lives there — the miss is `Ok(None)` \
on every path. The id is the whole address: it is `UNIQUE`, so it names at most one row, and \
the lineage a [`{key}`] carries is stored beside it rather than looked up with it.",
kind.as_str(),
key = model.key.name,
));
let delete_doc = super::leading(&format!(
"Remove the [`{record}`] at `id` from {}, and everything stored FOR it — `true` where a row \
was there.\n\nThe id is the whole address, as it is for \
[`{get_name}`](Self::{get_name}), so the answer is a yes-or-no rather than a count. Every \
edge-stored collection's rows and every provenance row go with it, in ONE transaction, by \
statements this lane writes rather than by a cascade the schema does not declare. A miss is \
`Ok(false)` and never an error.",
kind.as_str()
));
let purge_doc = super::leading(&format!(
"Remove every [`{record}`] in {} that `filter` names, and everything stored for each of them \
— answering with how many RECORDS went.\n\nThis is the RE-INDEX road: a source that produced \
fourteen rows and now produces nine leaves five behind, and *what it used to produce* is a \
set nobody holds — the predicate those rows are under is what a caller has. The filter is \
REQUIRED, and one that lowers to no predicate at all is refused with \
`SqlWriteError::Unscoped` before anything runs, rather than emptying the table.",
kind.as_str()
));
let gate = model.framework(&["gate"], "if_tracing");
let ungated = model.framework(&["gate"], "if_no_tracing");
let entries = |observed: bool| {
let get_body = self.observed(
model,
observed,
"get",
quote!(#get::<#row, #db, #executor>(executor, id, false)),
);
let insert_body = self.observed(
model,
observed,
"insert",
quote!(#insert::<#row, #db, #executor>(executor, record)),
);
let upsert_body = self.observed(
model,
observed,
"upsert",
quote!(#upsert::<#row, #db, #executor>(executor, record)),
);
let delete_body = self.observed(
model,
observed,
"delete",
quote!(#delete::<#row, #db, #executor>(executor, id)),
);
let purge_body = self.observed(
model,
observed,
"delete_where",
quote!(#delete_where::<#row, #db, #executor>(executor, filter)),
);
quote! {
impl #record {
#[doc = #get_doc]
#vis async fn #get_name<'c, #db, #executor>(
executor: #executor,
id: &<#record as #identifiable>::Id,
) -> ::core::result::Result<::core::option::Option<#record>, #error>
where
#db: #dialect,
#row: #query<#db, Record = #record> + for<'r> #from_row<'r, <#db as #database>::Row>,
for<'e> &'e mut <#db as #database>::Connection:
#sqlx_executor<'e, Database = #db>,
<#db as #database>::Arguments: #into_arguments<#db>,
#executor: #acquire<'c, Database = #db>,
{
#get_body
}
#[doc = #insert_doc]
#vis async fn #insert_name<'c, #db, #executor>(
executor: #executor,
record: #record,
) -> ::core::result::Result<(), #write_error>
where
#db: #dialect + #write_transaction,
#row: #write<#db, Record = #record>,
::core::primitive::i64: #carrier<#db>,
for<'e> &'e mut <#db as #database>::Connection:
#sqlx_executor<'e, Database = #db>,
<#db as #database>::Arguments: #into_arguments<#db>,
#executor: #acquire<'c, Database = #db> + #begin_write,
{
#insert_body
}
#[doc = #upsert_doc]
#vis async fn #upsert_name<'c, #db, #executor>(
executor: #executor,
record: #record,
) -> ::core::result::Result<(), #write_error>
where
#db: #dialect + #write_transaction + #upsert_clause,
#row: #write<#db, Record = #record>,
::core::primitive::i64: #carrier<#db>,
for<'e> &'e mut <#db as #database>::Connection:
#sqlx_executor<'e, Database = #db>,
<#db as #database>::Arguments: #into_arguments<#db>,
#executor: #acquire<'c, Database = #db> + #begin_write,
{
#upsert_body
}
#[doc = #delete_doc]
#vis async fn #delete_name<'c, #db, #executor>(
executor: #executor,
id: &<#record as #identifiable>::Id,
) -> ::core::result::Result<::core::primitive::bool, #write_error>
where
#db: #dialect + #write_transaction + #affected,
#row: #write<#db, Record = #record>,
for<'e> &'e mut <#db as #database>::Connection:
#sqlx_executor<'e, Database = #db>,
<#db as #database>::Arguments: #into_arguments<#db>,
#executor: #acquire<'c, Database = #db> + #begin_write,
{
#delete_body
}
#[doc = #purge_doc]
#vis async fn #purge_name<'c, #db, #executor>(
executor: #executor,
filter: &<#record as #vocabulary<#db>>::Comparison,
) -> ::core::result::Result<::core::primitive::u64, #write_error>
where
#db: #dialect + #write_transaction + #affected,
#row: #write<#db, Record = #record>,
#record: #vocabulary<#db, Comparison: #complex<#db>>,
for<'e> &'e mut <#db as #database>::Connection:
#sqlx_executor<'e, Database = #db>,
<#db as #database>::Arguments: #into_arguments<#db>,
#executor: #acquire<'c, Database = #db> + #begin_write,
{
#purge_body
}
}
}
};
let watched = entries(true);
let plain = entries(false);
quote! {
impl #record {
#[doc = #find_doc]
#[inline]
#vis fn #find<'a, #db, #executor>(
executor: #executor,
) -> #find_ty<'a, #row, #db, #executor>
where
#db: #backend + #database,
#row: #query<#db>,
{
#find_ty::new(executor, false)
}
#[doc = #snapshot_doc]
#[inline]
#vis fn #snapshot<'a, #db, #executor>(
executor: #executor,
) -> #find_ty<'a, #row, #db, #executor>
where
#db: #backend + #database + #snapshot_trait,
#row: #query<#db>,
{
#find_ty::new(executor, true)
}
}
#gate! { #watched }
#ungated! { #plain }
}
}
fn observed(
&self,
model: &RecordModel,
observed: bool,
entry: &str,
call: proc_macro2::TokenStream,
) -> proc_macro2::TokenStream {
if !observed {
return quote!(#call.await);
}
let instrument = model.framework(&["tracing"], "Instrument");
let span = model.framework(&["tracing"], "span");
let level = model.framework(&["tracing"], "Level");
let constant = model.tracing.unwrap_or(TracingLevel::Info).constant();
let record = model.record.to_string();
let database = self.kind().as_str();
quote! {
{
use #instrument as _;
#call
.instrument(#span!(
#level::#constant,
"ingraph.query",
record = #record,
entry = #entry,
db = #database,
))
.await
}
}
}
}
fn positions(
model: &RecordModel,
columns: &[&PersistColumn],
) -> (proc_macro2::TokenStream, Vec<proc_macro2::TokenStream>) {
let declared: Vec<Option<&crate::model::Condition>> = columns
.iter()
.map(|column| model.condition(&column.source))
.collect();
super::positions(&declared)
}