use crate::error::BaseError;
use crate::table::{QueryParams, SortOrder, TableConfig, WhereCondition};
#[cfg(feature = "mysql")]
use serde::Serialize;
use serde_json::Value;
use std::collections::HashSet;
use std::sync::Arc;
pub const MAX_TABLE_QUERY_PAGE_SIZE: usize = super::query_params::MAX_QUERY_PAGE_SIZE;
#[derive(Debug, Clone)]
pub struct TableQuery {
table_config: Arc<TableConfig>,
user_roles: Arc<[String]>,
user_roles_set: HashSet<String>,
query_params: QueryParams,
include_trashed: bool,
allow_full_table: bool,
#[cfg(feature = "mysql")]
#[allow(dead_code)]
pool: Option<Arc<sqlx::MySqlPool>>,
slow_threshold: Option<std::time::Duration>,
request_id: Option<crate::action::RequestId>,
}
#[cfg(feature = "mysql")]
fn is_valid_identifier(s: &str) -> bool {
if s.is_empty() {
return false;
}
let mut chars = s.chars();
match chars.next() {
Some(c) if c.is_ascii_alphabetic() || c == '_' => {}
_ => return false,
}
chars.all(|c| c.is_ascii_alphanumeric() || c == '_')
}
impl TableQuery {
#[cfg(feature = "mysql")]
fn quote_identifier(&self, field: &str) -> Result<String, BaseError> {
if !is_valid_identifier(field) {
return Err(BaseError::FieldNotFound(
self.table_config.table_name.clone(),
field.to_string(),
));
}
Ok(format!("`{}`", field.replace('`', "``")))
}
#[cfg(feature = "mysql")]
fn quoted_table_name(&self) -> Result<String, BaseError> {
let name = &self.table_config.table_name;
if !is_valid_identifier(name) {
return Err(BaseError::FieldNotFound(
name.clone(),
"非法表名".to_string(),
));
}
Ok(format!("`{}`", name.replace('`', "``")))
}
#[cfg(feature = "mysql")]
pub fn new(
table_config: Arc<TableConfig>,
user_roles: Arc<[String]>,
pool: Option<Arc<sqlx::MySqlPool>>,
) -> Self {
let user_roles_set: HashSet<String> = user_roles.iter().cloned().collect();
Self {
table_config,
user_roles,
user_roles_set,
query_params: QueryParams::new(),
include_trashed: false,
allow_full_table: false,
pool,
slow_threshold: None,
request_id: None,
}
}
#[cfg(not(feature = "mysql"))]
pub fn new(
table_config: Arc<TableConfig>,
user_roles: Arc<[String]>,
_pool: Option<()>,
) -> Self {
let user_roles_set: HashSet<String> = user_roles.iter().cloned().collect();
Self {
table_config,
user_roles,
user_roles_set,
query_params: QueryParams::new(),
include_trashed: false,
allow_full_table: false,
slow_threshold: None,
request_id: None,
}
}
pub fn with_slow_threshold(mut self, threshold: Option<std::time::Duration>) -> Self {
self.slow_threshold = threshold;
self
}
pub fn with_request_id(mut self, request_id: crate::action::RequestId) -> Self {
self.request_id = Some(request_id);
self
}
fn validate_read_field(&self, field_name: &str) -> Result<(), BaseError> {
let field_config = self.table_config.get_field(field_name).ok_or_else(|| {
BaseError::FieldNotFound(self.table_config.table_name.clone(), field_name.to_string())
})?;
if !field_config.permissions.can_read(&self.user_roles_set) {
return Err(BaseError::FieldPermissionDenied(
self.table_config.table_name.clone(),
field_name.to_string(),
"用户无读取权限".to_string(),
));
}
Ok(())
}
fn validate_all_fields_readable_for_roles(
&self,
roles: &HashSet<String>,
) -> Result<(), BaseError> {
if let Some(field_name) = self
.table_config
.fields
.iter()
.filter_map(|(field_name, field_config)| {
(!field_config.permissions.can_read(roles)).then_some(field_name)
})
.min()
{
return Err(BaseError::FieldPermissionDenied(
self.table_config.table_name.clone(),
field_name.clone(),
"用户无读取权限".to_string(),
));
}
Ok(())
}
#[cfg(feature = "mysql")]
fn validate_all_fields_readable(&self) -> Result<(), BaseError> {
self.validate_all_fields_readable_for_roles(&self.user_roles_set)
}
pub fn select_fields(mut self, fields: &[&str]) -> Result<Self, BaseError> {
if fields.is_empty() {
return Err(BaseError::ParamInvalid(
"fields".to_string(),
"查询字段列表不能为空".to_string(),
));
}
for field_name in fields {
self.validate_read_field(field_name)?;
}
self.query_params.fields = Some(fields.iter().map(|s| s.to_string()).collect());
Ok(self)
}
pub fn ensure_fields_readable(&self, user: &crate::action::User) -> Result<(), BaseError> {
self.validate_all_fields_readable_for_roles(&user.roles)
}
pub fn where_eq(mut self, field: &str, value: Value) -> Result<Self, BaseError> {
self.validate_filter_field(field)?;
self.query_params.where_conditions.push(WhereCondition::Eq {
field: field.to_string(),
value,
});
Ok(self)
}
pub fn where_in(mut self, field: &str, values: Vec<Value>) -> Result<Self, BaseError> {
if values.is_empty() {
return Err(BaseError::ParamInvalid(
"values".to_string(),
"IN 列表不能为空".to_string(),
));
}
if values.len() > Self::MAX_IN_LIST_SIZE {
return Err(BaseError::ParamInvalid(
"values".to_string(),
format!(
"IN 列表元素数 {} 超过上限 {}",
values.len(),
Self::MAX_IN_LIST_SIZE
),
));
}
self.validate_filter_field(field)?;
self.query_params.where_conditions.push(WhereCondition::In {
field: field.to_string(),
values,
});
Ok(self)
}
pub fn where_like(mut self, field: &str, pattern: String) -> Result<Self, BaseError> {
if pattern.len() > Self::MAX_LIKE_PATTERN_LEN {
return Err(BaseError::ParamInvalid(
"pattern".to_string(),
format!(
"LIKE pattern 长度 {} 超过上限 {}",
pattern.len(),
Self::MAX_LIKE_PATTERN_LEN
),
));
}
self.validate_filter_field(field)?;
self.query_params
.where_conditions
.push(WhereCondition::Like {
field: field.to_string(),
pattern,
});
Ok(self)
}
pub fn where_contains(mut self, field: &str, keyword: &str) -> Result<Self, BaseError> {
if keyword.trim().is_empty() {
return Err(BaseError::ParamInvalid(
"keyword".to_string(),
"搜索关键词不能为空".to_string(),
));
}
let escaped = keyword
.replace('\\', "\\\\")
.replace('%', "\\%")
.replace('_', "\\_");
let pattern = format!("%{}%", escaped);
self = self.where_like(field, pattern)?;
Ok(self)
}
pub fn where_ne(mut self, field: &str, value: Value) -> Result<Self, BaseError> {
self.validate_filter_field(field)?;
self.query_params.where_conditions.push(WhereCondition::Ne {
field: field.to_string(),
value,
});
Ok(self)
}
pub fn where_lt(mut self, field: &str, value: Value) -> Result<Self, BaseError> {
self.validate_filter_field(field)?;
self.query_params.where_conditions.push(WhereCondition::Lt {
field: field.to_string(),
value,
});
Ok(self)
}
pub fn where_lte(mut self, field: &str, value: Value) -> Result<Self, BaseError> {
self.validate_filter_field(field)?;
self.query_params
.where_conditions
.push(WhereCondition::Lte {
field: field.to_string(),
value,
});
Ok(self)
}
pub fn where_gt(mut self, field: &str, value: Value) -> Result<Self, BaseError> {
self.validate_filter_field(field)?;
self.query_params.where_conditions.push(WhereCondition::Gt {
field: field.to_string(),
value,
});
Ok(self)
}
pub fn where_gte(mut self, field: &str, value: Value) -> Result<Self, BaseError> {
self.validate_filter_field(field)?;
self.query_params
.where_conditions
.push(WhereCondition::Gte {
field: field.to_string(),
value,
});
Ok(self)
}
pub fn where_between(mut self, field: &str, lo: Value, hi: Value) -> Result<Self, BaseError> {
self.validate_filter_field(field)?;
self.query_params
.where_conditions
.push(WhereCondition::Between {
field: field.to_string(),
lo,
hi,
});
Ok(self)
}
pub fn where_null(mut self, field: &str) -> Result<Self, BaseError> {
self.validate_filter_field(field)?;
self.query_params
.where_conditions
.push(WhereCondition::IsNull {
field: field.to_string(),
});
Ok(self)
}
pub fn where_not_null(mut self, field: &str) -> Result<Self, BaseError> {
self.validate_filter_field(field)?;
self.query_params
.where_conditions
.push(WhereCondition::IsNotNull {
field: field.to_string(),
});
Ok(self)
}
pub fn where_not_in(mut self, field: &str, values: Vec<Value>) -> Result<Self, BaseError> {
if values.is_empty() {
return Err(BaseError::ParamInvalid(
"values".to_string(),
"NOT IN 列表不能为空".to_string(),
));
}
if values.len() > Self::MAX_IN_LIST_SIZE {
return Err(BaseError::ParamInvalid(
"values".to_string(),
format!(
"NOT IN 列表元素数 {} 超过上限 {}",
values.len(),
Self::MAX_IN_LIST_SIZE
),
));
}
self.validate_filter_field(field)?;
self.query_params
.where_conditions
.push(WhereCondition::NotIn {
field: field.to_string(),
values,
});
Ok(self)
}
fn validate_order_field(&self, field: &str) -> Result<(), BaseError> {
let field_config = self.table_config.get_field(field).ok_or_else(|| {
BaseError::FieldNotFound(self.table_config.table_name.clone(), field.to_string())
})?;
if !field_config.sortable {
return Err(BaseError::FieldPermissionDenied(
self.table_config.table_name.clone(),
field.to_string(),
"字段不允许排序".to_string(),
));
}
if !field_config.permissions.can_sort(&self.user_roles_set) {
return Err(BaseError::FieldPermissionDenied(
self.table_config.table_name.clone(),
field.to_string(),
"用户无排序权限".to_string(),
));
}
Ok(())
}
pub fn order_by(mut self, field: &str, order: SortOrder) -> Result<Self, BaseError> {
self.validate_order_field(field)?;
self.query_params.order_by.push((field.to_string(), order));
Ok(self)
}
pub fn page(mut self, page: usize, page_size: usize) -> Result<Self, BaseError> {
if page == 0 || page_size == 0 {
return Err(BaseError::ParamInvalid(
"page".to_string(),
"页码与每页大小必须从 1 开始且大于 0".to_string(),
));
}
if page_size > MAX_TABLE_QUERY_PAGE_SIZE {
return Err(BaseError::ParamInvalid(
"page_size".to_string(),
format!("每页大小不能超过 {}", MAX_TABLE_QUERY_PAGE_SIZE),
));
}
self.query_params.page = Some(page);
self.query_params.page_size = Some(page_size);
Ok(self)
}
pub fn with_trashed(mut self) -> Self {
self.include_trashed = true;
self
}
pub fn allow_full_table(mut self) -> Self {
self.allow_full_table = true;
self
}
fn validate_filter_field(&self, field: &str) -> Result<(), BaseError> {
let field_config = self.table_config.get_field(field).ok_or_else(|| {
BaseError::FieldNotFound(self.table_config.table_name.clone(), field.to_string())
})?;
if !field_config.filterable {
return Err(BaseError::FieldPermissionDenied(
self.table_config.table_name.clone(),
field.to_string(),
"字段不允许筛选".to_string(),
));
}
if !field_config.permissions.can_filter(&self.user_roles_set) {
return Err(BaseError::FieldPermissionDenied(
self.table_config.table_name.clone(),
field.to_string(),
"用户无筛选权限".to_string(),
));
}
Ok(())
}
const MAX_WHERE_DEPTH: usize = 32;
const MAX_LIKE_PATTERN_LEN: usize = 128;
const MAX_IN_LIST_SIZE: usize = 500;
fn validate_condition_tree(
&self,
condition: &WhereCondition,
depth: usize,
) -> Result<(), BaseError> {
if depth > Self::MAX_WHERE_DEPTH {
return Err(BaseError::ParamInvalid(
"where".to_string(),
format!("嵌套布尔条件层数超过上限 {}", Self::MAX_WHERE_DEPTH),
));
}
match condition {
WhereCondition::And { conditions } | WhereCondition::Or { conditions } => {
if conditions.is_empty() {
return Err(BaseError::ParamInvalid(
"where".to_string(),
"AND/OR 布尔组不能为空".to_string(),
));
}
for child in conditions {
self.validate_condition_tree(child, depth + 1)?;
}
Ok(())
}
leaf => {
let field = leaf.field().ok_or_else(|| {
BaseError::ParamInvalid(
"condition".to_string(),
"条件节点缺少字段名".to_string(),
)
})?;
self.validate_filter_field(field)?;
if let WhereCondition::Like { pattern, .. } = leaf {
if pattern.len() > Self::MAX_LIKE_PATTERN_LEN {
return Err(BaseError::ParamInvalid(
"pattern".to_string(),
format!(
"LIKE pattern 长度 {} 超过上限 {}",
pattern.len(),
Self::MAX_LIKE_PATTERN_LEN
),
));
}
}
if let WhereCondition::In { values, .. } | WhereCondition::NotIn { values, .. } =
leaf
{
if values.is_empty() {
return Err(BaseError::ParamInvalid(
"values".to_string(),
"IN/NOT IN 列表不能为空".to_string(),
));
}
if values.len() > Self::MAX_IN_LIST_SIZE {
return Err(BaseError::ParamInvalid(
"values".to_string(),
format!(
"IN/NOT IN 列表元素数 {} 超过上限 {}",
values.len(),
Self::MAX_IN_LIST_SIZE
),
));
}
}
Ok(())
}
}
}
pub fn where_or(mut self, conditions: Vec<WhereCondition>) -> Result<Self, BaseError> {
let group = WhereCondition::Or { conditions };
self.validate_condition_tree(&group, 0)?;
self.query_params.where_conditions.push(group);
Ok(self)
}
pub fn where_and(mut self, conditions: Vec<WhereCondition>) -> Result<Self, BaseError> {
let group = WhereCondition::And { conditions };
self.validate_condition_tree(&group, 0)?;
self.query_params.where_conditions.push(group);
Ok(self)
}
pub fn where_tree(mut self, condition: WhereCondition) -> Result<Self, BaseError> {
self.validate_condition_tree(&condition, 0)?;
self.query_params.where_conditions.push(condition);
Ok(self)
}
#[allow(dead_code)]
pub fn get_query_params(&self) -> &QueryParams {
&self.query_params
}
#[allow(dead_code)]
pub fn get_table_config(&self) -> &Arc<TableConfig> {
&self.table_config
}
#[allow(dead_code)]
pub fn get_user_roles(&self) -> &[String] {
&self.user_roles
}
#[cfg(test)]
pub fn new_without_pool(table_config: Arc<TableConfig>) -> Self {
Self::new(table_config, Arc::from(vec![]), None)
}
}
#[cfg(feature = "mysql")]
impl TableQuery {
fn with_effective_pagination(self) -> Result<(Self, usize, usize), BaseError> {
let page = self.query_params.page.unwrap_or(1);
let page_size = self
.query_params
.page_size
.unwrap_or(super::query_params::DEFAULT_QUERY_PAGE_SIZE);
let query = self.page(page, page_size)?;
Ok((query, page, page_size))
}
pub async fn paginate<T>(self) -> Result<crate::table::PaginatedResult<T>, BaseError>
where
T: for<'r> sqlx::FromRow<'r, sqlx::mysql::MySqlRow> + Send + Unpin + Serialize,
{
let _pool = self
.pool
.as_ref()
.ok_or(BaseError::DatabaseNotInitialized)?;
let (query, page, page_size) = self.with_effective_pagination()?;
let total = query.count_internal().await?;
if total == 0 {
return Ok(crate::table::PaginatedResult::empty(page, page_size));
}
let data = query.select().await?;
Ok(crate::table::PaginatedResult::new(
data, total, page, page_size,
))
}
async fn count_internal(&self) -> Result<usize, BaseError> {
let pool = self
.pool
.as_ref()
.ok_or(BaseError::DatabaseNotInitialized)?;
let (sql, params) = self.build_count_sql()?;
let mut query = sqlx::query_scalar::<_, i64>(&sql);
for param in params {
query = Self::bind_count_param(query, ¶m);
}
let count = Self::timed(
self.slow_threshold,
self.request_id,
&self.table_config.table_name,
"count",
query.fetch_one(pool.as_ref()),
)
.await
.map_err(|e| BaseError::DatabaseQueryFailed(yang_db::DbError::from(e)))?;
Ok(count as usize)
}
pub async fn count(self) -> Result<u64, BaseError> {
self.count_internal().await.map(|n| n as u64)
}
fn append_where_to_sql(
&self,
sql: &mut String,
params: &mut Vec<SqlParam>,
apply_soft_delete: bool,
) -> Result<(), BaseError> {
let has_soft_delete = apply_soft_delete
&& !self.include_trashed
&& self.table_config.soft_delete_field.is_some();
if self.query_params.where_conditions.is_empty() && !has_soft_delete {
return Ok(());
}
sql.push_str(" WHERE ");
let mut first = true;
for condition in &self.query_params.where_conditions {
if !first {
sql.push_str(" AND ");
}
first = false;
self.render_condition(condition, sql, params, 0)?;
}
if has_soft_delete {
if let Some(field) = &self.table_config.soft_delete_field {
let quoted = self.quote_identifier(field)?;
if !first {
sql.push_str(" AND ");
}
sql.push_str(&format!("{} IS NULL", quoted));
}
}
Ok(())
}
fn render_condition(
&self,
condition: &WhereCondition,
sql: &mut String,
params: &mut Vec<SqlParam>,
depth: usize,
) -> Result<(), BaseError> {
if depth > Self::MAX_WHERE_DEPTH {
return Err(BaseError::ParamInvalid(
"where".to_string(),
format!("嵌套布尔条件层数超过上限 {}", Self::MAX_WHERE_DEPTH),
));
}
match condition {
WhereCondition::Eq { field, value } => {
let quoted = self.quote_identifier(field)?;
sql.push_str(&format!("{} = ?", quoted));
params.push(SqlParam::from_json(value)?);
}
WhereCondition::In { field, values } => {
if values.len() > Self::MAX_IN_LIST_SIZE {
return Err(BaseError::ParamInvalid(
"values".to_string(),
format!(
"IN 列表元素数 {} 超过上限 {}",
values.len(),
Self::MAX_IN_LIST_SIZE
),
));
}
let quoted = self.quote_identifier(field)?;
if values.is_empty() {
sql.push_str("1=0");
} else {
let placeholders = vec!["?"; values.len()].join(", ");
sql.push_str(&format!("{} IN ({})", quoted, placeholders));
for value in values {
params.push(SqlParam::from_json(value)?);
}
}
}
WhereCondition::Like { field, pattern } => {
if pattern.len() > Self::MAX_LIKE_PATTERN_LEN {
return Err(BaseError::ParamInvalid(
"pattern".to_string(),
format!(
"LIKE pattern 长度 {} 超过上限 {}",
pattern.len(),
Self::MAX_LIKE_PATTERN_LEN
),
));
}
let quoted = self.quote_identifier(field)?;
sql.push_str(&format!("{} LIKE ?", quoted));
params.push(SqlParam::String(pattern.clone()));
}
WhereCondition::Gt { field, value } => {
let quoted = self.quote_identifier(field)?;
sql.push_str(&format!("{} > ?", quoted));
params.push(SqlParam::from_json(value)?);
}
WhereCondition::Gte { field, value } => {
let quoted = self.quote_identifier(field)?;
sql.push_str(&format!("{} >= ?", quoted));
params.push(SqlParam::from_json(value)?);
}
WhereCondition::Lt { field, value } => {
let quoted = self.quote_identifier(field)?;
sql.push_str(&format!("{} < ?", quoted));
params.push(SqlParam::from_json(value)?);
}
WhereCondition::Lte { field, value } => {
let quoted = self.quote_identifier(field)?;
sql.push_str(&format!("{} <= ?", quoted));
params.push(SqlParam::from_json(value)?);
}
WhereCondition::IsNull { field } => {
let quoted = self.quote_identifier(field)?;
sql.push_str(&format!("{} IS NULL", quoted));
}
WhereCondition::IsNotNull { field } => {
let quoted = self.quote_identifier(field)?;
sql.push_str(&format!("{} IS NOT NULL", quoted));
}
WhereCondition::Ne { field, value } => {
let quoted = self.quote_identifier(field)?;
sql.push_str(&format!("{} <> ?", quoted));
params.push(SqlParam::from_json(value)?);
}
WhereCondition::Between { field, lo, hi } => {
let quoted = self.quote_identifier(field)?;
sql.push_str(&format!("{} BETWEEN ? AND ?", quoted));
params.push(SqlParam::from_json(lo)?);
params.push(SqlParam::from_json(hi)?);
}
WhereCondition::NotIn { field, values } => {
if values.len() > Self::MAX_IN_LIST_SIZE {
return Err(BaseError::ParamInvalid(
"values".to_string(),
format!(
"NOT IN 列表元素数 {} 超过上限 {}",
values.len(),
Self::MAX_IN_LIST_SIZE
),
));
}
let quoted = self.quote_identifier(field)?;
if values.is_empty() {
sql.push_str("1=1");
} else {
let placeholders = vec!["?"; values.len()].join(", ");
sql.push_str(&format!("{} NOT IN ({})", quoted, placeholders));
for value in values {
params.push(SqlParam::from_json(value)?);
}
}
}
WhereCondition::And { conditions } => {
self.render_group(conditions, " AND ", "1=1", sql, params, depth)?;
}
WhereCondition::Or { conditions } => {
self.render_group(conditions, " OR ", "1=0", sql, params, depth)?;
}
}
Ok(())
}
fn render_group(
&self,
conditions: &[WhereCondition],
separator: &str,
empty_literal: &str,
sql: &mut String,
params: &mut Vec<SqlParam>,
depth: usize,
) -> Result<(), BaseError> {
if conditions.is_empty() {
sql.push_str(empty_literal);
return Ok(());
}
sql.push('(');
let mut first = true;
for cond in conditions {
if !first {
sql.push_str(separator);
}
first = false;
self.render_condition(cond, sql, params, depth + 1)?;
}
sql.push(')');
Ok(())
}
fn build_count_sql(&self) -> Result<(String, Vec<SqlParam>), BaseError> {
let mut sql = format!("SELECT COUNT(*) FROM {}", self.quoted_table_name()?);
let mut params = Vec::new();
self.append_where_to_sql(&mut sql, &mut params, true)?;
Ok((sql, params))
}
fn bind_count_param<'q>(
query: sqlx::query::QueryScalar<'q, sqlx::MySql, i64, sqlx::mysql::MySqlArguments>,
param: &SqlParam,
) -> sqlx::query::QueryScalar<'q, sqlx::MySql, i64, sqlx::mysql::MySqlArguments> {
match param {
SqlParam::Null => query.bind(Option::<i32>::None),
SqlParam::Bool(b) => query.bind(*b),
SqlParam::Int(i) => query.bind(*i),
SqlParam::Uint(u) => query.bind(*u),
SqlParam::Float(f) => query.bind(*f),
SqlParam::String(s) => query.bind(s.clone()),
SqlParam::DateTime(dt) => query.bind(*dt),
SqlParam::Bytes(b) => query.bind(b.clone()),
SqlParam::Json(j) => query.bind(j.clone()),
}
}
pub async fn select<T>(self) -> Result<Vec<T>, BaseError>
where
T: for<'r> sqlx::FromRow<'r, sqlx::mysql::MySqlRow> + Send + Unpin,
{
let pool = self
.pool
.as_ref()
.ok_or(BaseError::DatabaseNotInitialized)?;
let (sql, params) = self.build_select_sql(None)?;
Self::timed(
self.slow_threshold,
self.request_id,
&self.table_config.table_name,
"select",
Self::run_fetch_all(pool.as_ref(), &sql, ¶ms),
)
.await
}
pub async fn select_in_tx<T>(self, tx: &mut yang_db::Transaction) -> Result<Vec<T>, BaseError>
where
T: for<'r> sqlx::FromRow<'r, sqlx::mysql::MySqlRow> + Send + Unpin,
{
let (sql, params) = self.build_select_sql(None)?;
let executor = tx.executor().ok_or_else(|| {
BaseError::DatabaseTransactionFailed(yang_db::DbError::TransactionError(
"事务已提交或回滚".to_string(),
))
})?;
Self::timed(
self.slow_threshold,
self.request_id,
&self.table_config.table_name,
"select_in_tx",
Self::run_fetch_all(executor, &sql, ¶ms),
)
.await
}
fn build_select_sql(
&self,
hard_limit: Option<usize>,
) -> Result<(String, Vec<SqlParam>), BaseError> {
let mut sql = String::from("SELECT ");
let mut params = Vec::new();
if let Some(fields) = &self.query_params.fields {
if fields.is_empty() {
self.validate_all_fields_readable()?;
sql.push('*');
} else {
let quoted_fields: Result<Vec<String>, BaseError> = fields
.iter()
.map(|f| {
self.validate_read_field(f)?;
self.quote_identifier(f)
})
.collect();
sql.push_str("ed_fields?.join(", "));
}
} else {
self.validate_all_fields_readable()?;
sql.push('*');
}
sql.push_str(&format!(" FROM {}", self.quoted_table_name()?));
self.append_where_to_sql(&mut sql, &mut params, true)?;
let order_source = if !self.query_params.order_by.is_empty() {
Some(&self.query_params.order_by)
} else if !self.table_config.default_order.is_empty() {
Some(&self.table_config.default_order)
} else {
None
};
if let Some(orders) = order_source {
sql.push_str(" ORDER BY ");
let order_clauses: Result<Vec<String>, BaseError> = orders
.iter()
.map(|(field, order)| {
self.validate_order_field(field)?;
let direction = match order {
SortOrder::Asc => "ASC",
SortOrder::Desc => "DESC",
};
self.quote_identifier(field)
.map(|quoted| format!("{} {}", quoted, direction))
})
.collect();
sql.push_str(&order_clauses?.join(", "));
}
if let (Some(page), Some(page_size)) = (self.query_params.page, self.query_params.page_size)
{
let offset = page.saturating_sub(1).saturating_mul(page_size);
sql.push_str(&format!(" LIMIT {} OFFSET {}", page_size, offset));
} else if let Some(limit) = hard_limit {
sql.push_str(&format!(" LIMIT {}", limit));
}
Ok((sql, params))
}
fn bind_param<'q, T>(
query: sqlx::query::QueryAs<'q, sqlx::MySql, T, sqlx::mysql::MySqlArguments>,
param: &SqlParam,
) -> sqlx::query::QueryAs<'q, sqlx::MySql, T, sqlx::mysql::MySqlArguments>
where
T: for<'r> sqlx::FromRow<'r, sqlx::mysql::MySqlRow> + Send + Unpin,
{
match param {
SqlParam::Null => query.bind(Option::<i32>::None),
SqlParam::Bool(b) => query.bind(*b),
SqlParam::Int(i) => query.bind(*i),
SqlParam::Uint(u) => query.bind(*u),
SqlParam::Float(f) => query.bind(*f),
SqlParam::String(s) => query.bind(s.clone()),
SqlParam::DateTime(dt) => query.bind(*dt),
SqlParam::Bytes(b) => query.bind(b.clone()),
SqlParam::Json(j) => query.bind(j.clone()),
}
}
pub async fn fetch_optional<T>(self) -> Result<Option<T>, BaseError>
where
T: for<'r> sqlx::FromRow<'r, sqlx::mysql::MySqlRow> + Send + Unpin,
{
let pool = self
.pool
.as_ref()
.ok_or(BaseError::DatabaseNotInitialized)?;
let (sql, params) = self.build_select_sql(Some(1))?;
let mut query = sqlx::query_as::<_, T>(&sql);
for param in params {
query = Self::bind_param(query, ¶m);
}
let result = Self::timed(
self.slow_threshold,
self.request_id,
&self.table_config.table_name,
"fetch_optional",
query.fetch_optional(pool.as_ref()),
)
.await
.map_err(|e| BaseError::DatabaseQueryFailed(yang_db::DbError::from(e)))?;
Ok(result)
}
pub async fn insert(
self,
data: std::collections::HashMap<String, Value>,
) -> Result<u64, BaseError> {
let pool = self
.pool
.as_ref()
.ok_or(BaseError::DatabaseNotInitialized)?;
let data = self.prepare_and_validate_insert(data)?;
let (sql, params) = self.build_insert_sql(&data)?;
let result = Self::timed(
self.slow_threshold,
self.request_id,
&self.table_config.table_name,
"insert",
Self::run_execute(pool.as_ref(), &sql, ¶ms),
)
.await?;
Ok(result.rows_affected())
}
pub async fn insert_in_tx(
self,
tx: &mut yang_db::Transaction,
data: std::collections::HashMap<String, Value>,
) -> Result<u64, BaseError> {
let data = self.prepare_and_validate_insert(data)?;
let (sql, params) = self.build_insert_sql(&data)?;
let executor = tx.executor().ok_or_else(|| {
BaseError::DatabaseTransactionFailed(yang_db::DbError::TransactionError(
"事务已提交或回滚".to_string(),
))
})?;
let result = Self::timed(
self.slow_threshold,
self.request_id,
&self.table_config.table_name,
"insert_in_tx",
Self::run_execute(executor, &sql, ¶ms),
)
.await?;
Ok(result.rows_affected())
}
pub async fn insert_returning_id(
self,
data: std::collections::HashMap<String, Value>,
) -> Result<(u64, u64), BaseError> {
let pool = self
.pool
.as_ref()
.ok_or(BaseError::DatabaseNotInitialized)?;
let data = self.prepare_and_validate_insert(data)?;
let (sql, params) = self.build_insert_sql(&data)?;
let result = Self::timed(
self.slow_threshold,
self.request_id,
&self.table_config.table_name,
"insert_returning_id",
Self::run_execute(pool.as_ref(), &sql, ¶ms),
)
.await?;
Ok((result.rows_affected(), result.last_insert_id()))
}
pub async fn insert_returning_id_in_tx(
self,
tx: &mut yang_db::Transaction,
data: std::collections::HashMap<String, Value>,
) -> Result<(u64, u64), BaseError> {
let data = self.prepare_and_validate_insert(data)?;
let (sql, params) = self.build_insert_sql(&data)?;
let executor = tx.executor().ok_or_else(|| {
BaseError::DatabaseTransactionFailed(yang_db::DbError::TransactionError(
"事务已提交或回滚".to_string(),
))
})?;
let result = Self::timed(
self.slow_threshold,
self.request_id,
&self.table_config.table_name,
"insert_returning_id_in_tx",
Self::run_execute(executor, &sql, ¶ms),
)
.await?;
Ok((result.rows_affected(), result.last_insert_id()))
}
fn prepare_and_validate_insert(
&self,
data: std::collections::HashMap<String, Value>,
) -> Result<std::collections::HashMap<String, Value>, BaseError> {
let mut prepared = data;
for (field_name, field_config) in &self.table_config.fields {
if !field_config.permissions.can_write(&self.user_roles_set) {
if let Some(v) = prepared.get(field_name) {
if !v.is_null() {
return Err(BaseError::FieldPermissionDenied(
self.table_config.table_name.clone(),
field_name.clone(),
"用户无写入权限".to_string(),
));
}
}
}
}
for (field_name, field_config) in &self.table_config.fields {
if let Some(default) = &field_config.default_value {
let missing = prepared
.get(field_name)
.map(|v| v.is_null())
.unwrap_or(true);
if missing {
prepared.insert(field_name.clone(), default.clone());
}
}
}
if let Some(ts) = &self.table_config.timestamp_fields {
let now = chrono::Utc::now().timestamp();
for ts_field in [&ts.created_at, &ts.updated_at].into_iter().flatten() {
if self.table_config.fields.contains_key(ts_field) {
let missing = prepared.get(ts_field).map(|v| v.is_null()).unwrap_or(true);
if missing {
prepared.insert(ts_field.clone(), Value::Number(now.into()));
}
}
}
}
for (field_name, field_config) in &self.table_config.fields {
if !field_config.permissions.can_write(&self.user_roles_set) {
continue;
}
let value = prepared.get(field_name).unwrap_or(&Value::Null);
field_config.validate(value)?;
}
Ok(prepared)
}
fn build_insert_sql(
&self,
data: &std::collections::HashMap<String, Value>,
) -> Result<(String, Vec<SqlParam>), BaseError> {
let mut fields = Vec::with_capacity(data.len());
let mut placeholders = Vec::with_capacity(data.len());
let mut params = Vec::with_capacity(data.len());
for (field_name, value) in data {
if !self.table_config.fields.contains_key(field_name) {
return Err(BaseError::FieldNotFound(
self.table_config.table_name.clone(),
field_name.clone(),
));
}
let quoted = self.quote_identifier(field_name)?;
fields.push(quoted);
placeholders.push("?".to_string());
params.push(SqlParam::from_json(value)?);
}
let sql = format!(
"INSERT INTO {} ({}) VALUES ({})",
self.quoted_table_name()?,
fields.join(", "),
placeholders.join(", ")
);
Ok((sql, params))
}
pub async fn update(
self,
data: std::collections::HashMap<String, Value>,
) -> Result<u64, BaseError> {
let pool = self
.pool
.as_ref()
.ok_or(BaseError::DatabaseNotInitialized)?;
self.validate_update_data(&data)?;
let (sql, params) = self.build_update_sql(&data)?;
let result = Self::timed(
self.slow_threshold,
self.request_id,
&self.table_config.table_name,
"update",
Self::run_execute(pool.as_ref(), &sql, ¶ms),
)
.await?;
Ok(result.rows_affected())
}
pub async fn update_in_tx(
self,
tx: &mut yang_db::Transaction,
data: std::collections::HashMap<String, Value>,
) -> Result<u64, BaseError> {
self.validate_update_data(&data)?;
let (sql, params) = self.build_update_sql(&data)?;
let executor = tx.executor().ok_or_else(|| {
BaseError::DatabaseTransactionFailed(yang_db::DbError::TransactionError(
"事务已提交或回滚".to_string(),
))
})?;
let result = Self::timed(
self.slow_threshold,
self.request_id,
&self.table_config.table_name,
"update_in_tx",
Self::run_execute(executor, &sql, ¶ms),
)
.await?;
Ok(result.rows_affected())
}
#[cfg(test)]
pub fn validate_update_data(
&self,
data: &std::collections::HashMap<String, Value>,
) -> Result<(), BaseError> {
self.validate_update_data_impl(data)
}
#[cfg(not(test))]
fn validate_update_data(
&self,
data: &std::collections::HashMap<String, Value>,
) -> Result<(), BaseError> {
self.validate_update_data_impl(data)
}
fn validate_update_data_impl(
&self,
data: &std::collections::HashMap<String, Value>,
) -> Result<(), BaseError> {
for (field_name, value) in data {
let field_config = self.table_config.get_field(field_name).ok_or_else(|| {
BaseError::FieldNotFound(self.table_config.table_name.clone(), field_name.clone())
})?;
if !field_config.permissions.can_write(&self.user_roles_set) {
return Err(BaseError::FieldPermissionDenied(
self.table_config.table_name.clone(),
field_name.clone(),
"用户无写入权限".to_string(),
));
}
field_config.validate(value)?;
}
Ok(())
}
#[cfg(test)]
#[allow(private_interfaces)]
pub fn build_update_sql(
&self,
data: &std::collections::HashMap<String, Value>,
) -> Result<(String, Vec<SqlParam>), BaseError> {
self.build_update_sql_impl(data)
}
#[cfg(not(test))]
fn build_update_sql(
&self,
data: &std::collections::HashMap<String, Value>,
) -> Result<(String, Vec<SqlParam>), BaseError> {
self.build_update_sql_impl(data)
}
fn build_update_sql_impl(
&self,
data: &std::collections::HashMap<String, Value>,
) -> Result<(String, Vec<SqlParam>), BaseError> {
if data.is_empty() {
return Err(BaseError::ParamInvalid(
"data".to_string(),
"无可更新字段".to_string(),
));
}
let need_timestamp = self
.table_config
.timestamp_fields
.as_ref()
.and_then(|ts| ts.updated_at.as_ref())
.is_some_and(|updated_at| self.table_config.fields.contains_key(updated_at));
let mut owned_data;
let working: &std::collections::HashMap<String, Value> = if need_timestamp {
owned_data = data.clone();
let ts = self.table_config.timestamp_fields.as_ref().unwrap();
let updated_at = ts.updated_at.as_ref().unwrap();
let now = chrono::Utc::now().timestamp();
owned_data.insert(updated_at.clone(), Value::Number(now.into()));
&owned_data
} else {
data
};
let mut set_clauses = Vec::with_capacity(working.len());
let mut params = Vec::with_capacity(working.len());
for (field_name, value) in working {
if !self.table_config.fields.contains_key(field_name) {
return Err(BaseError::FieldNotFound(
self.table_config.table_name.clone(),
field_name.clone(),
));
}
let quoted = self.quote_identifier(field_name)?;
set_clauses.push(format!("{} = ?", quoted));
params.push(SqlParam::from_json(value)?);
}
let mut sql = format!(
"UPDATE {} SET {}",
self.quoted_table_name()?,
set_clauses.join(", ")
);
if self.query_params.where_conditions.is_empty() && !self.allow_full_table {
return Err(BaseError::MissingWhereClause("UPDATE".to_string()));
}
self.append_where_to_sql(&mut sql, &mut params, false)?;
Ok((sql, params))
}
pub async fn delete(self) -> Result<u64, BaseError> {
if let Some(soft_delete_field) = &self.table_config.soft_delete_field {
let now = chrono::Utc::now().timestamp();
let mut data = std::collections::HashMap::new();
data.insert(soft_delete_field.clone(), Value::Number(now.into()));
let (sql, params) = self.build_update_sql_impl(&data)?;
let pool = self
.pool
.as_ref()
.ok_or(BaseError::DatabaseNotInitialized)?;
let result = Self::timed(
self.slow_threshold,
self.request_id,
&self.table_config.table_name,
"delete",
Self::run_execute(pool.as_ref(), &sql, ¶ms),
)
.await?;
return Ok(result.rows_affected());
}
let pool = self
.pool
.as_ref()
.ok_or(BaseError::DatabaseNotInitialized)?;
let (sql, params) = self.build_delete_sql()?;
let result = Self::timed(
self.slow_threshold,
self.request_id,
&self.table_config.table_name,
"delete",
Self::run_execute(pool.as_ref(), &sql, ¶ms),
)
.await?;
Ok(result.rows_affected())
}
pub async fn delete_in_tx(self, tx: &mut yang_db::Transaction) -> Result<u64, BaseError> {
if let Some(soft_delete_field) = &self.table_config.soft_delete_field {
let now = chrono::Utc::now().timestamp();
let mut data = std::collections::HashMap::new();
data.insert(soft_delete_field.clone(), Value::Number(now.into()));
let (sql, params) = self.build_update_sql_impl(&data)?;
let executor = tx.executor().ok_or_else(|| {
BaseError::DatabaseTransactionFailed(yang_db::DbError::TransactionError(
"事务已提交或回滚".to_string(),
))
})?;
let result = Self::timed(
self.slow_threshold,
self.request_id,
&self.table_config.table_name,
"delete_in_tx",
Self::run_execute(executor, &sql, ¶ms),
)
.await?;
return Ok(result.rows_affected());
}
let (sql, params) = self.build_delete_sql()?;
let executor = tx.executor().ok_or_else(|| {
BaseError::DatabaseTransactionFailed(yang_db::DbError::TransactionError(
"事务已提交或回滚".to_string(),
))
})?;
let result = Self::timed(
self.slow_threshold,
self.request_id,
&self.table_config.table_name,
"delete_in_tx",
Self::run_execute(executor, &sql, ¶ms),
)
.await?;
Ok(result.rows_affected())
}
#[cfg(test)]
#[allow(private_interfaces)]
pub fn build_delete_sql(&self) -> Result<(String, Vec<SqlParam>), BaseError> {
self.build_delete_sql_impl()
}
#[cfg(test)]
#[allow(private_interfaces)]
pub fn build_select_sql_for_test(&self) -> Result<(String, Vec<SqlParam>), BaseError> {
self.build_select_sql(None)
}
#[cfg(test)]
#[allow(private_interfaces)]
pub fn build_insert_sql_for_test(
&self,
data: std::collections::HashMap<String, Value>,
) -> Result<(String, Vec<SqlParam>), BaseError> {
let prepared = self.prepare_and_validate_insert(data)?;
self.build_insert_sql(&prepared)
}
#[cfg(not(test))]
fn build_delete_sql(&self) -> Result<(String, Vec<SqlParam>), BaseError> {
self.build_delete_sql_impl()
}
fn build_delete_sql_impl(&self) -> Result<(String, Vec<SqlParam>), BaseError> {
let mut sql = format!("DELETE FROM {}", self.quoted_table_name()?);
let mut params = Vec::new();
if self.query_params.where_conditions.is_empty() && !self.allow_full_table {
return Err(BaseError::MissingWhereClause("DELETE".to_string()));
}
self.append_where_to_sql(&mut sql, &mut params, false)?;
Ok((sql, params))
}
fn bind_execute_param<'q>(
query: sqlx::query::Query<'q, sqlx::MySql, sqlx::mysql::MySqlArguments>,
param: &SqlParam,
) -> sqlx::query::Query<'q, sqlx::MySql, sqlx::mysql::MySqlArguments> {
match param {
SqlParam::Null => query.bind(Option::<i32>::None),
SqlParam::Bool(b) => query.bind(*b),
SqlParam::Int(i) => query.bind(*i),
SqlParam::Uint(u) => query.bind(*u),
SqlParam::Float(f) => query.bind(*f),
SqlParam::String(s) => query.bind(s.clone()),
SqlParam::DateTime(dt) => query.bind(*dt),
SqlParam::Bytes(b) => query.bind(b.clone()),
SqlParam::Json(j) => query.bind(j.clone()),
}
}
pub(crate) async fn timed<F, R>(
threshold: Option<std::time::Duration>,
request_id: Option<crate::action::RequestId>,
table: &str,
op: &'static str,
fut: F,
) -> R
where
F: std::future::Future<Output = R>,
{
let threshold = match threshold {
Some(t) => t,
None => return fut.await,
};
let start = std::time::Instant::now();
let result = fut.await;
let elapsed = start.elapsed();
if elapsed >= threshold {
let elapsed_ms = elapsed.as_secs_f64() * 1000.0;
match request_id {
Some(rid) => tracing::warn!(
table = %table,
op,
elapsed_ms,
request_id = %rid,
"慢查询",
),
None => tracing::warn!(table = %table, op, elapsed_ms, "慢查询"),
}
}
result
}
async fn run_execute<'e, E>(
executor: E,
sql: &str,
params: &[SqlParam],
) -> Result<sqlx::mysql::MySqlQueryResult, BaseError>
where
E: sqlx::Executor<'e, Database = sqlx::MySql>,
{
let mut query = sqlx::query(sql);
for param in params {
query = Self::bind_execute_param(query, param);
}
query
.execute(executor)
.await
.map_err(|e| BaseError::DatabaseExecuteFailed(yang_db::DbError::from(e)))
}
async fn run_fetch_all<'e, E, T>(
executor: E,
sql: &str,
params: &[SqlParam],
) -> Result<Vec<T>, BaseError>
where
E: sqlx::Executor<'e, Database = sqlx::MySql>,
T: for<'r> sqlx::FromRow<'r, sqlx::mysql::MySqlRow> + Send + Unpin,
{
let mut query = sqlx::query_as::<_, T>(sql);
for param in params {
query = Self::bind_param(query, param);
}
query
.fetch_all(executor)
.await
.map_err(|e| BaseError::DatabaseQueryFailed(yang_db::DbError::from(e)))
}
}
#[cfg(feature = "mysql")]
#[derive(Debug, Clone)]
#[cfg_attr(test, derive(PartialEq))]
#[allow(dead_code)] pub(crate) enum SqlParam {
Null,
Bool(bool),
Int(i64),
Uint(u64),
Float(f64),
String(String),
DateTime(chrono::NaiveDateTime),
Bytes(Vec<u8>),
Json(serde_json::Value),
}
#[cfg(feature = "mysql")]
impl SqlParam {
fn from_json(value: &Value) -> Result<Self, BaseError> {
match value {
Value::Null => Ok(SqlParam::Null),
Value::Bool(b) => Ok(SqlParam::Bool(*b)),
Value::Number(n) => {
if let Some(i) = n.as_i64() {
Ok(SqlParam::Int(i))
} else if let Some(u) = n.as_u64() {
Ok(SqlParam::Uint(u))
} else if let Some(f) = n.as_f64() {
Ok(SqlParam::Float(f))
} else {
Err(BaseError::DatabaseQueryFailed(
yang_db::DbError::QueryError(format!("不支持的数字类型: {}", n)),
))
}
}
Value::String(s) => {
if let Ok(dt) = chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%dT%H:%M:%S")
.or_else(|_| chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S"))
.or_else(|_| chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%dT%H:%M:%S%.f"))
{
return Ok(SqlParam::DateTime(dt));
}
Ok(SqlParam::String(s.clone()))
}
Value::Array(_) => Ok(SqlParam::Json(value.clone())),
Value::Object(_) => Ok(SqlParam::Json(value.clone())),
}
}
}
#[cfg(all(test, feature = "mysql"))]
mod tests {
use super::*;
use std::collections::HashSet;
use std::sync::Arc;
fn test_query() -> TableQuery {
let config = Arc::new(
crate::table::TableConfig::new("users")
.field(crate::table::FieldConfig::new(
"id",
crate::table::FieldType::Integer,
))
.expect("有效字段配置应注册成功"),
);
let roles: Arc<[String]> = Arc::from(Vec::<String>::new());
TableQuery::new(config, roles, None)
}
#[test]
fn test_page_rejects_page_size_above_production_limit() {
let err = test_query()
.page(1, 101)
.expect_err("page_size 超过 100 应被拒绝");
assert!(matches!(err, BaseError::ParamInvalid(field, _) if field == "page_size"));
}
#[test]
fn test_default_order_rejects_unsortable_field() {
let config = Arc::new(
crate::table::TableConfig::new("users")
.field(
crate::table::FieldConfig::new("secret_rank", crate::table::FieldType::Integer)
.sortable(false),
)
.expect("有效字段配置应注册成功")
.default_order(vec![(
"secret_rank".to_string(),
crate::table::SortOrder::Desc,
)]),
);
let roles: Arc<[String]> = Arc::from(Vec::<String>::new());
let query = TableQuery::new(config, roles, None);
let err = query
.build_select_sql(None)
.expect_err("默认排序不应绕过 sortable(false)");
assert!(
matches!(err, BaseError::FieldPermissionDenied(table, field, _) if table == "users" && field == "secret_rank")
);
}
#[test]
fn test_select_star_rejects_unreadable_field() {
let protected_permissions = crate::table::FieldPermissions {
readable_roles: HashSet::from(["admin".to_string()]),
..crate::table::FieldPermissions::default()
};
let config = Arc::new(
crate::table::TableConfig::new("users")
.field(crate::table::FieldConfig::new(
"id",
crate::table::FieldType::Integer,
))
.expect("有效字段配置应注册成功")
.field(
crate::table::FieldConfig::new(
"secret",
crate::table::FieldType::String { max_length: 64 },
)
.permissions(protected_permissions),
)
.expect("有效字段配置应注册成功"),
);
let roles: Arc<[String]> = Arc::from(Vec::<String>::new());
let query = TableQuery::new(config, roles, None);
let err = query
.build_select_sql(None)
.expect_err("SELECT * 不应返回用户无权读取的字段");
assert!(
matches!(err, BaseError::FieldPermissionDenied(table, field, _) if table == "users" && field == "secret")
);
}
#[test]
fn test_select_projection_permission_matrix() {
let protected = crate::table::FieldPermissions {
readable_roles: HashSet::from(["admin".to_string()]),
..crate::table::FieldPermissions::default()
};
let all_readable = Arc::new(
crate::table::TableConfig::new("public_rows")
.field(crate::table::FieldConfig::new(
"id",
crate::table::FieldType::Integer,
))
.expect("公开字段配置应有效")
.field(crate::table::FieldConfig::new(
"name",
crate::table::FieldType::String { max_length: 64 },
))
.expect("公开字段配置应有效"),
);
let roles: Arc<[String]> = Arc::from(vec!["user".to_string()]);
let (sql, _) = TableQuery::new(all_readable, Arc::clone(&roles), None)
.build_select_sql(None)
.expect("全部字段可读时 SELECT * 应成功");
assert!(sql.starts_with("SELECT * FROM `public_rows`"));
let partially_readable = Arc::new(
crate::table::TableConfig::new("mixed_rows")
.field(crate::table::FieldConfig::new(
"id",
crate::table::FieldType::Integer,
))
.expect("公开字段配置应有效")
.field(
crate::table::FieldConfig::new(
"secret",
crate::table::FieldType::String { max_length: 64 },
)
.permissions(protected.clone()),
)
.expect("受限字段配置应有效"),
);
let partial_err =
TableQuery::new(Arc::clone(&partially_readable), Arc::clone(&roles), None)
.build_select_sql(None)
.expect_err("部分字段不可读时 SELECT * 应 fail-closed");
assert!(
matches!(partial_err, BaseError::FieldPermissionDenied(table, field, _) if table == "mixed_rows" && field == "secret")
);
let explicit_err = TableQuery::new(partially_readable, Arc::clone(&roles), None)
.select_fields(&["id", "secret"])
.expect_err("显式请求受限字段应被拒绝");
assert!(
matches!(explicit_err, BaseError::FieldPermissionDenied(table, field, _) if table == "mixed_rows" && field == "secret")
);
let none_readable = Arc::new(
crate::table::TableConfig::new("private_rows")
.field(
crate::table::FieldConfig::new("alpha", crate::table::FieldType::Integer)
.permissions(protected.clone()),
)
.expect("受限字段配置应有效")
.field(
crate::table::FieldConfig::new("beta", crate::table::FieldType::Integer)
.permissions(protected),
)
.expect("受限字段配置应有效"),
);
let none_err = TableQuery::new(none_readable, roles, None)
.build_select_sql(None)
.expect_err("零字段可读时 SELECT * 应 fail-closed");
assert!(matches!(
none_err,
BaseError::FieldPermissionDenied(table, _, _) if table == "private_rows"
));
}
#[test]
fn test_unreadable_field_errors_are_deterministic() {
let protected = crate::table::FieldPermissions {
readable_roles: HashSet::from(["admin".to_string()]),
..crate::table::FieldPermissions::default()
};
let user = crate::action::User::new(1, "reader").with_roles(["user"]);
for _ in 0..64 {
let config = Arc::new(
crate::table::TableConfig::new("secrets")
.field(
crate::table::FieldConfig::new(
"z_secret",
crate::table::FieldType::Integer,
)
.permissions(protected.clone()),
)
.expect("受限字段配置应有效")
.field(
crate::table::FieldConfig::new(
"a_secret",
crate::table::FieldType::Integer,
)
.permissions(protected.clone()),
)
.expect("受限字段配置应有效")
.field(
crate::table::FieldConfig::new(
"m_secret",
crate::table::FieldType::Integer,
)
.permissions(protected.clone()),
)
.expect("受限字段配置应有效"),
);
let roles: Arc<[String]> = Arc::from(vec!["user".to_string()]);
let query = TableQuery::new(config, roles, None);
let sql_err = query
.build_select_sql(None)
.expect_err("SELECT * 应拒绝受限字段");
assert!(
matches!(sql_err, BaseError::FieldPermissionDenied(_, field, _) if field == "a_secret")
);
let action_err = query
.ensure_fields_readable(&user)
.expect_err("整实体 Action 应拒绝受限字段");
assert!(
matches!(action_err, BaseError::FieldPermissionDenied(_, field, _) if field == "a_secret")
);
}
}
#[test]
fn test_effective_pagination_applies_default_limit_to_data_query_sql() {
let (query, page, page_size) = test_query()
.with_effective_pagination()
.expect("默认分页参数应合法");
assert_eq!(page, 1);
assert_eq!(
page_size,
crate::table::query_params::DEFAULT_QUERY_PAGE_SIZE
);
let (sql, _) = query
.build_select_sql(None)
.expect("默认分页后的 SELECT SQL 应可构建");
assert!(
sql.contains(&format!(
" LIMIT {} OFFSET 0",
crate::table::query_params::DEFAULT_QUERY_PAGE_SIZE
)),
"分页数据查询必须包含默认 LIMIT,实际 SQL: {sql}"
);
}
}