use std::collections::VecDeque;
pub mod paging;
use super::{Capabilities, DbError, ErrorKind, QueryOptions, Row, RowLimit, TxOptions, Value};
pub trait Reader: Send {
fn next_row(&mut self) -> Result<Option<Row>, DbError>;
fn has_next_set(&mut self) -> Result<bool, DbError>;
fn finish(&mut self) -> Result<(), DbError>;
fn read_all(&mut self) -> Result<Vec<Row>, DbError> {
Ok(self.read_sets()?.into_iter().flatten().collect())
}
fn read_sets(&mut self) -> Result<Vec<Vec<Row>>, DbError> {
let mut sets = Vec::new();
loop {
let mut set = Vec::new();
while let Some(row) = self.next_row()? {
set.push(row);
}
sets.push(set);
if !self.has_next_set()? {
break;
}
}
self.finish()?;
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(&mut self) -> Result<Option<Row>, DbError> {
if self.done {
return Ok(None);
}
Ok(self.sets.front_mut().and_then(VecDeque::pop_front))
}
fn has_next_set(&mut self) -> Result<bool, DbError> {
if self.done {
return Ok(false);
}
self.sets.pop_front();
let more = !self.sets.is_empty();
if !more {
self.done = true;
}
Ok(more)
}
fn finish(&mut self) -> Result<(), DbError> {
self.sets.clear();
self.done = true;
Ok(())
}
}
pub trait Pool: Send + Sync {
fn capabilities(&self) -> Capabilities;
fn defaults(&self) -> super::PoolDefaults {
super::PoolDefaults::default()
}
fn acquire(&self) -> Result<Box<dyn Session>, DbError>;
fn execute(&self, sql: &str, mut options: QueryOptions) -> Result<u64, DbError> {
options.validate_execute()?;
super::reject_unhandled_pool_options(&options)?;
super::resolve_provider_timeout(&mut options, self.defaults().timeout)?;
let mut session = self.acquire()?;
session.execute(sql, options)
}
fn fetch(&self, sql: &str, mut options: QueryOptions) -> Result<Box<dyn Reader + '_>, DbError> {
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()?;
let mut reader = session.fetch(sql, options)?;
let sets = collect_sets(reader.as_mut(), limit)?;
Ok(Box::new(BufferedReader::from_sets(sets)))
}
fn fetch_all(&self, sql: &str, options: QueryOptions) -> Result<Vec<Row>, DbError> {
let limit = options.resolved_limit(self.defaults());
let mut reader = self.fetch(sql, options)?;
let sets = collect_sets(reader.as_mut(), limit)?;
Ok(sets.into_iter().flatten().collect())
}
fn fetch_first(&self, sql: &str, options: QueryOptions) -> Result<Option<Row>, DbError> {
let mut reader = self.fetch(sql, options)?;
let first = reader.next_row()?;
reader.finish()?;
Ok(first)
}
fn fetch_one(&self, sql: &str, options: QueryOptions) -> Result<Row, DbError> {
let mut reader = self.fetch(sql, options)?;
let first = reader.next_row()?;
let more = reader.next_row()?.is_some();
reader.finish()?;
match first {
None => Err(row_cardinality_error(false)),
Some(_) if more => Err(row_cardinality_error(true)),
Some(row) => Ok(row),
}
}
fn fetch_scalar(&self, sql: &str, options: QueryOptions) -> Result<Value, DbError> {
let row = self.fetch_one(sql, options)?;
row.value_at(0)
}
}
pub trait Session: Send {
fn defaults(&self) -> super::PoolDefaults {
super::PoolDefaults::default()
}
fn execute(&mut self, sql: &str, options: QueryOptions) -> Result<u64, DbError>;
fn fetch(&mut self, sql: &str, options: QueryOptions) -> Result<Box<dyn Reader + '_>, DbError>;
fn fetch_all(&mut self, sql: &str, options: QueryOptions) -> Result<Vec<Row>, DbError> {
let limit = options.resolved_limit(self.defaults());
let mut reader = self.fetch(sql, options)?;
let sets = collect_sets(reader.as_mut(), limit)?;
Ok(sets.into_iter().flatten().collect())
}
fn fetch_first(&mut self, sql: &str, options: QueryOptions) -> Result<Option<Row>, DbError> {
let mut reader = self.fetch(sql, options)?;
let first = reader.next_row()?;
reader.finish()?;
Ok(first)
}
fn fetch_one(&mut self, sql: &str, options: QueryOptions) -> Result<Row, DbError> {
let mut reader = self.fetch(sql, options)?;
let first = reader.next_row()?;
let more = reader.next_row()?.is_some();
reader.finish()?;
match first {
None => Err(row_cardinality_error(false)),
Some(_) if more => Err(row_cardinality_error(true)),
Some(row) => Ok(row),
}
}
fn fetch_scalar(&mut self, sql: &str, options: QueryOptions) -> Result<Value, DbError> {
let row = self.fetch_one(sql, options)?;
row.value_at(0)
}
fn execute_trusted_script(&mut self, sql: &str, options: QueryOptions) -> Result<(), DbError>;
fn begin(&mut self, options: TxOptions) -> Result<Box<dyn Transaction<'_> + '_>, DbError>;
}
pub trait Transaction<'session>: Send {
fn defaults(&self) -> super::PoolDefaults {
super::PoolDefaults::default()
}
fn execute(&mut self, sql: &str, options: QueryOptions) -> Result<u64, DbError>;
fn fetch(&mut self, sql: &str, options: QueryOptions) -> Result<Box<dyn Reader + '_>, DbError>;
fn fetch_all(&mut self, sql: &str, options: QueryOptions) -> Result<Vec<Row>, DbError> {
let limit = options.resolved_limit(self.defaults());
let mut reader = self.fetch(sql, options)?;
let sets = collect_sets(reader.as_mut(), limit)?;
Ok(sets.into_iter().flatten().collect())
}
fn fetch_first(&mut self, sql: &str, options: QueryOptions) -> Result<Option<Row>, DbError> {
let mut reader = self.fetch(sql, options)?;
let first = reader.next_row()?;
reader.finish()?;
Ok(first)
}
fn fetch_one(&mut self, sql: &str, options: QueryOptions) -> Result<Row, DbError> {
let mut reader = self.fetch(sql, options)?;
let first = reader.next_row()?;
let more = reader.next_row()?.is_some();
reader.finish()?;
match first {
None => Err(row_cardinality_error(false)),
Some(_) if more => Err(row_cardinality_error(true)),
Some(row) => Ok(row),
}
}
fn fetch_scalar(&mut self, sql: &str, options: QueryOptions) -> Result<Value, DbError> {
let row = self.fetch_one(sql, options)?;
row.value_at(0)
}
fn execute_trusted_script(&mut self, sql: &str, options: QueryOptions) -> Result<(), DbError>;
fn commit(self: Box<Self>) -> Result<(), DbError>;
fn rollback(self: Box<Self>) -> Result<(), DbError>;
}
fn row_cardinality_error(more_than_one: bool) -> DbError {
DbError::new(if more_than_one {
ErrorKind::TooManyRows
} else {
ErrorKind::NoRows
})
}
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()? {
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()? {
break;
}
if sets.len() == limit.max_sets() {
return Err(DbError::new(ErrorKind::Overflow));
}
}
reader.finish()?;
Ok(sets)
}