pub mod expr;
use std::marker::PhantomData;
use derive_more::with_trait::Debug;
use thiserror::Error;
use crate::db;
pub use crate::db::query::expr::{Expr, ExprAdd, ExprDiv, ExprMul, ExprOrd, ExprSort, ExprSub};
use crate::db::query::expr::{OrderByExpr, SqlQueryBuilder};
use crate::db::{Auto, DatabaseBackend, ForeignKey, Model, StatementResult, ToDbFieldValue};
const ERROR_PREFIX: &str = "expression error:";
#[derive(Debug, Error)]
#[non_exhaustive]
pub enum QueryBuildingError {
#[error("{ERROR_PREFIX} unsupported expression: {0}")]
UnsupportedExpr(String),
#[error(transparent)]
SeaQuery(#[from] sea_query::error::Error),
}
pub struct Query<T> {
filter: Option<Expr>,
limit: Option<u64>,
order_by: Vec<OrderByExpr>,
offset: Option<u64>,
phantom_data: PhantomData<fn() -> T>,
}
impl<T> Debug for Query<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Query")
.field("filter", &self.filter)
.field("order_by", &self.order_by)
.field("limit", &self.limit)
.field("offset", &self.offset)
.field("phantom_data", &self.phantom_data)
.finish()
}
}
impl<T> Clone for Query<T> {
fn clone(&self) -> Self {
Self {
filter: self.filter.clone(),
limit: self.limit,
order_by: self.order_by.clone(),
offset: self.offset,
phantom_data: PhantomData,
}
}
}
impl<T> PartialEq for Query<T> {
fn eq(&self, other: &Self) -> bool {
self.filter == other.filter
}
}
impl<T: Model> Default for Query<T> {
fn default() -> Self {
Self::new()
}
}
impl<T: Model> Query<T> {
#[must_use]
pub fn new() -> Self {
Self {
filter: None,
limit: None,
order_by: Vec::new(),
offset: None,
phantom_data: PhantomData,
}
}
pub fn filter(&mut self, filter: Expr) -> &mut Self {
self.filter = Some(filter);
self
}
pub fn limit(&mut self, limit: u64) -> &mut Self {
self.limit = Some(limit);
self
}
pub fn order_by<I, O>(&mut self, order_by: I) -> &mut Self
where
O: Into<OrderByExpr>,
I: IntoIterator<Item = O>,
{
self.order_by = order_by.into_iter().map(Into::into).collect();
self
}
pub fn offset(&mut self, offset: u64) -> &mut Self {
self.offset = Some(offset);
self
}
pub async fn all<DB: DatabaseBackend>(&self, mut db: DB) -> db::Result<Vec<T>> {
db.query(self).await
}
pub async fn get<DB: DatabaseBackend>(&self, mut db: DB) -> db::Result<Option<T>> {
db.get(self).await
}
pub async fn count<DB: DatabaseBackend>(&self, mut db: DB) -> db::Result<u64> {
db.count(self).await
}
pub async fn exists<DB: DatabaseBackend>(&self, mut db: DB) -> db::Result<bool> {
db.exists(self).await
}
pub async fn delete<DB: DatabaseBackend>(&self, mut db: DB) -> db::Result<StatementResult> {
db.delete(self).await
}
pub(super) fn add_filter_to_statement<S: sea_query::ConditionalStatement>(
&self,
statement: &mut S,
sql_builder: &dyn SqlQueryBuilder,
) -> Result<(), QueryBuildingError> {
if let Some(filter) = &self.filter {
statement.and_where(filter.as_sea_query_expr(sql_builder)?);
}
Ok(())
}
pub(super) fn add_limit_to_statement(&self, statement: &mut sea_query::SelectStatement) {
if let Some(limit) = self.limit {
statement.limit(limit);
}
}
pub(super) fn add_order_by_to_statement(
&self,
statement: &mut sea_query::SelectStatement,
sql_builder: &dyn SqlQueryBuilder,
) -> Result<(), QueryBuildingError> {
for order_by in &self.order_by {
order_by.add_to_statement(statement, sql_builder)?;
}
Ok(())
}
pub(super) fn add_offset_to_statement(&self, statement: &mut sea_query::SelectStatement) {
if let Some(offset) = self.offset {
statement.offset(offset);
}
}
}
pub trait IntoField<T> {
fn into_field(self) -> T;
}
impl<T: ToDbFieldValue> IntoField<T> for T {
fn into_field(self) -> T {
self
}
}
impl<T> IntoField<Auto<T>> for T {
fn into_field(self) -> Auto<T> {
Auto::fixed(self)
}
}
impl IntoField<String> for &str {
fn into_field(self) -> String {
self.to_string()
}
}
impl<T: Model + Send + Sync> IntoField<ForeignKey<T>> for T {
fn into_field(self) -> ForeignKey<T> {
ForeignKey::from(self)
}
}
impl<T: Model + Send + Sync> IntoField<ForeignKey<T>> for &T {
fn into_field(self) -> ForeignKey<T> {
ForeignKey::from(self)
}
}
#[cfg(test)]
mod tests {
use cot_macros::model;
use super::*;
use crate::db::{MockDatabaseBackend, RowsNum};
#[model]
#[derive(std::fmt::Debug, PartialEq, Eq)]
struct MockModel {
#[model(primary_key)]
id: i32,
}
#[test]
fn query_new() {
let query: Query<MockModel> = Query::new();
assert!(query.filter.is_none());
assert!(query.limit.is_none());
assert!(query.offset.is_none());
}
#[test]
fn query_default() {
let query: Query<MockModel> = Query::default();
assert!(query.filter.is_none());
assert!(query.limit.is_none());
assert!(query.offset.is_none());
}
#[test]
fn query_filter() {
let mut query: Query<MockModel> = Query::new();
query.filter(Expr::eq(Expr::field("name"), Expr::value("John")));
assert!(query.filter.is_some());
}
#[test]
fn query_limit() {
let mut query: Query<MockModel> = Query::new();
query.limit(10);
assert!(query.limit.is_some());
assert_eq!(query.limit.unwrap(), 10);
}
#[test]
fn query_offset() {
let mut query: Query<MockModel> = Query::new();
query.offset(10);
assert!(query.offset.is_some());
assert_eq!(query.offset.unwrap(), 10);
}
#[cot::test]
async fn query_all() {
let mut db = MockDatabaseBackend::new();
db.expect_query().returning(|_| Ok(Vec::<MockModel>::new()));
let query: Query<MockModel> = Query::new();
let result = query.all(&mut db).await;
assert_eq!(result.unwrap(), Vec::<MockModel>::new());
}
#[cot::test]
async fn query_get() {
let mut db = MockDatabaseBackend::new();
db.expect_get().returning(|_| Ok(Option::<MockModel>::None));
let query: Query<MockModel> = Query::new();
let result = query.get(&mut db).await;
assert_eq!(result.unwrap(), Option::<MockModel>::None);
}
#[cot::test]
async fn query_exists() {
let mut db = MockDatabaseBackend::new();
db.expect_exists()
.returning(|_: &Query<MockModel>| Ok(false));
let query: Query<MockModel> = Query::new();
let result = query.exists(&mut db).await;
assert!(result.is_ok());
}
#[cot::test]
async fn query_delete() {
let mut db = MockDatabaseBackend::new();
db.expect_delete()
.returning(|_: &Query<MockModel>| Ok(StatementResult::new(RowsNum(0))));
let query: Query<MockModel> = Query::new();
let result = query.delete(&mut db).await;
assert!(result.is_ok());
}
}