use std::{collections::VecDeque, future::Future, pin::Pin};
pub mod paging;
use super::{
Capabilities, DbError, ErrorKind, PoolDefaults, QueryOptions, Row, RowLimit, TxOptions, Value,
};
pub type DbFuture<'a, T> = Pin<Box<dyn Future<Output = Result<T, DbError>> + 'a>>;
pub trait Reader {
fn next_row_async(&mut self) -> DbFuture<'_, Option<Row>>;
fn has_next_set_async(&mut self) -> DbFuture<'_, bool>;
fn finish_async(&mut self) -> DbFuture<'_, ()>;
fn read_all_async(&mut self) -> DbFuture<'_, Vec<Row>> {
Box::pin(async move {
Ok(self
.read_sets_async()
.await?
.into_iter()
.flatten()
.collect())
})
}
fn read_sets_async(&mut self) -> DbFuture<'_, Vec<Vec<Row>>> {
Box::pin(async move {
let mut sets = Vec::new();
loop {
let mut set = Vec::new();
while let Some(row) = self.next_row_async().await? {
set.push(row);
}
sets.push(set);
if !self.has_next_set_async().await? {
break;
}
}
self.finish_async().await?;
Ok(sets)
})
}
}
#[derive(Debug)]
pub struct BufferedReader {
sets: VecDeque<VecDeque<Row>>,
done: bool,
}
impl BufferedReader {
#[must_use]
pub fn new(rows: Vec<Row>) -> Self {
Self::from_sets(vec![rows])
}
#[must_use]
pub fn from_sets(sets: Vec<Vec<Row>>) -> Self {
Self {
sets: sets.into_iter().map(VecDeque::from).collect(),
done: false,
}
}
}
impl Reader for BufferedReader {
fn next_row_async(&mut self) -> DbFuture<'_, Option<Row>> {
let row = if self.done {
None
} else {
self.sets.front_mut().and_then(VecDeque::pop_front)
};
Box::pin(async move { Ok(row) })
}
fn has_next_set_async(&mut self) -> DbFuture<'_, bool> {
if self.done {
return Box::pin(async { Ok(false) });
}
self.sets.pop_front();
let more = !self.sets.is_empty();
if !more {
self.done = true;
}
Box::pin(async move { Ok(more) })
}
fn finish_async(&mut self) -> DbFuture<'_, ()> {
self.sets.clear();
self.done = true;
Box::pin(async { Ok(()) })
}
}
pub trait Pool {
fn capabilities(&self) -> Capabilities;
fn defaults(&self) -> PoolDefaults {
PoolDefaults::default()
}
fn acquire_async(&self) -> DbFuture<'_, Box<dyn Session>>;
fn execute_async<'a>(&'a self, sql: &'a str, mut options: QueryOptions) -> DbFuture<'a, u64> {
Box::pin(async move {
options.validate_execute()?;
super::reject_unhandled_pool_options(&options)?;
super::resolve_provider_timeout(&mut options, self.defaults().timeout)?;
let mut session = self.acquire_async().await?;
session.execute_async(sql, options).await
})
}
fn fetch_async<'a>(
&'a self,
sql: &'a str,
mut options: QueryOptions,
) -> DbFuture<'a, Box<dyn Reader + 'a>> {
Box::pin(async move {
super::reject_unhandled_pool_options(&options)?;
let limit = options.resolved_limit(self.defaults());
options.limit = super::LimitSetting::Set(limit);
super::resolve_provider_timeout(&mut options, self.defaults().timeout)?;
let mut session = self.acquire_async().await?;
let mut reader = session.fetch_async(sql, options).await?;
let sets = collect_sets(reader.as_mut(), limit).await?;
Ok(Box::new(BufferedReader::from_sets(sets)) as Box<dyn Reader + 'a>)
})
}
fn fetch_all_async<'a>(
&'a self,
sql: &'a str,
options: QueryOptions,
) -> DbFuture<'a, Vec<Row>> {
Box::pin(async move {
let limit = options.resolved_limit(self.defaults());
let mut reader = self.fetch_async(sql, options).await?;
let sets = collect_sets(reader.as_mut(), limit).await?;
Ok(sets.into_iter().flatten().collect())
})
}
fn fetch_first_async<'a>(
&'a self,
sql: &'a str,
options: QueryOptions,
) -> DbFuture<'a, Option<Row>> {
Box::pin(async move {
let mut reader = self.fetch_async(sql, options).await?;
let first = reader.next_row_async().await?;
reader.finish_async().await?;
Ok(first)
})
}
fn fetch_one_async<'a>(&'a self, sql: &'a str, options: QueryOptions) -> DbFuture<'a, Row> {
Box::pin(async move {
let mut reader = self.fetch_async(sql, options).await?;
let first = reader.next_row_async().await?;
let more = reader.next_row_async().await?.is_some();
reader.finish_async().await?;
match first {
None => Err(super::row_cardinality_error(false)),
Some(_) if more => Err(super::row_cardinality_error(true)),
Some(row) => Ok(row),
}
})
}
fn fetch_scalar_async<'a>(
&'a self,
sql: &'a str,
options: QueryOptions,
) -> DbFuture<'a, Value> {
Box::pin(async move {
let row = self.fetch_one_async(sql, options).await?;
row.value_at(0)
})
}
}
pub trait Session {
fn defaults(&self) -> PoolDefaults {
PoolDefaults::default()
}
fn execute_async<'a>(&'a mut self, sql: &'a str, options: QueryOptions) -> DbFuture<'a, u64>;
fn fetch_async<'a>(
&'a mut self,
sql: &'a str,
options: QueryOptions,
) -> DbFuture<'a, Box<dyn Reader + 'a>>;
fn fetch_all_async<'a>(
&'a mut self,
sql: &'a str,
options: QueryOptions,
) -> DbFuture<'a, Vec<Row>> {
let limit = options.resolved_limit(self.defaults());
Box::pin(async move {
let mut reader = self.fetch_async(sql, options).await?;
let sets = collect_sets(reader.as_mut(), limit).await?;
Ok(sets.into_iter().flatten().collect())
})
}
fn fetch_first_async<'a>(
&'a mut self,
sql: &'a str,
options: QueryOptions,
) -> DbFuture<'a, Option<Row>> {
Box::pin(async move {
let mut reader = self.fetch_async(sql, options).await?;
let first = reader.next_row_async().await?;
reader.finish_async().await?;
Ok(first)
})
}
fn fetch_one_async<'a>(&'a mut self, sql: &'a str, options: QueryOptions) -> DbFuture<'a, Row> {
Box::pin(async move {
let mut reader = self.fetch_async(sql, options).await?;
let first = reader.next_row_async().await?;
let more = reader.next_row_async().await?.is_some();
reader.finish_async().await?;
match first {
None => Err(super::row_cardinality_error(false)),
Some(_) if more => Err(super::row_cardinality_error(true)),
Some(row) => Ok(row),
}
})
}
fn fetch_scalar_async<'a>(
&'a mut self,
sql: &'a str,
options: QueryOptions,
) -> DbFuture<'a, Value> {
Box::pin(async move {
let row = self.fetch_one_async(sql, options).await?;
row.value_at(0)
})
}
fn execute_trusted_script_async<'a>(
&'a mut self,
sql: &'a str,
options: QueryOptions,
) -> DbFuture<'a, ()>;
fn begin_async<'a>(
&'a mut self,
options: TxOptions,
) -> DbFuture<'a, Box<dyn Transaction<'a> + 'a>>;
}
pub trait Transaction<'session> {
fn defaults(&self) -> PoolDefaults {
PoolDefaults::default()
}
fn execute_async<'a>(&'a mut self, sql: &'a str, options: QueryOptions) -> DbFuture<'a, u64>;
fn fetch_async<'a>(
&'a mut self,
sql: &'a str,
options: QueryOptions,
) -> DbFuture<'a, Box<dyn Reader + 'a>>;
fn fetch_all_async<'a>(
&'a mut self,
sql: &'a str,
options: QueryOptions,
) -> DbFuture<'a, Vec<Row>> {
let limit = options.resolved_limit(self.defaults());
Box::pin(async move {
let mut reader = self.fetch_async(sql, options).await?;
let sets = collect_sets(reader.as_mut(), limit).await?;
Ok(sets.into_iter().flatten().collect())
})
}
fn fetch_first_async<'a>(
&'a mut self,
sql: &'a str,
options: QueryOptions,
) -> DbFuture<'a, Option<Row>> {
Box::pin(async move {
let mut reader = self.fetch_async(sql, options).await?;
let first = reader.next_row_async().await?;
reader.finish_async().await?;
Ok(first)
})
}
fn fetch_one_async<'a>(&'a mut self, sql: &'a str, options: QueryOptions) -> DbFuture<'a, Row> {
Box::pin(async move {
let mut reader = self.fetch_async(sql, options).await?;
let first = reader.next_row_async().await?;
let more = reader.next_row_async().await?.is_some();
reader.finish_async().await?;
match first {
None => Err(super::row_cardinality_error(false)),
Some(_) if more => Err(super::row_cardinality_error(true)),
Some(row) => Ok(row),
}
})
}
fn fetch_scalar_async<'a>(
&'a mut self,
sql: &'a str,
options: QueryOptions,
) -> DbFuture<'a, Value> {
Box::pin(async move {
let row = self.fetch_one_async(sql, options).await?;
row.value_at(0)
})
}
fn execute_trusted_script_async<'a>(
&'a mut self,
sql: &'a str,
options: QueryOptions,
) -> DbFuture<'a, ()>;
fn commit_async(self: Box<Self>) -> DbFuture<'session, ()>;
fn rollback_async(self: Box<Self>) -> DbFuture<'session, ()>;
}
async fn collect_sets(reader: &mut dyn Reader, limit: RowLimit) -> Result<Vec<Vec<Row>>, DbError> {
let mut sets = Vec::new();
let mut rows = 0usize;
let mut bytes = 0usize;
loop {
let mut set = Vec::new();
while let Some(row) = reader.next_row_async().await? {
if rows == limit.rows() {
return Err(DbError::new(ErrorKind::Overflow));
}
let size = row.encoded_bytes()?;
bytes = bytes
.checked_add(size)
.ok_or_else(|| DbError::new(ErrorKind::Overflow))?;
if bytes > limit.bytes() {
return Err(DbError::new(ErrorKind::Overflow));
}
rows = rows
.checked_add(1)
.ok_or_else(|| DbError::new(ErrorKind::Overflow))?;
set.push(row);
}
sets.push(set);
if !reader.has_next_set_async().await? {
break;
}
if sets.len() == limit.max_sets() {
return Err(DbError::new(ErrorKind::Overflow));
}
}
reader.finish_async().await?;
Ok(sets)
}