use super::CrossingError;
use crate::{CursorError, comparison::sql::SqlLoweringError, query::PagingOrderError};
const SKIP_CEILING: u64 = i64::MAX as u64;
#[derive(Debug)]
pub enum SqlQueryError {
Sql(sqlx::Error),
Lowering(SqlLoweringError),
Order(crate::comparison::sql::SqlOrderError),
PageOrder(PagingOrderError),
Cursor(CursorError),
Skip(u64),
Crossing(CrossingError),
}
impl From<sqlx::Error> for SqlQueryError {
#[inline]
fn from(error: sqlx::Error) -> Self {
Self::Sql(error)
}
}
impl From<SqlLoweringError> for SqlQueryError {
#[inline]
fn from(error: SqlLoweringError) -> Self {
Self::Lowering(error)
}
}
impl From<crate::comparison::sql::SqlOrderError> for SqlQueryError {
#[inline]
fn from(error: crate::comparison::sql::SqlOrderError) -> Self {
Self::Order(error)
}
}
impl From<PagingOrderError> for SqlQueryError {
#[inline]
fn from(error: PagingOrderError) -> Self {
Self::PageOrder(error)
}
}
impl From<CursorError> for SqlQueryError {
#[inline]
fn from(error: CursorError) -> Self {
Self::Cursor(error)
}
}
impl From<CrossingError> for SqlQueryError {
#[inline]
fn from(error: CrossingError) -> Self {
Self::Crossing(error)
}
}
impl core::fmt::Display for SqlQueryError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Self::Sql(error) => write!(f, "this query did not run: {error}"),
Self::Lowering(error) => write!(f, "this query's predicate does not lower here: {error}"),
Self::Order(error) => write!(f, "this query's order cannot be rendered here: {error}"),
Self::PageOrder(error) => write!(f, "this query's order cannot be paged: {error}"),
Self::Cursor(error) => write!(f, "this query cannot resume there: {error}"),
Self::Skip(skip) => write!(
f,
"a skip of {skip} is past the {SKIP_CEILING} this dialect's OFFSET holds"
),
Self::Crossing(error) => write!(f, "this row and its record do not cross: {error}"),
}
}
}
impl core::error::Error for SqlQueryError {
fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
match self {
Self::Sql(error) => Some(error),
Self::Lowering(error) => Some(error),
Self::Order(error) => Some(error),
Self::PageOrder(error) => Some(error),
Self::Cursor(error) => Some(error),
Self::Skip(_) => None,
Self::Crossing(error) => Some(&**error),
}
}
}
impl crate::ToErrorCode for SqlQueryError {
fn error_code(&self) -> crate::ErrorCode {
match self {
Self::Sql(_) => crate::ErrorCode::StoreRefused,
Self::Lowering(_) => crate::ErrorCode::UnsupportedFilter,
Self::Order(_) => crate::ErrorCode::UnrenderableOrder,
Self::PageOrder(_) => crate::ErrorCode::UnpageableOrder,
Self::Cursor(_) => crate::ErrorCode::UnusableCursor,
Self::Crossing(_) => crate::ErrorCode::UnreadableRow,
Self::Skip(_) => crate::ErrorCode::OversizedSkip,
}
}
}
#[derive(Debug)]
pub enum SqlWriteError {
Sql(sqlx::Error),
Lowering(SqlLoweringError),
Crossing(CrossingError),
Unscoped(&'static crate::FieldName),
}
impl From<sqlx::Error> for SqlWriteError {
#[inline]
fn from(error: sqlx::Error) -> Self {
Self::Sql(error)
}
}
impl From<SqlLoweringError> for SqlWriteError {
#[inline]
fn from(error: SqlLoweringError) -> Self {
Self::Lowering(error)
}
}
impl From<CrossingError> for SqlWriteError {
#[inline]
fn from(error: CrossingError) -> Self {
Self::Crossing(error)
}
}
impl core::fmt::Display for SqlWriteError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Self::Sql(error) => write!(f, "this write did not run: {error}"),
Self::Lowering(error) => write!(f, "this write's statement does not render here: {error}"),
Self::Crossing(error) => write!(f, "this record and its row do not cross: {error}"),
Self::Unscoped(table) => write!(
f,
"this delete names no row, so it would empty `{}` — a filter that lowers to no predicate is \
refused rather than run",
table.as_str()
),
}
}
}
impl core::error::Error for SqlWriteError {
fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
match self {
Self::Sql(error) => Some(error),
Self::Lowering(error) => Some(error),
Self::Crossing(error) => Some(&**error),
Self::Unscoped(_) => None,
}
}
}
pub(super) fn offset(skip: u64) -> Result<u64, SqlQueryError> {
if skip > SKIP_CEILING {
return Err(SqlQueryError::Skip(skip));
}
Ok(skip)
}
#[cfg(test)]
mod tests;