use crate::column::Column;
use crate::expr::Expr;
use crate::types::Boolean;
use crate::value::SqlValue;
use core::fmt::Write;
use core::marker::PhantomData;
pub trait Table {
const NAME: &'static str;
}
pub trait Selection {
type Table;
fn write_select(&self, sql: &mut String);
}
#[derive(Debug, Clone, Copy, Default)]
pub struct All<T> {
_ty: PhantomData<T>,
}
impl<T> All<T> {
pub fn new() -> Self {
Self { _ty: PhantomData }
}
}
impl<T: Table> Selection for All<T> {
type Table = T;
fn write_select(&self, sql: &mut String) {
sql.push('*');
}
}
impl<C: Column> Selection for C {
type Table = C::Table;
fn write_select(&self, sql: &mut String) {
sql.push_str(C::NAME);
}
}
macro_rules! impl_selection_tuple {
($head:ident $(, $tail:ident)+) => {
impl<$head, $($tail),+> Selection for ($head, $($tail),+)
where
$head: Column,
$($tail: Column<Table = $head::Table>),+
{
type Table = $head::Table;
#[allow(non_snake_case)]
fn write_select(&self, sql: &mut String) {
let ($head, $($tail),+) = self;
Selection::write_select($head, sql);
$(
sql.push_str(", ");
Selection::write_select($tail, sql);
)+
}
}
};
}
impl_selection_tuple!(A, B);
impl_selection_tuple!(A, B, C);
impl_selection_tuple!(A, B, C, D);
impl_selection_tuple!(A, B, C, D, E);
impl_selection_tuple!(A, B, C, D, E, F);
impl_selection_tuple!(A, B, C, D, E, F, G);
impl_selection_tuple!(A, B, C, D, E, F, G, H);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Direction {
Asc,
Desc,
}
#[derive(Debug, Clone)]
struct OrderClause {
name: &'static str,
dir: Direction,
}
#[derive(Debug, Clone, PartialEq)]
pub struct QueryOutput {
pub sql: String,
pub params: Vec<SqlValue>,
}
trait SqlWriter {
fn write_to(&self, sql: &mut String, params: &mut Vec<SqlValue>);
}
impl<E: Expr<SqlType = Boolean> + 'static> SqlWriter for E {
fn write_to(&self, sql: &mut String, params: &mut Vec<SqlValue>) {
<E as Expr>::write_to(self, sql, params);
}
}
pub struct Query<T: Table, S: Selection<Table = T>> {
selection: S,
where_parts: Vec<Box<dyn SqlWriter>>,
order_by: Vec<OrderClause>,
limit: Option<u64>,
offset: Option<u64>,
_table: PhantomData<T>,
}
impl<T: Table> Default for Query<T, All<T>> {
fn default() -> Self {
Self::new()
}
}
impl<T: Table> Query<T, All<T>> {
pub fn new() -> Self {
Self {
selection: All::new(),
where_parts: Vec::new(),
order_by: Vec::new(),
limit: None,
offset: None,
_table: PhantomData,
}
}
}
impl<T: Table, S: Selection<Table = T>> Query<T, S> {
pub fn filter<P>(mut self, predicate: P) -> Self
where
P: Expr<SqlType = Boolean> + 'static,
{
self.where_parts.push(Box::new(predicate));
self
}
pub fn select<NS: Selection<Table = T>>(self, selection: NS) -> Query<T, NS> {
Query {
selection,
where_parts: self.where_parts,
order_by: self.order_by,
limit: self.limit,
offset: self.offset,
_table: PhantomData,
}
}
pub fn order_by<C: Column<Table = T>>(mut self, _column: C) -> Self {
self.order_by.push(OrderClause {
name: C::NAME,
dir: Direction::Asc,
});
self
}
pub fn order_by_desc<C: Column<Table = T>>(mut self, _column: C) -> Self {
self.order_by.push(OrderClause {
name: C::NAME,
dir: Direction::Desc,
});
self
}
pub fn limit(mut self, n: u64) -> Self {
self.limit = Some(n);
self
}
pub fn offset(mut self, n: u64) -> Self {
self.offset = Some(n);
self
}
pub fn to_sql(&self) -> QueryOutput {
let mut sql = String::from("SELECT ");
self.selection.write_select(&mut sql);
sql.push_str(" FROM ");
sql.push_str(T::NAME);
let mut params = Vec::new();
if !self.where_parts.is_empty() {
sql.push_str(" WHERE ");
let mut first = true;
for part in &self.where_parts {
if !first {
sql.push_str(" AND ");
}
part.write_to(&mut sql, &mut params);
first = false;
}
}
if !self.order_by.is_empty() {
sql.push_str(" ORDER BY ");
let mut first = true;
for o in &self.order_by {
if !first {
sql.push_str(", ");
}
sql.push_str(o.name);
if o.dir == Direction::Desc {
sql.push_str(" DESC");
}
first = false;
}
}
if let Some(n) = self.limit {
write!(&mut sql, " LIMIT {n}").unwrap();
}
if let Some(n) = self.offset {
write!(&mut sql, " OFFSET {n}").unwrap();
}
QueryOutput { sql, params }
}
}