use core::{
borrow::{Borrow, BorrowMut},
marker::PhantomData,
};
use super::{OpenSubquery, QuoteIdent, SqlConjunction, quote_ident};
use crate::FieldName;
pub trait ClauseTransition<Next> {}
pub struct SelectClause;
pub struct FromClause;
pub struct WhereClause;
pub struct OrderByClause;
pub struct LimitClause;
pub struct OffsetClause;
pub struct Finalize;
impl ClauseTransition<SelectClause> for SelectClause {}
impl ClauseTransition<FromClause> for SelectClause {}
impl ClauseTransition<WhereClause> for FromClause {}
impl ClauseTransition<WhereClause> for WhereClause {}
impl ClauseTransition<OrderByClause> for FromClause {}
impl ClauseTransition<OrderByClause> for WhereClause {}
impl ClauseTransition<OrderByClause> for OrderByClause {}
impl ClauseTransition<LimitClause> for FromClause {}
impl ClauseTransition<LimitClause> for WhereClause {}
impl ClauseTransition<LimitClause> for OrderByClause {}
impl ClauseTransition<OffsetClause> for LimitClause {}
impl ClauseTransition<Finalize> for FromClause {}
impl ClauseTransition<Finalize> for WhereClause {}
impl ClauseTransition<Finalize> for OrderByClause {}
impl ClauseTransition<Finalize> for LimitClause {}
impl ClauseTransition<Finalize> for OffsetClause {}
const STATEMENT_CAPACITY: usize = 1024;
#[must_use]
pub struct QueryBuilder<Op, Db, QB = sqlx::QueryBuilder<Db>> {
inner: QB,
pushed_select_field: bool,
pushed_order_by: bool,
state: PhantomData<fn() -> Op>,
db: PhantomData<fn() -> Db>,
}
impl<Db: sqlx::Database> QueryBuilder<SelectClause, Db> {
pub fn select() -> Self {
Self::select_into(sqlx::QueryBuilder::new(String::with_capacity(
STATEMENT_CAPACITY,
)))
}
}
impl<Db, QB> QueryBuilder<SelectClause, Db, QB>
where
Db: sqlx::Database,
QB: BorrowMut<sqlx::QueryBuilder<Db>>,
{
pub fn select_into(mut holder: QB) -> Self {
holder.borrow_mut().push("SELECT ");
Self {
inner: holder,
pushed_select_field: false,
pushed_order_by: false,
state: PhantomData,
db: PhantomData,
}
}
}
impl<Op, Db, QB> Borrow<sqlx::QueryBuilder<Db>> for QueryBuilder<Op, Db, QB>
where
Db: sqlx::Database,
QB: BorrowMut<sqlx::QueryBuilder<Db>>,
{
#[inline]
fn borrow(&self) -> &sqlx::QueryBuilder<Db> {
self.inner.borrow()
}
}
impl<Op, Db, QB> BorrowMut<sqlx::QueryBuilder<Db>> for QueryBuilder<Op, Db, QB>
where
Db: sqlx::Database,
QB: BorrowMut<sqlx::QueryBuilder<Db>>,
{
#[inline]
fn borrow_mut(&mut self) -> &mut sqlx::QueryBuilder<Db> {
self.inner.borrow_mut()
}
}
impl<S, Db, QB> QueryBuilder<S, Db, QB> {
#[inline]
fn advance<Next>(self) -> QueryBuilder<Next, Db, QB>
where
S: ClauseTransition<Next>,
{
QueryBuilder {
inner: self.inner,
pushed_select_field: self.pushed_select_field,
pushed_order_by: self.pushed_order_by,
state: PhantomData,
db: PhantomData,
}
}
}
impl<Op, Db, QB> QueryBuilder<Op, Db, QB>
where
Db: sqlx::Database,
QB: BorrowMut<sqlx::QueryBuilder<Db>>,
{
#[inline]
pub fn inner_mut(&mut self) -> &mut sqlx::QueryBuilder<Db> {
self.inner.borrow_mut()
}
fn push_select_field(&mut self) {
if self.pushed_select_field {
self.inner.borrow_mut().push(", ");
}
self.pushed_select_field = true;
}
fn push_order_by(&mut self) {
if self.pushed_order_by {
self.inner.borrow_mut().push(", ");
} else {
self.inner.borrow_mut().push(" ORDER BY ");
}
self.pushed_order_by = true;
}
}
impl<S, Db, QB> QueryBuilder<S, Db, QB>
where
S: ClauseTransition<SelectClause>,
Db: sqlx::Database,
QB: BorrowMut<sqlx::QueryBuilder<Db>>,
{
pub fn push_field(self, name: &str) -> QueryBuilder<SelectClause, Db, QB> {
self.push_field_with(|qb| {
qb.push(name);
})
}
pub fn push_field_with(
mut self,
field: impl FnOnce(&mut sqlx::QueryBuilder<Db>),
) -> QueryBuilder<SelectClause, Db, QB> {
self.push_select_field();
field(self.inner.borrow_mut());
self.advance()
}
}
impl<S, Db, QB> QueryBuilder<S, Db, QB>
where
S: ClauseTransition<FromClause>,
Db: sqlx::Database,
QB: BorrowMut<sqlx::QueryBuilder<Db>>,
{
pub fn from(mut self, table: &str) -> QueryBuilder<FromClause, Db, QB> {
{
let qb = self.inner.borrow_mut();
qb.push(" FROM ");
qb.push(table);
}
self.advance()
}
}
impl<S: ClauseTransition<WhereClause>, Db, QB> QueryBuilder<S, Db, QB> {
#[inline]
pub fn begin_where(self) -> QueryBuilder<WhereClause, Db, QB> {
self.advance()
}
}
impl<S, Db, QB> QueryBuilder<S, Db, QB>
where
S: ClauseTransition<OrderByClause>,
Db: sqlx::Database + QuoteIdent,
QB: BorrowMut<sqlx::QueryBuilder<Db>>,
{
pub fn order_by(self, column: &FieldName, desc: bool) -> QueryBuilder<OrderByClause, Db, QB> {
self.order_by_nulls(column, desc, None)
}
pub fn order_by_nulls(
self,
column: &FieldName,
desc: bool,
nulls: Option<super::NullPosition>,
) -> QueryBuilder<OrderByClause, Db, QB> {
self.order_by_with(
|qb| {
qb.push(quote_ident::<Db>(column));
},
desc,
nulls,
)
}
}
impl<S, Db, QB> QueryBuilder<S, Db, QB>
where
S: ClauseTransition<OrderByClause>,
Db: sqlx::Database,
QB: BorrowMut<sqlx::QueryBuilder<Db>>,
{
pub fn order_by_with(
mut self,
subject: impl FnOnce(&mut sqlx::QueryBuilder<Db>),
desc: bool,
nulls: Option<super::NullPosition>,
) -> QueryBuilder<OrderByClause, Db, QB> {
self.push_order_by();
{
let qb = self.inner.borrow_mut();
subject(qb);
qb.push(if desc { " DESC" } else { " ASC" });
if let Some(nulls) = nulls {
qb.push(nulls.as_str());
}
}
self.advance()
}
pub fn order_by_sub_select(
self,
body: impl FnOnce(&mut sqlx::QueryBuilder<Db>),
desc: bool,
nulls: Option<super::NullPosition>,
) -> QueryBuilder<OrderByClause, Db, QB> {
self.order_by_with(
|qb| super::SubjectSlot::new(qb, super::SubjectShape::SubSelect).write(body),
desc,
nulls,
)
}
}
impl<S, Db, QB> QueryBuilder<S, Db, QB>
where
S: ClauseTransition<LimitClause>,
Db: sqlx::Database,
QB: BorrowMut<sqlx::QueryBuilder<Db>>,
for<'t> i64: sqlx::Encode<'t, Db>,
i64: sqlx::Type<Db>,
{
pub fn limit(mut self, limit: u64) -> QueryBuilder<LimitClause, Db, QB> {
{
let qb = self.inner.borrow_mut();
qb.push(" LIMIT ");
qb.push_bind(clamp_to_i64(limit));
}
self.advance()
}
}
impl<S, Db, QB> QueryBuilder<S, Db, QB>
where
S: ClauseTransition<OffsetClause>,
Db: sqlx::Database,
QB: BorrowMut<sqlx::QueryBuilder<Db>>,
for<'t> i64: sqlx::Encode<'t, Db>,
i64: sqlx::Type<Db>,
{
pub fn offset(mut self, offset: u64) -> QueryBuilder<OffsetClause, Db, QB> {
{
let qb = self.inner.borrow_mut();
qb.push(" OFFSET ");
qb.push_bind(clamp_to_i64(offset));
}
self.advance()
}
}
impl<S, Db> QueryBuilder<S, Db>
where
S: ClauseTransition<Finalize>,
Db: sqlx::Database,
{
#[inline]
pub fn finalize(self) -> sqlx::QueryBuilder<Db> {
self.inner
}
}
impl<'q, S, Db> QueryBuilder<S, Db, OpenSubquery<'q, Db>>
where
S: ClauseTransition<Finalize>,
Db: sqlx::Database,
{
#[inline]
pub fn finalize(mut self) -> SqlConjunction<'q, Db> {
self.inner_mut().push(" )");
self.inner.0
}
}
#[inline]
fn clamp_to_i64(value: u64) -> i64 {
i64::try_from(value).unwrap_or(i64::MAX)
}
#[cfg(test)]
mod tests;