diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/mapper/AppearancePatentCleanItemMapper.java b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/mapper/AppearancePatentCleanItemMapper.java
index 753138fce..0ab8ec364 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/mapper/AppearancePatentCleanItemMapper.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/mapper/AppearancePatentCleanItemMapper.java
@@ -10,11 +10,12 @@ import java.time.LocalDate;
import java.util.List;
/**
- * 外观专利无侵权数据(biz_appearance_patent_clean_item,V189)数据访问口。
+ * 外观专利无侵权数据(biz_appearance_patent_clean_item,V189;V192 起 ASIN 累计唯一键)数据访问口。
*
- *
出表成功点由 {@code AppearancePatentCleanSyncService}(Phase 2)按 result_id
- * 覆盖式落表({@link #deleteByResultId} + {@link #insertBatch});后管只读页
- * (Phase 3)走 {@link #countCleanItems}/{@link #selectCleanItemPage}。SQL 全部落
+ *
出表成功点由 {@code AppearancePatentCleanSyncService} 按唯一键 upsert 累计落表
+ * ({@link #upsertBatch},2026-11-11 客户拍板「同 ASIN 只保留一条」;旧的按 result_id
+ * delete-then-insert 覆盖式重写已退役——重投递载荷读不准时它会抹掉存量,实抹 1902 行);
+ * 后管只读页(Phase 3)走 {@link #countCleanItems}/{@link #selectCleanItemPage}。SQL 全部落
* {@code mapper/appearancepatent/AppearancePatentCleanItemMapper.xml}(铁律 1)。
*
* {@code userIds}(2026-11-11 分组筛选,主管=组长):服务侧由 {@code ShopManageGroupMapper
@@ -24,16 +25,16 @@ import java.util.List;
@Mapper
public interface AppearancePatentCleanItemMapper extends BaseMapper {
- /** 删除某次结果文件已同步的全部明细行(覆盖式重写第一步,AC-2)。 */
- int deleteByResultId(@Param("resultId") Long resultId);
-
/**
- * 多值批量插入明细行(调用方按 ≤500 行/批分批,蓝图 §3.3)。
+ * 多值批量 upsert 明细行(调用方按 ≤500 行/批分批),冲突键=
+ * {@code uk_company_user_country_asin}:同 ASIN 重复检测更新那条(刷新
+ * synced_at),不同 ASIN 全保留,跨任务累计,永不删除 。
*
- * 刻意不写 synced_at:该列有 DB 默认值 CURRENT_TIMESTAMP,显式传 null 会覆盖掉
- * 默认值(同 ShopDataCrawlItemMapper#insertBatch 的口径)。
+ * INSERT 路径不写 synced_at(列有 DB 默认值 CURRENT_TIMESTAMP,显式传 null
+ * 会覆盖掉默认值);UPDATE 路径在 XML 里显式刷 CURRENT_TIMESTAMP(两段口径分开,
+ * 见 XML 注释)。
*/
- int insertBatch(@Param("rows") List rows);
+ int upsertBatch(@Param("rows") List rows);
/** 只读页总数(与 {@link #selectCleanItemPage} 同一过滤面)。 */
long countCleanItems(@Param("companyId") Long companyId,
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentCleanItemQueryService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentCleanItemQueryService.java
index e822b0182..8315a8deb 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentCleanItemQueryService.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentCleanItemQueryService.java
@@ -308,8 +308,8 @@ public class AppearancePatentCleanItemQueryService {
*
* {@code supervisorUserId} 必须是显式传入的主管 id:SQL 里那条 {@code } 缺值时不生效,
* 等于删掉整个过滤面(最坏是全表),所以这里先挡空值/非法值并抛业务错误——宁可拒绝,不接
- * 「不按主管收窄的删除」。本方法只删快照明细行,不碰结果文件与任务记录(与同步链的
- * {@code deleteByResultId} 覆盖式重写互不影响:下一次同步会按 result_id 重新写入)。
+ * 「不按主管收窄的删除」。本方法只删快照明细行,不碰结果文件与任务记录(同步链是
+ * upsert 累计、永不删除——下一次出表只会按唯一键重写/新增,不会找回这里删掉的行)。
*
* @return 实际删除行数(前端拿它做「已删除 N 条」的反馈,不猜)
*/
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentCleanSyncService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentCleanSyncService.java
index f1ace8cda..ac335c031 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentCleanSyncService.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentCleanSyncService.java
@@ -26,8 +26,9 @@ import java.util.List;
import java.util.Map;
/**
- * 出表成功点把「结论=无侵权」行按 result_id 覆盖式落后管新表(v1.3 R1,
- * {@code biz_appearance_patent_clean_item},V189)。
+ * 出表成功点把「结论=无侵权」行按 ASIN 累计落后管表(v1.3 R1,
+ * {@code biz_appearance_patent_clean_item},V189;V192 起唯一键
+ * {@code uk_company_user_country_asin})。
*
* 触发点(蓝图 §3.3)=出表成功(结果文件已上传 OSS、result_file_url 回填) ,
* 三条出表路径全部覆盖:①异步出表作业成功(handler.process true 返回,经宿主
@@ -35,19 +36,26 @@ import java.util.Map;
* (handler.fallbackAssembleOnFailure 产出可下载部分结果,同上);③同步装配分支
* ({@code AppearancePatentResultJobSupport#finalizeTask} 内联成功,直调本服务)。
* 调用时机必须在 worker 的 {@code cleanupAfterSuccess} 之前 ——分片载荷
- * ({@code biz_task_chunk.payload_json})是本服务唯一行数据源,清理一过就再也读不回。
+ * ({@code biz_task_chunk.payload_json})是本服务唯一行数据源,清理一过就再也读不回。
*
* 过滤口径 :conclusion 与 {@code AppearancePatentLlmClient.NO_INFRINGEMENT}
* 常量精确相等(字符串全等,不模糊、不 trim 变体;严格口径=用户拍板 ①)。
+ * 空串 ASIN 的行不落表(ASIN 累计唯一键会把它折叠成一条;镜像结果文件原因 sheet
+ * 「空 ASIN 跳过」的既有先例),计入日志。
* 常量单一来源在 LlmClient,本类反射读取,不另抄字面量(黄金测试
- * {@code AppearancePatentChunkRowContractTest} 钉字段名与取值)。
+ * {@code AppearancePatentChunkRowContractTest} 钉字段名与取值)。
*
* 失败语义(AC-3/R5) :入口吞掉一切异常只留日志,绝不反写任务/结果/作业——
- * 出表链不因同步失败改变任何终态。
+ * 出表链不因同步失败改变任何终态。
*
- * 幂等(AC-2) :按 result_id delete-then-insert 覆盖式重写(同
- * {@code ShopDataCrawlItemStoreService} 模式),批量插入分批 ≤500/批;
- * 事务收口在删除+插入两步,中途失败不留半批。
+ *
累计语义(2026-11-11 客户拍板「ASIN 累计、同 ASIN 只保留一条」,V192 同窗) :
+ * 按 {@code uk_company_user_country_asin} upsert、永不删除 ——同 ASIN 重复检测
+ * 更新那条(值与 synced_at 刷新),不同 ASIN(含同品牌)全保留,跨任务累计。
+ * 旧的按 result_id delete-then-insert 覆盖式重写已退役:已交付任务被事件重投时
+ * 载荷重读可能与出表口径不一致(现网实录:交付 XLSX 里有上千行无侵权、同步读载荷
+ * 却 cleanRows=0),覆盖语义在 cleanRows=0 时把该 result 上次的贡献整段抹掉
+ * (2026-11-11 04:00 实抹 1902 行)——upsert-only 下读出 0 行=什么都不写,存量
+ * 天然保留。批量 upsert 分批 ≤500/批,事务收口(中途失败不留半批)。
*/
@Slf4j
@Service
@@ -126,10 +134,13 @@ public class AppearancePatentCleanSyncService {
task.getId(), result.getId());
return;
}
- List rows = extractCleanRows(task, result, companyId, payloadRows);
- int deleted = replaceRows(result.getId(), rows);
- log.info("[appearance-patent] clean-item synced taskId={} resultId={} payloadRows={} cleanRows={} deleted={} companyId={}",
- task.getId(), result.getId(), payloadRows.size(), rows.size(), deleted, companyId);
+ CleanExtraction extraction = extractCleanRows(task, result, companyId, payloadRows);
+ List rows = extraction.rows();
+ int upserted = upsertRows(rows);
+ log.info("[appearance-patent] clean-item synced taskId={} resultId={} payloadRows={} cleanRows={} "
+ + "blankAsinSkipped={} upserted={} companyId={}",
+ task.getId(), result.getId(), payloadRows.size(), rows.size(),
+ extraction.blankAsinSkipped(), upserted, companyId);
}
/**
@@ -187,21 +198,31 @@ public class AppearancePatentCleanSyncService {
}
/**
- * 严格口径过滤:conclusion 与常量精确相等(字符串全等,不模糊、不 trim 变体)。
- * {@code row_no} 按 payload 全行序号计(含未入选行):重同步时序号稳定,
+ * 严格口径过滤:conclusion 与常量精确相等(字符串全等,不模糊、不 trim 变体);
+ * 空串 ASIN 的无侵权行不落表(累计唯一键会折叠成一条;镜像原因 sheet 的空 ASIN
+ * 跳过先例),计数进日志。{@code row_no} 按 payload 全行序号计(含未入选行):
* 序号缺口即可审计出被过滤的行。
*/
- private List extractCleanRows(FileTaskEntity task, FileResultEntity result,
- Long companyId, Map payloadRows) {
+ private CleanExtraction extractCleanRows(FileTaskEntity task, FileResultEntity result,
+ Long companyId, Map payloadRows) {
List rows = new ArrayList<>();
+ int blankAsin = 0;
int rowNo = 0;
for (AppearancePatentResultRowDto row : payloadRows.values()) {
if (CLEAN_CONCLUSION.equals(row.getConclusion())) {
- rows.add(toEntity(task, result, companyId, rowNo, row));
+ if (row.getAsin() == null || row.getAsin().isBlank()) {
+ blankAsin++;
+ } else {
+ rows.add(toEntity(task, result, companyId, rowNo, row));
+ }
}
rowNo++;
}
- return rows;
+ return new CleanExtraction(rows, blankAsin);
+ }
+
+ /** 过滤结果:入选行+空 ASIN 跳过数(日志口径,读不出原因的行不静默消失)。 */
+ private record CleanExtraction(List rows, int blankAsinSkipped) {
}
private CleanItemEntity toEntity(FileTaskEntity task, FileResultEntity result, Long companyId,
@@ -231,16 +252,20 @@ public class AppearancePatentCleanSyncService {
return entity;
}
- /** 按 result_id 覆盖式重写:删除+分批插入收在同一事务(AC-2,中途失败不留半批)。 */
- private int replaceRows(Long resultId, List rows) {
- Integer deleted = transactionTemplate.execute(status -> {
- int removed = cleanItemMapper.deleteByResultId(resultId);
+ /**
+ * 按唯一键 upsert、永不删除(V192 累计语义):分批 ≤500/批收在同一事务,
+ * 中途失败不留半批。读出 0 行时一个字节都不写——重投递载荷读不准(cleanRows=0)
+ * 绝不反噬存量(2026-11-11 事故的根治点)。
+ */
+ private int upsertRows(List rows) {
+ Integer upserted = transactionTemplate.execute(status -> {
+ int touched = 0;
for (int from = 0; from < rows.size(); from += PAGE_OR_BATCH_SIZE) {
- cleanItemMapper.insertBatch(rows.subList(from, Math.min(from + PAGE_OR_BATCH_SIZE, rows.size())));
+ touched += cleanItemMapper.upsertBatch(rows.subList(from, Math.min(from + PAGE_OR_BATCH_SIZE, rows.size())));
}
- return removed;
+ return touched;
});
- return deleted == null ? 0 : deleted;
+ return upserted == null ? 0 : upserted;
}
private static String loadNoInfringementConclusion() {
diff --git a/backend-java/src/main/resources/db/V192__appearance_patent_clean_item_asin_unique.sql b/backend-java/src/main/resources/db/V192__appearance_patent_clean_item_asin_unique.sql
new file mode 100644
index 000000000..739107aa0
--- /dev/null
+++ b/backend-java/src/main/resources/db/V192__appearance_patent_clean_item_asin_unique.sql
@@ -0,0 +1,75 @@
+-- 迁移 V192:无侵权数据按 ASIN 累计的唯一键(2026-11-11 客户拍板「同 ASIN 只保留一条」)
+-- ================================================================================
+-- 0. 编号说明:本件初稿编 V191,与另一路会话已提交的 V191(菜单更名,9acb2211)撞号,
+-- 落盘前改 V192——Flyway 同号两文件会让两台 java 同时起不来(MigrationInventoryTest 同轮判红)。
+-- 1. 变更目的:客户口径「ASIN 累计的」「不同 ASIN 同品牌都要留着」——同一公司/管理员
+-- +国家+ASIN 只保留一条,重复检测更新那条(最近一次检测的值与 synced_at)。
+-- 同步链(AppearancePatentCleanSyncService)随之从「按 result_id delete-then-insert
+-- 覆盖式重写」改为「按唯一键 upsert、永不删除」。本迁移负责数据底座:
+-- 备份 → 存量去重 → 唯一键替换。
+--
+-- 2. 现网事故背景(当天归因,写死防复发):已交付任务被事件重投时,同步链从分片
+-- 载荷重读行(唯一数据源),重投载荷与出表口径可能不一致(2026-11-11 实测:交付
+-- 的结果 XLSX 里有上千行「无侵权」,同步读载荷却 cleanRows=0)——旧覆盖语义在
+-- cleanRows=0 时按 result_id 删光自己上次的贡献(04:00 一笔 deleted=1902 抹掉
+-- 先锋-团队全部存量)。upsert-only 语义下重投读出 0 行=什么都不写,存量天然保留。
+--
+-- 3. 形状口径:
+-- - 唯一键 uk_company_user_country_asin (company_id, user_id, country, asin):
+-- 四列在 V189 全部 NOT NULL,无 NULL 边界(空串 ASIN 行按组折叠成一条,
+-- 同步链已不再落空 ASIN 的新行)。
+-- - 撤销 uk_result_row (result_id, row_no):它是旧覆盖语义的幂等键;upsert 语义下
+-- 同一 (result_id, row_no) 可能被多行复用(不同 ASIN 的行后来被别的任务更新),
+-- 继续保留反而会在跨任务更新时撞假唯一。本表只由同步链写入,撤销无旁路依赖
+-- (清理安全排查:全仓引用仅同步链与只读页,读侧不按该键查询)。
+-- - 去重保留规则=(synced_at, id) 最大(最近一次检测;同刻按 id 稳定序)。
+-- 用 DATE_FORMAT+LPAD 拼定长 rank 串比较,避开 1093(同表删除取同表子查询)
+-- ——派生表物化后 JOIN 删除,MySQL 5.7/8 通用。
+--
+-- 4. 备份与回滚:第 1 步先落全量备份表 bak_v191(当天上午刚发生数据抹除疑云,
+-- 动任何行之前先留底)。回滚=
+-- DROP INDEX 用 SHOW INDEX 先确认再手工执行(MySQL 无 DROP INDEX IF EXISTS);
+-- 数据回滚=TRUNCATE biz_appearance_patent_clean_item 后
+-- INSERT ... SELECT FROM biz_appearance_patent_clean_item_bak_v191
+-- (仅限本迁移后尚未新增行时;bak_v191 确认不再需要后手工 DROP)。
+--
+-- 5. 可重跑性:备份表 IF NOT EXISTS 可重跑;去重 DELETE 与 ALTER 重跑会报
+-- (唯一键已存在/0 行可删)——Flyway 正常只执行一次,人工重跑前先
+-- SHOW INDEX 核对现状,不要盲跑。
+--
+-- 6. 验证 SQL(迁移后跑,不许只看启动日志 Successfully applied):
+-- SHOW CREATE TABLE biz_appearance_patent_clean_item;
+-- -> 期望含 uk_company_user_country_asin(company_id,user_id,country,asin),
+-- 不再含 uk_result_row;idx_company/idx_task/idx_asin 保留。
+-- SELECT COUNT(*) FROM biz_appearance_patent_clean_item_bak_v191; -- 去重前行数
+-- SELECT COUNT(*) FROM biz_appearance_patent_clean_item; -- 去重后行数
+-- 应用侧:MigrationInventoryTest 自动覆盖本迁移;同步语义由
+-- AppearancePatentCleanSyncTest 钉住「永不删除、upsert 累计」。
+-- =============================================================
+
+-- 第 1 步:全量备份(去重动数据之前的底)
+CREATE TABLE IF NOT EXISTS biz_appearance_patent_clean_item_bak_v191 AS
+SELECT * FROM biz_appearance_patent_clean_item;
+
+-- 第 2 步:按 (company_id, user_id, country, asin) 去重,保留 (synced_at, id) 最大的一行
+DELETE i
+FROM biz_appearance_patent_clean_item i
+JOIN (
+ SELECT t.id
+ FROM biz_appearance_patent_clean_item t
+ JOIN (
+ SELECT company_id, user_id, country, asin,
+ MAX(CONCAT(DATE_FORMAT(synced_at, '%Y%m%d%H%i%s'), LPAD(id, 15, '0'))) AS keep_rank
+ FROM biz_appearance_patent_clean_item
+ GROUP BY company_id, user_id, country, asin
+ ) k ON t.company_id = k.company_id
+ AND t.user_id = k.user_id
+ AND t.country = k.country
+ AND t.asin = k.asin
+ AND CONCAT(DATE_FORMAT(t.synced_at, '%Y%m%d%H%i%s'), LPAD(t.id, 15, '0')) < k.keep_rank
+) d ON i.id = d.id;
+
+-- 第 3 步:唯一键替换(uk_result_row 退役,ASIN 累计键上岗)
+ALTER TABLE biz_appearance_patent_clean_item
+ DROP INDEX uk_result_row,
+ ADD UNIQUE KEY uk_company_user_country_asin (company_id, user_id, country, asin);
diff --git a/backend-java/src/main/resources/mapper/appearancepatent/AppearancePatentCleanItemMapper.xml b/backend-java/src/main/resources/mapper/appearancepatent/AppearancePatentCleanItemMapper.xml
index 5c97d49cd..c3fa6afdd 100644
--- a/backend-java/src/main/resources/mapper/appearancepatent/AppearancePatentCleanItemMapper.xml
+++ b/backend-java/src/main/resources/mapper/appearancepatent/AppearancePatentCleanItemMapper.xml
@@ -44,13 +44,17 @@
-
- DELETE FROM biz_appearance_patent_clean_item
- WHERE result_id = #{resultId}
-
-
-
-
+
+
INSERT INTO biz_appearance_patent_clean_item
(result_id, task_id, user_id, company_id, row_no,
asin, country, sku, brand, price, title, image_url, item_url, conclusion,
@@ -62,6 +66,23 @@
#{row.imageUrl}, #{row.itemUrl}, #{row.conclusion},
#{row.titleReason}, #{row.appearanceReason}, #{row.patentReason}, #{row.sourceFilename})
+ ON DUPLICATE KEY UPDATE
+ result_id = VALUES(result_id),
+ task_id = VALUES(task_id),
+ user_id = VALUES(user_id),
+ row_no = VALUES(row_no),
+ sku = VALUES(sku),
+ brand = VALUES(brand),
+ price = VALUES(price),
+ title = VALUES(title),
+ image_url = VALUES(image_url),
+ item_url = VALUES(item_url),
+ conclusion = VALUES(conclusion),
+ title_reason = VALUES(title_reason),
+ appearance_reason = VALUES(appearance_reason),
+ patent_reason = VALUES(patent_reason),
+ source_filename = VALUES(source_filename),
+ synced_at = CURRENT_TIMESTAMP
diff --git a/backend-java/src/test/java/com/nanri/aiimage/MigratedSqlEquivalenceTest.java b/backend-java/src/test/java/com/nanri/aiimage/MigratedSqlEquivalenceTest.java
index c6cd8b585..0d0e9f887 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/MigratedSqlEquivalenceTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/MigratedSqlEquivalenceTest.java
@@ -164,8 +164,10 @@ class MigratedSqlEquivalenceTest {
// v1.3 Phase 1(2026-11-10):appearancepatent 模块首份 mapper,4 条全部新写
//(覆盖式重写 delete/insert + 只读页 count/page select;V189 建表同窗),
// 注解时代没有原文可对撞,逐条点名留痕(XML_SELECT_TOTAL 同轮 103 → 105)。
- "AppearancePatentCleanItemMapper#deleteByResultId",
- "AppearancePatentCleanItemMapper#insertBatch",
+ // 2026-11-11「ASIN 累计」改造(V192 同窗):deleteByResultId+insertBatch
+ // 退役,由 upsertBatch(ON DUPLICATE KEY UPDATE,永不删除)顶替——NOT_MIGRATED
+ // 里的两条旧点名换成 upsertBatch 一条,净减 1(XML_STATEMENT_TOTAL 同轮 156 → 155)。
+ "AppearancePatentCleanItemMapper#upsertBatch",
"AppearancePatentCleanItemMapper#countCleanItems",
"AppearancePatentCleanItemMapper#selectCleanItemPage",
// 2026-11-11「按主管划分」(一主管一卡):4 条新写的 select——主管聚合
diff --git a/backend-java/src/test/java/com/nanri/aiimage/SqlLayeringConventionTest.java b/backend-java/src/test/java/com/nanri/aiimage/SqlLayeringConventionTest.java
index f29b9f82c..01f45d46f 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/SqlLayeringConventionTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/SqlLayeringConventionTest.java
@@ -106,7 +106,9 @@ class SqlLayeringConventionTest {
//(该文件 XML_SELECT_TOTAL 105 → 109)。
// 155 → 156:2026-11-11 卡片「删除」落 1 条 delete(deleteSupervisorItems,谓词与按主管导出
// 逐字同源)——delete 不计入该文件 XML_SELECT_TOTAL,只点名进 NOT_MIGRATED。
- private static final int XML_STATEMENT_TOTAL = 156;
+ // 156 → 155:2026-11-11「ASIN 累计」(V191 同窗)把同步链的 deleteByResultId+insertBatch
+ // 两条合并成 1 条 upsertBatch(ON DUPLICATE KEY UPDATE,永不删除)——净减 1 条。
+ private static final int XML_STATEMENT_TOTAL = 155;
/**
* wrapper 里夹带函数级 SQL 的现状("这不是简单单表"的证据),文件名 → 条数:
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentCleanSyncRoundTripTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentCleanSyncRoundTripTest.java
index e4cd23af6..e9b19d030 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentCleanSyncRoundTripTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentCleanSyncRoundTripTest.java
@@ -31,17 +31,19 @@ import static org.mockito.Mockito.when;
/**
* 「出表成功 → 同步落表 → 后管立即可查」全链 mock 回环(2026-11-10,用户口径
- * 「mock 一下测一下看看能不能同步」)。
+ * 「mock 一下测一下看看能不能同步」;2026-11-11 随「ASIN 累计」改造更新写侧语义)。
*
* 与 {@code AppearancePatentCleanSyncTest}(写侧逐格判据)互补:本类把 mapper mock 成一张
* 内存假表 ,按 {@code AppearancePatentCleanItemMapper.xml} 的真实语义模拟
* {@code biz_appearance_patent_clean_item}——id 自增、synced_at 取 DB 默认 CURRENT_TIMESTAMP
- * (同秒自增保序)、过滤面 company eq/task eq/ASIN 前缀/synced_at 半开区间、
+ * (同秒自增保序)、写侧按 {@code uk_company_user_country_asin}(V192)upsert 且永不删除、
+ * 过滤面 company eq/task eq/ASIN 前缀/synced_at 半开区间、
* ORDER BY synced_at DESC, id DESC——然后驱动两支真实服务 跑完整链:
*
*
* 写侧 {@code AppearancePatentCleanSyncService}:出表未成功不写行;url 回填后同步,
- * 严格口径只落「无侵权」行;补检重出按 result_id 覆盖式重写;
+ * 严格口径只落「无侵权」行(空 ASIN 不落);补检重出只更新不删除 ——改判侵权的行
+ * 保留原快照、仍无侵权的行按唯一键刷新;不同任务同 ASIN 只留一条(唯一键兜底);
* 读侧 {@code AppearancePatentCleanItemQueryService}(后管只读页同一入口):同步后立即可查,
* 分公司隔离(本公司看得见、别家看不见)、任务号/ASIN 前缀/同步日期窗口筛选与 SQL 同语义。
*
@@ -58,7 +60,8 @@ class AppearancePatentCleanSyncRoundTripTest {
TransientPayloadStorageService storage = mock(TransientPayloadStorageService.class);
when(taskChunkMapper.selectList(any())).thenReturn(List.of(chunk(33001L)));
when(adminUserMapper.selectById(77L)).thenReturn(user(77L, 7L));
- // 第一次出表 4 行 payload(2 无侵权+1 待复核+1 侵权);补检后首行翻成侵权
+ // 第一次出表 4 行 payload(2 无侵权+1 待复核+1 侵权);补检后首行翻成侵权;
+ // 第二个任务复检 B0CLEAN002 并新增 B0CLEAN003
when(storage.resolvePayload(anyString(), anyString()))
.thenReturn(json.writeValueAsString(List.of(
row("t1", "B0CLEAN001", "无侵权"),
@@ -67,7 +70,10 @@ class AppearancePatentCleanSyncRoundTripTest {
row("t4", "B0BAD0001", "侵权"))))
.thenReturn(json.writeValueAsString(List.of(
row("t1", "B0CLEAN001", "侵权"),
- row("t2", "B0CLEAN002", "无侵权"))));
+ row("t2", "B0CLEAN002", "无侵权"))))
+ .thenReturn(json.writeValueAsString(List.of(
+ row("t2", "B0CLEAN002", "无侵权"),
+ row("t5", "B0CLEAN003", "无侵权"))));
AppearancePatentCleanSyncService sync = new AppearancePatentCleanSyncService(
cleanItemMapper, taskChunkMapper, adminUserMapper, json, storage,
mock(org.springframework.transaction.PlatformTransactionManager.class));
@@ -84,6 +90,7 @@ class AppearancePatentCleanSyncRoundTripTest {
sync.syncFromResult(task, result(34819L, "oss://bucket/appearance_patent_33001.xlsx"));
assertEquals(2, table.rows.size(), "同步后假表恰有 2 行无侵权");
assertEquals(0, table.rows.get(0).getRowNo(), "row_no 按 payload 全行序号计(含被过滤行)");
+ LocalDateTime clean002BeforeResync = table.findByAsin("B0CLEAN002").getSyncedAt();
// ② 后管同一查询入口立即可见(超管全量),行值与 payload 一致(AC-1)、synced_at 倒序
AppearancePatentCleanItemPageVo vo = query.page(null, null, null, null, null, null, null, null, null);
@@ -101,22 +108,37 @@ class AppearancePatentCleanSyncRoundTripTest {
assertEquals(0L, query.page(null, null, null, null, null, null, null, null, 9L).getTotal(),
"别的公司查不到本公司同步行");
- // ④ 补检重新出表 → 覆盖式重写:首行翻成侵权后全库只剩 1 行(uk(result_id,row_no) 零重复)
+ // ④ 补检重新出表 → 只更新不删除(2026-11-11 累计语义):首行翻成侵权后不再落新行、
+ // 也不删旧行——改判侵权的 B0CLEAN001 保留原快照,B0CLEAN002 按唯一键刷新 synced_at。
+ // 旧覆盖语义在这里会把整段贡献抹掉(2026-11-11 实抹 1902 行的事故形状)。
sync.syncFromResult(task, result(34819L, "oss://bucket/appearance_patent_33001_retry.xlsx"));
- assertEquals(1, table.rows.size(), "覆盖式重写后只剩仍满足严格口径的 1 行");
- assertEquals(1, table.rows.get(0).getRowNo());
- assertEquals("B0CLEAN002", table.rows.get(0).getAsin());
- assertEquals(1L, query.page(null, null, null, null, null, null, null, null, null).getTotal(),
- "重出后后管立即可见新结果面");
+ assertEquals(2, table.rows.size(), "补检重出零删除:改判侵权的行保留原快照,仍无侵权的行原地刷新");
+ assertEquals("无侵权", table.findByAsin("B0CLEAN001").getConclusion(),
+ "重检改判侵权=不再落新行,旧无侵权快照保留(累计语义不回溯改写)");
+ assertTrue(table.findByAsin("B0CLEAN002").getSyncedAt().isAfter(clean002BeforeResync),
+ "同 ASIN 重复检测=唯一键命中原地更新,synced_at 刷新");
+ assertEquals(2L, query.page(null, null, null, null, null, null, null, null, null).getTotal(),
+ "重出后后管立即可见(不回退行数)");
- // ⑤ 后管筛选面与 XML 同语义:任务号 eq、ASIN 前缀、同步日期半开区间
- assertEquals(1L, query.page(null, null, 33001L, null, null, null, null, null, null).getTotal());
- assertEquals(0L, query.page(null, null, 99999L, null, null, null, null, null, null).getTotal());
- assertEquals(1L, query.page(null, null, null, "B0CLEAN", null, null, null, null, null).getTotal(),
- "ASIN 前缀命中");
- assertEquals(0L, query.page(null, null, null, "B0NOPE", null, null, null, null, null).getTotal());
+ // ⑤ 不同任务同 ASIN 只留一条、新 ASIN 追加:第二任务复检 B0CLEAN002 + 新增 B0CLEAN003
+ // → 全库 3 行(B0CLEAN002 仍只有一条,task_id 刷新成复检任务)
+ FileTaskEntity task2 = task(33002L, 77L);
+ sync.syncFromResult(task2, result(34820L, "oss://bucket/appearance_patent_33002.xlsx"));
+ assertEquals(3, table.rows.size(), "不同 ASIN 全保留:B0CLEAN001/002/003 各一条");
+ CleanItemEntity clean002 = table.findByAsin("B0CLEAN002");
+ assertEquals(33002L, clean002.getTaskId(), "同 ASIN 重复检测更新那条:归属刷新成最近一次检测的任务");
+ assertEquals(1L, query.page(null, null, null, "B0CLEAN003", null, null, null, null, null).getTotal(),
+ "新 ASIN 追加后按前缀可查");
+ assertEquals(3L, query.page(null, null, null, "B0CLEAN", null, null, null, null, null).getTotal(),
+ "ASIN 前缀命中累计后的三条(B0CLEAN001/002/003)");
+
+ // ⑥ 后管筛选面与 XML 同语义:任务号 eq、同步日期半开区间
+ assertEquals(1L, query.page(null, null, 33001L, null, null, null, null, null, null).getTotal(),
+ "任务 33001 只剩 B0CLEAN001 的原快照(B0CLEAN002 已被复检任务接管)");
+ assertEquals(2L, query.page(null, null, 33002L, null, null, null, null, null, null).getTotal(),
+ "任务 33002 拥有接管的 B0CLEAN002 + 新增的 B0CLEAN003");
LocalDate syncDay = table.lastSyncedAt.toLocalDate();
- assertEquals(1L, query.page(null, null, null, null, null, syncDay, syncDay, null, null).getTotal(),
+ assertEquals(3L, query.page(null, null, null, null, null, syncDay, syncDay, null, null).getTotal(),
"同步当天闭区间命中(synced_at < 次日 0 点)");
assertEquals(0L, query.page(null, null, null, null, null,
syncDay.plusDays(1), syncDay.plusDays(1), null, null).getTotal(),
@@ -128,7 +150,8 @@ class AppearancePatentCleanSyncRoundTripTest {
/**
* 内存假表:按 {@code AppearancePatentCleanItemMapper.xml} 真实语义模拟
- * {@code biz_appearance_patent_clean_item}(含 id 自增与 synced_at DB 默认值)。
+ * {@code biz_appearance_patent_clean_item}(含 id 自增、synced_at DB 默认值、
+ * uk_company_user_country_asin upsert 且永不删除)。
*/
private static final class FakeCleanItemTable {
private final List rows = new ArrayList<>();
@@ -136,39 +159,69 @@ class AppearancePatentCleanSyncRoundTripTest {
/** 模拟 DB CURRENT_TIMESTAMP 默认值;逐行 +1s 使「后同步在前」可断言。 */
private LocalDateTime lastSyncedAt = LocalDateTime.of(2026, 11, 10, 10, 30, 0);
- int deleteByResultId(Long resultId) {
- int before = rows.size();
- rows.removeIf(row -> resultId.equals(row.getResultId()));
- return before - rows.size();
+ /** 按 uk_company_user_country_asin(V192)upsert:命中即原地刷新,未命中才追加;永不删除。 */
+ int upsertBatch(List batch) {
+ int touched = 0;
+ if (batch != null) {
+ for (CleanItemEntity row : batch) {
+ CleanItemEntity existing = findByAsinScope(row);
+ lastSyncedAt = lastSyncedAt.plusSeconds(1);
+ if (existing == null) {
+ CleanItemEntity stored = new CleanItemEntity();
+ stored.setId(++idSeq);
+ copyRow(stored, row);
+ stored.setSyncedAt(lastSyncedAt);
+ rows.add(stored);
+ } else {
+ copyRow(existing, row);
+ existing.setSyncedAt(lastSyncedAt);
+ }
+ touched++;
+ }
+ }
+ return touched;
}
- int insertBatch(List batch) {
- for (CleanItemEntity row : batch) {
- CleanItemEntity stored = new CleanItemEntity();
- stored.setId(++idSeq);
- stored.setResultId(row.getResultId());
- stored.setTaskId(row.getTaskId());
- stored.setUserId(row.getUserId());
- stored.setCompanyId(row.getCompanyId());
- stored.setRowNo(row.getRowNo());
- stored.setAsin(row.getAsin());
- stored.setCountry(row.getCountry());
- stored.setSku(row.getSku());
- stored.setBrand(row.getBrand());
- stored.setPrice(row.getPrice());
- stored.setTitle(row.getTitle());
- stored.setImageUrl(row.getImageUrl());
- stored.setItemUrl(row.getItemUrl());
- stored.setConclusion(row.getConclusion());
- stored.setTitleReason(row.getTitleReason());
- stored.setAppearanceReason(row.getAppearanceReason());
- stored.setPatentReason(row.getPatentReason());
- stored.setSourceFilename(row.getSourceFilename());
- lastSyncedAt = lastSyncedAt.plusSeconds(1);
- stored.setSyncedAt(lastSyncedAt);
- rows.add(stored);
+ CleanItemEntity findByAsin(String asin) {
+ for (CleanItemEntity row : rows) {
+ if (asin.equals(row.getAsin())) {
+ return row;
+ }
}
- return batch == null ? 0 : batch.size();
+ throw new AssertionError("假表里找不到 ASIN " + asin);
+ }
+
+ private CleanItemEntity findByAsinScope(CleanItemEntity row) {
+ for (CleanItemEntity candidate : rows) {
+ if (row.getCompanyId().equals(candidate.getCompanyId())
+ && row.getUserId().equals(candidate.getUserId())
+ && row.getCountry().equals(candidate.getCountry())
+ && row.getAsin().equals(candidate.getAsin())) {
+ return candidate;
+ }
+ }
+ return null;
+ }
+
+ private void copyRow(CleanItemEntity target, CleanItemEntity row) {
+ target.setResultId(row.getResultId());
+ target.setTaskId(row.getTaskId());
+ target.setUserId(row.getUserId());
+ target.setCompanyId(row.getCompanyId());
+ target.setRowNo(row.getRowNo());
+ target.setAsin(row.getAsin());
+ target.setCountry(row.getCountry());
+ target.setSku(row.getSku());
+ target.setBrand(row.getBrand());
+ target.setPrice(row.getPrice());
+ target.setTitle(row.getTitle());
+ target.setImageUrl(row.getImageUrl());
+ target.setItemUrl(row.getItemUrl());
+ target.setConclusion(row.getConclusion());
+ target.setTitleReason(row.getTitleReason());
+ target.setAppearanceReason(row.getAppearanceReason());
+ target.setPatentReason(row.getPatentReason());
+ target.setSourceFilename(row.getSourceFilename());
}
long count(Long companyId, Long taskId, String asin, String country,
@@ -216,13 +269,11 @@ class AppearancePatentCleanSyncRoundTripTest {
}
}
- /** mapper mock 全部接在假表上:四支方法与 XML 同语义。 */
+ /** mapper mock 全部接在假表上:写侧 upsert+读侧 count/page,与 XML 同语义。 */
private static AppearancePatentCleanItemMapper mapperOver(FakeCleanItemTable table) {
AppearancePatentCleanItemMapper mapper = mock(AppearancePatentCleanItemMapper.class);
- when(mapper.deleteByResultId(anyLong()))
- .thenAnswer(inv -> table.deleteByResultId(inv.getArgument(0, Long.class)));
- when(mapper.insertBatch(any()))
- .thenAnswer(inv -> table.insertBatch(inv.getArgument(0)));
+ when(mapper.upsertBatch(any()))
+ .thenAnswer(inv -> table.upsertBatch(inv.getArgument(0)));
when(mapper.countCleanItems(any(), any(), any(), any(), any(), any(), any()))
.thenAnswer(inv -> table.count(inv.getArgument(0), inv.getArgument(1), inv.getArgument(2),
inv.getArgument(3), inv.getArgument(4), inv.getArgument(5)));
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentCleanSyncTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentCleanSyncTest.java
index 8f84af7fa..daa2892a6 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentCleanSyncTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentCleanSyncTest.java
@@ -14,7 +14,6 @@ import com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity;
import com.nanri.aiimage.modules.task.service.TransientPayloadStorageService;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
-import org.mockito.InOrder;
import java.io.IOException;
import java.lang.reflect.Method;
@@ -32,26 +31,31 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
/**
- * AC-1/AC-2/AC-3(v1.3 R1/R5):外观专利出表成功 → 「结论=无侵权」行同步落后管新表。
+ * AC-1/AC-2/AC-3(v1.3 R1/R5;AC-2 已按 2026-11-11「ASIN 累计」口径修订):外观专利出表成功
+ * → 「结论=无侵权」行同步落后管表。
*
* Phase 2 已激活。前 5 支是 Phase 0 预置的接缝判据 (接缝名是判据的一部分,
* 改名必须同步改判据并在蓝图 §5 登记);后 8 支是激活时补的真实对象行为样本:
*
*
* AC-1 :payload N 行、其中 M 行「结论=无侵权」→ {@code biz_appearance_patent_clean_item}
- * 恰有 M 行;{@code company_id}=任务 owner 用户的 {@code users.company_id};行字段与三因
- * 字段值等;非无侵权行零落表;owner 读不出 company_id ⇒ 跳过并留日志,不得回填默认公司
- * (铁律 30:读不出≠没有);
- * AC-2 :同一任务补检/重试重新出表 → 按 {@code result_id} 覆盖式重写,
- * {@code uk(result_id, row_no)} 下零重复行;出表失败(success=0/无持久化行)不写任何行;
+ * 恰有 M 行(空串 ASIN 的无侵权行不落表,只计数留痕);{@code company_id}=任务 owner 用户的
+ * {@code users.company_id};行字段与三因字段值等;非无侵权行零落表;owner 读不出 company_id
+ * ⇒ 跳过并留日志,不得回填默认公司 (铁律 30:读不出≠没有);
+ * AC-2(2026-11-11 修订,V192 同窗) :按唯一键 {@code uk_company_user_country_asin}
+ * upsert、永不删除 ——同 ASIN 重复检测更新那条,不同 ASIN 全保留,跨任务累计;
+ * 旧「按 result_id delete-then-insert 覆盖式重写」退役(重投递载荷读不准 cleanRows=0 时
+ * 它会抹掉存量,2026-11-11 实抹 1902 行);重投递读出 0 行=一个字节都不写;
+ * 出表失败(success=0/无持久化行)不写任何行;
* AC-3 :同步抛任何异常 → 任务终态与 {@code biz_file_result} 不被改写,错误只进日志;
* 同步装配路径(shouldAssembleSynchronously 分支)与异步出表作业两条触发点各一支判据 ——
* 装配分支的判据是接缝格(该分支当前恒不启用,无法行为触发);异步作业与失败兜底两路
@@ -109,15 +113,22 @@ class AppearancePatentCleanSyncTest {
}
@Test
- void 覆盖式落表走MapperXML按resultId重写() throws IOException {
+ void 累计落表走MapperXML按ASIN唯一键upsert() throws IOException {
Path mapper = MAIN.resolve("modules/appearancepatent/mapper/AppearancePatentCleanItemMapper.java");
assertTrue(Files.exists(mapper), "同步落表必须走 AppearancePatentCleanItemMapper(铁律 1:SQL 收口 Mapper 层)");
Path xml = findCleanItemMapperXml();
assertNotNull(xml, "mapper XML 必须落在 src/main/resources/mapper/**(铁律 1)");
- String sql = stripComments(Files.readString(xml));
- assertTrue(sql.contains("result_id"), "覆盖式重写的删除与插入都要按 result_id 键(AC-2,同 ShopDataCrawlItemStoreService 模式)");
- assertTrue(sql.toLowerCase().contains("delete"), "XML 必须含按 result_id 的 delete(delete-then-insert 覆盖式)");
- assertTrue(sql.toLowerCase().contains("insert"), "XML 必须含批量 insert(分批 ≤500/批,蓝图 §3.3)");
+ String sql = stripComments(Files.readString(xml)).replaceAll("(?s)", "");
+ assertTrue(sql.contains("upsertBatch"), "XML 必须含 upsertBatch 批量 upsert(分批 ≤500/批)");
+ assertTrue(sql.toUpperCase().contains("ON DUPLICATE KEY UPDATE"),
+ "累计语义=唯一键冲突时更新(ON DUPLICATE KEY UPDATE),V192 同窗");
+ assertTrue(sql.contains("company_id") && sql.contains("user_id")
+ && sql.contains("country") && sql.contains("asin"),
+ "upsert 的冲突键四元组(uk_company_user_country_asin,V191)必须全部出现在列清单");
+ assertFalse(sql.contains("deleteByResultId"),
+ "按 result_id 的覆盖式删除必须退役——重投递载荷读不准时它会抹掉存量(2026-11-11 实抹 1902 行)");
+ assertTrue(sql.toUpperCase().contains("DELETE"),
+ "XML 仍须保留按主管删除的 delete(deleteSupervisorItems,管理面显式动作,与同步链无关)");
}
@Test
@@ -140,22 +151,25 @@ class AppearancePatentCleanSyncTest {
when(taskChunkMapper.selectList(any())).thenReturn(List.of(chunk(33001L)));
when(adminUserMapper.selectById(77L)).thenReturn(user(7L));
ObjectMapper mapper = new ObjectMapper();
- // 行序即 row_no 序:clean(0)/clean(1)/待复核(2)/侵权(3)。字面量取值口径由黄金测试
- // AppearancePatentChunkRowContractTest#无侵权常量快照单一来源 钉在 LlmClient。
+ // 行序即 row_no 序:clean(0)/clean(1)/clean 但空 ASIN(2)/待复核(3)/侵权(4)。
+ // 字面量取值口径由黄金测试 AppearancePatentChunkRowContractTest#无侵权常量快照单一来源 钉在 LlmClient。
String payloadJson = mapper.writeValueAsString(List.of(
row("t1", "B0CLEAN001", "无侵权"),
row("t2", "B0CLEAN002", "无侵权"),
- row("t3", "B0RECHK01", "外观无侵权·商标待复核"),
- row("t4", "B0BAD0001", "侵权")));
+ blankAsinRow("t3"),
+ row("t4", "B0RECHK01", "外观无侵权·商标待复核"),
+ row("t5", "B0BAD0001", "侵权")));
AppearancePatentCleanSyncService service = service(cleanItemMapper, taskChunkMapper, adminUserMapper, payloadJson);
service.syncFromResult(task(33001L, 77L), result(34819L, 33001L, "oss://result/x.xlsx"));
- verify(cleanItemMapper).deleteByResultId(34819L);
@SuppressWarnings("unchecked")
ArgumentCaptor> rows = ArgumentCaptor.forClass((Class) List.class);
- verify(cleanItemMapper).insertBatch(rows.capture());
- assertEquals(2, rows.getValue().size(), "严格口径只应落 2 行:待复核与侵权行零落表(用户拍板 ①)");
+ verify(cleanItemMapper).upsertBatch(rows.capture());
+ // 写侧唯一交互=upsertBatch:同步链没有删除通道(接口上已无 deleteByResultId)
+ verifyNoMoreInteractions(cleanItemMapper);
+ assertEquals(2, rows.getValue().size(),
+ "严格口径只应落 2 行:待复核与侵权行零落表(用户拍板 ①),空 ASIN 行不落表(累计唯一键折叠口径)");
CleanItemEntity first = rows.getValue().get(0);
assertEquals(34819L, first.getResultId());
assertEquals(33001L, first.getTaskId());
@@ -194,7 +208,7 @@ class AppearancePatentCleanSyncTest {
}
@Test
- void 重新出表按resultId覆盖式重写零重复() throws Exception {
+ void 重复出表永不删除按唯一键累计upsert() throws Exception {
AppearancePatentCleanItemMapper cleanItemMapper = mock(AppearancePatentCleanItemMapper.class);
TaskChunkMapper taskChunkMapper = mock(TaskChunkMapper.class);
AdminUserMapper adminUserMapper = mock(AdminUserMapper.class);
@@ -202,7 +216,8 @@ class AppearancePatentCleanSyncTest {
when(adminUserMapper.selectById(77L)).thenReturn(user(7L));
ObjectMapper mapper = new ObjectMapper();
TransientPayloadStorageService storage = mock(TransientPayloadStorageService.class);
- // 补检后首行结论翻成侵权:覆盖式重写后只剩 1 行(row_no=1),uk(result_id, row_no) 下零重复
+ // 补检后首行结论翻成侵权:upsert 语义下只剩 1 行入选,且全程零删除——
+ // 唯一键 uk_company_user_country_asin(V192)由 DB 兜底「同 ASIN 只保留一条」
when(storage.resolvePayload(anyString(), anyString()))
.thenReturn(mapper.writeValueAsString(List.of(
row("t1", "B0CLEAN001", "无侵权"),
@@ -221,13 +236,14 @@ class AppearancePatentCleanSyncTest {
syncService.syncFromResult(task, result);
syncService.syncFromResult(task, result);
- InOrder order = inOrder(cleanItemMapper);
- order.verify(cleanItemMapper, times(2)).deleteByResultId(34819L);
@SuppressWarnings("unchecked")
ArgumentCaptor> batches = ArgumentCaptor.forClass((Class) List.class);
- verify(cleanItemMapper, times(2)).insertBatch(batches.capture());
+ verify(cleanItemMapper, times(2)).upsertBatch(batches.capture());
assertEquals(2, batches.getAllValues().get(0).size());
- assertEquals(1, batches.getAllValues().get(1).size(), "覆盖式重写:重出后只落仍满足严格口径的行");
+ assertEquals(1, batches.getAllValues().get(1).size(),
+ "重出后只 upsert 仍满足严格口径的行;累计语义由 DB 唯一键兜底");
+ // 两次同步对写侧的全部交互只有 upsertBatch:同步链没有删除通道(2026-11-11 误抹 1902 行的根治点)
+ verifyNoMoreInteractions(cleanItemMapper);
}
@Test
@@ -266,7 +282,7 @@ class AppearancePatentCleanSyncTest {
AdminUserMapper adminUserMapper = mock(AdminUserMapper.class);
when(taskChunkMapper.selectList(any())).thenReturn(List.of(chunk(33001L)));
when(adminUserMapper.selectById(77L)).thenReturn(user(7L));
- when(cleanItemMapper.deleteByResultId(anyLong())).thenThrow(new RuntimeException("db down"));
+ when(cleanItemMapper.upsertBatch(any())).thenThrow(new RuntimeException("db down"));
AppearancePatentCleanSyncService service = service(cleanItemMapper, taskChunkMapper, adminUserMapper,
new ObjectMapper().writeValueAsString(List.of(row("t1", "B0CLEAN001", "无侵权"))));
@@ -352,6 +368,11 @@ class AppearancePatentCleanSyncTest {
return row;
}
+ /** 结论无侵权但 ASIN 为空串的行:累计唯一键会把空 ASIN 折叠成一条,同步链不落表、只计数留痕。 */
+ private static AppearancePatentResultRowDto blankAsinRow(String rowToken) {
+ return row(rowToken, "", "无侵权");
+ }
+
private static FileTaskEntity task(long taskId, Long userId) {
FileTaskEntity task = new FileTaskEntity();
task.setId(taskId);