1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
//! 写入执行(`mysql` feature):写路径分 insert / update / delete / 批量 upsert 四类
//! (各自带事务内变体),含插入数据准备(默认值/时间戳/租户注入)与更新数据校验。
#![cfg(feature = "mysql")]
use super::TableQuery;
use crate::error::BaseError;
use serde_json::Value;
/// 批量 upsert 的计划产物:一次性校验通过的待写行集与 ODKU 赋值列。
///
/// 只由 [`TableQuery::plan_upsert_batch`] 构造,是「校验已完成、只剩执行」的中间态;
/// 空批不会产出它(计划返回 `None`)。
struct PreparedUpsertBatch {
/// 逐行同构的 INSERT 行(已补默认值/时间戳、已剔自增列)。
rows: Vec<std::collections::HashMap<String, Value>>,
/// ODKU 赋值列(已含 `updated_at`);列序由生成器按 INSERT 列序收敛。
tail: Vec<String>,
}
impl TableQuery {
/// 执行 INSERT 操作
///
/// 插入数据到表中,包括以下步骤:
/// 1. 按表定义验证所有字段值
/// 2. 检查用户是否有字段的写入权限
/// 3. 构建 INSERT SQL 语句
/// 4. 执行插入操作
/// 5. 返回影响行数
///
/// # 参数
///
/// - `data`:要插入的 [`crate::table::Record`]
///
/// # 返回值
///
/// - `Ok(u64)`:插入成功,返回影响行数(通常为 1)
/// - `Err(BaseError)`:插入失败,返回错误
///
/// # 错误
///
/// - `BaseError::DatabaseNotInitialized`:数据库未初始化
/// - `BaseError::FieldRequired`:必填字段缺失
/// - `BaseError::FieldPermissionDenied`:用户无字段写入权限
/// - `BaseError::ValidationFailed`:字段值验证失败
/// - `BaseError::DatabaseExecuteFailed`:数据库执行失败
///
/// # 示例
///
/// ```rust,ignore
/// use yang_base::table::Record;
///
/// # async fn example() -> Result<(), yang_base::error::BaseError> {
/// let data = Record::new()
/// .set("name", "张三")
/// .set("email", "zhangsan@example.com");
///
/// // 执行插入
/// let affected = query.insert(data).await?;
/// println!("插入成功,影响行数: {}", affected);
/// # Ok(())
/// # }
/// ```
pub async fn insert(self, data: crate::table::Record) -> Result<u64, BaseError> {
// 填充默认值/时间戳并校验(顺序:写权限→填充默认值→必填/类型校验)
let data = self.prepare_and_validate_insert(data.into_columns())?;
self.compile_db_write_query()?
.insert(&data)
.await
.map_err(BaseError::DatabaseExecuteFailed)?;
Ok(1)
}
/// 在事务中执行 INSERT 操作
///
/// 与 [`TableQuery::insert`] 完全一致的写权限校验/默认值填充/时间戳/必填校验
/// 流程,但在调用方提供的事务内执行,可与其它写操作原子提交。
///
/// # 错误
///
/// - `BaseError::DatabaseTransactionFailed`:事务已提交/回滚
/// - 其余同 [`TableQuery::insert`]
pub async fn insert_in_tx(
self,
tx: &mut yang_db::Transaction,
data: crate::table::Record,
) -> Result<u64, BaseError> {
let data = self.prepare_and_validate_insert(data.into_columns())?;
let query = tx.table(&self.table_config.table_ref);
self.apply_write_plan(query)?
.insert(&data)
.await
.map_err(BaseError::DatabaseExecuteFailed)?;
Ok(1)
}
/// 执行 INSERT 操作并返回自增主键
///
/// 与 [`TableQuery::insert`] 完全一致的校验与拼 SQL 流程,但额外返回本次
/// INSERT 产生的自增主键值(`last_insert_id`),便于调用方拿到新建记录 ID。
///
/// # 参数
///
/// - `data`:要插入的数据
///
/// # 返回值
///
/// - `Ok((affected, id))`:插入成功,返回 (影响行数, 自增主键值)。
/// 表无自增列时 `id` 为 0。
/// - `Err(BaseError)`:插入失败
///
/// # 错误
///
/// - `BaseError::DatabaseNotInitialized`:数据库未初始化
/// - `BaseError::FieldRequired`:必填字段缺失
/// - `BaseError::FieldPermissionDenied`:用户无字段写入权限
/// - `BaseError::DatabaseExecuteFailed`:数据库执行失败
pub async fn insert_returning_id(
self,
data: crate::table::Record,
) -> Result<(u64, u64), BaseError> {
let data = self.prepare_and_validate_insert(data.into_columns())?;
let id = self
.compile_db_write_query()?
.insert(&data)
.await
.map_err(BaseError::DatabaseExecuteFailed)?;
Ok((1, id))
}
/// 在事务中执行 INSERT 并返回自增主键
///
/// 与 [`TableQuery::insert_returning_id`] 一致,但在事务内执行。批量写入或
/// 「插入父行→用其主键插入子行」等需要拿到新 ID 再继续的原子场景使用。
pub async fn insert_returning_id_in_tx(
self,
tx: &mut yang_db::Transaction,
data: crate::table::Record,
) -> Result<(u64, u64), BaseError> {
let data = self.prepare_and_validate_insert(data.into_columns())?;
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))
}
/// 在调用方事务内批量 upsert(`INSERT ... ON DUPLICATE KEY UPDATE`)。
///
/// - INSERT 列集与值 = [`TableQuery::prepare_and_validate_insert`] 的输出(写权限 /
/// 自增剔除 / 缺省补 `default_value` / 补 `created_at`+`updated_at` / 必填校验),
/// 与单行插入**共用同一个函数**;
/// - UPDATE 分支只写 `update_columns ∪ {updated_at}`。框架补出来的默认值与
/// `created_at` **都不在**赋值列里,这正是「省略即保持原值」与「创建时间不被刷新」
/// 的落点。
///
/// # 调用方义务(框架不兜、也兜不了)
///
/// - 冲突键由**表上的唯一索引**决定,本方法无法指定;
/// - 本方法**没有 WHERE**。身份列(如 `source_key`)必须由调用方自己从
/// `update_columns` 里排除:把它放进赋值列,跨源命中就会把归属**静默改写**——
/// 而逐行路径的 `where_eq(id)+where_eq(owner)` 至少还会撞唯一索引响亮失败。
/// - 调用方应在事务前做归属预检,并在同一事务内做写后归属再断言。
///
/// # 错误
///
/// - `BaseError::ParamInvalid`:带 where / 软删表未 `with_trashed` / 行集不一致 /
/// 赋值列为空或不在提供列内 / 赋值列是自增列
/// - `BaseError::FieldPermissionDenied`:显式提交 `not_writable` 列(`created_at` 等),
/// 沿用 prepare 的错误
/// - `BaseError::DatabaseExecuteFailed`:数据库执行失败
///
/// # 返回值
///
/// `rows_affected` 之和 ∈ `[N, 2N]`(1=插入,2=更新且值有变;sqlx 带
/// `CLIENT_FOUND_ROWS` ⇒「命中但值未变」也计 1)。**不是行数**(要行数用
/// `rows.len()`),也**分不出 inserted/updated**。
pub async fn upsert_batch_in_tx(
self,
tx: &mut yang_db::Transaction,
rows: Vec<crate::table::Record>,
update_columns: &[&str],
) -> Result<u64, BaseError> {
// 空批 = 写 0 行:没写就没写,不发明语句(生成器也会拒空数据)。
let Some(batch) = self.plan_upsert_batch(rows, update_columns)? else {
return Ok(0);
};
// 不走 apply_write_plan:写路径计划只挂 WHERE 与软删守卫,而本方法两者都不支持
// (plan_upsert_batch 已把带 where / 软删表的调用拒掉),挂上去只会给人
// 「守卫已应用」的错觉。
let affected = tx
.table(&self.table_config.table_ref)
.upsert_batch(&batch.rows, &batch.tail)
.await
.map_err(BaseError::DatabaseExecuteFailed)?;
Ok(affected)
}
/// 校验并准备一批 upsert:`Ok(None)` = 空批(写 0 行),`Ok(Some(_))` = 可执行计划。
///
/// 失败面顺序即调用方踩坑的顺序:空批 → where → 软删 → 逐行列集 → 赋值列。
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();
// 空批 = 写 0 行:没有第一行可推赋值列,也不发明语句。
let Some(first) = records.next() else {
return Ok(None);
};
// ODKU 没有 WHERE:带条件的调用会被静默忽略(写错行远比报错危险),直接拒绝。
if !self.query_params.where_conditions.is_empty() {
return Err(BaseError::ParamInvalid(
"where".to_string(),
"批量 upsert 不支持 where 条件:ON DUPLICATE KEY UPDATE 没有 WHERE,条件会被静默忽略"
.to_string(),
));
}
// 软删守卫是 `deleted_at IS NULL` 这类 WHERE,批量 upsert 表达不了:命中已软删行时
// 会把它们改活,而逐行 update 路径上这会被守卫挡住。
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(),
));
}
// 第 1 条记录的两套列集就是全批基准:provided 管「省略即重置」,prepared 管列集
// 异构。先取 provided 再 prepare——prepare 会把默认值与时间戳补进来,之后就分不出
// 「调用方写过这一列」与「框架补的」了。
let first_provided: std::collections::BTreeSet<String> =
first.as_map().keys().cloned().collect();
let first_prepared = self.prepare_and_validate_insert(first.into_columns())?;
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())?;
let prepared_keys: std::collections::BTreeSet<String> =
prepared.keys().cloned().collect();
// 第 1 条在循环外已处理,这里从第 2 条起数。
let row_number = offset + 2;
// 某行省略了带默认值的列 ⇒ 批量路径会拿第 1 行的值替它做 ODKU 赋值,等价于
// 「省略即重置」(prepared 两侧都被默认值补齐,只看 prepared 拦不住)。
if provided != first_provided {
return Err(BaseError::ParamInvalid(
"rows".to_string(),
format!("批量 upsert 第 {row_number} 条记录提供的列集与第 1 条不一致"),
));
}
// 列集异构交给生成器只会得到一条更晚、更难归因的 SerializationError。
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 {
// 要求 ⊆ provided 而不是 ⊆ prepared:prepared 里有框架补出来的默认值与
// created_at,让它们进赋值列就等于「省略即重置」「创建时间被刷新」。
// created_at 不必单独排除:它是 Audience::Nobody,调用方提交会先吃
// FieldPermissionDenied,永远进不了 provided,上一条已把它挡住。
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 里"),
));
}
}
// 赋值列 = 调用方白名单(去重)+ updated_at(语义同 with_updated_timestamp:列存在
// 且不在集合里时追加)。列序不在这里排:生成器按 INSERT 列序收敛。
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,
}))
}
/// 填充默认值/时间戳并验证插入数据
///
/// 处理顺序(修复 required+default 字段被误报 FieldRequired 的问题):
/// 1. 字段与写权限校验:显式提交只读字段时拒绝;null 自增主键视为未提供
/// 2. 规范化数据库生成字段:未提供或为 null 的自增字段交给数据库生成
/// 3. 填充默认值:data 中缺失且配置了 `default_value` 的字段补默认值
/// 4. 填充时间戳:`timestamp_fields` 配置且列存在、调用方未提供时,写入当前时间
/// 5. 必填/类型/验证器校验:在补齐后的数据上执行
///
/// # 参数
///
/// - `data`:调用方提供的原始插入数据
///
/// # 返回值
///
/// - `Ok(HashMap)`:补齐默认值与时间戳后的最终插入数据
/// - `Err(BaseError)`:权限或校验失败
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;
// tenant key 只能由请求上下文注入,业务输入不得覆盖。
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());
}
// 1. 校验调用方显式提交的字段和写权限。只有 null 自增主键可视为“未提供”,
// 其余只读字段即使提交 null 也必须拒绝,避免绕过字段边界并覆盖数据库默认值。
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(),
));
}
}
// 2. 数据库生成的自增字段未提供或为 null 时,不进入 INSERT 字段列表。
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);
}
}
// 3. 填充默认值(仅缺失时;显式 null 仍受 nullable/required 约束)
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());
}
}
}
// 4. 填充创建/更新时间戳(列存在且调用方未提供时)
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()));
}
}
}
}
// 5. 在补齐后的数据上执行必填/类型/验证器校验
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)
}
/// 执行 UPDATE 操作
///
/// 更新表中的数据,包括以下步骤:
/// 1. 按表定义验证所有字段值
/// 2. 检查用户是否有字段的写入权限
/// 3. 构建 UPDATE SQL 语句
/// 4. 应用已配置的 WHERE 条件
/// 5. 执行更新操作
/// 6. 返回影响行数
///
/// # 参数
///
/// - `data`:要更新的 [`crate::table::Record`]
///
/// # 返回值
///
/// - `Ok(u64)`:更新成功,返回影响行数
/// - `Err(BaseError)`:更新失败,返回错误
///
/// # 错误
///
/// - `BaseError::DatabaseNotInitialized`:数据库未初始化
/// - `BaseError::FieldNotFound`:字段不存在
/// - `BaseError::FieldPermissionDenied`:用户无字段写入权限
/// - `BaseError::ValidationFailed`:字段值验证失败
/// - `BaseError::DatabaseExecuteFailed`:数据库执行失败
///
/// # 示例
///
/// ```rust,ignore
/// use yang_base::table::Record;
/// use serde_json::json;
///
/// # async fn example() -> Result<(), yang_base::error::BaseError> {
/// let data = Record::new()
/// .set("name", "李四")
/// .set("email", "lisi@example.com");
///
/// // 执行更新(需要先设置 WHERE 条件)
/// let affected = query
/// .where_eq("id", json!(1))?
/// .update(data)
/// .await?;
/// println!("更新成功,影响行数: {}", affected);
/// # Ok(())
/// # }
/// ```
pub async fn update(self, data: crate::table::Record) -> Result<u64, BaseError> {
let data = self.prepare_update_data(data.into_columns())?;
self.compile_db_write_query()?
.update(&data)
.await
.map_err(BaseError::DatabaseExecuteFailed)
}
/// 在事务中执行 UPDATE 操作
///
/// 与 [`TableQuery::update`] 一致的字段校验/权限/WHERE 守卫/自动 `updated_at`
/// 逻辑,但在事务内执行。
///
/// # 错误
///
/// - `BaseError::DatabaseTransactionFailed`:事务已提交/回滚
/// - 其余同 [`TableQuery::update`]
pub async fn update_in_tx(
self,
tx: &mut yang_db::Transaction,
data: crate::table::Record,
) -> Result<u64, BaseError> {
let data = self.prepare_update_data(data.into_columns())?;
let query = tx.table(&self.table_config.table_ref);
self.apply_write_plan(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)
}
/// 验证更新数据
///
/// 验证所有要更新的字段值的合法性和用户权限
///
/// # 参数
///
/// - `data`:要更新的数据
///
/// # 返回值
///
/// - `Ok(())`:验证通过
/// - `Err(BaseError)`:验证失败
///
/// # 错误
///
/// - `BaseError::FieldNotFound`:字段不存在
/// - `BaseError::FieldPermissionDenied`:用户无字段写入权限
/// - `BaseError::ValidationFailed`:字段值验证失败
#[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(),
));
}
// 只验证提供的字段(与 INSERT 不同,UPDATE 不需要验证所有字段)
for (field_name, value) in data {
if self
.tenant_scope
.as_ref()
.is_some_and(|(tenant_field, _)| tenant_field == field_name)
{
return Err(BaseError::PermissionDenied(format!(
"禁止修改租户字段: {field_name}"
)));
}
// 1. 检查字段是否存在于表配置中
let field_config = self.table_config.get_field(field_name).ok_or_else(|| {
BaseError::FieldNotFound(self.table_config.table_name.clone(), field_name.clone())
})?;
// 2. 检查用户是否有写入权限
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(),
));
}
// 3. 验证显式提供的字段值。部分更新不要求提交其它必填字段,但若本字段
// 被显式设为 null,仍执行 required 约束。
field_config.validate(value, &self.regex_cache)?;
}
Ok(())
}
/// 批量 upsert 的**计划**(不连库、不执行)——测试专用。
///
/// 只把 [`TableQuery::plan_upsert_batch`] 的产物摊平成 `(待写行集, 赋值列)`,让无库
/// 用例能断言「哪些列进了 INSERT、哪些列进了 ODKU 尾巴」;生产路径不经过这里。
// 摊平元组比再发明一个测试专用结构体更省;clippy 只嫌它长。
#[allow(clippy::type_complexity)]
#[cfg(test)]
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)))
}
/// 执行 DELETE 操作
///
/// 删除表中的数据,支持软删除和物理删除两种模式:
/// 1. 如果配置了软删除字段(soft_delete_field),执行 UPDATE 设置删除标记
/// 2. 如果未配置软删除字段,执行物理删除
/// 3. 应用已配置的 WHERE 条件
/// 4. 返回影响行数
///
/// # 返回值
///
/// - `Ok(u64)`:删除成功,返回影响行数
/// - `Err(BaseError)`:删除失败,返回错误
///
/// # 错误
///
/// - `BaseError::DatabaseNotInitialized`:数据库未初始化
/// - `BaseError::DatabaseExecuteFailed`:数据库执行失败
///
/// # 示例
///
/// ```rust,ignore
/// use serde_json::json;
/// use yang_base::table::{Field, Table};
///
/// # async fn example() -> Result<(), yang_base::error::BaseError> {
/// let users = Table::new("users")
/// .fields(vec![
/// Field::id("id"),
/// Field::string("name", 50).required(),
/// Field::soft_delete("deleted_at"),
/// ])
/// .build()?;
///
/// // 执行软删除(实际上是 UPDATE deleted_at = <timestamp>)
/// let affected = users
/// .bind(pool)
/// .query(["admin"])
/// .where_eq("id", json!(1))?
/// .delete()
/// .await?;
/// println!("删除成功,影响行数: {}", affected);
/// # Ok(())
/// # }
/// ```
pub async fn delete(self) -> Result<u64, BaseError> {
if let Some(soft_delete_field) = &self.table_config.soft_delete_field {
let data = self.with_updated_timestamp(std::collections::HashMap::from([(
soft_delete_field.clone(),
Value::Number(chrono::Utc::now().timestamp().into()),
)]))?;
return self
.compile_db_write_query()?
.update(&data)
.await
.map_err(BaseError::DatabaseExecuteFailed);
}
self.compile_db_write_query()?
.delete()
.await
.map_err(BaseError::DatabaseExecuteFailed)
}
/// 在事务中执行 DELETE 操作
///
/// 与 [`TableQuery::delete`] 一致:配置了软删除字段时走 UPDATE 标记(同样在
/// 事务内),否则物理删除;WHERE 守卫与软删语义完全复用。
///
/// # 错误
///
/// - `BaseError::DatabaseTransactionFailed`:事务已提交/回滚
/// - 其余同 [`TableQuery::delete`]
pub async fn delete_in_tx(self, tx: &mut yang_db::Transaction) -> Result<u64, BaseError> {
let query = tx.table(&self.table_config.table_ref);
if let Some(soft_delete_field) = &self.table_config.soft_delete_field {
let data = self.with_updated_timestamp(std::collections::HashMap::from([(
soft_delete_field.clone(),
Value::Number(chrono::Utc::now().timestamp().into()),
)]))?;
return self
.apply_write_plan(query)?
.update(&data)
.await
.map_err(BaseError::DatabaseExecuteFailed);
}
self.apply_write_plan(query)?
.delete()
.await
.map_err(BaseError::DatabaseExecuteFailed)
}
}