P2-1: 权限对拍扩容(真实实体只读权限对拍)+ 报告 + 手册坑位

platform-parity 新增「真实实体只读权限对拍」模式:
- RealEntityPrivilegeRunner:从客户库真实 SYS_FILTERRULE(1079 条活跃规则)发现
  可确定性复现的 (实体,用户,角色) 案例(只挑 []→全表、USERID={CURRENTUSERID}→
  WHERE userid=<uid> 两类形态,且仅当用户全部交集规则均可复现才取正例),
  真实用户 ctx 驱动引擎行级过滤 vs JDBC 等价 WHERE 逐行 diff;负例无命中角色→
  PrivilegeException(HTTP 非 200)。全程只读,绝不向客户库写规则。
- ParityCli 增 --realprivilege 模式 + JSON/MD 报告;SelfCheckRunner 抽出 checkRows
  复用自对拍豁免内核(BOOLEAN 域外/计算列/物理孤儿/xml/JSON 空值),纯增量不改既有路径。

实测(8085 客户库只读):HR_SAFETYCARD/HR_OTHERCARD/HR_CONSTRUCTORCARD/HR_MEMBERCARD
共 4 实体 805 行 100% 逐行一致 + 5/5 负例被拒。

报告:platform-auth/P2组织权限实测报告.md(移植清单/REST 7 例证据/对拍扩容/
密码哈希=无盐小写 MD5 客户库实证)。

手册新坑:§5.32(userid 36/32 长度不一致 varchar 等值)、§5.33(真实规则形态多样
只纳入可复现形态对拍)、§5.OTP(私有 jar 模块内仓库)。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
2026-06-11 13:39:17 +08:00
parent 8d1d2ab0f7
commit 82f52c1114
5 changed files with 705 additions and 0 deletions

View File

