use crate::{AnyQuery, AsValue, Driver, Prepared, Result, RowOwned, RowsAffected, truncate_long};
use anyhow::anyhow;
use std::{
borrow::Cow,
fmt::{self, Display},
};
#[derive(Default, Clone, Debug)]
pub struct RawQuery(pub String);
impl Display for RawQuery {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", truncate_long(&self.0))
}
}
#[derive(Debug)]
pub enum Query<D: Driver> {
Raw(RawQuery),
Prepared(D::Prepared),
}
impl<D: Driver> Query<D> {
pub const fn raw(value: String) -> Self {
Query::Raw(RawQuery(value))
}
pub const fn prepared(value: D::Prepared) -> Self {
Query::Prepared(value)
}
pub const fn is_prepared(&self) -> bool {
matches!(self, Query::Prepared(..))
}
pub fn as_str(&self) -> Cow<'_, str> {
match self {
Query::Raw(RawQuery(sql)) => Cow::Borrowed(sql),
Query::Prepared(prepared) => Cow::Owned(format!("{prepared:?}")),
}
}
#[inline(always)]
pub fn is_empty(&self) -> bool {
match self {
Query::Raw(RawQuery(sql)) => sql.is_empty(),
Query::Prepared(prepared) => prepared.is_empty(),
}
}
pub fn clear_bindings(&mut self) -> Result<&mut Self> {
if let Self::Prepared(prepared) = self {
prepared.clear_bindings()?;
};
Ok(self)
}
pub fn bind(&mut self, value: impl AsValue) -> Result<&mut Self> {
let Self::Prepared(prepared) = self else {
return Err(anyhow!("Cannot bind a raw query"));
};
prepared.bind(value)?;
Ok(self)
}
pub fn bind_index(&mut self, value: impl AsValue, index: u64) -> Result<&mut Self> {
let Self::Prepared(prepared) = self else {
return Err(anyhow!("Cannot bind index of a raw query"));
};
prepared.bind_index(value, index)?;
Ok(self)
}
pub fn into_any(self) -> AnyQuery {
self.into()
}
}
impl<D: Driver> Default for Query<D> {
fn default() -> Self {
Self::raw(Default::default())
}
}
impl<D: Driver> From<&str> for Query<D> {
fn from(value: &str) -> Self {
Self::raw(value.into())
}
}
impl<D: Driver> From<String> for Query<D> {
fn from(value: String) -> Self {
Self::raw(value)
}
}
impl<D, P> From<P> for Query<D>
where
D: Driver<Prepared = P>,
P: Prepared,
{
fn from(value: P) -> Self {
Self::prepared(value)
}
}
impl<D: Driver> Display for Query<D> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Query::Raw(v) => v.fmt(f),
Query::Prepared(query) => query.fmt(f),
}
}
}
impl<D: Driver> AsMut<Query<D>> for Query<D> {
fn as_mut(&mut self) -> &mut Query<D> {
self
}
}
#[derive(Debug)]
pub enum QueryResult<R = RowOwned> {
Row(R),
Affected(RowsAffected),
}
pub type QueryResultOwned = QueryResult<RowOwned>;