use core::marker::PhantomData;
use super::{
BeginRead, SqlDialect, SqlOrdering, SqlQuery, SqlQueryError,
error::offset,
hydrate::{absorb, aggregates, hydrate},
snapshot::{close_read, open_read},
};
use crate::{
Cursor, FieldName, Identifiable, OrderTerm, Record, Walk,
comparison::{
At, Backend, ComplexComparison,
sql::{
OrderSubjects, QueryBuilder, SelectClause, SqlConjunction, SqlKeyset, SqlOrder, SubjectShape,
SubjectSlot, Utf8BytesMut, WhereClause, fold_columns, push_index, quote_ident,
},
},
query::{DEFAULT_PAGE_SIZE, Edge, MAX_PAGE_SIZE, Page, partition},
};
type RowComparison<Row, Db> = <<Row as SqlQuery<Db>>::Record as Record<Db>>::Comparison;
#[derive(Debug, PartialEq, Eq)]
enum Position<'a, V> {
Start,
Cursor(&'a Cursor<V>),
Skip(u64),
}
impl<V> Clone for Position<'_, V> {
#[inline]
fn clone(&self) -> Self {
*self
}
}
impl<V> Copy for Position<'_, V> {}
impl<'a, V> Position<'a, V> {
const fn is_set(self) -> bool {
match self {
Self::Start => false,
Self::Cursor(_) => true,
Self::Skip(skip) => skip > 0,
}
}
fn offset(self) -> Result<Option<u64>, SqlQueryError> {
match self {
Self::Start | Self::Cursor(_) | Self::Skip(0) => Ok(None),
Self::Skip(skip) => offset(skip).map(Some),
}
}
const fn cursor(self) -> Option<&'a Cursor<V>> {
match self {
Self::Cursor(cursor) => Some(cursor),
Self::Start | Self::Skip(_) => None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Forward;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Backward;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Positioned;
#[must_use = "a query builder renders nothing until it is fetched"]
pub struct Find<'a, Row, Db, A>
where
Row: SqlQuery<Db>,
Db: Backend + sqlx::Database,
{
executor: A,
filter: Option<&'a RowComparison<Row, Db>>,
scope: Option<&'a RowComparison<Row, Db>>,
snapshot: bool,
}
#[must_use = "a query builder renders nothing until it is fetched"]
pub struct Limited<'a, Row, Db, A>
where
Row: SqlQuery<Db>,
Db: Backend + sqlx::Database,
{
find: Find<'a, Row, Db, A>,
limit: u32,
}
#[must_use = "a query builder renders nothing until it is fetched"]
pub struct Ordered<'a, Row, Db, A>
where
Row: SqlOrdering<Db>,
Db: Backend + sqlx::Database,
{
find: Find<'a, Row, Db, A>,
order: Vec<Row::Order>,
subjects: Row::Subjects,
}
#[must_use = "a query builder renders nothing until it is fetched"]
pub struct Paging<'a, Row, Db, A, S>
where
Row: SqlOrdering<Db>,
Db: Backend + sqlx::Database,
{
ordered: Ordered<'a, Row, Db, A>,
size: u32,
walk: Walk,
position: Position<'a, Row::Value>,
state: PhantomData<fn() -> S>,
}
impl<'a, Row, Db, A> Find<'a, Row, Db, A>
where
Row: SqlQuery<Db>,
Db: Backend + sqlx::Database,
{
#[inline]
pub const fn new(executor: A, snapshot: bool) -> Self {
Self {
executor,
filter: None,
scope: None,
snapshot,
}
}
#[inline]
pub fn filter(mut self, filter: &'a RowComparison<Row, Db>) -> Self {
self.filter = Some(filter);
self
}
#[inline]
pub fn scope(mut self, scope: &'a RowComparison<Row, Db>) -> Self {
self.scope = Some(scope);
self
}
#[inline]
pub const fn limit(self, limit: u32) -> Limited<'a, Row, Db, A> {
Limited { find: self, limit }
}
}
impl<'a, Row, Db, A> Find<'a, Row, Db, A>
where
Row: SqlOrdering<Db>,
Db: Backend + sqlx::Database,
{
#[inline]
pub fn order(self, written: &[Row::Order]) -> Ordered<'a, Row, Db, A> {
let order = Row::complete(written);
Ordered {
find: self,
subjects: Row::subjects(&order),
order,
}
}
}
impl<'a, Row, Db, A> Ordered<'a, Row, Db, A>
where
Row: SqlOrdering<Db>,
Db: Backend + sqlx::Database,
{
#[inline]
pub fn first(self, first: u32) -> Paging<'a, Row, Db, A, Forward> {
self.page(first, Walk::Forward)
}
#[inline]
pub fn last(self, last: u32) -> Paging<'a, Row, Db, A, Backward> {
self.page(last, Walk::Backward)
}
#[inline]
pub fn after(self, cursor: &'a Cursor<Row::Value>) -> Paging<'a, Row, Db, A, Positioned> {
self.first(DEFAULT_PAGE_SIZE).after(cursor)
}
#[inline]
pub fn before(self, cursor: &'a Cursor<Row::Value>) -> Paging<'a, Row, Db, A, Positioned> {
self.last(DEFAULT_PAGE_SIZE).before(cursor)
}
#[inline]
pub fn skip(self, skip: u64) -> Paging<'a, Row, Db, A, Positioned> {
self.first(DEFAULT_PAGE_SIZE).skip(skip)
}
fn page<S>(self, size: u32, walk: Walk) -> Paging<'a, Row, Db, A, S> {
Paging {
ordered: self,
size: size.min(MAX_PAGE_SIZE),
walk,
position: Position::Start,
state: PhantomData,
}
}
}
impl<'a, Row, Db, A> Paging<'a, Row, Db, A, Forward>
where
Row: SqlOrdering<Db>,
Db: Backend + sqlx::Database,
{
#[inline]
pub fn after(self, cursor: &'a Cursor<Row::Value>) -> Paging<'a, Row, Db, A, Positioned> {
self.at(Position::Cursor(cursor))
}
#[inline]
pub fn skip(self, skip: u64) -> Paging<'a, Row, Db, A, Positioned> {
self.at(Position::Skip(skip))
}
}
impl<'a, Row, Db, A> Paging<'a, Row, Db, A, Backward>
where
Row: SqlOrdering<Db>,
Db: Backend + sqlx::Database,
{
#[inline]
pub fn before(self, cursor: &'a Cursor<Row::Value>) -> Paging<'a, Row, Db, A, Positioned> {
self.at(Position::Cursor(cursor))
}
#[inline]
pub fn skip(self, skip: u64) -> Paging<'a, Row, Db, A, Positioned> {
self.at(Position::Skip(skip))
}
}
impl<'a, Row, Db, A, S> Paging<'a, Row, Db, A, S>
where
Row: SqlOrdering<Db>,
Db: Backend + sqlx::Database,
{
#[inline]
#[must_use]
pub const fn size(&self) -> u32 {
self.size
}
#[inline]
const fn window(&self) -> u32 {
self.size.saturating_add(1)
}
fn at(self, position: Position<'a, Row::Value>) -> Paging<'a, Row, Db, A, Positioned> {
Paging {
ordered: self.ordered,
size: self.size,
walk: self.walk,
position,
state: PhantomData,
}
}
fn terms(&self) -> Vec<OrderTerm> {
self
.ordered
.order
.iter()
.flat_map(|term| Row::term(term.clone()).levels())
.collect()
}
}
fn open<Row, Db>(
sorts: impl FnOnce(QueryBuilder<SelectClause, Db>) -> QueryBuilder<SelectClause, Db>,
) -> Result<QueryBuilder<WhereClause, Db>, SqlQueryError>
where
Row: SqlQuery<Db>,
Db: SqlDialect,
{
let builder = fold_columns::<Db, _>(
Row::COLUMNS,
QueryBuilder::<SelectClause, Db>::select(),
&mut |builder, column| builder.push_field(column.as_str()),
);
Ok(
sorts(aggregates::<Row, Db>(builder)?)
.from(quote_ident::<Db>(Row::ADDRESS.table()).as_str())
.begin_where(),
)
}
const SORT_ALIAS: &str = "__ig_ord";
const ALIAS_END: &str = "__";
fn sort_alias(level: usize) -> Utf8BytesMut {
let mut alias = Utf8BytesMut::new();
alias.push_str(SORT_ALIAS);
push_index(level, &mut alias);
alias.push_str(ALIAS_END);
alias
}
fn sorts<'a, Db, S>(
order: SqlOrder<'a, Db>,
subjects: &'a S,
at: At<'a>,
) -> impl FnOnce(QueryBuilder<SelectClause, Db>) -> QueryBuilder<SelectClause, Db> + 'a
where
Db: SqlDialect,
S: OrderSubjects<Db> + ?Sized,
{
let terms = order.terms();
move |mut builder| {
for level in 0..terms.len() {
let shape = subjects.shape(terms, level);
match shape {
SubjectShape::Column => continue,
SubjectShape::Companion | SubjectShape::SubSelect => {}
}
let alias = sort_alias(level);
builder = builder.push_field_with(|qb| {
subjects.push_subject(SubjectSlot::new(qb, shape), at, terms, level);
qb.push(" AS ");
qb.push(quote_ident::<Db>(FieldName::new(alias.as_str())));
});
}
builder
}
}
fn predicates<Row, Db, K>(
builder: &mut QueryBuilder<WhereClause, Db>,
filter: Option<&RowComparison<Row, Db>>,
scope: Option<&RowComparison<Row, Db>>,
extra: Option<&K>,
) -> Result<(), SqlQueryError>
where
Row: SqlQuery<Db>,
Db: SqlDialect,
K: ComplexComparison<Db>,
{
let address = Row::ADDRESS;
let mut conjunction = SqlConjunction::new(builder.inner_mut());
if let Some(filter) = filter {
conjunction = filter.apply(At::new(&address), conjunction)?;
}
if let Some(scope) = scope {
conjunction = scope.apply(At::new(&address), conjunction)?;
}
if let Some(extra) = extra {
conjunction = extra.apply(At::new(&address), conjunction)?;
}
let _ = conjunction;
Ok(())
}
fn address<Row, Db>(
ids: &[<Row::Record as Identifiable>::Id],
) -> Result<sqlx::QueryBuilder<Db>, SqlQueryError>
where
Row: SqlQuery<Db>,
Db: SqlDialect,
{
composed::<Row, Db>(ids, None)
}
fn composed<Row, Db>(
ids: &[<Row::Record as Identifiable>::Id],
filter: Option<&RowComparison<Row, Db>>,
) -> Result<sqlx::QueryBuilder<Db>, SqlQueryError>
where
Row: SqlQuery<Db>,
Db: SqlDialect,
{
let predicate = Row::addresses(ids)?;
let mut builder = open::<Row, Db>(|builder| builder)?;
predicates::<Row, Db, Row::Address>(&mut builder, filter, None, Some(&predicate))?;
Ok(builder.finalize())
}
pub async fn gathered<Row, Db>(
conn: &mut Db::Connection,
ids: &[<Row::Record as Identifiable>::Id],
filter: Option<&<Row::Record as Record<Db>>::Comparison>,
) -> Result<Vec<Row>, SqlQueryError>
where
Row: SqlQuery<Db> + for<'r> sqlx::FromRow<'r, Db::Row>,
Db: SqlDialect,
for<'e> &'e mut Db::Connection: sqlx::Executor<'e, Database = Db>,
Db::Arguments: sqlx::IntoArguments<Db>,
{
let mut statement = composed::<Row, Db>(ids, filter)?;
Ok(decode::<Row, Db>(conn, &mut statement, usize::MAX).await?.0)
}
pub(super) fn scan<Row, Db>(
filter: Option<&RowComparison<Row, Db>>,
scope: Option<&RowComparison<Row, Db>>,
limit: Option<u32>,
) -> Result<sqlx::QueryBuilder<Db>, SqlQueryError>
where
Row: SqlQuery<Db>,
Db: SqlDialect,
i64: sqlx::Type<Db>,
for<'t> i64: sqlx::Encode<'t, Db>,
{
let mut builder = open::<Row, Db>(|builder| builder)?;
predicates::<Row, Db, RowComparison<Row, Db>>(&mut builder, filter, scope, None)?;
Ok(match limit {
Some(limit) => builder.limit(u64::from(limit)).finalize(),
None => builder.finalize(),
})
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum SortValues {
Projected,
Unread,
}
struct Ordering<'a, Row, Db>
where
Row: SqlOrdering<Db>,
Db: Backend + sqlx::Database,
{
order: SqlOrder<'a, Db>,
subjects: &'a Row::Subjects,
keyset: Option<&'a SqlKeyset<'a, Row::Value, Db, &'a Row::Subjects>>,
values: SortValues,
}
fn ordered<Row, Db>(
filter: Option<&RowComparison<Row, Db>>,
scope: Option<&RowComparison<Row, Db>>,
ordering: Ordering<'_, Row, Db>,
walk: Walk,
limit: Option<u32>,
skip: Option<u64>,
) -> Result<sqlx::QueryBuilder<Db>, SqlQueryError>
where
Row: SqlOrdering<Db>,
Db: SqlDialect,
i64: sqlx::Type<Db>,
for<'t> i64: sqlx::Encode<'t, Db>,
{
let address = Row::ADDRESS;
let at = At::new(&address);
let mut builder = match ordering.values {
SortValues::Projected => open::<Row, Db>(sorts(ordering.order, ordering.subjects, at))?,
SortValues::Unread => open::<Row, Db>(|builder| builder)?,
};
predicates::<Row, Db, SqlKeyset<'_, Row::Value, Db, &Row::Subjects>>(
&mut builder,
filter,
scope,
ordering.keyset,
)?;
let builder = ordering
.order
.push_order_by_with(builder, walk, at, ordering.subjects);
Ok(match (limit, skip) {
(Some(limit), Some(skip)) => builder.limit(u64::from(limit)).offset(skip).finalize(),
(Some(limit), None) => builder.limit(u64::from(limit)).finalize(),
(None, _) => builder.finalize(),
})
}
async fn begin<Db>(conn: &mut Db::Connection, snapshot: bool) -> Result<(), sqlx::Error>
where
Db: SqlDialect,
for<'e> &'e mut Db::Connection: sqlx::Executor<'e, Database = Db>,
Db::Arguments: sqlx::IntoArguments<Db>,
{
if snapshot {
sqlx::Executor::execute(&mut *conn, Db::BEGIN).await?;
}
Ok(())
}
async fn end<Db>(conn: &mut Db::Connection, snapshot: bool, ok: bool) -> Result<(), sqlx::Error>
where
Db: SqlDialect,
for<'e> &'e mut Db::Connection: sqlx::Executor<'e, Database = Db>,
Db::Arguments: sqlx::IntoArguments<Db>,
{
if !snapshot {
return Ok(());
}
if ok {
sqlx::Executor::execute(&mut *conn, Db::COMMIT).await?;
return Ok(());
}
drop(sqlx::Executor::execute(&mut *conn, Db::ROLLBACK).await);
Ok(())
}
async fn run<'c, Row, Db, A>(
executor: A,
snapshot: bool,
mut statement: sqlx::QueryBuilder<Db>,
) -> Result<Vec<Row::Record>, SqlQueryError>
where
Row: SqlQuery<Db> + for<'r> sqlx::FromRow<'r, Db::Row>,
Db: SqlDialect,
for<'e> &'e mut Db::Connection: sqlx::Executor<'e, Database = Db>,
Db::Arguments: sqlx::IntoArguments<Db>,
A: sqlx::Acquire<'c, Database = Db>,
{
let mut held = executor.acquire().await?;
let conn = &mut *held;
begin::<Db>(conn, snapshot).await?;
let records = raise::<Row, Db>(conn, &mut statement).await;
end::<Db>(conn, snapshot, records.is_ok()).await?;
records
}
async fn raise<Row, Db>(
conn: &mut Db::Connection,
statement: &mut sqlx::QueryBuilder<Db>,
) -> Result<Vec<Row::Record>, SqlQueryError>
where
Row: SqlQuery<Db> + for<'r> sqlx::FromRow<'r, Db::Row>,
Db: SqlDialect,
for<'e> &'e mut Db::Connection: sqlx::Executor<'e, Database = Db>,
Db::Arguments: sqlx::IntoArguments<Db>,
{
let mut rows = decode::<Row, Db>(conn, statement, usize::MAX).await?.0;
let mut records = Vec::with_capacity(rows.len());
for row in rows.drain(..) {
records.push(row.record()?);
}
Ok(records)
}
async fn decode<Row, Db>(
conn: &mut Db::Connection,
statement: &mut sqlx::QueryBuilder<Db>,
ceiling: usize,
) -> Result<(Vec<Row>, Vec<Db::Row>, bool), SqlQueryError>
where
Row: SqlQuery<Db> + for<'r> sqlx::FromRow<'r, Db::Row>,
Db: SqlDialect,
for<'e> &'e mut Db::Connection: sqlx::Executor<'e, Database = Db>,
Db::Arguments: sqlx::IntoArguments<Db>,
{
let mut raw = sqlx::Executor::fetch_all(&mut *conn, statement.build()).await?;
let more = raw.len() > ceiling;
raw.truncate(ceiling);
let mut rows = Vec::with_capacity(raw.len());
for row in &raw {
let mut decoded = Row::from_row(row)?;
absorb::<Row, Db>(&mut decoded, row)?;
rows.push(decoded);
}
hydrate::<Row, Db>(conn, &mut rows).await?;
Ok((rows, raw, more))
}
async fn edges<Row, Db, T>(
conn: &mut Db::Connection,
statement: &mut sqlx::QueryBuilder<Db>,
order: &[Row::Order],
terms: &[OrderTerm],
size: usize,
mut mint: impl FnMut(Row) -> Result<T, SqlQueryError>,
) -> Result<(Vec<Edge<T, Row::Value>>, bool), SqlQueryError>
where
Row: SqlOrdering<Db> + for<'r> sqlx::FromRow<'r, Db::Row>,
Db: SqlDialect,
for<'e> &'e mut Db::Connection: sqlx::Executor<'e, Database = Db>,
Db::Arguments: sqlx::IntoArguments<Db>,
{
let (mut rows, raw, more) = decode::<Row, Db>(conn, statement, size).await?;
let mut levels: Vec<(&Row::Order, usize)> = Vec::with_capacity(terms.len());
for term in order {
for level in Row::term(term.clone()).levels() {
levels.push((term, level.leaf().unwrap_or(0)));
}
}
debug_assert_eq!(
levels.len(),
terms.len(),
"a page's cursor holds one slot per rendered term"
);
let mut edges = Vec::with_capacity(rows.len());
for (row, from) in rows.drain(..).zip(&raw) {
let mut values: Vec<Option<Row::Value>> = Vec::with_capacity(levels.len());
for (at, (term, leaf)) in levels.iter().enumerate() {
values.push(row.value((*term).clone(), *leaf, from, sort_alias(at).as_str())?);
}
let cursor = Cursor::at(terms, values);
edges.push(Edge::new(mint(row)?, cursor));
}
Ok((edges, more))
}
impl<'a, Row, Db, A> Find<'a, Row, Db, A>
where
Row: SqlQuery<Db> + for<'r> sqlx::FromRow<'r, Db::Row>,
Db: SqlDialect,
i64: sqlx::Type<Db>,
for<'t> i64: sqlx::Encode<'t, Db>,
for<'e> &'e mut Db::Connection: sqlx::Executor<'e, Database = Db>,
Db::Arguments: sqlx::IntoArguments<Db>,
{
pub async fn fetch<'c>(self) -> Result<Vec<Row::Record>, SqlQueryError>
where
A: sqlx::Acquire<'c, Database = Db>,
{
let statement = scan::<Row, Db>(self.filter, self.scope, None)?;
run::<Row, Db, A>(self.executor, self.snapshot, statement).await
}
}
impl<'a, Row, Db, A> Limited<'a, Row, Db, A>
where
Row: SqlQuery<Db> + for<'r> sqlx::FromRow<'r, Db::Row>,
Db: SqlDialect,
i64: sqlx::Type<Db>,
for<'t> i64: sqlx::Encode<'t, Db>,
for<'e> &'e mut Db::Connection: sqlx::Executor<'e, Database = Db>,
Db::Arguments: sqlx::IntoArguments<Db>,
{
pub async fn fetch<'c>(self) -> Result<Vec<Row::Record>, SqlQueryError>
where
A: sqlx::Acquire<'c, Database = Db>,
{
let statement = scan::<Row, Db>(self.find.filter, self.find.scope, Some(self.limit))?;
run::<Row, Db, A>(self.find.executor, self.find.snapshot, statement).await
}
}
impl<'a, Row, Db, A> Ordered<'a, Row, Db, A>
where
Row: SqlOrdering<Db> + for<'r> sqlx::FromRow<'r, Db::Row>,
Db: SqlDialect,
i64: sqlx::Type<Db>,
for<'t> i64: sqlx::Encode<'t, Db>,
for<'e> &'e mut Db::Connection: sqlx::Executor<'e, Database = Db>,
Db::Arguments: sqlx::IntoArguments<Db>,
{
pub async fn fetch<'c>(self) -> Result<Vec<Row::Record>, SqlQueryError>
where
A: sqlx::Acquire<'c, Database = Db>,
{
let terms: Vec<OrderTerm> = self
.order
.iter()
.flat_map(|term| Row::term(term.clone()).levels())
.collect();
let order = SqlOrder::<Db>::new(&terms)?;
let statement = ordered::<Row, Db>(
self.find.filter,
self.find.scope,
Ordering {
order,
subjects: &self.subjects,
keyset: None,
values: SortValues::Unread,
},
Walk::Forward,
None,
None,
)?;
run::<Row, Db, A>(self.find.executor, self.find.snapshot, statement).await
}
}
impl<'a, Row, Db, A, S> Paging<'a, Row, Db, A, S>
where
Row: SqlOrdering<Db> + for<'r> sqlx::FromRow<'r, Db::Row>,
Db: SqlDialect,
i64: sqlx::Type<Db>,
for<'t> i64: sqlx::Encode<'t, Db>,
for<'e> &'e mut Db::Connection: sqlx::Executor<'e, Database = Db>,
Db::Arguments: sqlx::IntoArguments<Db>,
{
pub async fn fetch<'c>(self) -> Result<Page<Row::Record, Row::Value>, SqlQueryError>
where
A: sqlx::Acquire<'c, Database = Db>,
{
self.page(|row| Ok(row.record()?)).await
}
pub async fn rows<'c>(self) -> Result<Page<Row, Row::Value>, SqlQueryError>
where
A: sqlx::Acquire<'c, Database = Db>,
{
self.page(Ok).await
}
async fn page<'c, T>(
self,
mint: impl FnMut(Row) -> Result<T, SqlQueryError>,
) -> Result<Page<T, Row::Value>, SqlQueryError>
where
A: sqlx::Acquire<'c, Database = Db>,
{
let terms = self.terms();
let terms = partition::<Db>(&terms).paging::<Db>()?;
let order = SqlOrder::<Db>::new(terms)?;
let subjects = &self.ordered.subjects;
let keyset = self
.position
.cursor()
.map(|cursor| SqlKeyset::resume_with(order, cursor, self.walk, subjects))
.transpose()?;
let mut statement = ordered::<Row, Db>(
self.ordered.find.filter,
self.ordered.find.scope,
Ordering {
order,
subjects,
keyset: keyset.as_ref(),
values: SortValues::Projected,
},
self.walk,
Some(self.window()),
self.position.offset()?,
)?;
let mut held = self.ordered.find.executor.acquire().await?;
let conn = &mut *held;
let snapshot = self.ordered.find.snapshot;
begin::<Db>(conn, snapshot).await?;
let fetched = edges::<Row, Db, T>(
conn,
&mut statement,
&self.ordered.order,
terms,
self.size as usize,
mint,
)
.await;
end::<Db>(conn, snapshot, fetched.is_ok()).await?;
let (mut edges, more) = fetched?;
let resumed = self.position.is_set();
if matches!(self.walk, Walk::Backward) {
edges.reverse();
}
Ok(match self.walk {
Walk::Forward => Page::new(edges, more, resumed),
Walk::Backward => Page::new(edges, resumed, more),
})
}
}
pub async fn get<'c, Row, Db, A>(
executor: A,
id: &<Row::Record as Identifiable>::Id,
snapshot: bool,
) -> Result<Option<Row::Record>, SqlQueryError>
where
Row: SqlQuery<Db> + for<'r> sqlx::FromRow<'r, Db::Row>,
Db: SqlDialect,
for<'e> &'e mut Db::Connection: sqlx::Executor<'e, Database = Db>,
Db::Arguments: sqlx::IntoArguments<Db>,
A: sqlx::Acquire<'c, Database = Db>,
{
let statement = address::<Row, Db>(core::slice::from_ref(id))?;
let records = run::<Row, Db, A>(executor, snapshot, statement).await?;
Ok(records.into_iter().next())
}
pub async fn rows<'c, Row, Db, A>(
executor: A,
ids: &[<Row::Record as Identifiable>::Id],
) -> Result<Vec<Row>, SqlQueryError>
where
Row: SqlQuery<Db> + for<'r> sqlx::FromRow<'r, Db::Row>,
Db: SqlDialect,
for<'e> &'e mut Db::Connection: sqlx::Executor<'e, Database = Db>,
Db::Arguments: sqlx::IntoArguments<Db>,
A: sqlx::Acquire<'c, Database = Db> + BeginRead,
{
let mut statement = address::<Row, Db>(ids)?;
let mut held = executor.acquire().await?;
let conn = &mut *held;
let opened = open_read::<Db, A>(conn).await?;
let decoded = decode::<Row, Db>(conn, &mut statement, usize::MAX).await;
close_read::<Db>(conn, opened, decoded.is_ok()).await?;
Ok(decoded?.0)
}
#[cfg(test)]
mod shadow_tests;
#[cfg(test)]
mod tests;