diff --git a/platform-parity/src/main/java/com/eip4/platform/parity/diff/DiffReport.java b/platform-parity/src/main/java/com/eip4/platform/parity/diff/DiffReport.java index ce37a88..18f73c9 100644 --- a/platform-parity/src/main/java/com/eip4/platform/parity/diff/DiffReport.java +++ b/platform-parity/src/main/java/com/eip4/platform/parity/diff/DiffReport.java @@ -53,6 +53,21 @@ public class DiffReport { /** COLUMNSQL 计算列(元数据配子查询,引擎以计算值覆盖物理列;新旧行为一致):不参与值比对,整列登记。 */ public final Set engineComputedSqlColumns = new TreeSet<>(); + /** + * 物理孤儿列:物理表/视图有此列、引擎不返回(MISSING_RIGHT),且该列在 SYS_ENTITYATTRIBUTE + * 无活跃元数据 —— 引擎元数据驱动 SELECT 永不读它(物理冗余列,新旧系统行为一致)。整列登记不判负。 + */ + public final Set physicalOrphanColumns = new TreeSet<>(); + + /** xml 物理类型列:JDBC {@code xml::text} 带 {@code } 声明头/首尾空白,引擎读路径剥离;XML 归一后等值。 */ + public final Set xmlRepresentationColumns = new TreeSet<>(); + + /** 引擎对 JSON 类型列的物理 null 渲染为空数组/空串(如 DETAILS):左 null + 右空 = 语义等值,整列登记。 */ + public final Set engineEmptyForNullColumns = new TreeSet<>(); + + /** 多重集兜底模式:视图无稳定唯一行键,放弃逐行配对、按行多重集比较(行集语义一致即判一致)。 */ + public boolean multisetMode; + public DiffReport(String label) { this.label = label; } @@ -136,6 +151,10 @@ public class DiffReport { m.put("engineNullOmittedColumns", new ArrayList<>(engineNullOmittedColumns)); m.put("explainedBooleanDomainCells", new LinkedHashMap<>(explainedBooleanDomainCells)); m.put("engineComputedSqlColumns", new ArrayList<>(engineComputedSqlColumns)); + m.put("physicalOrphanColumns", new ArrayList<>(physicalOrphanColumns)); + m.put("xmlRepresentationColumns", new ArrayList<>(xmlRepresentationColumns)); + m.put("engineEmptyForNullColumns", new ArrayList<>(engineEmptyForNullColumns)); + m.put("multisetMode", multisetMode); m.put("clean", isClean()); m.put("consistencyRate", consistencyRate()); List> ms = new ArrayList<>(); @@ -170,6 +189,21 @@ public class DiffReport { sb.append("- COLUMNSQL 计算列(引擎子查询覆盖物理列,不参与值比对): `") .append(String.join(", ", engineComputedSqlColumns)).append("`\n"); } + if (!physicalOrphanColumns.isEmpty()) { + sb.append("- 物理孤儿列(物理有列、无活跃元数据,引擎不读 → 不判负): `") + .append(String.join(", ", physicalOrphanColumns)).append("`\n"); + } + if (!xmlRepresentationColumns.isEmpty()) { + sb.append("- XML 表示差异列(声明头/首尾空白,XML 归一后等值): `") + .append(String.join(", ", xmlRepresentationColumns)).append("`\n"); + } + if (!engineEmptyForNullColumns.isEmpty()) { + sb.append("- 引擎空值渲染列(物理 null 渲染为空数组/空串,语义等值): `") + .append(String.join(", ", engineEmptyForNullColumns)).append("`\n"); + } + if (multisetMode) { + sb.append("- 对拍模式:多重集兜底(视图无稳定唯一行键,按行多重集比较)\n"); + } if (!explainedBooleanDomainCells.isEmpty()) { sb.append("- 已归因差异(BOOLEAN 域外脏数据,引擎归 null,新旧行为一致): "); explainedBooleanDomainCells.forEach((c, n) -> sb.append('`').append(c).append("`x").append(n).append(' ')); diff --git a/platform-parity/src/main/java/com/eip4/platform/parity/diff/Normalizer.java b/platform-parity/src/main/java/com/eip4/platform/parity/diff/Normalizer.java index 3e219a7..04a917b 100644 --- a/platform-parity/src/main/java/com/eip4/platform/parity/diff/Normalizer.java +++ b/platform-parity/src/main/java/com/eip4/platform/parity/diff/Normalizer.java @@ -142,6 +142,71 @@ public final class Normalizer { return Kind.OTHER; } + /** + * xml 物理类型列归一比较:PG {@code xml::text}(JDBC 直连侧)会保留入库时的 {@code } + * 声明头(XML prolog)与首尾空白/空行;引擎读路径(REST 出口)把它们剥离。二者语义同一份 XML。 + * 归一做法:剥去开头的 XML 声明 {@code },再 trim 全部首尾空白后比较剩余正文。 + * + *

只做"声明头 + 首尾空白"两类表示差异的吸收;正文任何实质字符差异仍判不等(守门:不吞真差异)。 + */ + public static boolean xmlEqual(Object a, Object b) { + if (a == null || b == null) { + return a == null && b == null; + } + String sa = stripXmlProlog(a.toString()); + String sb = stripXmlProlog(b.toString()); + return sa.equals(sb); + } + + private static String stripXmlProlog(String s) { + String t = s.strip(); + if (t.startsWith(""); + if (end >= 0) { + t = t.substring(end + 2).strip(); + } + } + return t; + } + + /** + * 引擎对 JSON/数组类型列的物理 null 渲染为空表示(空数组 {@code []} → {@code ""}、空串)的等值判定: + * 左(物理基线)为 null,右(引擎)为空串 {@code ""} → 语义等值(同一份"无值",新旧引擎渲染一致)。 + * 仅此一个方向(左 null / 右空串)成立;两侧都有内容或都 null 由常规 {@link #equal} 处理。 + */ + public static boolean nullVsEngineEmpty(Object left, Object right) { + return left == null && right instanceof CharSequence cs && cs.length() == 0; + } + + /** + * 多重集分组键:把单值归一为「与 {@link #equal} 同口径可比」的稳定字符串, + * 供 {@link RowDiff#diffMultiset} 给无稳定主键的视图按行多重集配对。 + * + *

关键:必须吸收 {@link #equal} 里跨族等值的两类——(a) 整数↔等值小数(2 vs 2.000000)、 + * (b) DATE/TIME 的 epoch(Long) ↔ ISO 串。否则同一行在两侧因表示不同被分到不同桶,假阳性。 + * 分别归一:数值统一到去尾零 BigDecimal 的 plain 串;时间统一到 epoch 毫秒串;其余按规范字符串。 + */ + public static String groupingKey(Object v) { + Object c = canonical(v); + if (c == null) { + return "NULL"; + } + // 时间:Long 或 ISO instant 串都归一到 epoch 毫秒(与 equal 的 epochOf 同口径) + Long e = epochOf(c); + // Long 既可能是时间也可能是普通整数;但普通整数与"等值小数"也要统一 → 一律走数值归一, + // 只有当对端是 ISO 串时 equal 才按时间比;分组键无对端,故:ISO 串 → epoch,Long/数值 → 数值串。 + if (c instanceof String s && looksLikeIsoInstant(s) && e != null) { + return "N:" + e; + } + if (c instanceof Long l) { + return "N:" + new BigDecimal(l).toPlainString(); + } + if (c instanceof BigDecimal bd) { + return "N:" + bd.toPlainString(); + } + return "S:" + c; + } + /** char(n) 定长列尾部空格归一(只去尾部,保留中间与前导)。 */ public static String stripTrailing(String s) { if (s == null) { diff --git a/platform-parity/src/main/java/com/eip4/platform/parity/diff/RowDiff.java b/platform-parity/src/main/java/com/eip4/platform/parity/diff/RowDiff.java index 462ddbd..88431c6 100644 --- a/platform-parity/src/main/java/com/eip4/platform/parity/diff/RowDiff.java +++ b/platform-parity/src/main/java/com/eip4/platform/parity/diff/RowDiff.java @@ -67,6 +67,31 @@ public final class RowDiff { return this; } + /** 实体活跃元数据列集(大写);为空表示"未知/不启用物理孤儿列豁免"(规则失效,照旧判负)。 */ + private java.util.Set metadataColumns = java.util.Set.of(); + private boolean metadataColumnsKnown = false; + + /** + * 注入实体的「活跃元数据列集」,启用物理孤儿列豁免:某列在物理基线(左)存在、引擎(右)缺, + * 且该列不在元数据列集 → 引擎元数据驱动 SELECT 永不读它(物理冗余列,新旧行为一致), + * 登记 {@link DiffReport#physicalOrphanColumns} 不判负。仅自对拍模式生效。 + * + *

传 null 视为"元数据未知",规则不启用(保守:照旧报 MISSING_RIGHT,不误豁免)。 + */ + public RowDiff metadataColumns(java.util.Set cols) { + this.metadataColumnsKnown = cols != null; + this.metadataColumns = cols == null ? java.util.Set.of() : cols; + return this; + } + + /** xml 物理类型列集(大写):JDBC {@code xml::text} 带声明头/首尾空白,引擎读路径剥离 —— XML 归一后比较。 */ + private java.util.Set xmlColumns = java.util.Set.of(); + + public RowDiff xmlColumns(java.util.Set cols) { + this.xmlColumns = cols == null ? java.util.Set.of() : cols; + return this; + } + public DiffReport diff(String label, List> left, List> right) { DiffReport report = new DiffReport(label); report.keyColumns.addAll(keyColumns); @@ -102,6 +127,94 @@ public final class RowDiff { return report; } + /** + * 多重集对拍兜底:SQL 视图无稳定唯一行键({表名}_ID 在两侧坍缩/不唯一,如 VIEW_OA_MEETING + * 两侧仅 5 distinct/83 行)时,逐行配对必然错位、报满 onlyLeft/onlyRight 假阳性。 + * 此路径放弃配对,把两侧规范化为「行多重集」直接比较:行集语义一致(内容相同、仅顺序/键不可配对) + * 即判一致,否则报为剩余的多重集差异(净增/净缺行数登记到 onlyInLeft/onlyInRight 计数)。 + * + *

比对域 = 左侧物理列集减去 {物理孤儿列、COLUMNSQL 计算列、不稳定主键列}, + * 与逐行模式同口径(引擎计算列/null 省略列不参与);每列值经 {@link Normalizer} 规范化。 + * 仅自对拍模式({@code rightOnlyColumnsAsInfo}=true)使用。 + * + * @param excludeColumns 额外排除的列(通常是不稳定的 {表名}_ID;视图生成的 _ID 两侧表示不同) + */ + public DiffReport diffMultiset(String label, List> left, + List> right, java.util.Set excludeColumns) { + DiffReport report = new DiffReport(label); + report.multisetMode = true; + report.leftRowCount = left == null ? 0 : left.size(); + report.rightRowCount = right == null ? 0 : right.size(); + + // 比对域:左侧物理列,去掉孤儿/计算/显式排除列(引擎不返回或不可比的列) + java.util.LinkedHashSet domain = new java.util.LinkedHashSet<>(); + if (left != null) { + for (Map row : left) { + for (String c : row.keySet()) { + String cu = c == null ? null : c.toUpperCase(); + if (cu == null || computedSqlColumns.contains(cu)) { + continue; + } + if (excludeColumns != null && excludeColumns.contains(cu)) { + continue; + } + if (metadataColumnsKnown && !metadataColumns.contains(cu)) { + report.physicalOrphanColumns.add(cu); + continue; + } + domain.add(cu); + } + } + } + report.keyColumns.add("(multiset:" + String.join("+", domain) + ")"); + + Map leftBag = rowBag(left, domain); + Map rightBag = rowBag(right, domain); + // 多重集差:两侧抵消后剩余即净差异行 + int onlyLeft = 0; + int onlyRight = 0; + int matched = 0; + java.util.Set allRowKeys = new java.util.TreeSet<>(); + allRowKeys.addAll(leftBag.keySet()); + allRowKeys.addAll(rightBag.keySet()); + for (String rk : allRowKeys) { + int lc = leftBag.getOrDefault(rk, 0); + int rc = rightBag.getOrDefault(rk, 0); + matched += Math.min(lc, rc); + if (lc > rc) { + onlyLeft += lc - rc; + } else if (rc > lc) { + onlyRight += rc - lc; + } + } + report.matchedRows = matched; + for (int i = 0; i < onlyLeft; i++) { + report.onlyInLeft.add("(multiset-net-left)"); + } + for (int i = 0; i < onlyRight; i++) { + report.onlyInRight.add("(multiset-net-right)"); + } + return report; + } + + /** 把结果集规范化为「行→出现次数」多重集;行键 = 域内各列规范值的拼接串。 */ + private Map rowBag(List> rows, java.util.Set domain) { + Map bag = new java.util.HashMap<>(); + if (rows == null) { + return bag; + } + for (Map row : rows) { + Map upper = upperKeys(row); + StringBuilder sb = new StringBuilder(); + for (String col : domain) { + // groupingKey 与逐行 equal 同口径:吸收整数↔等值小数、epoch↔ISO 时间表示差异 + sb.append(Normalizer.groupingKey(upper.get(col))).append(SEP); + } + bag.merge(sb.toString(), 1, Integer::sum); + } + return bag; + } + /** 逐列比较一行(主键已匹配);列集 = 两侧并集。 */ private DiffReport.RowMismatch diffRow(String key, Map l, Map r, DiffReport report) { @@ -128,6 +241,10 @@ public final class RowDiff { if (rightOnlyColumnsAsInfo && lu.get(col) == null) { // 引擎 JSON 对 null 值列整列省略:左 null + 右缺列 = 语义等值 report.engineNullOmittedColumns.add(col); + } else if (rightOnlyColumnsAsInfo && metadataColumnsKnown && !metadataColumns.contains(col)) { + // 物理孤儿列:物理表有此列(左)、引擎不返回(右),且该列无活跃元数据 —— + // 引擎元数据驱动 SELECT 永不读它(新旧系统行为相同),登记不判负 + report.physicalOrphanColumns.add(col); } else { mm.cells.add(new DiffReport.CellDiff(col, lu.get(col), null, "MISSING_RIGHT")); } @@ -144,7 +261,21 @@ public final class RowDiff { // 两侧都有该列(可能值为 null) Object lv = lu.get(col); Object rv = ru.get(col); - if (!Normalizer.equal(lv, rv)) { + boolean equal = Normalizer.equal(lv, rv); + if (!equal && xmlColumns.contains(col)) { + // xml 物理列:JDBC xml::text 带 声明头/首尾空白,引擎读路径剥离 —— XML 归一后比 + equal = Normalizer.xmlEqual(lv, rv); + if (equal) { + report.xmlRepresentationColumns.add(col); + } + } + if (!equal && rightOnlyColumnsAsInfo && Normalizer.nullVsEngineEmpty(lv, rv)) { + // 引擎对 JSON 类型列(如 PM_CALCBASICSCONFIG.DETAILS)的物理 null 渲染为空数组/空串: + // 左 null + 右空(""/[]) = 语义等值(新旧引擎渲染一致),登记不判负 + equal = true; + report.engineEmptyForNullColumns.add(col); + } + if (!equal) { if (rv == null && lv != null && booleanDomainColumns.contains(col) && !isZeroOrOne(lv)) { // BOOLEAN 列域外脏数据(如 2/-1):引擎(新旧一致)归 null,已归因不判负 diff --git a/platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/JdbcResultReader.java b/platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/JdbcResultReader.java index 4af14f9..1395edc 100644 --- a/platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/JdbcResultReader.java +++ b/platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/JdbcResultReader.java @@ -47,10 +47,26 @@ public class JdbcResultReader { for (Map r : rows) { Map m = new LinkedHashMap<>(); for (Map.Entry e : r.entrySet()) { - m.put(e.getKey() == null ? null : e.getKey().toUpperCase(), e.getValue()); + m.put(e.getKey() == null ? null : e.getKey().toUpperCase(), materialize(e.getValue())); } out.add(m); } return out; } + + /** + * 物化 JDBC 惰性/流式类型为可比可序列化的标量: + * {@code xml} 列经 PG 驱动返回 {@link java.sql.SQLXML}(PgSQLXML),其 {@code toString()} 非 XML 正文、 + * 且 Jackson 无法序列化(内含 binaryStream)。统一取 {@code getString()} 得 XML 文本,与引擎侧对齐。 + */ + private static Object materialize(Object v) { + if (v instanceof java.sql.SQLXML xml) { + try { + return xml.getString(); + } catch (java.sql.SQLException ex) { + return null; + } + } + return v; + } } diff --git a/platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/SelfCheckRunner.java b/platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/SelfCheckRunner.java index d3931d4..51083c3 100644 --- a/platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/SelfCheckRunner.java +++ b/platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/SelfCheckRunner.java @@ -59,15 +59,35 @@ public class SelfCheckRunner { List keys = (!left.isEmpty() && left.get(0).containsKey(pk)) ? List.of(pk) : RowDiff.inferKeyColumns(t, left.isEmpty() ? right : left); - if (!left.isEmpty() && !RowDiff.keyIsUnique(keys, left)) { + boolean keyUniqueLeft = !left.isEmpty() && RowDiff.keyIsUnique(keys, left); + if (!left.isEmpty() && !keyUniqueLeft) { List composite = RowDiff.allIdColumns(left); - keys = RowDiff.keyIsUnique(composite, left) ? composite : List.of(); + if (RowDiff.keyIsUnique(composite, left)) { + keys = composite; + keyUniqueLeft = true; + } else { + keys = List.of(); + } } - // 自对拍模式:引擎计算列(右独有)登记不判负;BOOLEAN 域外脏数据归 null 为已归因差异 - return new RowDiff(keys, true) + // 自对拍模式:引擎计算列(右独有)登记不判负;BOOLEAN 域外脏数据归 null 为已归因差异; + // 物理孤儿列(无活跃元数据)/xml 表示差异/JSON 空值渲染均按元数据感知豁免 + RowDiff rd = new RowDiff(keys, true) .booleanDomainColumns(booleanColumns(t)) .computedSqlColumns(computedSqlColumns(t)) - .diff(t, left, right); + .metadataColumns(metadataColumns(t)) + .xmlColumns(xmlColumns(t)); + // 主键在两侧均唯一才走逐行配对;否则(SQL 视图无稳定唯一行键,如 VIEW_OA_MEETING + // {表名}_ID 两侧坍缩)退多重集兜底 —— 排除不稳定的 {表名}_ID 列 + if (keyUniqueLeft && RowDiff.keyIsUnique(keys, right)) { + DiffReport rowwise = rd.diff(t, left, right); + // 逐行配对退化检测:两侧均非空却零配对(SQL 视图 {表名}_ID 两侧各自唯一但取值不相交—— + // 视图按行生成 _ID,两端表示不同)→ 主键不可跨端配对,退多重集兜底 + if (rowwise.matchedRows == 0 && !left.isEmpty() && !right.isEmpty()) { + return rd.diffMultiset(t, left, right, java.util.Set.of(pk)); + } + return rowwise; + } + return rd.diffMultiset(t, left, right, java.util.Set.of(pk)); } /** @@ -84,8 +104,10 @@ public class SelfCheckRunner { return error(t, "引擎读路径失败(抽样): " + e.getMessage()); } String pk = t + "_ID"; + // 关联/视图表无 {表名}_ID 主键(如 SYS_ROLE_ROLE / OA_*RELATION):抽样按 IN(pk) 回查不成立, + // 退全量 check() —— 其复合键/多重集兜底能正确处理无稳定主键的大表 if (right.isEmpty() || !upper(right.get(0)).containsKey(pk)) { - return error(t, "抽样模式需 {表名}_ID 主键且结果非空"); + return check(t); } List pks = new java.util.ArrayList<>(right.size()); for (Map r : right) { @@ -95,16 +117,28 @@ public class SelfCheckRunner { } } List> left = new java.util.ArrayList<>(pks.size()); - for (int i = 0; i < pks.size(); i += 1000) { - List chunk = pks.subList(i, Math.min(i + 1000, pks.size())); - String in = String.join(",", java.util.Collections.nCopies(chunk.size(), "?")); - left.addAll(jdbc.query( - "SELECT * FROM " + t + " WHERE " + pk + " IN (" + in + ")", - chunk.toArray())); + try { + for (int i = 0; i < pks.size(); i += 1000) { + List chunk = pks.subList(i, Math.min(i + 1000, pks.size())); + String in = String.join(",", java.util.Collections.nCopies(chunk.size(), "?")); + left.addAll(jdbc.query( + "SELECT * FROM " + t + " WHERE " + pk + " IN (" + in + ")", + chunk.toArray())); + } + } catch (Exception inErr) { + // IN(pk) 回查失败(如 SQL 视图 {表名}_ID 是引擎合成列,JDBC 侧不可过滤)→ 退全量 check() + return check(t); + } + // 合成主键签名:引擎 {表名}_ID 在物理侧大面积查不到(回查行数远小于抽样行数)—— + // 引擎按行生成 _ID(如 VIEW_HR_CHECKINOUTSELECT 的 md5 合成键),抽样不可信,退全量多重集 + if (left.size() * 2 < pks.size()) { + return check(t); } return new RowDiff(List.of(pk), true) .booleanDomainColumns(booleanColumns(t)) .computedSqlColumns(computedSqlColumns(t)) + .metadataColumns(metadataColumns(t)) + .xmlColumns(xmlColumns(t)) .diff(t + "[抽样" + right.size() + "行]", left, right); } @@ -157,6 +191,51 @@ public class SelfCheckRunner { } } + /** + * 实体的「活跃元数据列集」(大写):SYS_ENTITYATTRIBUTE 中 isactive=1 的 columnname。 + * 用于物理孤儿列豁免——MISSING_RIGHT 且列不在此集 → 引擎元数据驱动 SELECT 永不读它。 + * 查询失败/空集返回 null(规则不启用,保守判负,绝不误豁免)。 + */ + private java.util.Set metadataColumns(String table) { + try { + var rows = jdbc.query( + "SELECT a.columnname FROM sys_entityattribute a " + + "JOIN sys_entity e ON a.entityid = e.sys_entity_id " + + "WHERE upper(trim(e.tablename)) = ? AND a.isactive = 1", + table.toUpperCase()); + java.util.Set cols = new java.util.HashSet<>(); + for (var r : rows) { + Object c = r.values().iterator().next(); + if (c != null) { + cols.add(c.toString().trim().toUpperCase()); + } + } + return cols.isEmpty() ? null : cols; + } catch (Exception e) { + return null; + } + } + + /** 实体的 xml 物理类型列集(大写):JDBC xml::text 带声明头/空白,引擎读路径剥离 → XML 归一比较。 */ + private java.util.Set xmlColumns(String table) { + try { + var rows = jdbc.query( + "SELECT upper(column_name) c FROM information_schema.columns " + + "WHERE upper(table_name) = ? AND data_type = 'xml'", + table.toUpperCase()); + java.util.Set cols = new java.util.HashSet<>(); + for (var r : rows) { + Object c = r.values().iterator().next(); + if (c != null) { + cols.add(c.toString().trim().toUpperCase()); + } + } + return cols; + } catch (Exception e) { + return java.util.Set.of(); + } + } + private static DiffReport error(String table, String msg) { DiffReport r = new DiffReport(table); DiffReport.RowMismatch mm = new DiffReport.RowMismatch("RUNNER_ERROR"); diff --git a/platform-parity/src/test/java/com/eip4/platform/parity/diff/RowDiffTest.java b/platform-parity/src/test/java/com/eip4/platform/parity/diff/RowDiffTest.java index 75f13ef..d4840bb 100644 --- a/platform-parity/src/test/java/com/eip4/platform/parity/diff/RowDiffTest.java +++ b/platform-parity/src/test/java/com/eip4/platform/parity/diff/RowDiffTest.java @@ -320,4 +320,129 @@ class RowDiffTest { assertTrue(rep.isClean()); assertEquals(2, rep.matchedRows); } + + // ===== P1-1 全库对拍归因(2026-06-11):物理孤儿列 / XML 表示 / 空值渲染 / 多重集兜底 ===== + + @org.junit.jupiter.api.Test + @DisplayName("物理孤儿列:MISSING_RIGHT 且列无活跃元数据 → 登记不判负(如 SYS_CODERULE.ORGID)") + void physicalOrphanColumnExempted() { + // 左(物理)有 ORGID 列、右(引擎)缺;ORGID 不在活跃元数据列集 → 物理冗余列,不判负 + var l = List.>of(new java.util.HashMap<>() {{ + put("T_ID", "k1"); put("NAME", "n"); put("ORGID", "org-1"); + }}); + var r = List.>of(new java.util.HashMap<>(Map.of("T_ID", "k1", "NAME", "n"))); + DiffReport rep = new RowDiff(List.of("T_ID"), true) + .metadataColumns(java.util.Set.of("T_ID", "NAME")).diff("T", l, r); + assertTrue(rep.isClean(), () -> rep.toMarkdown()); + assertTrue(rep.physicalOrphanColumns.contains("ORGID")); + // 未注入元数据列集时不启用规则,仍报 MISSING_RIGHT(保守:不误豁免) + assertFalse(new RowDiff(List.of("T_ID"), true).diff("T", l, r).isClean()); + // 列在活跃元数据里却 MISSING_RIGHT → 真缺陷,不豁免 + var rep2 = new RowDiff(List.of("T_ID"), true) + .metadataColumns(java.util.Set.of("T_ID", "NAME", "ORGID")).diff("T", l, r); + assertFalse(rep2.isClean()); + assertEquals("MISSING_RIGHT", rep2.mismatches.get(0).cells.get(0).reason); + } + + @org.junit.jupiter.api.Test + @DisplayName("XML 表示差异:声明头/首尾空白被 XML 归一吸收(如 VIEW_PAGE.XML),正文真差异仍判负") + void xmlRepresentationNormalized() { + // 左 JDBC xml::text 带 声明头 + 前导换行;右引擎剥离 —— 正文同一份 + String jdbc = "\n\n"; + String engine = ""; + var l = List.>of(new java.util.HashMap<>(Map.of("T_ID", "k1", "XML", jdbc))); + var r = List.>of(new java.util.HashMap<>(Map.of("T_ID", "k1", "XML", engine))); + DiffReport rep = new RowDiff(List.of("T_ID"), true) + .xmlColumns(java.util.Set.of("XML")).diff("T", l, r); + assertTrue(rep.isClean(), () -> rep.toMarkdown()); + assertTrue(rep.xmlRepresentationColumns.contains("XML")); + // 未注入 xml 列集时仍判负(规则不扩大化) + assertFalse(new RowDiff(List.of("T_ID"), true).diff("T", l, r).isClean()); + // 正文实质差异:XML 归一后仍不等 → 判负(守门,不吞真差异) + var l2 = List.>of(new java.util.HashMap<>( + Map.of("T_ID", "k1", "XML", ""))); + var r2 = List.>of(new java.util.HashMap<>( + Map.of("T_ID", "k1", "XML", ""))); + assertFalse(new RowDiff(List.of("T_ID"), true) + .xmlColumns(java.util.Set.of("XML")).diff("T", l2, r2).isClean()); + } + + @org.junit.jupiter.api.Test + @DisplayName("引擎空值渲染:物理 null 引擎渲染为空串/空数组(如 DETAILS)→ 语义等值不判负") + void engineEmptyForNullExempted() { + // 左物理 DETAILS=null,右引擎渲染为 ""(JSON 空数组 [] 经 asText 得空串) + var l = List.>of(new java.util.HashMap<>() {{ + put("T_ID", "k1"); put("DETAILS", null); + }}); + var r = List.>of(new java.util.HashMap<>(Map.of("T_ID", "k1", "DETAILS", ""))); + DiffReport rep = new RowDiff(List.of("T_ID"), true).diff("T", l, r); + assertTrue(rep.isClean(), () -> rep.toMarkdown()); + assertTrue(rep.engineEmptyForNullColumns.contains("DETAILS")); + // 录制重放(非自对拍)模式不启用:左 null 右 "" 判负 + assertFalse(new RowDiff(List.of("T_ID")).diff("T", l, r).isClean()); + // 左有内容、右空串 → 真差异,不豁免 + var l2 = List.>of(new java.util.HashMap<>(Map.of("T_ID", "k1", "DETAILS", "x"))); + assertFalse(new RowDiff(List.of("T_ID"), true).diff("T", l2, r).isClean()); + } + + @org.junit.jupiter.api.Test + @DisplayName("多重集兜底:视图 {表名}_ID 两侧坍缩,行集内容一致但不可配对 → multiset 判一致") + void multisetFallbackForUnstableKey() { + // 视图 _ID 两侧表示不同且坍缩;排除 {表名}_ID 后行内容多重集一致 + var l = List.>of( + new java.util.HashMap<>(Map.of("V_ID", "a", "NAME", "甲", "AMT", new BigDecimal("1.00"))), + new java.util.HashMap<>(Map.of("V_ID", "a", "NAME", "乙", "AMT", new BigDecimal("2.0")))); + var r = List.>of( + new java.util.HashMap<>(Map.of("V_ID", "x", "NAME", "乙", "AMT", 2L)), + new java.util.HashMap<>(Map.of("V_ID", "y", "NAME", "甲", "AMT", 1))); + DiffReport rep = new RowDiff(List.of("V_ID"), true).diffMultiset("V", l, r, java.util.Set.of("V_ID")); + assertTrue(rep.isClean(), () -> rep.toMarkdown()); + assertTrue(rep.multisetMode); + assertEquals(2, rep.matchedRows); + // 行集净差异仍被检出:右缺一行 → onlyInRight 计数 + var r2 = List.>of( + new java.util.HashMap<>(Map.of("V_ID", "x", "NAME", "乙", "AMT", 2L))); + DiffReport rep2 = new RowDiff(List.of("V_ID"), true).diffMultiset("V", l, r2, java.util.Set.of("V_ID")); + assertFalse(rep2.isClean()); + assertEquals(1, rep2.onlyInLeft.size()); + } + + @org.junit.jupiter.api.Test + @DisplayName("多重集兜底:物理孤儿列在多重集模式下也被排除登记,不污染行比较") + void multisetExcludesOrphanColumns() { + var l = List.>of( + new java.util.HashMap<>(Map.of("V_ID", "a", "NAME", "甲", "ORGID", "o1")), + new java.util.HashMap<>(Map.of("V_ID", "b", "NAME", "乙", "ORGID", "o2"))); + var r = List.>of( + new java.util.HashMap<>(Map.of("V_ID", "x", "NAME", "乙")), + new java.util.HashMap<>(Map.of("V_ID", "y", "NAME", "甲"))); + DiffReport rep = new RowDiff(List.of("V_ID"), true) + .metadataColumns(java.util.Set.of("V_ID", "NAME")) + .diffMultiset("V", l, r, java.util.Set.of("V_ID")); + assertTrue(rep.isClean(), () -> rep.toMarkdown()); + assertTrue(rep.physicalOrphanColumns.contains("ORGID")); + } + + // ---- Normalizer 新归一规则单测 ---- + + @org.junit.jupiter.api.Test + @DisplayName("Normalizer.xmlEqual:声明头 + 首尾空白吸收,正文差异守门") + void normalizerXmlEqual() { + assertTrue(Normalizer.xmlEqual("\n", "")); + assertTrue(Normalizer.xmlEqual(" \n", "")); + assertTrue(Normalizer.xmlEqual("", "")); + assertFalse(Normalizer.xmlEqual("", "")); + assertTrue(Normalizer.xmlEqual(null, null)); + assertFalse(Normalizer.xmlEqual(null, "")); + } + + @org.junit.jupiter.api.Test + @DisplayName("Normalizer.nullVsEngineEmpty:左 null 右空串成立,其余不成立") + void normalizerNullVsEmpty() { + assertTrue(Normalizer.nullVsEngineEmpty(null, "")); + assertFalse(Normalizer.nullVsEngineEmpty(null, "x")); + assertFalse(Normalizer.nullVsEngineEmpty("", null)); + assertFalse(Normalizer.nullVsEngineEmpty(null, null)); + assertFalse(Normalizer.nullVsEngineEmpty("x", "")); + } }