@@ -25,6 +25,7 @@ import com.fasterxml.jackson.databind.SerializationFeature;
* --entities=EIP4PT_ALLTYPE,EIP4PT_ORDER # 或 --all
* [--seed] # 先灌种子(建 ≥20 实体 + 每实体 50 行)
* [--privilege] # C2 数据行级权限对拍(3 受控实体×3 用户 + 负例)
* [--realprivilege [--realEntities=HR_SAFETYCARD,...]] # P2 真实实体只读权限对拍(客户库真实规则)
* [--jdbc=jdbc:postgresql://localhost:5433/eip4m0] [--user=zhengwr] [--pass=]
* [--engine=http://localhost:8084] [--out=parity-reports]
* }</pre>
@@ -70,6 +71,15 @@ public final class ParityCli {
System.exit(code);
}
// P2 真实实体只读权限对拍:--realprivilege [--realEntities=HR_SAFETYCARD,HR_EMPLOYEE]
if (opt.containsKey("realprivilege")) {
String ents = opt.getOrDefault("realEntities",
"HR_SAFETYCARD,HR_OTHERCARD,HR_EMPLOYEE,HR_CONSTRUCTORCARD,HR_MEMBERCARD");
List<String> realTables = new ArrayList<>(Arrays.asList(ents.split(",")));
int code = runRealPrivilege(engine, ds, outDir, realTables);
System.exit(code);
}
List<String> entities = new ArrayList<>();
if (opt.containsKey("seed")) {
System.out.println("[seed] 建实体 + 灌数据(固定种子 " + ParitySeeder.SEED + ")...");
@@ -244,6 +254,184 @@ public final class ParityCli {
Files.writeString(path, sb.toString());
}
/**
* P2 真实实体只读权限对拍:从客户库真实 SYS_FILTERRULE 配置发现可复现 (实体,用户,规则) 案例,
* 用真实用户上下文驱动引擎行级过滤 vs JDBC 等价 WHERE 逐行 diff;并对每个候选实体跑负例
* (无命中角色 → PrivilegeException)。<b>全程只读,不写客户库规则</b>。
* 退出码:正例全一致(或无可复现案例但负例全被拒)=0,正例有差异=2。
*/
private static int runRealPrivilege(String engine, javax.sql.DataSource ds, Path outDir,
List<String> tables) throws Exception {
System.out.println("=== P2 真实实体只读权限对拍(--realprivilege)===");
System.out.println("候选实体: " + tables);
RealEntityPrivilegeRunner runner = new RealEntityPrivilegeRunner(engine, ds);
String someUser = runner.anyRealUser();
List<Map<String, Object>> entityFindings = new ArrayList<>();
List<DiffReport> positives = new ArrayList<>();
int cleanCount = 0;
long totalRows = 0;
int negPass = 0;
int negTotal = 0;
for (String tbl : tables) {
String t = tbl.trim().toUpperCase();
Map<String, Object> f = new LinkedHashMap<>();
f.put("entity", t);
int rules = runner.activeRuleCount(t);
f.put("activeRules", rules);
// 正例:发现可复现案例
RealEntityPrivilegeRunner.Case c = runner.discoverCase(t);
if (c != null) {
DiffReport r = runner.checkPositive(c);
positives.add(r);
totalRows += r.leftRowCount;
boolean clean = r.isClean();
if (clean) {
cleanCount++;
}
f.put("positiveCase", Map.of(
"user", c.userId,
"role", c.roleId,
"ruleShape", RealEntityPrivilegeRunner.RULE_VIEW_ALL.equals(c.ruleShape)
? "view-all" : "userid-self",
"equivalentWhere", c.equivalentWhere == null ? "(全表)" : c.equivalentWhere,
"rows", r.leftRowCount,
"consistencyRate", Math.round(r.consistencyRate() * 10000.0) / 10000.0,
"clean", clean));
System.out.printf(" 正例 %-26s 规则=%-12s 行=%-4d 一致率=%.4f %s%n",
t, RealEntityPrivilegeRunner.RULE_VIEW_ALL.equals(c.ruleShape) ? "view-all" : "userid-self",
r.leftRowCount, r.consistencyRate(), clean ? "OK" : "DIFF");
} else {
f.put("positiveCase", rules > 0
? "有真实规则但无可复现形态案例(规则形态未纳入复现集,如实登记)"
: "客户库该实体无生效规则");
System.out.printf(" 正例 %-26s (无可复现案例:活跃规则=%d)%n", t, rules);
}
// 负例:无命中角色 → 期望非 200(仅对有规则的实体断言;无规则实体登记 200=不触发拒绝)
if (rules > 0 && someUser != null) {
int code = runner.checkNegativeStatus(t, someUser);
negTotal++;
boolean rejected = code != 200;
if (rejected) {
negPass++;
}
f.put("negativeHttp", code);
f.put("negativeRejected", rejected);
System.out.printf(" 负例 %-26s 无命中角色 → HTTP=%d %s%n",
t, code, rejected ? "REJECTED(OK)" : "NOT-REJECTED");
} else {
f.put("negativeHttp", rules > 0 ? "(无可用真实用户)" : "(无规则,跳过)");
}
entityFindings.add(f);
}
boolean allPositiveClean = cleanCount == positives.size();
boolean allNegRejected = negTotal == 0 || negPass == negTotal;
boolean ok = allPositiveClean;
String ts = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd-HHmmss"));
Path json = outDir.resolve("realprivilege-parity-" + ts + ".json");
Path md = outDir.resolve("realprivilege-parity-" + ts + ".md");
writeRealPrivilegeJson(json, entityFindings, positives, cleanCount, totalRows, negPass, negTotal);
writeRealPrivilegeMarkdown(md, entityFindings, positives, cleanCount, totalRows, negPass, negTotal);
System.out.println("\n=== P2 真实实体权限对拍汇总 ===");
System.out.println("候选实体: " + tables.size());
System.out.println("可复现正例: " + positives.size() + ",全一致: " + cleanCount);
System.out.println("总比对行数(JDBC 基线侧): " + totalRows);
System.out.println("负例(无命中角色被拒): " + negPass + "/" + negTotal);
System.out.println("结果: " + (ok && allNegRejected ? "✅ 通过" : "⚠️ 存在失败"));
System.out.println("报告: " + json + " / " + md);
return ok ? 0 : 2;
}
private static void writeRealPrivilegeJson(Path path, List<Map<String, Object>> findings,
List<DiffReport> positives, int cleanCount, long totalRows,
int negPass, int negTotal) throws Exception {
ObjectMapper m = new ObjectMapper().enable(SerializationFeature.INDENT_OUTPUT);
Map<String, Object> root = new LinkedHashMap<>();
Map<String, Object> summary = new LinkedHashMap<>();
summary.put("mode", "realprivilege");
summary.put("candidateEntities", findings.size());
summary.put("reproduciblePositives", positives.size());
summary.put("positiveClean", cleanCount);
summary.put("totalRows", totalRows);
summary.put("positiveConsistencyRate", positives.isEmpty() ? 1.0 : (double) cleanCount / positives.size());
summary.put("negativeRejected", negPass + "/" + negTotal);
summary.put("allPass", cleanCount == positives.size());
root.put("summary", summary);
root.put("entities", findings);
List<Map<String, Object>> rs = new ArrayList<>();
for (DiffReport r : positives) {
rs.add(r.toSummaryMap());
}
root.put("positiveReports", rs);
Files.writeString(path, m.writeValueAsString(root));
}
private static void writeRealPrivilegeMarkdown(Path path, List<Map<String, Object>> findings,
List<DiffReport> positives, int cleanCount, long totalRows,
int negPass, int negTotal) throws Exception {
StringBuilder sb = new StringBuilder();
sb.append("# P2 真实实体只读权限对拍报告\n\n");
sb.append("> 数据源:客户库真实 SYS_FILTERRULE 配置(只读,未写任何规则)。\n");
sb.append("> 方法:从真实规则发现可复现 (实体,用户,角色) 案例,真实用户 ctx 驱动引擎行级过滤 vs JDBC 等价 WHERE 逐行 diff。\n\n");
sb.append("- 候选实体: ").append(findings.size()).append("\n");
sb.append("- 可复现正例: ").append(positives.size()).append(",全一致: ").append(cleanCount)
.append(positives.isEmpty() ? "" : (cleanCount == positives.size() ? " ✅" : " ⚠️")).append("\n");
sb.append("- 总比对行数(JDBC 基线侧): ").append(totalRows).append("\n");
sb.append("- 负例(无命中角色被拒): ").append(negPass).append("/").append(negTotal)
.append(negTotal > 0 && negPass == negTotal ? " ✅ 全部被拒" : "").append("\n\n");
sb.append("## 逐实体发现与对拍\n\n");
sb.append("| 实体 | 活跃规则 | 正例规则形态 | 等价 WHERE | 行数 | 一致率 | 负例HTTP | 结果 |\n");
sb.append("|---|---|---|---|---|---|---|---|\n");
int pi = 0;
for (Map<String, Object> f : findings) {
Object pc = f.get("positiveCase");
String shape = "—";
String where = "—";
String rows = "—";
String rate = "—";
String result = "—";
if (pc instanceof Map<?, ?> pcm) {
shape = String.valueOf(pcm.get("ruleShape"));
where = String.valueOf(pcm.get("equivalentWhere"));
rows = String.valueOf(pcm.get("rows"));
rate = String.valueOf(pcm.get("consistencyRate"));
result = Boolean.TRUE.equals(pcm.get("clean")) ? "✅" : "⚠️";
pi++;
} else {
shape = "(无可复现案例)";
}
sb.append("| ").append(f.get("entity"))
.append(" | ").append(f.get("activeRules"))
.append(" | ").append(shape)
.append(" | ").append(where)
.append(" | ").append(rows)
.append(" | ").append(rate)
.append(" | ").append(f.getOrDefault("negativeHttp", "—"))
.append(" | ").append(result).append(" |\n");
}
sb.append("\n## 说明\n\n");
sb.append("- 正例只挑两类<b>可确定性复现</b>等价 WHERE 的真实规则形态:空条件 `[]`(查看全部→全表)、");
sb.append("`USERID={CURRENTUSERID}`(查看自己→`WHERE userid=<uid>`)。其余真实形态(`KIND=N`、");
sb.append("`{CURRENTUSERORGID}` 子查询、OWNNERPROJECT 等)语义虽真实但等价 WHERE 重建脆弱,不纳入正例避免假阳性。\n");
sb.append("- 用户挑选:仅当真实用户对该实体的<b>全部</b>交集规则都属可复现形态才取为正例");
sb.append("(否则引擎会 OR 进不可复现规则,等价 WHERE 不成立)。\n");
sb.append("- 负例:无命中角色 → 引擎 `getWhereClause` first 分支抛 `PrivilegeException`(HTTP 非 200);");
sb.append("只读构造 ctx,绝不向客户库写规则。\n\n");
for (DiffReport r : positives) {
if (!r.isClean()) {
sb.append(r.toMarkdown()).append("\n");
}
}
Files.writeString(path, sb.toString());
}
private static List<String> listEip4ptEntities(javax.sql.DataSource ds) {
return new org.springframework.jdbc.core.JdbcTemplate(ds).queryForList(
"SELECT tablename FROM sys_entity WHERE tablename LIKE ? AND isactive=1 ORDER BY tablename",

View File

@@ -0,0 +1,246 @@
package com.eip4.platform.parity.selfcheck;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;
import com.eip4.platform.parity.diff.DiffReport;
/**
* 真实实体只读权限对拍(P2 扩容)。
*
* <p>区别于 C2 的种子实体对拍(EIP4PT_* 自造规则),本模式直接<b>从客户库真实
* {@code SYS_FILTERRULE} 配置中发现可复现的 (实体, 用户, 角色, 等价 WHERE) 案例</b>,
* 用真实用户上下文驱动引擎行级过滤路径,与 JDBC 同语义 WHERE 逐行对拍。<b>全程只读,
* 绝不向客户库写任何规则</b>(任务红线)。
*
* <h3>可复现规则形态(只挑这两类构造确定性等价 WHERE)</h3>
* <ul>
* <li><b>空条件 {@code []}</b>(「查看全部」角色)→ 引擎 {@code (1=1)} → 等价 WHERE 为<b>无</b>(全表)。</li>
* <li><b>{@code [{USERID = {CURRENTUSERID}}]}</b>(「查看自己」角色)→ 引擎 {@code P.USERID='<uid>'}
* → 等价 WHERE {@code WHERE userid = '<uid>'}。</li>
* </ul>
* 其余形态(KIND=N 静态、{@code {CURRENTUSERORGID}} 子查询、OWNNERPROJECT 等)语义虽真实,
* 但等价 WHERE 重建脆弱,不纳入正例对拍(避免假阳性);改由报告如实登记「该实体有真实规则但
* 形态未纳入复现集」。
*
* <h3>用户挑选纪律</h3>
* 仅当某真实用户对该实体的「全部生效规则」恰好都属上述可复现形态(即用户的有效角色与该实体规则
* 的交集只命中可复现规则),才取该用户做正例——否则引擎会 OR 进无法复现的规则,等价 WHERE 不成立。
*
* <h3>负例</h3>
* 任取一个该实体配了规则但用户<b>无任何命中角色</b>的上下文 → 引擎 {@code getWhereClause} 的
* first 分支抛 {@code PrivilegeException}(HTTP 非 200),断言之(印证「规则存在但无命中角色 → 拒绝」)。
* 客户库无现成规则的实体则只跑此负例路径(只读构造 ctx,不写规则)。
*/
public class RealEntityPrivilegeRunner {
/** 引擎对「查看全部」空条件规则的 JSON 形态(filterrule 列存的精确串)。 */
static final String RULE_VIEW_ALL = "[]";
/** 引擎对「查看自己」CURRENTUSERID 规则的 JSON 形态。 */
static final String RULE_USERID_SELF =
"[{\"preConditional\":\"USERID\",\"sign\":\"=\",\"backConditional\":\"{CURRENTUSERID}\","
+ "\"type\":\"CURRENTUSERID\",\"op\":null}]";
private final EngineHttpClient engine;
private final JdbcResultReader jdbc;
private final SelfCheckRunner selfCheck;
private final org.springframework.jdbc.core.JdbcTemplate jt;
public RealEntityPrivilegeRunner(String engineBaseUrl, DataSource dataSource) {
this.engine = new EngineHttpClient(engineBaseUrl);
this.jdbc = new JdbcResultReader(dataSource);
this.selfCheck = new SelfCheckRunner(engineBaseUrl, dataSource);
this.jt = new org.springframework.jdbc.core.JdbcTemplate(dataSource);
}
/** 一个可复现正例案例(发现自客户库)。 */
public static final class Case {
public final String table;
public final String userId;
public final String roleId;
public final String ruleShape; // RULE_VIEW_ALL / RULE_USERID_SELF
public final String equivalentWhere; // null=全表
Case(String table, String userId, String roleId, String ruleShape, String equivalentWhere) {
this.table = table;
this.userId = userId;
this.roleId = roleId;
this.ruleShape = ruleShape;
this.equivalentWhere = equivalentWhere;
}
}
/**
* 在客户库为某实体发现一个可复现正例:挑一个真实用户,其对该实体生效的规则恰好<b>仅命中一条</b>
* 可复现形态规则(view-all 或 userid-self),返回该 (用户, 角色, 等价 WHERE)。无则返回 null。
*/
public Case discoverCase(String table) {
String t = table.toUpperCase();
// 该实体的全部生效规则(rid, roleid, shape)
List<Map<String, Object>> rules = jdbc.query(
"SELECT fr.sys_filterrule_id AS rid, frr.roleid AS roleid, fr.filterrule AS shape "
+ "FROM sys_filterrule fr "
+ "JOIN sys_entity e ON e.sys_entity_id = fr.entityid AND upper(trim(e.tablename)) = ? "
+ "JOIN sys_filterrulerole frr ON frr.filterruleid = fr.sys_filterrule_id "
+ "WHERE fr.isactive = 1", t);
if (rules.isEmpty()) {
return null;
}
// 候选可复现规则角色 → shape
for (String shape : new String[] {RULE_VIEW_ALL, RULE_USERID_SELF}) {
for (Map<String, Object> r : rules) {
String shapeVal = str(r.get("SHAPE"));
if (!shape.equals(shapeVal)) {
continue;
}
String roleId = str(r.get("ROLEID"));
// 找一个持有该角色(直接或经 SYS_ROLE_ROLE 派生)的真实在岗用户,
// 且其对该实体的<b>全部</b>交集规则都属可复现形态(否则 OR 进不可复现规则)
String uid = pickUserWithOnlyReproducibleRules(t, roleId);
if (uid != null) {
String where = RULE_VIEW_ALL.equals(shape)
? null
: "userid = '" + uid + "'";
return new Case(t, uid, roleId, shape, where);
}
}
}
return null;
}
/**
* 挑一个持有 {@code targetRole} 的真实用户,其对实体 {@code table} 的全部交集规则都是可复现形态。
* 经 {@code RoleServiceImpl.findRolesByUserId} 同语义(直接角色 UNION SYS_ROLE_ROLE 派生)。
*/
private String pickUserWithOnlyReproducibleRules(String table, String targetRole) {
List<String> uids = jt.queryForList(
"WITH direct AS ("
+ " SELECT trim(u.sys_user_id) uid, ugr.roleid"
+ " FROM sys_user u"
+ " JOIN sys_usergroupuser ugu ON ugu.userid = u.sys_user_id::bpchar"
+ " JOIN sys_usergrouprole ugr ON ugr.usergroupid::text = ugu.usergroupid::text"
+ " WHERE u.state = 1"
+ "), eff AS ("
+ " SELECT uid, roleid FROM direct"
+ " UNION SELECT d.uid, trim(rr.datarole) FROM direct d"
+ " JOIN sys_role_role rr ON rr.operatorrole = d.roleid"
+ ") "
// 持有目标角色的用户
+ "SELECT eff.uid FROM eff WHERE eff.roleid = ? "
// 排除「对该实体还命中任何非可复现规则」的用户
+ "EXCEPT "
+ "SELECT eff.uid FROM eff "
+ " JOIN sys_filterrule fr ON fr.isactive = 1 "
+ " JOIN sys_entity e ON e.sys_entity_id = fr.entityid AND upper(trim(e.tablename)) = ? "
+ " JOIN sys_filterrulerole frr ON frr.filterruleid = fr.sys_filterrule_id "
+ " AND frr.roleid = eff.roleid "
+ "WHERE fr.filterrule NOT IN (?, ?) "
+ "LIMIT 50",
String.class, targetRole, table, RULE_VIEW_ALL, RULE_USERID_SELF);
// 优先返回「该 WHERE 下有 >0 行」的用户(更有信息量),否则取首个(空集也是合法对拍)
String fallback = null;
for (String uid : uids) {
if (fallback == null) {
fallback = uid;
}
// 用户对该实体的有效规则是 view-all → 任意行;userid-self → 该 userid 的行数
try {
Long n = jt.queryForObject(
"SELECT count(*) FROM " + table + " WHERE userid = ?", Long.class, uid);
if (n != null && n > 0) {
return uid;
}
} catch (Exception ignore) {
// 该实体无 userid 列 → userid-self 形态不适用此实体,跳过
}
}
return fallback;
}
/** 跑一个可复现正例:引擎(asUser+role)行级过滤 vs JDBC 等价 WHERE,逐行 diff(复用自对拍豁免内核)。 */
public DiffReport checkPositive(Case c) {
String label = c.table + "[用户 " + shortId(c.userId) + "/规则 "
+ (RULE_VIEW_ALL.equals(c.ruleShape) ? "view-all" : "userid-self") + "]";
List<Map<String, Object>> left;
List<Map<String, Object>> right;
try {
left = c.equivalentWhere == null
? jdbc.readAll(c.table)
: jdbc.query("SELECT * FROM " + c.table + " WHERE " + c.equivalentWhere);
} catch (Exception e) {
return error(label, "JDBC 基线读失败: " + e.getMessage());
}
try {
right = engine.listAll(c.table, "asUser=" + c.userId + "&roles=" + c.roleId);
} catch (Exception e) {
return error(label, "引擎过滤路径失败: " + e.getMessage());
}
return selfCheck.checkRows(c.table, label, left, right);
}
/**
* 负例:对该实体用「无任何命中角色」的真实用户上下文访问 → 期望引擎抛 PrivilegeException(非 200)。
* 只读构造 ctx(asUser=任意真实用户 + roles=一个绝不命中的占位角色),不写客户库。
* @return HTTP 状态码(期望 != 200);该实体无规则则返回 200(无规则不触发拒绝,如实登记)。
*/
public int checkNegativeStatus(String table, String someRealUser) {
try {
// 用一个绝不存在于该实体规则角色集的占位角色,触发 first 分支拒绝
return engine.statusOf(table.toUpperCase(),
"asUser=" + someRealUser + "&roles=ROLE_NOBODY_REALPARITY");
} catch (Exception e) {
return -1;
}
}
/** 该实体在客户库是否配了生效规则(决定走正例还是仅负例报告)。 */
public int activeRuleCount(String table) {
Long n = jt.queryForObject(
"SELECT count(*) FROM sys_filterrule fr "
+ "JOIN sys_entity e ON e.sys_entity_id = fr.entityid "
+ "WHERE fr.isactive = 1 AND upper(trim(e.tablename)) = ?",
Long.class, table.toUpperCase());
return n == null ? 0 : n.intValue();
}
/** 取一个真实在岗用户 id(负例 ctx 用,任意一个即可)。 */
public String anyRealUser() {
List<String> ids = jt.queryForList(
"SELECT trim(sys_user_id) FROM sys_user WHERE state = 1 LIMIT 1", String.class);
return ids.isEmpty() ? null : ids.get(0);
}
private static String str(Object o) {
return o == null ? null : o.toString().trim();
}
private static String shortId(String id) {
if (id == null) {
return "?";
}
return id.length() > 8 ? id.substring(0, 8) : id;
}
private static DiffReport error(String label, String msg) {
DiffReport r = new DiffReport(label);
DiffReport.RowMismatch mm = new DiffReport.RowMismatch("RUNNER_ERROR");
mm.cells.add(new DiffReport.CellDiff("error", null, msg, "VALUE"));
r.mismatches.add(mm);
return r;
}
/** 工具:为一批候选实体并行无关地各发现一个正例案例(null 表示未发现可复现案例)。 */
public List<Case> discoverCases(List<String> tables) {
List<Case> out = new ArrayList<>();
for (String t : tables) {
Case c = discoverCase(t);
if (c != null) {
out.add(c);
}
}
return out;
}
}

View File

@@ -142,6 +142,46 @@ public class SelfCheckRunner {
.diff(t + "[抽样" + right.size() + "行]", left, right);
}
/**
* 对一组<b>已抓取</b>的两侧行集(左=JDBC 基线、右=引擎)按该实体的自对拍豁免规则逐行 diff。
* 供「真实实体只读权限对拍」复用同一套归一/豁免内核(BOOLEAN 域外/计算列/物理孤儿/xml/JSON 空值),
* 仅驱动方式不同(权限对拍的右侧来自 {@code asUser&roles} 过滤路径,左侧来自规则等价 WHERE)。
*
* @param table 实体名(决定主键约定与豁免列集)
* @param label 报告标签(如 {@code HR_SAFETYCARD[用户 xxx/规则 view-all]})
*/
public DiffReport checkRows(String table, String label,
List<Map<String, Object>> left, List<Map<String, Object>> right) {
String t = table.toUpperCase();
String pk = t + "_ID";
List<String> keys = (!left.isEmpty() && left.get(0).containsKey(pk))
? List.of(pk)
: RowDiff.inferKeyColumns(t, left.isEmpty() ? right : left);
boolean keyUniqueLeft = !left.isEmpty() && RowDiff.keyIsUnique(keys, left);
if (!left.isEmpty() && !keyUniqueLeft) {
List<String> composite = RowDiff.allIdColumns(left);
if (RowDiff.keyIsUnique(composite, left)) {
keys = composite;
keyUniqueLeft = true;
} else {
keys = List.of();
}
}
RowDiff rd = new RowDiff(keys, true)
.booleanDomainColumns(booleanColumns(t))
.computedSqlColumns(computedSqlColumns(t))
.metadataColumns(metadataColumns(t))
.xmlColumns(xmlColumns(t));
if (keyUniqueLeft && RowDiff.keyIsUnique(keys, right)) {
DiffReport rowwise = rd.diff(label, left, right);
if (rowwise.matchedRows == 0 && !left.isEmpty() && !right.isEmpty()) {
return rd.diffMultiset(label, left, right, java.util.Set.of(pk));
}
return rowwise;
}
return rd.diffMultiset(label, left, right, java.util.Set.of(pk));
}
private static Map<String, Object> upper(Map<String, Object> row) {
Map<String, Object> m = new java.util.LinkedHashMap<>();
row.forEach((k, v) -> m.put(k == null ? null : k.toUpperCase(), v));