#![cfg(any(feature = "mysql", feature = "postgres"))]
use super::TableQuery;
use crate::action::builtin::add::ReturningTarget;
use crate::database::{AnyTransaction, AnyTransactionKind};
use crate::error::BaseError;
use crate::table::field_config::Audience;
use serde_json::Value;
fn record_into_columns(record: crate::table::Record) -> std::collections::HashMap<String, Value> {
#[cfg(feature = "mysql")]
{
record.into_columns()
}
#[cfg(not(feature = "mysql"))]
{
record.into_map().into_iter().collect()
}
}
fn json_to_u64(value: &Value) -> Option<u64> {
match value {
Value::Number(number) => number
.as_u64()
.or_else(|| number.as_i64().and_then(|value| u64::try_from(value).ok())),
Value::String(text) => text.parse().ok(),
_ => None,
}
}
#[cfg(feature = "mysql")]
struct PreparedUpsertBatch {
rows: Vec<std::collections::HashMap<String, Value>>,
tail: Vec<String>,
}
#[cfg(feature = "postgres")]
#[derive(Debug)]
struct PreparedPgUpsert {
rows: Vec<std::collections::HashMap<String, Value>>,
provided_columns: std::collections::BTreeSet<String>,
}
impl TableQuery {
pub async fn insert(self, data: crate::table::Record) -> Result<u64, BaseError> {
let data = self.prepare_and_validate_insert(record_into_columns(data))?;
match self.backend()? {
#[cfg(feature = "mysql")]
yang_db::BackendKind::MySql => {
self.compile_db_write_query()?
.insert(&data)
.await
.map_err(BaseError::DatabaseExecuteFailed)?;
}
#[cfg(feature = "postgres")]
yang_db::BackendKind::PostgreSql => {
let database = self.pg_database()?;
let query = self.register_pg_fields(
self.apply_pg_write_plan(database.table(&self.table_config.table_ref))?,
data.keys(),
)?;
query
.insert_batch(std::slice::from_ref(&data))
.await
.map_err(BaseError::DatabaseExecuteFailed)?;
}
other => {
return Err(BaseError::ConfigError(format!(
"TableQuery 不支持当前数据库后端: {other:?}"
)));
}
}
Ok(1)
}
pub async fn insert_in_tx(
self,
tx: &mut AnyTransaction,
data: crate::table::Record,
) -> Result<u64, BaseError> {
self.ensure_same_source(tx)?;
let data = self.prepare_and_validate_insert(record_into_columns(data))?;
match tx.kind_mut() {
#[cfg(feature = "mysql")]
AnyTransactionKind::MySql(tx) => {
let query = tx.table(&self.table_config.table_ref);
self.apply_write_plan(query)?
.insert(&data)
.await
.map_err(BaseError::DatabaseExecuteFailed)?;
}
#[cfg(feature = "postgres")]
AnyTransactionKind::Postgres(tx) => {
let query = tx.table(&self.table_config.table_ref);
let query =
self.register_pg_fields(self.apply_pg_write_plan(query)?, data.keys())?;
query
.insert_batch(std::slice::from_ref(&data))
.await
.map_err(BaseError::DatabaseExecuteFailed)?;
}
}
Ok(1)
}
pub async fn insert_returning(
self,
data: crate::table::Record,
target: ReturningTarget<'_>,
) -> Result<crate::table::Record, BaseError> {
if matches!(target, ReturningTarget::Pk) {
self.ensure_single_primary_key("insert_returning(ReturningTarget::Pk)")?;
}
let data = self.prepare_and_validate_insert(record_into_columns(data))?;
match self.backend()? {
#[cfg(feature = "mysql")]
yang_db::BackendKind::MySql => {
let primary_key = self.table_config.primary_key.clone();
let allowed = match target {
ReturningTarget::Pk => true,
ReturningTarget::Columns(columns) => {
columns.len() == 1 && columns[0] == primary_key.as_str()
}
ReturningTarget::All => false,
};
if !allowed {
return Err(Self::mysql_returning_unsupported("非整型主键列或整行"));
}
let value = self.mysql_insert_returning_pk(&data).await?;
Ok(crate::table::Record::new().set(primary_key, value))
}
#[cfg(feature = "postgres")]
yang_db::BackendKind::PostgreSql => self.pg_insert_returning(&data, target).await,
other => Err(BaseError::ConfigError(format!(
"TableQuery 不支持当前数据库后端: {other:?}"
))),
}
}
#[cfg_attr(not(feature = "postgres"), allow(unused_variables))]
pub async fn insert_batch_returning(
self,
data: &[crate::table::Record],
target: ReturningTarget<'_>,
) -> Result<Vec<crate::table::Record>, BaseError> {
match self.backend()? {
#[cfg(feature = "mysql")]
yang_db::BackendKind::MySql => Err(Self::mysql_batch_returning_unsupported(
"insert_batch_returning",
)),
#[cfg(feature = "postgres")]
yang_db::BackendKind::PostgreSql => {
let Some(rows) = self.prepare_pg_insert_rows(data)? else {
return Ok(Vec::new());
};
let database = self.pg_database()?;
let query = self.register_pg_fields(
self.apply_pg_write_plan(database.table(&self.table_config.table_ref))?,
rows[0].keys(),
)?;
self.apply_pg_returning_target(query, target)?
.insert_batch_returning(&rows)
.await
.map_err(BaseError::DatabaseExecuteFailed)
}
other => Err(BaseError::ConfigError(format!(
"TableQuery 不支持当前数据库后端: {other:?}"
))),
}
}
#[cfg_attr(not(feature = "postgres"), allow(unused_variables))]
pub async fn insert_batch_returning_in_tx(
self,
tx: &mut AnyTransaction,
data: &[crate::table::Record],
target: ReturningTarget<'_>,
) -> Result<Vec<crate::table::Record>, BaseError> {
self.ensure_same_source(tx)?;
match tx.kind_mut() {
#[cfg(feature = "mysql")]
AnyTransactionKind::MySql(_) => Err(Self::mysql_batch_returning_unsupported(
"insert_batch_returning_in_tx",
)),
#[cfg(feature = "postgres")]
AnyTransactionKind::Postgres(tx) => {
let Some(rows) = self.prepare_pg_insert_rows(data)? else {
return Ok(Vec::new());
};
let query = self.register_pg_fields(
self.apply_pg_write_plan(tx.table(&self.table_config.table_ref))?,
rows[0].keys(),
)?;
self.apply_pg_returning_target(query, target)?
.insert_batch_returning(&rows)
.await
.map_err(BaseError::DatabaseExecuteFailed)
}
}
}
#[cfg(feature = "postgres")]
fn prepare_pg_insert_rows(
&self,
records: &[crate::table::Record],
) -> Result<Option<Vec<std::collections::HashMap<String, Value>>>, BaseError> {
let mut rows = Vec::with_capacity(records.len());
let mut base_keys: Option<std::collections::BTreeSet<String>> = None;
for (index, record) in records.iter().enumerate() {
let prepared = self.prepare_and_validate_insert(record_into_columns(record.clone()))?;
let keys: std::collections::BTreeSet<String> = prepared.keys().cloned().collect();
match &base_keys {
Some(base) if *base != keys => {
return Err(BaseError::ParamInvalid(
"data".to_string(),
format!(
"批量 insert 第 {} 条记录提供的列集与第 1 条不一致",
index + 1
),
));
}
None => base_keys = Some(keys),
_ => {}
}
rows.push(prepared);
}
Ok((!rows.is_empty()).then_some(rows))
}
pub async fn insert_returning_pk_value(
self,
data: crate::table::Record,
) -> Result<(u64, Value), BaseError> {
self.ensure_single_primary_key("insert_returning_pk_value")?;
let data = self.prepare_and_validate_insert(record_into_columns(data))?;
match self.backend()? {
#[cfg(feature = "mysql")]
yang_db::BackendKind::MySql => {
let value = self.mysql_insert_returning_pk(&data).await?;
Ok((1, value))
}
#[cfg(feature = "postgres")]
yang_db::BackendKind::PostgreSql => {
let primary_key = self.table_config.primary_key.clone();
let record = self.pg_insert_returning(&data, ReturningTarget::Pk).await?;
let value = record.get(&primary_key).cloned().ok_or_else(|| {
BaseError::ConfigError(
"INSERT ... RETURNING 未返回主键列,无法回填主键".to_string(),
)
})?;
Ok((1, value))
}
other => Err(BaseError::ConfigError(format!(
"TableQuery 不支持当前数据库后端: {other:?}"
))),
}
}
pub async fn insert_returning_id(
self,
data: crate::table::Record,
) -> Result<(u64, u64), BaseError> {
self.ensure_integer_primary_key()?;
let (affected, value) = self.insert_returning_pk_value(data).await?;
let id = json_to_u64(&value).ok_or_else(|| {
BaseError::ParamInvalid(
"primary_key".to_string(),
format!(
"insert_returning_id 仅支持整型主键,当前主键值为 {value};\
请改用 insert_returning_pk_value() 或 insert_returning(ReturningTarget::Pk)"
),
)
})?;
Ok((affected, id))
}
pub async fn insert_returning_id_in_tx(
self,
tx: &mut AnyTransaction,
data: crate::table::Record,
) -> Result<(u64, u64), BaseError> {
self.ensure_same_source(tx)?;
self.ensure_integer_primary_key()?;
let data = self.prepare_and_validate_insert(record_into_columns(data))?;
match tx.kind_mut() {
#[cfg(feature = "mysql")]
AnyTransactionKind::MySql(tx) => {
let query = tx.table(&self.table_config.table_ref);
let id = self
.apply_write_plan(query)?
.insert(&data)
.await
.map_err(BaseError::DatabaseExecuteFailed)?;
Ok((1, id))
}
#[cfg(feature = "postgres")]
AnyTransactionKind::Postgres(tx) => {
let primary_key = self.field_ref(&self.table_config.primary_key)?;
let query = tx.table(&self.table_config.table_ref);
let query =
self.register_pg_fields(self.apply_pg_write_plan(query)?, data.keys())?;
let id = query
.returning(primary_key)
.insert(&data)
.await
.map_err(BaseError::DatabaseExecuteFailed)?;
Ok((1, id))
}
}
}
fn ensure_integer_primary_key(&self) -> Result<(), BaseError> {
let primary_key = self.ensure_single_primary_key("insert_returning_id")?;
let config = self.table_config.get_field(primary_key).ok_or_else(|| {
BaseError::FieldNotFound(
self.table_config.table_name.clone(),
primary_key.to_string(),
)
})?;
if matches!(
config.field_type,
crate::table::FieldType::Integer | crate::table::FieldType::BigInt
) {
return Ok(());
}
Err(BaseError::ParamInvalid(
"primary_key".to_string(),
format!(
"insert_returning_id 仅支持整型主键,当前主键 {}.{primary_key} 为 {:?};\
请改用 insert_returning_pk_value() / insert_returning(ReturningTarget::Pk) \
取回真实类型主键,或 insert() 并在插入后按业务键查询",
self.table_config.table_name, config.field_type
),
))
}
fn ensure_single_primary_key(&self, operation: &str) -> Result<&str, BaseError> {
if self.table_config.primary_keys.len() != 1 {
return Err(BaseError::ConfigError(format!(
"{operation} 仅支持单主键表;表 {} 的主键为 {:?}",
self.table_config.table_name, self.table_config.primary_keys
)));
}
Ok(&self.table_config.primary_key)
}
#[cfg(feature = "mysql")]
fn mysql_returning_unsupported(what: &str) -> BaseError {
BaseError::ConfigError(format!(
"MySQL 不支持 INSERT ... RETURNING(请求 {what}):只能取回整型主键;\
请改用 insert_returning(ReturningTarget::Pk) 或插入后按业务键查询"
))
}
#[cfg(feature = "mysql")]
fn mysql_batch_returning_unsupported(entry: &str) -> BaseError {
BaseError::ConfigError(format!(
"{entry} 仅支持 PostgreSQL:MySQL 没有 RETURNING,批量写入无法按真实行回填;\
请改用 PostgreSQL,或逐条写入后按业务键查询"
))
}
#[cfg(feature = "mysql")]
async fn mysql_insert_returning_pk(
&self,
data: &std::collections::HashMap<String, Value>,
) -> Result<Value, BaseError> {
self.ensure_integer_primary_key()?;
let primary_key = &self.table_config.primary_key;
if let Some(value) = data.get(primary_key).filter(|value| !value.is_null()) {
if json_to_u64(value).is_none() {
return Err(Self::mysql_returning_unsupported("非整型主键值"));
}
return Ok(value.clone());
}
let id = self
.compile_db_write_query()?
.insert(data)
.await
.map_err(BaseError::DatabaseExecuteFailed)?;
Ok(Value::Number(id.into()))
}
#[cfg(feature = "postgres")]
fn apply_pg_returning_target<'a>(
&self,
query: yang_db::postgres::QueryBuilder<'a>,
target: ReturningTarget<'_>,
) -> Result<yang_db::postgres::QueryBuilder<'a>, BaseError> {
match target {
ReturningTarget::Pk => {
self.ensure_single_primary_key("ReturningTarget::Pk")?;
Ok(query.returning(self.field_ref(&self.table_config.primary_key)?))
}
ReturningTarget::All => Ok(query.returning_all()),
ReturningTarget::Columns(columns) => {
if columns.is_empty() {
return Err(BaseError::ParamInvalid(
"columns".to_string(),
"ReturningTarget::Columns 至少需要一列".to_string(),
));
}
for name in columns {
if !self.table_config.fields.contains_key(*name) {
return Err(BaseError::FieldNotFound(
self.table_config.table_name.clone(),
(*name).to_string(),
));
}
}
let refs = self.pg_field_refs(columns)?;
Ok(query.returning_columns(&refs))
}
}
}
#[cfg(feature = "postgres")]
async fn pg_insert_returning(
&self,
data: &std::collections::HashMap<String, Value>,
target: ReturningTarget<'_>,
) -> Result<crate::table::Record, BaseError> {
let database = self.pg_database()?;
let query = self.register_pg_fields(
self.apply_pg_write_plan(database.table(&self.table_config.table_ref))?,
data.keys(),
)?;
self.apply_pg_returning_target(query, target)?
.insert_returning(data)
.await
.map_err(BaseError::DatabaseExecuteFailed)
}
#[cfg(feature = "postgres")]
pub async fn upsert_batch(
self,
rows: Vec<crate::table::Record>,
conflict_columns: &[&str],
) -> Result<u64, BaseError> {
let Some(prepared) = self.prepare_pg_upsert_rows(rows, conflict_columns)? else {
return Ok(0);
};
self.execute_pg_upsert_batch(prepared, conflict_columns, None, None, false)
.await
}
#[cfg_attr(not(feature = "postgres"), allow(unused_variables))]
pub async fn upsert_batch_returning(
self,
rows: Vec<crate::table::Record>,
conflict_columns: &[&str],
target: ReturningTarget<'_>,
) -> Result<Vec<crate::table::Record>, BaseError> {
match self.backend()? {
#[cfg(feature = "mysql")]
yang_db::BackendKind::MySql => Err(Self::mysql_batch_returning_unsupported(
"upsert_batch_returning",
)),
#[cfg(feature = "postgres")]
yang_db::BackendKind::PostgreSql => {
let Some(prepared) = self.prepare_pg_upsert_rows(rows, conflict_columns)? else {
return Ok(Vec::new());
};
let database = self.pg_database()?;
let conflicts = self.pg_field_refs(conflict_columns)?;
let query = self.register_pg_fields(
database.table(&self.table_config.table_ref),
prepared.rows[0].keys(),
)?;
let columns = self.resolve_pg_update_columns(&prepared, conflict_columns, None)?;
let query = if columns.is_empty() {
query.do_nothing()
} else {
let names: Vec<&str> = columns.iter().map(String::as_str).collect();
query.update_columns(&self.pg_field_refs(&names)?)
};
self.apply_pg_returning_target(query, target)?
.upsert_batch_returning(&prepared.rows, &conflicts)
.await
.map_err(BaseError::DatabaseExecuteFailed)
}
other => Err(BaseError::ConfigError(format!(
"TableQuery 不支持当前数据库后端: {other:?}"
))),
}
}
#[cfg(feature = "postgres")]
pub async fn upsert_batch_with_update_columns(
self,
rows: Vec<crate::table::Record>,
conflict_columns: &[&str],
update_columns: &[&str],
) -> Result<u64, BaseError> {
let Some(prepared) = self.prepare_pg_upsert_rows(rows, conflict_columns)? else {
return Ok(0);
};
self.execute_pg_upsert_batch(
prepared,
conflict_columns,
None,
Some(update_columns),
false,
)
.await
}
#[cfg(feature = "postgres")]
pub async fn upsert_batch_do_nothing(
self,
rows: Vec<crate::table::Record>,
conflict_columns: &[&str],
) -> Result<u64, BaseError> {
let Some(prepared) = self.prepare_pg_upsert_rows(rows, conflict_columns)? else {
return Ok(0);
};
self.execute_pg_upsert_batch(prepared, conflict_columns, None, None, true)
.await
}
#[cfg(feature = "postgres")]
pub async fn upsert_batch_with_conflict_predicate(
self,
rows: Vec<crate::table::Record>,
conflict_columns: &[&str],
predicate: Option<&str>,
) -> Result<u64, BaseError> {
let Some(prepared) = self.prepare_pg_upsert_rows(rows, conflict_columns)? else {
return Ok(0);
};
self.execute_pg_upsert_batch(prepared, conflict_columns, predicate, None, false)
.await
}
pub async fn upsert_batch_in_tx(
self,
tx: &mut AnyTransaction,
rows: Vec<crate::table::Record>,
columns: &[&str],
) -> Result<u64, BaseError> {
self.ensure_same_source(tx)?;
match tx.kind_mut() {
#[cfg(feature = "mysql")]
AnyTransactionKind::MySql(tx) => {
let Some(batch) = self.plan_upsert_batch(rows, columns)? else {
return Ok(0);
};
tx.table(&self.table_config.table_ref)
.upsert_batch(&batch.rows, &batch.tail)
.await
.map_err(BaseError::DatabaseExecuteFailed)
}
#[cfg(feature = "postgres")]
AnyTransactionKind::Postgres(tx) => {
let Some(prepared) = self.prepare_pg_upsert_rows(rows, columns)? else {
return Ok(0);
};
self.execute_pg_upsert_batch_in_tx(tx, &prepared, columns, None, None, false)
.await
}
}
}
#[cfg(feature = "postgres")]
pub async fn upsert_batch_in_tx_with_update_columns(
self,
tx: &mut AnyTransaction,
rows: Vec<crate::table::Record>,
conflict_columns: &[&str],
update_columns: &[&str],
) -> Result<u64, BaseError> {
self.ensure_same_source(tx)?;
match tx.kind_mut() {
AnyTransactionKind::Postgres(tx) => {
let Some(prepared) = self.prepare_pg_upsert_rows(rows, conflict_columns)? else {
return Ok(0);
};
self.execute_pg_upsert_batch_in_tx(
tx,
&prepared,
conflict_columns,
None,
Some(update_columns),
false,
)
.await
}
#[cfg(feature = "mysql")]
AnyTransactionKind::MySql(_) => Err(BaseError::ConfigError(
"upsert_batch_in_tx_with_update_columns 仅支持 PostgreSQL;MySQL 请使用 upsert_batch_in_tx(rows, update_columns) 的 ON DUPLICATE KEY UPDATE 语义"
.to_string(),
)),
}
}
#[cfg(feature = "postgres")]
pub async fn upsert_batch_do_nothing_in_tx(
self,
tx: &mut AnyTransaction,
rows: Vec<crate::table::Record>,
conflict_columns: &[&str],
) -> Result<u64, BaseError> {
self.ensure_same_source(tx)?;
match tx.kind_mut() {
AnyTransactionKind::Postgres(tx) => {
let Some(prepared) = self.prepare_pg_upsert_rows(rows, conflict_columns)? else {
return Ok(0);
};
self.execute_pg_upsert_batch_in_tx(tx, &prepared, conflict_columns, None, None, true)
.await
}
#[cfg(feature = "mysql")]
AnyTransactionKind::MySql(_) => Err(BaseError::ConfigError(
"upsert_batch_do_nothing_in_tx 仅支持 PostgreSQL;MySQL 请使用 upsert_batch_in_tx 的 ON DUPLICATE KEY UPDATE 语义"
.to_string(),
)),
}
}
pub async fn upsert_batch_in_tx_with_conflict_predicate(
self,
tx: &mut AnyTransaction,
rows: Vec<crate::table::Record>,
columns: &[&str],
predicate: Option<&str>,
) -> Result<u64, BaseError> {
self.ensure_same_source(tx)?;
match tx.kind_mut() {
#[cfg(feature = "mysql")]
AnyTransactionKind::MySql(tx) => {
if let Some(predicate) = predicate {
return Err(BaseError::ConfigError(format!(
"MySQL 不支持 ON DUPLICATE KEY UPDATE 的冲突谓词(收到 `{predicate}`);\
请改用 PostgreSQL,或去掉谓词后使用 upsert_batch_in_tx"
)));
}
let Some(batch) = self.plan_upsert_batch(rows, columns)? else {
return Ok(0);
};
tx.table(&self.table_config.table_ref)
.upsert_batch(&batch.rows, &batch.tail)
.await
.map_err(BaseError::DatabaseExecuteFailed)
}
#[cfg(feature = "postgres")]
AnyTransactionKind::Postgres(tx) => {
let Some(prepared) = self.prepare_pg_upsert_rows(rows, columns)? else {
return Ok(0);
};
self.execute_pg_upsert_batch_in_tx(tx, &prepared, columns, predicate, None, false)
.await
}
}
}
#[cfg(feature = "postgres")]
fn prepare_pg_upsert_rows(
&self,
rows: Vec<crate::table::Record>,
conflict_columns: &[&str],
) -> Result<Option<PreparedPgUpsert>, BaseError> {
let total = rows.len();
if total == 0 {
return Ok(None);
}
if !self.query_params.where_conditions.is_empty() || !self.any_conditions.is_empty() {
return Err(BaseError::ParamInvalid(
"where".to_string(),
"批量 upsert 不支持 where / where_any 条件:ON CONFLICT 没有 WHERE,条件会被静默忽略"
.to_string(),
));
}
if self.table_config.soft_delete_field.is_some() && !self.include_trashed {
return Err(BaseError::ParamInvalid(
"soft_delete_field".to_string(),
"该表配置了软删字段,而批量 upsert 无法表达软删守卫;要么改用 update_in_tx,要么先 with_trashed()"
.to_string(),
));
}
if conflict_columns.is_empty() {
return Err(BaseError::ParamInvalid(
"conflict_columns".to_string(),
"PostgreSQL 批量 upsert 必须显式指定冲突列(ON CONFLICT 目标)".to_string(),
));
}
for name in conflict_columns {
if !self.table_config.fields.contains_key(*name) {
return Err(BaseError::FieldNotFound(
self.table_config.table_name.clone(),
(*name).to_string(),
));
}
}
if let Some(tenant_field) = self.tenant_key_field() {
if !conflict_columns.contains(&tenant_field) {
return Err(BaseError::ParamInvalid(
"conflict_columns".to_string(),
format!(
"表 {} 声明了租户字段 `{tenant_field}`,批量 upsert 的冲突列必须包含该字段,否则会跨租户改写",
self.table_config.table_name
),
));
}
}
let mut prepared_rows = Vec::with_capacity(total);
let mut base_keys: Option<std::collections::BTreeSet<String>> = None;
let mut provided_columns = std::collections::BTreeSet::new();
for (index, record) in rows.into_iter().enumerate() {
let provided: std::collections::BTreeSet<String> =
record.as_map().keys().cloned().collect();
if index == 0 {
provided_columns = provided.clone();
} else if provided != provided_columns {
return Err(BaseError::ParamInvalid(
"rows".to_string(),
format!(
"批量 upsert 第 {} 条记录提供的列集与第 1 条不一致",
index + 1
),
));
}
let prepared = self.prepare_and_validate_insert(record_into_columns(record))?;
let keys: std::collections::BTreeSet<String> = prepared.keys().cloned().collect();
match &base_keys {
Some(base) if *base != keys => {
return Err(BaseError::ParamInvalid(
"rows".to_string(),
format!(
"批量 upsert 第 {} 条记录提供的列集与第 1 条不一致",
index + 1
),
));
}
None => base_keys = Some(keys),
_ => {}
}
for name in conflict_columns {
if !prepared.contains_key(*name) {
return Err(BaseError::ParamInvalid(
"conflict_columns".to_string(),
format!("冲突列 `{name}` 不在第 {} 条待写记录里", index + 1),
));
}
}
prepared_rows.push(prepared);
}
Ok(Some(PreparedPgUpsert {
rows: prepared_rows,
provided_columns,
}))
}
#[cfg(feature = "postgres")]
fn pg_field_refs(&self, columns: &[&str]) -> Result<Vec<&yang_db::FieldRef>, BaseError> {
columns.iter().map(|name| self.field_ref(name)).collect()
}
#[cfg(feature = "postgres")]
fn tenant_key_field(&self) -> Option<&str> {
self.table_config
.fields
.iter()
.find_map(|(name, field)| field.tenant_key.then_some(name.as_str()))
}
fn is_framework_owned_column(&self, name: &str) -> bool {
if self
.table_config
.primary_keys
.iter()
.any(|primary| primary == name)
{
return true;
}
if let Some((tenant_field, _)) = &self.tenant_scope {
if tenant_field == name {
return true;
}
}
if self
.table_config
.get_field(name)
.is_some_and(|field| field.tenant_key || field.auto_increment)
{
return true;
}
if let Some(ts) = &self.table_config.timestamp_fields {
if ts.created_at.as_deref() == Some(name) || ts.deleted_at.as_deref() == Some(name) {
return true;
}
}
matches!(name, "created_at" | "tenant_id")
}
#[cfg(feature = "postgres")]
fn is_default_upsert_excluded_column(&self, name: &str) -> bool {
self.is_framework_owned_column(name) || matches!(name, "source_file" | "company")
}
#[cfg(feature = "postgres")]
fn default_pg_update_columns(
&self,
insert_columns: &[String],
conflict_columns: &[&str],
) -> Vec<String> {
insert_columns
.iter()
.filter(|name| !conflict_columns.contains(&name.as_str()))
.filter(|name| !self.is_default_upsert_excluded_column(name))
.cloned()
.collect()
}
#[cfg(feature = "postgres")]
fn validate_pg_update_columns(
&self,
provided_columns: &std::collections::BTreeSet<String>,
conflict_columns: &[&str],
update_columns: &[&str],
) -> Result<Vec<String>, BaseError> {
if update_columns.is_empty() {
return Err(BaseError::ParamInvalid(
"update_columns".to_string(),
"批量 upsert 至少需要一个可更新列".to_string(),
));
}
let mut columns = Vec::with_capacity(update_columns.len());
for name in update_columns {
if !self.table_config.fields.contains_key(*name) {
return Err(BaseError::FieldNotFound(
self.table_config.table_name.clone(),
(*name).to_string(),
));
}
if conflict_columns.contains(name) {
return Err(BaseError::ParamInvalid(
"update_columns".to_string(),
format!("更新列 `{name}` 是冲突列,不能出现在 DO UPDATE SET 里"),
));
}
if !provided_columns.contains(*name) {
return Err(BaseError::ParamInvalid(
"update_columns".to_string(),
format!("更新列 `{name}` 不在调用方提供的待写列里"),
));
}
if self.is_framework_owned_column(name) {
return Err(BaseError::ParamInvalid(
"update_columns".to_string(),
format!("更新列 `{name}` 是主键/租户/创建时间等框架保护列,不能被 upsert 覆盖"),
));
}
if !columns.iter().any(|existing| existing == name) {
columns.push((*name).to_string());
}
}
if let Some(updated_at) = self
.table_config
.timestamp_fields
.as_ref()
.and_then(|fields| fields.updated_at.as_ref())
.filter(|name| self.table_config.fields.contains_key(*name))
{
if !columns.iter().any(|existing| existing == updated_at) {
columns.push(updated_at.clone());
}
}
Ok(columns)
}
#[cfg(feature = "postgres")]
fn resolve_pg_update_columns(
&self,
prepared: &PreparedPgUpsert,
conflict_columns: &[&str],
update_columns: Option<&[&str]>,
) -> Result<Vec<String>, BaseError> {
match update_columns {
Some(explicit) => self.validate_pg_update_columns(
&prepared.provided_columns,
conflict_columns,
explicit,
),
None => {
let insert_columns: Vec<String> = prepared.rows[0].keys().cloned().collect();
Ok(self.default_pg_update_columns(&insert_columns, conflict_columns))
}
}
}
#[cfg(feature = "postgres")]
async fn execute_pg_upsert_batch(
self,
prepared: PreparedPgUpsert,
conflict_columns: &[&str],
conflict_predicate: Option<&str>,
update_columns: Option<&[&str]>,
do_nothing: bool,
) -> Result<u64, BaseError> {
let database = self.pg_database()?;
let conflicts = self.pg_field_refs(conflict_columns)?;
let query = self.register_pg_fields(
database.table(&self.table_config.table_ref),
prepared.rows[0].keys(),
)?;
let query = match conflict_predicate {
Some(predicate) => query.on_conflict_with_predicate(&conflicts, predicate),
None => query,
};
let query = if do_nothing {
query.do_nothing()
} else {
let columns =
self.resolve_pg_update_columns(&prepared, conflict_columns, update_columns)?;
if columns.is_empty() {
query.do_nothing()
} else {
let names: Vec<&str> = columns.iter().map(String::as_str).collect();
let refs = self.pg_field_refs(&names)?;
query.update_columns(&refs)
}
};
query
.upsert_batch(&prepared.rows, &conflicts)
.await
.map_err(BaseError::DatabaseExecuteFailed)
}
#[cfg(feature = "postgres")]
async fn execute_pg_upsert_batch_in_tx(
&self,
tx: &mut yang_db::postgres::Transaction,
prepared: &PreparedPgUpsert,
conflict_columns: &[&str],
conflict_predicate: Option<&str>,
update_columns: Option<&[&str]>,
do_nothing: bool,
) -> Result<u64, BaseError> {
let conflicts = self.pg_field_refs(conflict_columns)?;
let query = self.register_pg_fields(
tx.table(&self.table_config.table_ref),
prepared.rows[0].keys(),
)?;
let query = match conflict_predicate {
Some(predicate) => query.on_conflict_with_predicate(&conflicts, predicate),
None => query,
};
let query = if do_nothing {
query.do_nothing()
} else {
let columns =
self.resolve_pg_update_columns(prepared, conflict_columns, update_columns)?;
if columns.is_empty() {
query.do_nothing()
} else {
let names: Vec<&str> = columns.iter().map(String::as_str).collect();
let refs = self.pg_field_refs(&names)?;
query.update_columns(&refs)
}
};
query
.upsert_batch(&prepared.rows, &conflicts)
.await
.map_err(BaseError::DatabaseExecuteFailed)
}
#[cfg(feature = "mysql")]
fn plan_upsert_batch(
&self,
rows: Vec<crate::table::Record>,
update_columns: &[&str],
) -> Result<Option<PreparedUpsertBatch>, BaseError> {
let total = rows.len();
let mut records = rows.into_iter();
let Some(first) = records.next() else {
return Ok(None);
};
if !self.query_params.where_conditions.is_empty() {
return Err(BaseError::ParamInvalid(
"where".to_string(),
"批量 upsert 不支持 where 条件:ON DUPLICATE KEY UPDATE 没有 WHERE,条件会被静默忽略"
.to_string(),
));
}
if self.table_config.soft_delete_field.is_some() && !self.include_trashed {
return Err(BaseError::ParamInvalid(
"soft_delete_field".to_string(),
"该表配置了软删字段,而批量 upsert 无法表达软删守卫;要么改用 update_in_tx,要么先 with_trashed()"
.to_string(),
));
}
let first_provided: std::collections::BTreeSet<String> =
first.as_map().keys().cloned().collect();
let first_prepared = self.prepare_and_validate_insert(record_into_columns(first))?;
let first_prepared_keys: std::collections::BTreeSet<String> =
first_prepared.keys().cloned().collect();
let mut prepared_rows = Vec::with_capacity(total);
prepared_rows.push(first_prepared);
for (offset, record) in records.enumerate() {
let provided: std::collections::BTreeSet<String> =
record.as_map().keys().cloned().collect();
let prepared = self.prepare_and_validate_insert(record_into_columns(record))?;
let prepared_keys: std::collections::BTreeSet<String> =
prepared.keys().cloned().collect();
let row_number = offset + 2;
if provided != first_provided {
return Err(BaseError::ParamInvalid(
"rows".to_string(),
format!("批量 upsert 第 {row_number} 条记录提供的列集与第 1 条不一致"),
));
}
if prepared_keys != first_prepared_keys {
return Err(BaseError::ParamInvalid(
"rows".to_string(),
format!("批量 upsert 第 {row_number} 条记录提供的列集与第 1 条不一致"),
));
}
prepared_rows.push(prepared);
}
if update_columns.is_empty() {
return Err(BaseError::ParamInvalid(
"update_columns".to_string(),
"批量 upsert 至少需要一个可更新列(ON DUPLICATE KEY UPDATE 的赋值列)".to_string(),
));
}
for name in update_columns {
if !first_provided.contains(*name) {
return Err(BaseError::ParamInvalid(
"update_columns".to_string(),
format!(
"赋值列 `{name}` 不在调用方提供的列里(框架补出来的默认值与 created_at 不能当赋值列)"
),
));
}
if self
.table_config
.get_field(name)
.is_some_and(|field| field.auto_increment)
{
return Err(BaseError::ParamInvalid(
"update_columns".to_string(),
format!("赋值列 `{name}` 是自增列,不能出现在 ON DUPLICATE KEY UPDATE 里"),
));
}
}
for name in update_columns {
if self.is_framework_owned_column(name) {
return Err(BaseError::ParamInvalid(
"update_columns".to_string(),
format!("赋值列 `{name}` 是主键/租户/创建时间等框架保护列,不能被 upsert 覆盖"),
));
}
}
let mut tail: Vec<String> = Vec::with_capacity(update_columns.len() + 1);
for name in update_columns {
if !tail.iter().any(|existing| existing.as_str() == *name) {
tail.push((*name).to_string());
}
}
if let Some(updated_at) = self
.table_config
.timestamp_fields
.as_ref()
.and_then(|fields| fields.updated_at.as_ref())
.filter(|name| self.table_config.fields.contains_key(*name))
{
if !tail.iter().any(|existing| existing == updated_at) {
tail.push(updated_at.clone());
}
}
Ok(Some(PreparedUpsertBatch {
rows: prepared_rows,
tail,
}))
}
pub(crate) fn prepare_and_validate_insert(
&self,
data: std::collections::HashMap<String, Value>,
) -> Result<std::collections::HashMap<String, Value>, BaseError> {
let mut prepared = data;
if let Some((field, value)) = &self.tenant_scope {
if prepared.contains_key(field) {
return Err(BaseError::PermissionDenied(format!(
"禁止显式写入租户字段: {field}"
)));
}
prepared.insert(field.clone(), value.clone());
}
for (field_name, value) in &prepared {
let field_config = self.table_config.get_field(field_name).ok_or_else(|| {
BaseError::FieldNotFound(self.table_config.table_name.clone(), field_name.clone())
})?;
let omitted_auto_increment = field_config.auto_increment && value.is_null();
let injected_tenant = self
.tenant_scope
.as_ref()
.is_some_and(|(tenant_field, _)| tenant_field == field_name);
if !injected_tenant
&& !omitted_auto_increment
&& !field_config.permissions.can_write(&self.user_roles_set)
{
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 field_config.auto_increment
&& prepared
.get(field_name)
.map(serde_json::Value::is_null)
.unwrap_or(true)
{
prepared.remove(field_name);
}
}
for (field_name, field_config) in &self.table_config.fields {
if field_config.auto_increment {
continue;
}
if let Some(default) = &field_config.default_value {
if !prepared.contains_key(field_name) {
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;
}
if field_config.auto_increment && !prepared.contains_key(field_name) {
continue;
}
let value = prepared.get(field_name).unwrap_or(&Value::Null);
field_config.validate(value, &self.regex_cache)?;
}
Ok(prepared)
}
fn ensure_soft_delete_write_has_where(&self, op: &str) -> Result<(), BaseError> {
if self.include_trashed || self.table_config.soft_delete_field.is_none() {
return Ok(());
}
if self.query_params.where_conditions.is_empty() && self.any_conditions.is_empty() {
return Err(BaseError::MissingWhereClause(op.to_string()));
}
Ok(())
}
pub async fn update(self, data: crate::table::Record) -> Result<u64, BaseError> {
let data = self.prepare_update_data(record_into_columns(data))?;
self.ensure_soft_delete_write_has_where("UPDATE")?;
match self.backend()? {
#[cfg(feature = "mysql")]
yang_db::BackendKind::MySql => self
.compile_db_write_query()?
.update(&data)
.await
.map_err(BaseError::DatabaseExecuteFailed),
#[cfg(feature = "postgres")]
yang_db::BackendKind::PostgreSql => {
let database = self.pg_database()?;
let query = self.register_pg_fields(
self.apply_pg_write_plan(database.table(&self.table_config.table_ref))?,
data.keys(),
)?;
query
.update(&data)
.await
.map_err(BaseError::DatabaseExecuteFailed)
}
other => Err(BaseError::ConfigError(format!(
"TableQuery 不支持当前数据库后端: {other:?}"
))),
}
}
pub async fn update_in_tx(
self,
tx: &mut AnyTransaction,
data: crate::table::Record,
) -> Result<u64, BaseError> {
self.ensure_same_source(tx)?;
let data = self.prepare_update_data(record_into_columns(data))?;
self.ensure_soft_delete_write_has_where("UPDATE")?;
match tx.kind_mut() {
#[cfg(feature = "mysql")]
AnyTransactionKind::MySql(tx) => {
let query = tx.table(&self.table_config.table_ref);
self.apply_write_plan(query)?
.update(&data)
.await
.map_err(BaseError::DatabaseExecuteFailed)
}
#[cfg(feature = "postgres")]
AnyTransactionKind::Postgres(tx) => {
let query = tx.table(&self.table_config.table_ref);
let query =
self.register_pg_fields(self.apply_pg_write_plan(query)?, data.keys())?;
query
.update(&data)
.await
.map_err(BaseError::DatabaseExecuteFailed)
}
}
}
fn prepare_update_data(
&self,
data: std::collections::HashMap<String, Value>,
) -> Result<std::collections::HashMap<String, Value>, BaseError> {
self.validate_update_data(&data)?;
self.with_updated_timestamp(data)
}
fn with_updated_timestamp(
&self,
mut data: std::collections::HashMap<String, Value>,
) -> Result<std::collections::HashMap<String, Value>, BaseError> {
if data.is_empty() {
return Err(BaseError::ParamInvalid(
"data".to_string(),
"无可更新字段".to_string(),
));
}
if let Some(updated_at) = self
.table_config
.timestamp_fields
.as_ref()
.and_then(|fields| fields.updated_at.as_ref())
.filter(|name| self.table_config.fields.contains_key(*name))
{
data.insert(
updated_at.clone(),
Value::Number(chrono::Utc::now().timestamp().into()),
);
}
Ok(data)
}
#[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> {
if data.is_empty() {
return Err(BaseError::ParamInvalid(
"data".to_string(),
"至少需要一个更新字段".to_string(),
));
}
self.validate_update_fields(data, None)
}
fn validate_update_fields(
&self,
data: &std::collections::HashMap<String, Value>,
skip: Option<&str>,
) -> Result<(), BaseError> {
for (field_name, value) in data {
if skip.is_some_and(|name| name == field_name) {
continue;
}
if self
.tenant_scope
.as_ref()
.is_some_and(|(tenant_field, _)| tenant_field == field_name)
{
return Err(BaseError::PermissionDenied(format!(
"禁止修改租户字段: {field_name}"
)));
}
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, &self.regex_cache)?;
}
Ok(())
}
fn prepare_soft_delete_data(
&self,
data: std::collections::HashMap<String, Value>,
) -> Result<std::collections::HashMap<String, Value>, BaseError> {
let framework_managed = self.table_config.soft_delete_field.as_ref().filter(|name| {
self.table_config
.get_field(name)
.is_some_and(|field| matches!(field.permissions.writable, Audience::Nobody))
});
self.validate_update_fields(&data, framework_managed.map(String::as_str))?;
self.with_updated_timestamp(data)
}
#[allow(clippy::type_complexity)]
#[cfg(all(test, feature = "mysql"))]
pub fn upsert_batch_plan_for_test(
&self,
rows: Vec<crate::table::Record>,
update_columns: &[&str],
) -> Result<Option<(Vec<std::collections::HashMap<String, Value>>, Vec<String>)>, BaseError>
{
Ok(self
.plan_upsert_batch(rows, update_columns)?
.map(|batch| (batch.rows, batch.tail)))
}
pub async fn delete(self) -> Result<u64, BaseError> {
if let Some(soft_delete_field) = self.table_config.soft_delete_field.clone() {
let data = self.prepare_soft_delete_data(std::collections::HashMap::from([(
soft_delete_field,
Value::Number(chrono::Utc::now().timestamp().into()),
)]))?;
self.ensure_soft_delete_write_has_where("DELETE")?;
return self.execute_soft_delete(data).await;
}
self.execute_physical_delete().await
}
async fn execute_soft_delete(
self,
data: std::collections::HashMap<String, Value>,
) -> Result<u64, BaseError> {
match self.backend()? {
#[cfg(feature = "mysql")]
yang_db::BackendKind::MySql => self
.compile_db_write_query()?
.update(&data)
.await
.map_err(BaseError::DatabaseExecuteFailed),
#[cfg(feature = "postgres")]
yang_db::BackendKind::PostgreSql => {
let database = self.pg_database()?;
let query = self.register_pg_fields(
self.apply_pg_write_plan(database.table(&self.table_config.table_ref))?,
data.keys(),
)?;
query
.update(&data)
.await
.map_err(BaseError::DatabaseExecuteFailed)
}
other => Err(BaseError::ConfigError(format!(
"TableQuery 不支持当前数据库后端: {other:?}"
))),
}
}
async fn execute_physical_delete(self) -> Result<u64, BaseError> {
match self.backend()? {
#[cfg(feature = "mysql")]
yang_db::BackendKind::MySql => self
.compile_db_write_query()?
.delete()
.await
.map_err(BaseError::DatabaseExecuteFailed),
#[cfg(feature = "postgres")]
yang_db::BackendKind::PostgreSql => {
let database = self.pg_database()?;
self.apply_pg_write_plan(database.table(&self.table_config.table_ref))?
.delete()
.await
.map_err(BaseError::DatabaseExecuteFailed)
}
other => Err(BaseError::ConfigError(format!(
"TableQuery 不支持当前数据库后端: {other:?}"
))),
}
}
pub async fn delete_in_tx(self, tx: &mut AnyTransaction) -> Result<u64, BaseError> {
self.ensure_same_source(tx)?;
let soft_delete_data = self
.table_config
.soft_delete_field
.clone()
.map(|field| {
self.prepare_soft_delete_data(std::collections::HashMap::from([(
field,
Value::Number(chrono::Utc::now().timestamp().into()),
)]))
})
.transpose()?;
self.ensure_soft_delete_write_has_where("DELETE")?;
match tx.kind_mut() {
#[cfg(feature = "mysql")]
AnyTransactionKind::MySql(tx) => {
let query = tx.table(&self.table_config.table_ref);
if let Some(data) = soft_delete_data {
return self
.apply_write_plan(query)?
.update(&data)
.await
.map_err(BaseError::DatabaseExecuteFailed);
}
self.apply_write_plan(query)?
.delete()
.await
.map_err(BaseError::DatabaseExecuteFailed)
}
#[cfg(feature = "postgres")]
AnyTransactionKind::Postgres(tx) => {
let query = tx.table(&self.table_config.table_ref);
if let Some(data) = soft_delete_data {
let query =
self.register_pg_fields(self.apply_pg_write_plan(query)?, data.keys())?;
return query
.update(&data)
.await
.map_err(BaseError::DatabaseExecuteFailed);
}
self.apply_pg_write_plan(query)?
.delete()
.await
.map_err(BaseError::DatabaseExecuteFailed)
}
}
}
}
#[cfg(all(test, feature = "postgres"))]
mod pg_tests {
use super::*;
use crate::table::{Field, Record, Table};
use std::sync::Arc;
fn lazy_query(table: Table) -> TableQuery {
let definition = table.build().expect("测试表定义应有效");
TableQuery::new(
definition.shared_config(),
Arc::from(Vec::<String>::new()),
None,
)
}
#[test]
fn pg_upsert_rejects_where_any_conditions() {
let mut query = lazy_query(Table::new("pg_upsert_where_any").fields([
Field::id("id"),
Field::string("option_key", 64).required(),
Field::string("label", 64).required(),
]));
query
.any_conditions
.push(("option_key".to_string(), vec![serde_json::json!("opt_a")]));
let rows = vec![Record::new().set("option_key", "opt_a").set("label", "x")];
let error = query
.prepare_pg_upsert_rows(rows, &["option_key"])
.expect_err("where_any 条件不得在批量 upsert 中被静默忽略");
match error {
BaseError::ParamInvalid(field, message) => {
assert_eq!(field, "where");
assert!(
message.contains("where_any"),
"错误信息应点名 where_any: {message}"
);
}
other => panic!("应返回 ParamInvalid,实际: {other:?}"),
}
}
#[test]
fn insert_returning_id_rejects_non_integer_primary_key() {
let query = lazy_query(Table::new("pg_string_pk").fields([
Field::string("code", 32).primary_key().required(),
Field::string("name", 32).required(),
]));
let error = query
.ensure_integer_primary_key()
.expect_err("字符串主键必须被拒绝");
match error {
BaseError::ParamInvalid(field, message) => {
assert_eq!(field, "primary_key");
assert!(
message.contains("insert_returning_id"),
"错误信息应指引到 insert_returning_id: {message}"
);
assert!(
message.contains("insert()"),
"错误信息应给出替代入口: {message}"
);
}
other => panic!("应返回 ParamInvalid,实际: {other:?}"),
}
}
#[test]
fn insert_returning_id_accepts_integer_primary_key() {
let query = lazy_query(
Table::new("pg_int_pk").fields([Field::id("id"), Field::string("name", 32).required()]),
);
query.ensure_integer_primary_key().expect("整型主键应放行");
}
#[test]
fn pg_upsert_requires_tenant_key_in_conflict_columns() {
let query = lazy_query(Table::new("pg_upsert_tenant_conflict").fields([
Field::id("id"),
Field::bigint("tenant_id").tenant_key(),
Field::string("option_key", 64).required(),
Field::string("label", 64).required(),
]));
let rows = vec![Record::new()
.set("tenant_id", 1_i64)
.set("option_key", "opt_a")
.set("label", "x")];
let error = query
.prepare_pg_upsert_rows(rows, &["option_key"])
.expect_err("缺少租户冲突列必须拒绝");
match error {
BaseError::ParamInvalid(field, message) => {
assert_eq!(field, "conflict_columns");
assert!(
message.contains("tenant_id"),
"错误信息应点名租户字段: {message}"
);
}
other => panic!("应返回 ParamInvalid,实际: {other:?}"),
}
}
#[test]
fn pg_default_update_columns_exclude_tenant_key() {
let query = lazy_query(Table::new("pg_upsert_tenant_whitelist").fields([
Field::id("id"),
Field::bigint("tenant_id").tenant_key(),
Field::string("option_key", 64).required(),
Field::string("label", 64).required(),
]));
let rows = vec![Record::new()
.set("tenant_id", 1_i64)
.set("option_key", "opt_a")
.set("label", "x")];
let prepared = query
.prepare_pg_upsert_rows(rows, &["tenant_id", "option_key"])
.expect("含租户冲突列应通过校验")
.expect("非空批应产出计划");
let insert_columns: Vec<String> = prepared.rows[0].keys().cloned().collect();
let update_columns =
query.default_pg_update_columns(&insert_columns, &["tenant_id", "option_key"]);
assert!(
!update_columns.contains(&"tenant_id".to_string()),
"默认白名单不得包含租户列: {update_columns:?}"
);
assert!(
update_columns.contains(&"label".to_string()),
"非保护业务列应在默认白名单内: {update_columns:?}"
);
}
}
#[cfg(all(test, feature = "mysql"))]
mod batch_returning_mysql_tests {
use super::*;
use crate::database::AnyPool;
use crate::table::{Field, Record, Table};
use std::sync::Arc;
fn lazy_mysql_query(table: Table) -> TableQuery {
let definition = table.build().expect("测试表定义应有效");
let pool = sqlx::mysql::MySqlPoolOptions::new()
.connect_lazy("mysql://root@127.0.0.1:3306/test")
.expect("懒连接池构造不应触发网络连接");
TableQuery::new(
definition.shared_config(),
Arc::from(Vec::<String>::new()),
Some(AnyPool::MySql(Arc::new(pool))),
)
}
#[tokio::test]
async fn insert_batch_returning_rejects_mysql() {
let query = lazy_mysql_query(
Table::new("tq_batch_returning_mysql")
.fields([Field::id("id"), Field::string("label", 32).required()]),
);
let error = query
.insert_batch_returning(&[Record::new().set("label", "x")], ReturningTarget::Pk)
.await
.expect_err("MySQL 批量 RETURNING 必须被拒绝");
assert!(
matches!(
error,
BaseError::ConfigError(ref message) if message.contains("insert_batch_returning")
),
"应返回 ConfigError 并点名入口,实际: {error:?}"
);
}
#[tokio::test]
async fn upsert_batch_returning_rejects_mysql() {
let query = lazy_mysql_query(Table::new("tq_batch_upsert_returning_mysql").fields([
Field::id("id"),
Field::string("option_key", 32).required(),
Field::string("label", 32).required(),
]));
let error = query
.upsert_batch_returning(
vec![Record::new().set("option_key", "k").set("label", "x")],
&["option_key"],
ReturningTarget::Pk,
)
.await
.expect_err("MySQL 批量 upsert RETURNING 必须被拒绝");
assert!(
matches!(
error,
BaseError::ConfigError(ref message) if message.contains("upsert_batch_returning")
),
"应返回 ConfigError 并点名入口,实际: {error:?}"
);
}
}
#[cfg(test)]
mod delete_permission_tests {
use super::*;
use crate::table::{Field, Record, Table};
use std::sync::Arc;
fn query_for(table: Table, roles: &[&str]) -> TableQuery {
let definition = table.build().expect("测试表定义应有效");
TableQuery::new(
definition.shared_config(),
Arc::from(
roles
.iter()
.map(|role| (*role).to_string())
.collect::<Vec<String>>(),
),
None,
)
}
#[tokio::test]
async fn soft_delete_respects_explicit_soft_delete_write_audience() {
let query = query_for(
Table::new("tq_soft_delete_guard").fields([
Field::id("id"),
Field::soft_delete("deleted_at").writable_by(["admin"]),
]),
&["user"],
);
let error = query
.delete()
.await
.expect_err("无写权限的软删列必须被拒绝");
assert!(
matches!(
error,
BaseError::FieldPermissionDenied(_, ref field, _) if field == "deleted_at"
),
"应返回 deleted_at 的 FieldPermissionDenied,实际: {error:?}"
);
}
#[tokio::test]
async fn framework_managed_soft_delete_passes_field_permission_guard() {
let query = query_for(
Table::new("tq_soft_delete_framework")
.fields([Field::id("id"), Field::soft_delete("deleted_at")]),
&["user"],
)
.where_eq("id", serde_json::json!(1))
.expect("主键条件应有效");
let error = query
.delete()
.await
.expect_err("无连接池应在守卫通过后才报错");
assert!(
matches!(error, BaseError::DatabaseNotInitialized),
"默认软删列不应触发字段权限错误,实际: {error:?}"
);
}
#[tokio::test]
async fn soft_delete_update_without_where_is_rejected() {
let query = query_for(
Table::new("tq_soft_delete_zero_where_update").fields([
Field::id("id"),
Field::string("name", 32),
Field::soft_delete("deleted_at"),
]),
&["admin"],
);
let error = query
.update(Record::new().set("name", "x"))
.await
.expect_err("软删表零 WHERE 更新必须被拒绝");
assert!(
matches!(error, BaseError::MissingWhereClause(ref op) if op == "UPDATE"),
"应返回 UPDATE 的 MissingWhereClause,实际: {error:?}"
);
}
#[tokio::test]
async fn soft_delete_delete_without_where_is_rejected() {
let query = query_for(
Table::new("tq_soft_delete_zero_where_delete").fields([
Field::id("id"),
Field::string("name", 32),
Field::soft_delete("deleted_at"),
]),
&["user"],
);
let error = query
.delete()
.await
.expect_err("软删表零 WHERE 删除必须被拒绝");
assert!(
matches!(error, BaseError::MissingWhereClause(ref op) if op == "DELETE"),
"应返回 DELETE 的 MissingWhereClause,实际: {error:?}"
);
}
#[test]
fn soft_delete_zero_where_guard_scope() {
let query = query_for(
Table::new("tq_zero_where_plain").fields([Field::id("id")]),
&["user"],
);
query
.ensure_soft_delete_write_has_where("UPDATE")
.expect("非软删表不应触发守卫");
let query = query_for(
Table::new("tq_zero_where_trashed")
.fields([Field::id("id"), Field::soft_delete("deleted_at")]),
&["user"],
)
.with_trashed();
query
.ensure_soft_delete_write_has_where("UPDATE")
.expect("with_trashed 不应触发守卫");
let mut query = query_for(
Table::new("tq_zero_where_any")
.fields([Field::id("id"), Field::soft_delete("deleted_at")]),
&["user"],
);
query
.any_conditions
.push(("id".to_string(), vec![serde_json::json!(1)]));
query
.ensure_soft_delete_write_has_where("DELETE")
.expect("where_any 条件应被视为已有 WHERE");
let query = query_for(
Table::new("tq_zero_where_tenant").fields([
Field::id("id"),
Field::bigint("tenant_id").tenant_key(),
Field::soft_delete("deleted_at"),
]),
&["user"],
)
.scope_tenant("tenant_id", serde_json::json!(7))
.expect("租户条件注入应成功");
query
.ensure_soft_delete_write_has_where("UPDATE")
.expect("租户注入条件应被视为已有 WHERE");
}
}