feat(公司隔离): V145 给两张规则库表补归属,唯一键改每公司一套

品牌库/去重库原本没有公司这一列、唯一键是全局的,所以"每公司一套"无从谈起。
V145 破例物化 company_id(含品牌库的 uploader_user_id 审计锚点),并把
uk_data_value / uk_data_value_brand 换成带 company_id 前缀的新键(先 ADD 后 DROP)。

按生产实查改写了计划里的写法:biz_dedupe_total_data 507,306 行 / MySQL 8.4.8,
非末位加列与 MODIFY 收 nullability 都要重建表,故三条加列显式钉 ALGORITHM = INSTANT、
列直接建成 NOT NULL DEFAULT 1、四条索引操作钉 INPLACE, LOCK = NONE,
回填换成由 users 驱动、带 d.company_id = 1 幂等限定的反推 UPDATE。

DEFAULT 1 是为混合版本窗口留的(批量写失败只 log.warn,缺列会静默丢数),
摘它必须用 ALTER COLUMN ... DROP DEFAULT——MODIFY 会按当时列默认值物化 instant 列,
把反推好的归属洗回 1。启动期哨兵据此从只探 users 扩成探三张表。

第二家公司已于 10-04 14:55 开通,历史行的实际上传者从此不可追溯,这笔不能再等。
回滚走 docs/rollback-V145-company-scope.sql 人工补丁,不编成 V146(Flyway 扫描路径会自己跑)。
This commit is contained in:
2026-10-04 16:14:57 +08:00
parent fa0cde0706
commit e6c4c9e7cf
7 changed files with 800 additions and 49 deletions
@@ -39,15 +39,16 @@ class CompanyMigrationV144Test {
private static final Pattern VERSION_FILE = Pattern.compile("^V(\\d+)(?:_(\\d+))?__.*\\.sql$");
/**
* 生产库 flyway_schema_history 的存量校验和(2026-10-04 11:0x 只读实查,主机A 业务库)。
* 这两个号已经被应用,字节就此封死;改一个空格都会让下次重启启动期校验失败。
* 生产库 flyway_schema_history 的存量校验和(2026-10-04 15:0x 只读复查实查,主机A 业务库)。
* 这三个号已经被应用,字节就此封死;改一个空格都会让下次重启启动期校验失败。
*/
private record Applied(String fileName, int prodChecksum) {
}
private static final List<Applied> APPLIED_IN_PROD = List.of(
new Applied("V142__web_config_sha256.sql", 1152261840),
new Applied("V143__company_and_users_company_id.sql", 1539570901));
new Applied("V143__company_and_users_company_id.sql", 1539570901),
new Applied("V144__users_company_id_drop_default.sql", 1833593804));
// ---------------------------------------------------------------- 取文件
@@ -170,15 +171,19 @@ class CompanyMigrationV144Test {
}
}
/** 破坏点:取号取到已应用的 143(原地改)或取到退役洞 132/133,Flyway 启动期撞号或报未应用。 */
/**
* 破坏点:取号取到已应用的 143(原地改)或取到退役洞 132/133,Flyway 启动期撞号或报未应用。
*
* <p>这里<b>不</b>断言"V144 是当前最大版本":那条断言在 V145 落盘的那一秒就会红,而它想防的
* 撞号已经由 {@code MigrationInventoryTest#noDuplicateVersionFiles} 把守。留在这种"每次新增
* 迁移都必须回来删一行"的断言,本质是给下一笔迁移埋雷。</p>
*/
@Test
void migrationIsVersionedOneFourFour() throws IOException {
Path file = migration();
assertEquals(144, versionOf(file), "摘 DEFAULT 必须是 V144(V143 之后的下一号,不能原地改 V143)");
assertTrue(file.getFileName().toString().matches("^V144__[A-Za-z0-9_.-]+$"),
"命名应 V144__<snake 描述>.sql: " + file.getFileName());
int maxOnDisk = versionFiles().stream().mapToInt(CompanyMigrationV144Test::versionOf).max().orElse(0);
assertEquals(144, maxOnDisk, "V144 应是当前最大版本");
}
/**
@@ -0,0 +1,363 @@
package com.nanri.aiimage.config;
import org.junit.jupiter.api.Test;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.StringReader;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import java.util.zip.CRC32;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* V145(品牌库/去重库物化 company_id + 唯一键按公司放宽)的文件审计。
* 设计:crawler-plugin/docs/ops/brand-dedupe-company-isolation-design-2026-10-04.md §4 / §5;
* 实施:crawler-plugin/docs/plans/18-brand-dedupe-company-isolation.md Task 2。
*
* <p>本仓 pom 无 H2、无 testcontainers,迁移跑不起来,所以文件审计是唯一能守住的层——
* 与 {@link CompanyMigrationV143Test} / {@link CompanyMigrationV144Test} 同口径:
* 断言打在剥掉注释后的可执行 SQL 上(注释里的 {@code --} 与字符串字面量里的 {@code --} 必须区分开,
* 否则断言打在残缺 SQL 上,见 {@link #stripComments})。</p>
*
* <p>这里的断言形状与 V143 不同(不是"可空 → 回填 → MODIFY NOT NULL"三段式),原因是 2026-10-04
* 上线前实查:生产 MySQL 8.4.8,{@code biz_dedupe_total_data} 507,306 行 / 181.3 MB。三段式在这张表上
* 意味着一次 50.7 万行的单语句 UPDATE(对所有扫描行持 X 锁)加一次改 nullability 的重建。
* 那两条破坏点用例({@link #avoidsTheThreeStageThatWouldRebuildTheBigTable})钉的就是这个。</p>
*/
class CompanyScopeMigrationV145Test {
private static final Path ROOT = Path.of(System.getProperty("user.dir"));
private static final Path DB_DIR = ROOT.resolve("src/main/resources/db");
private static final String INVALID = "biz_invalid_asin_data";
private static final String DEDUPE = "biz_dedupe_total_data";
// ---------------------------------------------------------------- 取文件
private static List<Path> versionFiles() throws IOException {
try (Stream<Path> s = Files.list(DB_DIR)) {
return s.filter(p -> p.getFileName().toString().matches("^V\\d+(?:_\\d+)?__.*\\.sql$"))
.sorted()
.toList();
}
}
private static int versionOf(Path p) {
Matcher m = Pattern.compile("^V(\\d+)(?:_\\d+)?__").matcher(p.getFileName().toString());
return m.find() ? Integer.parseInt(m.group(1)) : -1;
}
private static Path migration() throws IOException {
List<Path> hits = versionFiles().stream()
.filter(p -> p.getFileName().toString().startsWith("V145__"))
.toList();
assertFalse(hits.isEmpty(), "缺少 V145__*.sql:两张规则库的 company_id 还没落盘");
assertEquals(1, hits.size(), "V145 只允许一个迁移文件(撞号会让 Flyway 启动失败)");
return hits.get(0);
}
private static String raw(Path file) throws IOException {
return Files.readString(file, StandardCharsets.UTF_8);
}
private static String rawMigration() throws IOException {
return raw(migration());
}
private static String statements() throws IOException {
return normalize(stripComments(rawMigration()));
}
// ------------------------------------------------------------ SQL 预处理
// 与 CompanyMigrationV144Test 逐字同实现:注释里的 -- 与字符串里的 -- 是两件事,
// 另写一版简化实现会让断言打在残缺 SQL 上(V144 那份注释就写着这个理由)。
private static String stripComments(String sql) {
StringBuilder out = new StringBuilder(sql.length());
int i = 0;
while (i < sql.length()) {
char c = sql.charAt(i);
if (c == '\'') {
int end = i + 1;
while (end < sql.length()) {
if (sql.charAt(end) == '\'') {
if (end + 1 < sql.length() && sql.charAt(end + 1) == '\'') {
end += 2;
continue;
}
break;
}
end++;
}
out.append(sql, i, Math.min(end + 1, sql.length()));
i = end + 1;
continue;
}
if (c == '-' && i + 1 < sql.length() && sql.charAt(i + 1) == '-') {
while (i < sql.length() && sql.charAt(i) != '\n') {
i++;
}
continue;
}
if (c == '/' && i + 1 < sql.length() && sql.charAt(i + 1) == '*') {
int end = sql.indexOf("*/", i + 2);
i = end < 0 ? sql.length() : end + 2;
continue;
}
out.append(c);
i++;
}
return out.toString();
}
private static String normalize(String sql) {
return sql.replaceAll("\\s+", " ").trim();
}
/** Flyway 的校验和:CRC32 逐 {@code BufferedReader.readLine()} 的 UTF-8 字节累加,行尾不入 CRC。 */
private static int flywayChecksum(String content) throws IOException {
CRC32 crc = new CRC32();
try (BufferedReader reader = new BufferedReader(new StringReader(content))) {
String line;
while ((line = reader.readLine()) != null) {
crc.update(line.getBytes(StandardCharsets.UTF_8));
}
}
return (int) crc.getValue();
}
// ------------------------------------------------------------------ 用例
/** 破坏点:取到已应用的 144(原地改=两台都起不来),或为没写出来的迁移预留号段留洞。 */
@Test
void migrationIsVersionedOneFourFive() throws IOException {
Path file = migration();
assertEquals(145, versionOf(file), "本迁移必须是 V145(V144 之后的下一号)");
assertTrue(file.getFileName().toString().matches("^V145__[A-Za-z0-9_.-]+\\.sql$"),
"命名应 V145__<snake 描述>.sql:" + file.getFileName());
}
/**
* 破坏点:只给一张表加列。另一张表的读侧会拿 null 去过滤 ⇒ 整页空,而不是"少一列"。
* 且必须是 {@code NOT NULL DEFAULT 1}:可空=混合窗口里旧 jar 写进来的行归不到任何公司。
*/
@Test
void bothRuleTablesGetANotNullCompanyColumn() throws IOException {
String sql = statements();
for (String table : List.of(INVALID, DEDUPE)) {
assertTrue(sql.contains("ALTER TABLE `" + table + "` ADD COLUMN `company_id` bigint NOT NULL DEFAULT 1"),
table + " 应一次到位加成 NOT NULL DEFAULT 1,实际:" + sql);
}
assertEquals(2, count(sql, "ADD COLUMN `company_id` bigint NOT NULL DEFAULT 1"),
"只允许这两张表各一次 company_id 加列(第三张=推翻了一期零 DDL)");
}
/**
* 破坏点:照 V143 抄三段式。在 507,306 行 / 181.3 MB 的 biz_dedupe_total_data 上,
* 单语句回填 UPDATE 会对所有扫描行持 X 锁,MODIFY 改 nullability 要重建表——
* 而这两件事都不会报错,只会让去重导入在业务时间卡住。
* 末位加列 + ALGORITHM=INSTANT 才是本表该用的形状(MySQL 8.4.8 实查版本已写进头注释)。
*/
@Test
void avoidsTheThreeStageThatWouldRebuildTheBigTable() throws IOException {
String sql = statements();
assertEquals(3, count(sql, "ALGORITHM = INSTANT"), "三条加列都要钉 INSTANT,不认就报 1846 而不是悄悄 COPY");
assertFalse(sql.contains(" AFTER "),
"非末位加列不能走 INSTANT(会重建聚簇记录),本迁移一律加在表尾");
assertFalse(sql.contains("MODIFY COLUMN"),
"不许用 MODIFY 收 nullability:那是第二次表重建,DEFAULT 已经由加列语句带上了");
List<String> updates = new ArrayList<>();
Matcher m = Pattern.compile("UPDATE `(biz_[a-z_]+|users)`[^;]*;").matcher(sql);
while (m.find()) {
updates.add(m.group());
}
assertEquals(1, updates.size(), "本迁移只允许一条 UPDATE(按上传账号反推第 2 家的去重行),实际 " + updates);
String derivation = updates.get(0);
assertTrue(derivation.contains("JOIN `users` u"), "那条 UPDATE 必须由 users 驱动,否则扫描面是 50.7 万行");
assertTrue(derivation.contains("u.`company_id` <> 1"),
"必须限定在\"不属于第 1 家\"的行上——写成 IS NULL 回填就是全表扫");
assertTrue(derivation.contains("d.`company_id` = 1"), "必须带幂等限定,重跑才是 no-op");
assertTrue(rawMigration().contains("派生值"),
"头注释必须写明历史行的 1 是加列时记录的默认值(不是写进每一行的),否则后人不知道摘 DEFAULT 前要重跑核对");
}
/**
* 破坏点:不补 uploader_user_id。AUTO 行永远没有审计锚点,下次再要回填就只能全表填 1(§1.1、§3.3)。
* 这一列必须是【可空且无默认值】:历史行确实无从追溯,补一个假的归属比留空更坏。
*/
@Test
void invalidAsinAlsoGainsUploaderAnchor() throws IOException {
String sql = statements();
assertTrue(sql.contains("ALTER TABLE `" + INVALID + "` ADD COLUMN `uploader_user_id` bigint NULL DEFAULT NULL"),
"uploader_user_id 应可空且无默认值");
assertTrue(rawMigration().contains("AUTO 行取 task.user_id"),
"头注释/列注释应写明这一列的两个取值来源,否则后人会以为它是操作人字段");
}
/**
* 破坏点:新唯一键没把 company_id 放第一位,或旧唯一键还在。
* 旧键不删,第二家公司写同一个 ASIN 会被 INSERT IGNORE 静默吞掉——整套改造白做,而且一声不响。
*/
@Test
void uniqueKeysAreReplacedNotLayered() throws IOException {
String sql = statements();
assertTrue(sql.contains("ADD UNIQUE KEY `uk_company_value_brand` (`company_id`, `data_value`, `brand`(191))"), sql);
assertTrue(sql.contains("ADD UNIQUE KEY `uk_company_data_value` (`company_id`, `data_value`)"), sql);
assertTrue(sql.contains("DROP INDEX `uk_data_value_brand`"), sql);
assertTrue(sql.contains("DROP INDEX `uk_data_value`"), sql);
// 先加新再删旧:中间任何一步失败都至少还有一个唯一键在守并发
assertTrue(sql.indexOf("ADD UNIQUE KEY `uk_company_value_brand`") < sql.indexOf("DROP INDEX `uk_data_value_brand`"),
"品牌库顺序必须是先 ADD 后 DROP");
assertTrue(sql.indexOf("ADD UNIQUE KEY `uk_company_data_value`") < sql.indexOf("DROP INDEX `uk_data_value`"),
"去重库顺序必须是先 ADD 后 DROP");
assertEquals(4, count(sql, "ALGORITHM = INPLACE, LOCK = NONE"),
"四条索引操作都要钉 INPLACE+LOCK=NONE,否则 MySQL 可以选 COPY 锁写");
assertFalse(sql.contains("USING BTREE `uk_"), "不该出现的形式");
}
/**
* 破坏点:写成裸 ALTER(不可重跑)。MySQL 的 DDL 不进事务,repair+重启会从第一条语句重跑整个文件,
* 裸 ALTER 在恢复路径上必撞 1060/1050。这里按"每条条件 DDL 都配一份元数据判断"计数,
* 数量由本轮扫描得出,不自挑。
*/
@Test
void everyConditionalDdlIsGuardedByInformationSchema() throws IOException {
String sql = statements();
long alters = count(sql, "ALTER TABLE");
assertEquals(7, alters, "本迁移应有 7 条条件 DDL(3 加列 + 4 索引),实际 " + alters);
assertEquals(alters, count(sql, "PREPARE stmt FROM @sql"), "每条条件 DDL 都要走 PREPARE");
assertEquals(alters, count(sql, "DEALLOCATE PREPARE stmt"), "PREPARE 名复用前必须 DEALLOCATE");
assertTrue(count(sql, "information_schema") >= alters,
"每条条件 DDL 各自要一次元数据存在性判断");
}
/** 破坏点:动了别的表 / 建了表(一期定案是业务表零 DDL,破例只限这两张)。 */
@Test
void touchesOnlyTheTwoRuleTables() throws IOException {
List<String> altered = new ArrayList<>();
Matcher m = Pattern.compile("ALTER TABLE `([a-z_]+)`").matcher(statements());
while (m.find()) {
altered.add(m.group(1));
}
assertEquals(List.of(DEDUPE, INVALID), altered.stream().distinct().sorted().toList(),
"V145 只允许动这两张表,实际动到了 " + altered);
assertFalse(statements().contains("CREATE TABLE"), "不建新表");
assertFalse(statements().contains("ALTER TABLE `users`"), "不许顺手改 users(V144 已经管过它;本迁移只读它)");
assertFalse(statements().contains("INSERT INTO `columns`"), "本迁移不加菜单,公司管理菜单归 V143");
}
/** 破坏点:头注释的"影响表与数据量"是估的。锁表风险的结论只有配上实查行数才站得住。 */
@Test
void headerCarriesMeasuredVolumesAndTheDefaultCountdown() throws IOException {
String raw = rawMigration();
for (int i = 1; i <= 6; i++) {
assertTrue(raw.contains(i + ". "), "头注释缺模板第 " + i + " 项");
}
for (String field : List.of("变更目的", "影响表与数据量", "锁表风险", "验证 SQL", "回滚步骤", "上线窗口")) {
assertTrue(raw.contains(field), "头注释应含必填项:" + field);
}
assertTrue(raw.contains("507,306"), "去重库行数必须是生产实查值(写进锁表风险的依据)");
assertTrue(raw.contains("14,284"), "品牌库行数必须是生产实查值");
assertTrue(raw.contains("8.4.8"), "DDL 形状是按生产 MySQL 版本选的,头注释要记下版本");
assertTrue(raw.contains("1364"), "头注释要写清 DEFAULT 1 是为混合窗口的旧 jar 存在(1364 是被吞掉的那条错)");
assertTrue(raw.contains("COMPANY_DEFAULT_STILL_PRESENT"),
"头注释必须点名启动期哨兵签名,摘 DEFAULT 的倒计时才有人接");
assertTrue(raw.contains("ALTER COLUMN") && raw.contains("DROP DEFAULT"),
"头注释要给出摘 DEFAULT 的安全写法(纯元数据),否则后人会照 V144 用 MODIFY 重建表");
assertTrue(raw.contains("已于 10-04 14:55 开通") || raw.contains("14:55"),
"第二家公司已经开通这件事必须写在头注释里——它是 DEFAULT 摘除时点被压缩的唯一依据");
}
/** 破坏点:验证段没核对派生值、没核对新键的幂等语义。 */
@Test
void shipsPostDeployVerificationSql() throws IOException {
String raw = rawMigration();
assertTrue(raw.contains("SHOW COLUMNS FROM `" + INVALID + "` LIKE 'company_id'"), "验证 SQL 要核对品牌库列");
assertTrue(raw.contains("SHOW COLUMNS FROM `" + DEDUPE + "` LIKE 'company_id'"), "验证 SQL 要核对去重库列");
assertTrue(raw.contains("Default = 1"), "验证 SQL 要写明期望 Default = 1(混合窗口)");
assertTrue(raw.contains("SUM(company_id <> 1)"), "验证 SQL 要核对历史行的派生值真的是 1");
assertTrue(raw.contains("u.`company_id` <> d.`company_id`"),
"验证 SQL 要核对反推那条 UPDATE 真跑到了(misfiled 必须为 0),否则第 2 段的归属无人复核");
assertTrue(raw.contains("重跑这两条"), "摘 DEFAULT 的那笔迁移必须重跑派生值核对,验证段要把这句话留下");
assertTrue(raw.contains("INSERT IGNORE 在新键下"), "验证 SQL 要复验新唯一键的幂等语义");
assertTrue(raw.contains("uploader_user_id") && raw.contains("ZZTEST"),
"验收 INSERT 必须显式带上 NOT NULL 的 uploader_user_id,否则那条 SQL 在生产直接报错、实验做不成");
}
/**
* 破坏点:回滚被编成 V146(Flyway 扫描路径里的任何 V*.sql 都会在下次启动自动执行),
* 或者回滚脚本没删历史行(重装时 Flyway 判定"已应用"而跳过重建)。
*/
@Test
void rollbackStaysOutOfFlywayScanAndCoversTheHistoryRow() throws IOException {
try (Stream<Path> s = Files.list(DB_DIR)) {
assertTrue(s.noneMatch(p -> p.getFileName().toString().startsWith("V146__")),
"回滚不许编成版本化迁移:V146 会被 Flyway 在下次启动自动执行");
}
Path rollback = ROOT.resolve("docs/rollback-V145-company-scope.sql");
assertTrue(Files.isRegularFile(rollback), "回滚人工补丁必须存在:" + rollback);
String whole = raw(rollback);
assertTrue(whole.contains("flyway_schema_history"), "回滚必须删本版本历史行");
String executable = normalize(stripComments(whole));
assertTrue(executable.contains("ADD UNIQUE KEY `uk_data_value_brand` (`data_value`, `brand`(191))"),
"回滚要把品牌库的全局唯一键加回来");
assertTrue(executable.contains("ADD UNIQUE KEY `uk_data_value` (`data_value`)"),
"回滚要去把去重库的全局唯一键加回来");
assertFalse(executable.contains("DROP COLUMN"),
"DROP COLUMN 是丢归属信息的动作,必须留在注释里由人工解开(第 2 家已开通,删了就无法再分清)");
}
/**
* 破坏点:头注释喊了哨兵,哨兵却没探这两列 ⇒ "有人盯着摘 DEFAULT"这件事是假的。
* 这条把文档承诺与代码实现对齐(§10 护栏 1 的可执行部分)。
*/
@Test
void startupSentinelActuallyWatchesTheTwoNewColumns() throws IOException {
Path guard = ROOT.resolve("src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java");
assertTrue(Files.isRegularFile(guard), "启动期 DEFAULT 哨兵应存在:" + guard);
String text = raw(guard);
assertTrue(text.contains("COMPANY_DEFAULT_STILL_PRESENT"), "哨兵标记串必须保持 ASCII 原样(巡检按它 grep docker logs)");
assertTrue(text.contains("'" + INVALID + "'"), "哨兵要探品牌库的 company_id,否则 V145 的 DEFAULT 没人盯");
assertTrue(text.contains("'" + DEDUPE + "'"), "哨兵要探去重库的 company_id");
assertTrue(text.contains("COLUMN_DEFAULT"), "哨兵应真的读列元数据,而不是靠猜");
}
/** 破坏点:盘点文档没跟着改,下一个人按"取号起点"取号就撞号。 */
@Test
void inventoryDocTracksV145() throws IOException {
Path doc = ROOT.resolve("docs/migration-inventory.md");
String text = raw(doc);
assertTrue(text.contains(migration().getFileName().toString()), "盘点文档应记录 V145 文件名");
assertTrue(text.contains("V146"), "盘点文档应把取号起点推到 V146");
assertTrue(text.contains("1833593804"), "盘点文档应记下 V144 的生产存量校验和");
assertTrue(text.contains("1539570901"), "盘点文档应保留 V143 的生产存量校验和");
}
/** 自检:本用例集扫的是真文件,且 normalize 后仍能命中关键串(0 命中的断言是恒绿的)。 */
@Test
void scannedSignaturesAreActuallyPresent() throws IOException {
String sql = statements();
assertTrue(sql.length() > 1000, "剥注释后的 SQL 太短,说明预处理把内容吃掉了:" + sql.length());
assertTrue(count(sql, "ALTER TABLE") > 0 && count(sql, "information_schema") > 0,
"关键签名 0 命中=预处理或文件路径坏了,本类的断言全部不可信");
}
private static long count(String haystack, String needle) {
int n = 0, i = haystack.indexOf(needle);
while (i >= 0) {
n++;
i = haystack.indexOf(needle, i + needle.length());
}
return n;
}
}