use crate::database::types::SqlValue;
use crate::models::model_query::ModelQuery;
use crate::models::query_builder::{AnyDatabase, DatabaseBackend, QueryBuilder};
use anyhow::Result;
use async_trait::async_trait;
use serde::{Deserialize, Serialize};
use std::collections::HashSet;
#[derive(Clone)]
pub struct Filter {
where_clause: String,
}
impl Filter {
pub fn new(condition: &str) -> Self {
Self {
where_clause: condition.to_string(),
}
}
pub fn and(mut self, condition: &str) -> Self {
self.where_clause.push_str(" AND ");
self.where_clause.push_str(condition);
self
}
pub fn or(mut self, condition: &str) -> Self {
self.where_clause.push_str(" OR ");
self.where_clause.push_str(condition);
self
}
pub fn clause(&self) -> &str {
&self.where_clause
}
}
pub struct UpdateBuilder {
set_clause: String,
}
impl Default for UpdateBuilder {
fn default() -> Self {
Self::new()
}
}
impl UpdateBuilder {
pub fn new() -> Self {
Self {
set_clause: String::new(),
}
}
pub fn set(mut self, column: &str, placeholder: &str) -> Self {
if !self.set_clause.is_empty() {
self.set_clause.push_str(", ");
}
self.set_clause
.push_str(&format!("{} = {}", column, placeholder));
self
}
pub fn clause(&self) -> &str {
&self.set_clause
}
pub fn is_empty(&self) -> bool {
self.set_clause.is_empty()
}
}
pub trait ChangeTracking {
fn mark_changed(&mut self, field: &str, is_null: bool);
fn is_changed(&self, field: &str) -> bool;
fn is_null(&self, field: &str) -> bool;
fn has_changes(&self) -> bool;
fn clear_changes(&mut self);
fn changed_fields(&self) -> Vec<String>;
fn changed_fields_set(&self) -> &HashSet<String>;
fn null_fields_set(&self) -> &HashSet<String>;
}
#[async_trait]
pub trait BaseModel: ChangeTracking + Sized + Clone + Send + Sync + 'static
where
Self: Serialize + for<'de> Deserialize<'de>,
{
type IdType: Clone + Send + Sync + std::fmt::Display + Into<SqlValue> + 'static;
const TABLE_NAME: &'static str;
const PRIMARY_KEY: &'static str;
fn id(&self) -> Self::IdType;
async fn from_row_data(data: serde_json::Value) -> Result<Self>;
fn get_field_value(&self, field_name: &str) -> crate::error::Result<SqlValue>;
fn query() -> crate::error::Result<ModelQuery<Self>> {
ModelQuery::new(Self::TABLE_NAME)
}
async fn get_by_id_static(id: Self::IdType) -> crate::error::Result<Option<Self>> {
Self::query()?.get_by_id(id).await
}
async fn where_eq_static<V: Into<SqlValue> + Send>(
column: &str,
value: V,
) -> crate::error::Result<Vec<Self>> {
Self::query()?.where_eq(column, value).get_all().await
}
async fn get_all() -> crate::error::Result<Vec<Self>> {
Self::query()?.get_all().await
}
async fn count_all() -> crate::error::Result<i64> {
Self::query()?.count().await
}
async fn count() -> crate::error::Result<i64> {
Self::count_all().await
}
async fn exists_any() -> crate::error::Result<bool> {
Self::query()?.exists().await
}
async fn get_by_id(id: Self::IdType) -> crate::error::Result<Option<Self>> {
Self::get_by_id_static(id).await
}
#[deprecated(since = "0.2.0", note = "Please use `get_by_id()` instead")]
async fn find(id: Self::IdType) -> crate::error::Result<Option<Self>> {
Self::get_by_id_static(id).await
}
#[deprecated(since = "0.2.0", note = "Please use `get_all()` instead")]
async fn all() -> crate::error::Result<Vec<Self>> {
Self::get_all().await
}
async fn delete(self) -> crate::error::Result<()> {
use crate::db::DB;
use crate::models::query_builder::{DatabaseBackend, QueryBuilder};
let db = DB::connection()
.ok_or_else(|| crate::error::Error::template("Database not configured".to_string()))?;
let backend = match db.as_ref() {
#[cfg(feature = "db-postgres")]
AnyDatabase::Postgres(_) => DatabaseBackend::Postgres,
#[cfg(feature = "db-mysql")]
AnyDatabase::MySQL(_) => DatabaseBackend::MySQL,
#[cfg(feature = "db-sqlite")]
AnyDatabase::SQLite(_) => DatabaseBackend::SQLite,
};
let query = QueryBuilder::new(backend)
.from(Self::TABLE_NAME)
.where_eq("id", self.id().into());
let (sql, params) = query.build_delete().map_err(|e| {
crate::error::Error::template(format!("Failed to build delete query: {}", e))
})?;
DB::execute_with_params(&sql, params)
.await
.map_err(|e| crate::error::Error::template(format!("Failed to delete: {}", e)))?;
Ok(())
}
async fn get_first() -> crate::error::Result<Option<Self>> {
Self::query()?.limit(1).get_first().await
}
#[deprecated(since = "0.2.0", note = "Please use `get_first()` instead")]
async fn first() -> crate::error::Result<Option<Self>> {
Self::get_first().await
}
async fn paginate(page: u32, per_page: u32) -> crate::error::Result<Vec<Self>> {
Self::query()?.paginate(page, per_page).get_all().await
}
async fn update(&mut self) -> crate::error::Result<()> {
use crate::db::DB;
use std::collections::HashMap;
if !self.has_changes() {
return Ok(());
}
let mut update_data = HashMap::new();
for field in self.changed_fields() {
let value = if self.is_null(&field) {
SqlValue::Null
} else {
self.get_field_value(&field)?
};
update_data.insert(field, value);
}
let db = DB::connection()
.ok_or_else(|| crate::error::Error::template("Database not configured".to_string()))?;
let backend = match db.as_ref() {
#[cfg(feature = "db-postgres")]
AnyDatabase::Postgres(_) => DatabaseBackend::Postgres,
#[cfg(feature = "db-mysql")]
AnyDatabase::MySQL(_) => DatabaseBackend::MySQL,
#[cfg(feature = "db-sqlite")]
AnyDatabase::SQLite(_) => DatabaseBackend::SQLite,
};
let query_builder = QueryBuilder::new(backend)
.from(Self::TABLE_NAME)
.where_eq(Self::PRIMARY_KEY, self.id().into());
let (sql, params) = query_builder.build_update(&update_data).map_err(|e| {
crate::error::Error::template(format!("Failed to build update query: {}", e))
})?;
DB::execute_with_params(&sql, params)
.await
.map_err(|e| crate::error::Error::template(format!("Failed to update: {}", e)))?;
self.clear_changes();
Ok(())
}
#[doc(hidden)]
async fn get_by_id_with_db(db: &AnyDatabase, id: Self::IdType) -> Result<Option<Self>> {
use crate::models::query_builder::{DatabaseBackend, QueryBuilder};
let backend = match db {
#[cfg(feature = "db-postgres")]
AnyDatabase::Postgres(_) => DatabaseBackend::Postgres,
#[cfg(feature = "db-mysql")]
AnyDatabase::MySQL(_) => DatabaseBackend::MySQL,
#[cfg(feature = "db-sqlite")]
AnyDatabase::SQLite(_) => DatabaseBackend::SQLite,
};
let query = QueryBuilder::new(backend)
.from(Self::TABLE_NAME)
.where_eq(Self::PRIMARY_KEY, id.into());
let (sql, params) = query
.build()
.map_err(|e| anyhow::anyhow!("Failed to build query: {}", e))?;
let results = Self::execute_select_query(&sql, params).await?;
Ok(results.into_iter().next())
}
async fn execute_select_query(
sql: &str,
params: Vec<crate::models::query_builder::SqlValue>,
) -> Result<Vec<Self>>;
async fn execute_select_one_query(
sql: &str,
params: Vec<crate::models::query_builder::SqlValue>,
) -> Result<Option<Self>>;
async fn execute_update_and_refetch(
db: &AnyDatabase,
sql: &str,
id: Self::IdType,
) -> Result<Self> {
match db {
#[cfg(feature = "db-postgres")]
AnyDatabase::Postgres(pool) => {
sqlx::query(sql).execute(pool).await?;
}
#[cfg(feature = "db-mysql")]
AnyDatabase::MySQL(pool) => {
sqlx::query(sql).execute(pool).await?;
}
#[cfg(feature = "db-sqlite")]
AnyDatabase::SQLite(pool) => {
sqlx::query(sql).execute(pool).await?;
}
}
Self::get_by_id_with_db(db, id.clone())
.await?
.ok_or_else(|| anyhow::anyhow!("Model not found after update"))
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
struct MySqlTestModel {
pub id: i32,
pub name: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
struct PostgresTestModel {
pub id: i32,
pub name: String,
}
#[test]
fn test_filter_creation() {
let filter = Filter::new("id = 1");
assert_eq!(filter.clause(), "id = 1");
}
#[test]
fn test_filter_chaining() {
let filter = Filter::new("status = 'active'")
.and("age > 18")
.or("department = 'IT'");
assert_eq!(
filter.clause(),
"status = 'active' AND age > 18 OR department = 'IT'"
);
}
#[test]
fn test_mysql_filter() {
let filter = Filter::new("status = ?").and("age > ?");
assert_eq!(filter.clause(), "status = ? AND age > ?");
}
#[test]
fn test_postgres_filter() {
let filter = Filter::new("status = $1").and("created_at > $2");
assert_eq!(filter.clause(), "status = $1 AND created_at > $2");
}
#[test]
fn test_update_builder() {
let updates = UpdateBuilder::new()
.set("name", "'New Name'")
.set("email", "'new@example.com'")
.set("age", "25");
assert_eq!(
updates.clause(),
"name = 'New Name', email = 'new@example.com', age = 25"
);
assert!(!updates.is_empty());
}
#[test]
fn test_empty_update_builder() {
let updates = UpdateBuilder::new();
assert!(updates.is_empty());
}
#[test]
fn test_update_builder_with_placeholders() {
let updates = UpdateBuilder::new().set("name", "?").set("email", "?");
assert_eq!(updates.clause(), "name = ?, email = ?");
}
#[test]
fn test_trait_compilation() {
assert_eq!(
std::mem::size_of::<MySqlTestModel>(),
std::mem::size_of::<PostgresTestModel>()
);
}
}