#![cfg(any(feature = "mysql", feature = "postgres"))]
use super::TableQuery;
use crate::error::BaseError;
#[cfg(feature = "mysql")]
use crate::table::SortOrder;
#[cfg(feature = "mysql")]
use crate::table::WhereCondition;
#[cfg(feature = "mysql")]
use serde_json::Value;
impl TableQuery {
pub(super) fn backend(&self) -> Result<yang_db::BackendKind, BaseError> {
self.pool
.as_ref()
.map(crate::database::AnyPool::backend)
.ok_or(BaseError::DatabaseNotInitialized)
}
pub(super) fn field_ref(&self, name: &str) -> Result<&yang_db::FieldRef, BaseError> {
#[cfg(feature = "mysql")]
let field = self.table_config.get_field_ref(name);
#[cfg(not(feature = "mysql"))]
let field = self.table_config.field_refs.get(name);
field.ok_or_else(|| {
BaseError::FieldNotFound(self.table_config.table_name.clone(), name.to_string())
})
}
#[cfg(feature = "mysql")]
pub(super) fn compile_predicate(
&self,
condition: &WhereCondition,
) -> Result<yang_db::Predicate, BaseError> {
Ok(match condition {
WhereCondition::Eq { field: name, value } => yang_db::Predicate::Compare(
self.field_ref(name)?.clone(),
yang_db::CompareOp::Eq,
value.clone(),
),
WhereCondition::Ne { field: name, value } => yang_db::Predicate::Compare(
self.field_ref(name)?.clone(),
yang_db::CompareOp::Ne,
value.clone(),
),
WhereCondition::Gt { field: name, value } => yang_db::Predicate::Compare(
self.field_ref(name)?.clone(),
yang_db::CompareOp::Gt,
value.clone(),
),
WhereCondition::Gte { field: name, value } => yang_db::Predicate::Compare(
self.field_ref(name)?.clone(),
yang_db::CompareOp::Gte,
value.clone(),
),
WhereCondition::Lt { field: name, value } => yang_db::Predicate::Compare(
self.field_ref(name)?.clone(),
yang_db::CompareOp::Lt,
value.clone(),
),
WhereCondition::Lte { field: name, value } => yang_db::Predicate::Compare(
self.field_ref(name)?.clone(),
yang_db::CompareOp::Lte,
value.clone(),
),
WhereCondition::Like {
field: name,
pattern,
} => yang_db::Predicate::Compare(
self.field_ref(name)?.clone(),
yang_db::CompareOp::Like,
Value::String(pattern.clone()),
),
WhereCondition::In {
field: name,
values,
} => yang_db::Predicate::In(self.field_ref(name)?.clone(), values.clone()),
WhereCondition::NotIn {
field: name,
values,
} => yang_db::Predicate::NotIn(self.field_ref(name)?.clone(), values.clone()),
WhereCondition::Between {
field: name,
lo,
hi,
} => yang_db::Predicate::Between(self.field_ref(name)?.clone(), lo.clone(), hi.clone()),
WhereCondition::IsNull { field: name } => {
yang_db::Predicate::IsNull(self.field_ref(name)?.clone())
}
WhereCondition::IsNotNull { field: name } => {
yang_db::Predicate::IsNotNull(self.field_ref(name)?.clone())
}
WhereCondition::And { conditions } => yang_db::Predicate::And(
conditions
.iter()
.map(|value| self.compile_predicate(value))
.collect::<Result<Vec<_>, _>>()?,
),
WhereCondition::Or { conditions } => yang_db::Predicate::Or(
conditions
.iter()
.map(|value| self.compile_predicate(value))
.collect::<Result<Vec<_>, _>>()?,
),
})
}
#[cfg(feature = "mysql")]
pub(super) fn compile_db_query(&self) -> Result<yang_db::QueryBuilder<'_>, BaseError> {
let pool = self
.pool
.as_ref()
.and_then(|pool| pool.as_mysql())
.ok_or(BaseError::DatabaseNotInitialized)?;
self.apply_read_plan(yang_db::QueryBuilder::from_pool(
pool,
&self.table_config.table_ref,
))
}
#[cfg(feature = "mysql")]
pub(super) fn compile_db_write_query(&self) -> Result<yang_db::QueryBuilder<'_>, BaseError> {
let pool = self
.pool
.as_ref()
.and_then(|pool| pool.as_mysql())
.ok_or(BaseError::DatabaseNotInitialized)?;
self.apply_write_plan(yang_db::QueryBuilder::from_pool(
pool,
&self.table_config.table_ref,
))
}
#[cfg(feature = "mysql")]
pub(super) fn apply_read_plan<'a>(
&self,
mut query: yang_db::QueryBuilder<'a>,
) -> Result<yang_db::QueryBuilder<'a>, BaseError> {
let selected = self.query_params.fields.as_ref().map_or_else(
|| {
self.default_read_fields()
.map(|values| values.into_iter().map(str::to_string).collect())
},
|values| Ok(values.clone()),
)?;
for name in selected {
let field = self.field_ref(&name)?;
query = query.field(field);
}
query = self.apply_where_guards(query)?;
let orders = if self.query_params.order_by.is_empty() {
&self.table_config.default_order
} else {
&self.query_params.order_by
};
for (name, order) in orders {
let field = self.field_ref(name)?;
let order = match order {
SortOrder::Asc => yang_db::SortOrder::Asc,
SortOrder::Desc => yang_db::SortOrder::Desc,
};
query = query.order(field, order);
}
if let Some(page_size) = self.query_params.page_size {
let page = self.query_params.page.unwrap_or(1).max(1);
let limit = u64::try_from(page_size).map_err(|_| {
BaseError::ParamInvalid("page_size".to_string(), "分页大小超出范围".to_string())
})?;
let offset = u64::try_from((page - 1).saturating_mul(page_size)).map_err(|_| {
BaseError::ParamInvalid("page".to_string(), "分页偏移超出范围".to_string())
})?;
query = query.limit(limit).offset(offset);
}
Ok(query)
}
#[cfg(feature = "mysql")]
pub(super) fn apply_write_plan<'a>(
&self,
query: yang_db::QueryBuilder<'a>,
) -> Result<yang_db::QueryBuilder<'a>, BaseError> {
self.apply_where_guards(query)
}
#[cfg(feature = "mysql")]
fn apply_where_guards<'a>(
&self,
mut query: yang_db::QueryBuilder<'a>,
) -> Result<yang_db::QueryBuilder<'a>, BaseError> {
for condition in &self.query_params.where_conditions {
query = query
.where_predicate(&self.compile_predicate(condition)?)
.map_err(BaseError::DatabaseQueryFailed)?;
}
if !self.include_trashed {
if let Some(name) = &self.table_config.soft_delete_field {
let field = self.field_ref(name)?;
query = query.where_null(field);
}
}
Ok(query)
}
}