SQL 差异说明重做(第 2 轮):规范化只留能讲清为什么保持语义的几步,结果看行出来先后的一段不动来源;具体说法先确认两边真的不同、另一边真的没有,其余给兜底

为什么:第 2 轮复验抓到第 1 版规范化里一批不保持语义的改写(15 个 blocker),说明里一批假话、矛盾话(10 多个
major)。根子是借用了 sqlglot simplify 等现成改写、又把「相等」当成「一样」、没管结果看行出来先后的查询;说明这边
是先改名再比、只看这一段有没有那个条件。这一轮把改写收窄到每一步都讲得清为什么保持语义,说明这边每句话都先验证。

规范化(backend/app/data/sql_semantics.py):
- 去掉 sqlglot 的 simplify(Decimal 折叠 0.1 + 0.2、-(-x) 化成 x、三项加乘拍平合常量、BETWEEN SYMMETRIC 丢了
  SYMMETRIC)、pushdown_projections、HAVING 挪进 WHERE(MySQL 不分大小写时同组的值各不一样)、只有一列的 IN 列表
  写成 =(SQLite 里 a IN (b) 是 a = +b)。只留自己写的几步:AND / OR、比较两边、一个节点的加乘两边排序,NOT 套
  比较翻过来,BETWEEN 拆开,IN 常量列表去重排序,COUNT(1)、MIN/MAX(DISTINCT)、IIF / IF 写成 CASE、CASE ELSE NULL、
  恒真的 1 = 1 去掉,IS NOT NULL / NOT LIKE 各方言统一成 NOT (…)。
- 新增 _Sensitivity:取行(含有 ORDER BY 并列)、DISTINCT ON、窗口函数、GROUP_CONCAT 这类聚合、聚合里的散列、当成标量
  的子查询,以及去重、分组、MIN/MAX 留下的值「相等却不一样」(MySQL 字符串、PG numeric、算出来的表达式)的一段,
  连同给它供行的子查询、CTE,都不调换来源、不排 GROUP BY 键、不改 DISTINCT、不并子查询。SQLite 的逗号连接和 CROSS
  JOIN 按原文分开(SQLite 不调换 CROSS JOIN 两边)。
- 列名表(CTE、子查询)写进里面那段的别名,实表别名带列名、递归 CTE(含 SQLite 不写 RECURSIVE、CTE 引用自己或后面的)、
  BETWEEN SYMMETRIC、FETCH WITH TIES 不走规范化;FETCH FIRST 写成 LIMIT;USING 只在简单写法下写成 ON。
- EXISTS 改写前先查聚合(含 ORDER BY 里的)和 OFFSET;合并只调换最外层不取行的 UNION ALL(PG/MySQL 另加按位置排序、
  各支列名一样的嵌套);后面有 RIGHT / FULL JOIN 时内连接不挪进 WHERE、开头的来源不调换。
- 子查询并进外层自己写(_merge_derived:只并内连接一侧、只筛行选列的),引用多次的简单 CTE 每处写回一份后整条语句
  的别名重新改成互不相同的(压测撞到的:同一个 CTE 并进外层和相关子查询两处,里层别名遮住外层);外层 WHERE 只挪进
  分组子查询的 HAVING(同一个值)。几个来源的 SELECT * 先写成各来源的 t.*(sqlglot 展开 * 时把实表排在子查询前面)。
- 解析丢了写法的不在语法树上判等价:0x10 和 x'10' 这类字面量、换了名字的类型名(SQLite 的 STRING 是数值亲和);
  SQLite 不带表名、带双引号、表结构里没有的列名保留大小写和引号(找不到这一列时被当成字符串)。

差异说明:
- 换了表的一边照它自己的表说(以前把 B 改名成 A 的表,中文名、detail 归错表)。
- 新增 _Range:同一个对象只和常量比的条件按取值逐段算,留下的行一样的不说(IN 和 OR、冗余 IS NOT NULL、拆成两段的
  时间、COUNT(*) > 1 和 >= 2);关联条件比相等关系的分组;聚合只在参数是列时说。
- 新增 _Usage:说「另一边没有这个条件 / 没有按时间筛选」之前,看另一边整条语句(含相关子查询、CTE、CASE、判空时连
  聚合参数)是否用这一列筛选;条件子查询里不带表名的列没给表结构时不拿来说具体的。
- 子查询要外面写法一模一样(含 NOT、IN 左边的列)才配对,位置照实说「id NOT IN 的子查询」;EXCEPT 按先后逐支比;
  order 只在最外层、没取行、没 DISTINCT ON / 窗口函数时说;LEFT 对 INNER 只在最外层、可空一侧没进 WHERE、结果不只是
  可空一侧的聚合时说;DISTINCT 对同列 GROUP BY、MySQL 表名只差大小写不说成不同;互相矛盾的一对不说。

测试:tests/fixtures/sql_pairs.py 加 nums 表和一组专挑写法差异的数据(0.1 + 0.2、像数字的文本、'SH' / 'sh'),
第 2 轮反例收进语料(_SAME_HARD 20 对、_SAME_R2 11 对、_DIFF_R2 36 对进执行比对;REGRESSIONS_R2 21 对、
DIALECT_SAME_R2 6 对、KNOWN_UNRECOGNIZED 4 对各方言只查结论);执行比对共 7 组数据、372 对,标 same 而没认出的
不许有具体说法;test_sql_semantics.py 补第 2 轮的说法用例和 normalize_sql「只改参数」的用例。这些新用例在上一版
上有 109 处失败。

验证:test_sql_semantics + test_verify_agent + test_sql_equivalence 973 passed;全量 -n 8:7853 passed、11 skipped。
等价改写 124 对认出 120 对(97%),不给表结构 117 对(94%)。复验者的脚本:vsprobe 变异压测 6 个种子约 4.3 万对无
误判等价;在私起的 PostgreSQL 18、MySQL 8.0 上重跑 vsadv 全部语料无 blocker;advfp 的 180 对等价对上具体说法 0 条;
自己的压测 3 个种子各约 1.5 万条可执行,规范形式相同的组执行结果全一致。
This commit is contained in:
ThearchyHelios
2026-10-05 12:00:36 +08:00
parent c55b1983f6
commit f16860f704
4 changed files with 3326 additions and 1353 deletions
File diff suppressed because it is too large Load Diff
+339 -10
View File
@@ -10,8 +10,10 @@ OR 里的标量子查询改成 CROSS JOIN,都是复验时真踩到的),所
2 的负幂次的倍数,不同的求和先后得到的浮点数一样;比较结果时浮点数另按 6 位小数取整(乘 0.9 这类每行都有舍入)。
语料(PAIRS,SQLite,拿去执行)每一项 (编号, A, B, 预期):same 是已知等价的改写(别名、CTE 改名、关联先后、条件
左右、子查询和 CTE 互换……),diff 是不许判等价的(换时间列、少一个条件、去重与否、外连接与内连接,以及只在某个方言、
某种排序规则下才等价的)。LIMIT 都带能定出唯一顺序的排序,没有 ORDER BY 的 LIMIT 不进语料。过去复验报过的反例都
左右、子查询和 CTE 互换……),编号以 hard: 开头的是要按语义推理才看得出等价的(条件挪进相关子查询、冗余条件),规范化
不保证认得出、认不出时只许给兜底说明;diff 是不许判等价的(换时间列、少一个条件、去重与否、外连接与内连接,以及只在
某个方言、某种排序规则下才等价的)。第 2 轮复验的反例在 _SAME_HARD、_SAME_R2、_DIFF_R2(执行)和 REGRESSIONS_R2、
DIALECT_SAME_R2、KNOWN_UNRECOGNIZED(各方言,只查结论)里。LIMIT 都带能定出唯一顺序的排序,没有 ORDER BY 的 LIMIT 不进语料。过去复验报过的反例都
收进来了:第 5 轮回退的「只在 IN 子查询里用到的 CTE」在 PAIRS 里;复验者留在 /private/tmp 的脚本里、在这几组数据上
结果不同的对是 VALIDATOR_DIFF(也进 PAIRS 执行);旧测试(五轮复核修正按复验报告补的用例,各方言,用到的列这个库里
不全有)里报过不同的对是 REGRESSIONS、意思一样的对是 DIALECT_SAME,这两份不执行,只查判没判等价。
@@ -36,6 +38,9 @@ DDL = {
"refunds": "id INTEGER PRIMARY KEY, order_id INTEGER, user_id INTEGER, amount REAL, state TEXT, refunded_at TEXT",
"payments": "id INTEGER PRIMARY KEY, order_id INTEGER, user_id INTEGER, amount REAL, method TEXT, paid_at TEXT",
"shipments": "id INTEGER PRIMARY KEY, order_id INTEGER, carrier TEXT, shipped_at TEXT",
# 一张叫 nums 的实表:SQLite 里不写 RECURSIVE 的递归 CTE(WITH nums(n) AS (… FROM nums …))引用的是它自己,换个名字
# 引用的就是这张表了
"nums": "n INTEGER",
}
@@ -95,8 +100,9 @@ def _rows(seed: int) -> dict[str, list[tuple]]:
# 关联不上订单的退款、付款
refunds.append((len(refunds) + 1, pick([None, 999]), pick(user_ids), pick(AMOUNTS), "done", pick(DATES)))
payments.append((len(payments) + 1, None, pick(user_ids), pick(AMOUNTS), "cash", pick(DATES)))
nums = [(n,) for n in rng.sample([1, 2, 3, 4, 10, 20], rng.randint(1, 4))]
return {"users": users, "stores": stores, "orders": orders, "orders_archive": archive, "order_items": items,
"refunds": refunds, "payments": payments, "shipments": shipments}
"refunds": refunds, "payments": payments, "shipments": shipments, "nums": nums}
def _edge_rows() -> dict[str, list[tuple]]:
@@ -107,17 +113,41 @@ def _edge_rows() -> dict[str, list[tuple]]:
(2, 1, None, 1, 2, None, 0, 0, "paid", "east", None, None, 0),
(3, None, 1, None, None, 100, 0, 1, "paid", None, "2026-09-30 23:59:59", "2026-09-01", 1)]
return {"users": users, "stores": stores, "orders": orders, "orders_archive": [], "order_items": [],
"refunds": [], "payments": [], "shipments": []}
"refunds": [], "payments": [], "shipments": [], "nums": []}
#: 生成数据用的种子(每个种子一组),外加一组极端数据
def _tricky_rows() -> dict[str, list[tuple]]:
"""一组专挑写法差异的数据(第 2 轮复验的反例在这上面现形):金额 0.1、0.2、0.3(浮点数 0.1 + 0.2 ≠ 0.3)、
100 * 0.07;状态里有像数字的文本('3.0'、'12')和大小写不同的 'PAID';用户名是像数字的文本('0100' 取两次负是
100);城市 'SH'、'sh';id 16 的订单(0x10);nums 表有几行。"""
users = [(1, "0100", "SH", 1, 3, None, "2026-09-01", 0), (2, "5", "sh", 0, 1, 1, "2026-09-02", 0),
(3, "alice", "Sh", None, None, 2, None, 1), (4, "Bob", None, 1, 5, None, "2026-08-31 23:59:59", None)]
stores = [(1, "s1", "SH", "east", 1), (2, "s2", "sh", None, None), (3, "3.0", "12", "west", 2)]
amounts = [0.1, 0.2, 0.3, 0.3, 0.30000000000000004, 7.0, 100 * 0.07, 12.5, None, 100.0, 0, 0.5]
statuses = ["paid", "PAID", "3.0", "12", None, "open", "void", "paid"]
orders = []
for i in range(1, 21):
orders.append((i, (i % 4) + 1 if i % 7 else None, (i % 3) + 1, i - 1 if i % 5 == 0 else None, (i % 2) + 1,
amounts[i % len(amounts)], [0, 0.5, None][i % 3], [0, 1, None][i % 3],
statuses[i % len(statuses)], ["east", "west", None][i % 3], DATES[i % len(DATES)],
DATES[(i * 3) % len(DATES)], [0, 1, None][i % 3]))
refunds = [(1, 1, 2, 0.1, "done", "2026-09-05"), (2, 16, 1, 0.2, None, None), (3, 3, None, 0.3, "done", "2026-09-30"),
(4, 99, 3, 7.0, "pending", "2026-10-01")]
payments = [(1, 1, 2, 0.3, "card", "2026-09-02"), (2, 16, 1, 0.1, "cash", None)]
items = [(1, 1, 1, 2, 0.1), (2, 16, 2, None, 0.2), (3, 3, 1, 1, None)]
shipments = [(1, 1, "sf", "2026-09-03"), (2, 16, None, None)]
return {"users": users, "stores": stores, "orders": orders, "orders_archive": orders[:5], "order_items": items,
"refunds": refunds, "payments": payments, "shipments": shipments, "nums": [(1,), (2,), (10,)]}
#: 生成数据用的种子(每个种子一组),外加一组极端数据、一组专挑写法差异的数据
SEEDS = (7, 11, 23, 42, 2026)
def build_databases() -> list[sqlite3.Connection]:
"""每组数据一个内存库。"""
out = []
for rows in [_rows(seed) for seed in SEEDS] + [_edge_rows()]:
for rows in [_rows(seed) for seed in SEEDS] + [_edge_rows(), _tricky_rows()]:
conn = sqlite3.connect(":memory:")
for name, ddl in DDL.items():
conn.execute(f"CREATE TABLE {name} ({ddl})")
@@ -847,9 +877,6 @@ DIALECT_SAME: list[tuple[str, str, str, str]] = [
("swapped_join_order_of_two_derived_tables_is_no_difference", "sqlite",
"WITH t AS (SELECT user_id, SUM(amount) AS total FROM orders GROUP BY user_id), u AS (SELECT user_id, COUNT(*) AS cnt FROM refunds GROUP BY user_id) SELECT COUNT(*) FROM t JOIN u ON u.user_id = t.user_id WHERE t.total > u.cnt",
"WITH t AS (SELECT user_id, SUM(amount) AS total FROM orders GROUP BY user_id), u AS (SELECT user_id, COUNT(*) AS cnt FROM refunds GROUP BY user_id) SELECT COUNT(*) FROM u JOIN t ON t.user_id = u.user_id WHERE t.total > u.cnt"),
("the_same_item_on_equivalent_layers_is_no_difference", "sqlite",
"WITH t AS (SELECT user_id, SUM(amount) AS total FROM orders WHERE user_id > 100 GROUP BY user_id) SELECT SUM(total) FROM t",
"WITH t AS (SELECT user_id, SUM(amount) AS total FROM orders GROUP BY user_id) SELECT SUM(total) FROM t WHERE user_id > 100"),
("derived_columns_renamed_on_one_side_are_paired", "sqlite",
"WITH t AS (SELECT user_id, SUM(amount) AS total, COUNT(*) AS n FROM orders GROUP BY user_id) SELECT COUNT(*) FROM t WHERE total > 100 AND n > 1",
"WITH t AS (SELECT user_id, SUM(amount) AS s, COUNT(*) AS c FROM orders GROUP BY user_id) SELECT COUNT(*) FROM t WHERE s > 100 AND c > 1"),
@@ -1860,6 +1887,308 @@ VALIDATOR_DIFF: list[tuple[str, str, str]] = [
]
# ---------------------------------------------------------------------------- 第 2 轮复验的反例
# 第 2 轮复验(重做之后的第一版)报的 blocker / major 和几位复验者留在 /private/tmp 的脚本里的对,改写到这个库的
# 表上(列名换成这里有的),SQLite 能执行的进执行比对;只在 PostgreSQL / MySQL 才有的写法进 REGRESSIONS_R2 只查结论。
#: 意思一样、但要按语义推理才看得出的(条件挪进相关子查询、冗余条件、写法不同的等价条件……):规范化不保证认得出,
#: 认不出时只许给兜底说明,不许给具体说法(复验专挑这类对查「说出不存在的差异」)
_SAME_HARD = [
# 条件挪进相关子查询(EXISTS 里引用外层的列):B 是有这个条件的,不能说「B 没有」
("r2-exists-moved-time", "SELECT COUNT(*) FROM orders o WHERE o.paid_at >= '2026-09-01' AND EXISTS "
"(SELECT 1 FROM refunds r WHERE r.order_id = o.id)",
"SELECT COUNT(*) FROM orders o WHERE EXISTS (SELECT 1 FROM refunds r WHERE r.order_id = o.id "
"AND o.paid_at >= '2026-09-01')"),
("r2-exists-moved-filter", "SELECT COUNT(*) FROM orders o WHERE o.status = 'paid' AND EXISTS "
"(SELECT 1 FROM refunds r WHERE r.order_id = o.id)",
"SELECT COUNT(*) FROM orders o WHERE EXISTS (SELECT 1 FROM refunds r WHERE r.order_id = o.id AND o.status = 'paid')"),
("r2-scalar-moved-filter", "SELECT COUNT(*) FROM orders o WHERE o.status = 'paid' AND o.amount > "
"(SELECT AVG(r.amount) FROM refunds r WHERE r.order_id = o.id)",
"SELECT COUNT(*) FROM orders o WHERE o.amount > (SELECT AVG(r.amount) FROM refunds r WHERE r.order_id = o.id "
"AND o.status = 'paid')"),
# refunds 没有 status 列:子查询里的 status 是外层 orders 的
("r2-in-moved-outer-column", "SELECT COUNT(*) FROM orders WHERE status = 'paid' AND id IN (SELECT order_id FROM refunds)",
"SELECT COUNT(*) FROM orders WHERE id IN (SELECT order_id FROM refunds WHERE status = 'paid')"),
# 一段时间拆成两段、IN 和 OR、多写一个下界:留下的行一样
("r2-time-split-range", "SELECT COUNT(*) FROM orders WHERE paid_at >= '2026-09-01' AND paid_at < '2026-10-01'",
"SELECT COUNT(*) FROM orders WHERE (paid_at >= '2026-09-01' AND paid_at < '2026-09-16') OR "
"(paid_at >= '2026-09-16' AND paid_at < '2026-10-01')"),
("r2-time-in-vs-or", "SELECT COUNT(*) FROM orders WHERE paid_at IN ('2026-09-01', '2026-09-30')",
"SELECT COUNT(*) FROM orders WHERE paid_at = '2026-09-01' OR paid_at = '2026-09-30'"),
("r2-time-redundant-lower", "SELECT COUNT(*) FROM orders WHERE paid_at >= '2026-09-01' AND paid_at < '2026-10-01'",
"SELECT COUNT(*) FROM orders WHERE paid_at >= '2026-09-01' AND paid_at < '2026-10-01' AND paid_at > '2026-08-01'"),
("r2-in-vs-or", "SELECT COUNT(*) FROM orders WHERE status IN ('paid', 'done')",
"SELECT COUNT(*) FROM orders WHERE status = 'paid' OR status = 'done'"),
("r2-redundant-not-null", "SELECT SUM(tax) FROM orders WHERE tax > 1 AND tax IS NOT NULL",
"SELECT SUM(tax) FROM orders WHERE tax > 1"),
("r2-redundant-not-null-join", "SELECT SUM(o.amount) FROM orders o JOIN users u ON u.id = o.user_id "
"WHERE o.user_id IS NOT NULL",
"SELECT SUM(o.amount) FROM orders o JOIN users u ON u.id = o.user_id"),
("r2-redundant-not-null-in", "SELECT COUNT(*) FROM orders WHERE store_id IN (SELECT id FROM stores "
"WHERE region = 'east') AND store_id IS NOT NULL",
"SELECT COUNT(*) FROM orders WHERE store_id IN (SELECT id FROM stores WHERE region = 'east')"),
("r2-count-col-vs-not-null-filter", "SELECT COUNT(tax) FROM orders", "SELECT COUNT(*) FROM orders WHERE tax IS NOT NULL"),
("r2-count-distinct-not-null", "SELECT COUNT(DISTINCT user_id) FROM orders WHERE user_id IS NOT NULL",
"SELECT COUNT(DISTINCT user_id) FROM orders"),
("r2-coalesce-gt", "SELECT COUNT(*) FROM orders WHERE COALESCE(amount, 0) > 10",
"SELECT COUNT(*) FROM orders WHERE amount > 10"),
("r2-left-coalesce-reject", "SELECT o.id FROM orders o LEFT JOIN users u ON u.id = o.user_id "
"WHERE COALESCE(u.grade, 0) > 1",
"SELECT o.id FROM orders o JOIN users u ON u.id = o.user_id WHERE COALESCE(u.grade, 0) > 1"),
("r2-left-count-nullable-side", "SELECT COUNT(r.id) FROM orders o LEFT JOIN refunds r ON r.order_id = o.id",
"SELECT COUNT(r.id) FROM orders o JOIN refunds r ON r.order_id = o.id"),
("r2-having-count-gt-1-vs-ge-2", "SELECT user_id FROM orders GROUP BY user_id HAVING COUNT(*) > 1",
"SELECT user_id FROM orders GROUP BY user_id HAVING COUNT(*) >= 2"),
("r2-having-noop", "SELECT store_id, SUM(amount) FROM orders GROUP BY store_id HAVING COUNT(*) > 0",
"SELECT store_id, SUM(amount) FROM orders GROUP BY store_id"),
("r2-scalar-max-commute", "SELECT max(amount, tax) FROM orders", "SELECT max(tax, amount) FROM orders"),
("r2-case-vs-coalesce", "SELECT SUM(CASE WHEN discount IS NULL THEN 0 ELSE discount END) FROM orders",
"SELECT SUM(COALESCE(discount, 0)) FROM orders"),
]
#: 意思一样、规范化认得出的改写(第 2 轮新增的几步)
_SAME_R2 = [
("r2-one-eq-one", "SELECT COUNT(*) FROM orders WHERE 1 = 1 AND status = 'paid'",
"SELECT COUNT(*) FROM orders WHERE status = 'paid'"),
("r2-not-is-not-null", "SELECT COUNT(*) FROM orders WHERE NOT (paid_at IS NOT NULL)",
"SELECT COUNT(*) FROM orders WHERE paid_at IS NULL"),
("r2-not-like", "SELECT COUNT(*) FROM orders WHERE status NOT LIKE 'p%'",
"SELECT COUNT(*) FROM orders WHERE NOT status LIKE 'p%'"),
("r2-iif-vs-case", "SELECT SUM(IIF(status = 'paid', amount, 0)) FROM orders",
"SELECT SUM(CASE WHEN status = 'paid' THEN amount ELSE 0 END) FROM orders"),
("r2-case-else-null", "SELECT SUM(CASE WHEN status = 'paid' THEN amount END) FROM orders",
"SELECT SUM(CASE WHEN status = 'paid' THEN amount ELSE NULL END) FROM orders"),
("r2-min-distinct", "SELECT MIN(DISTINCT amount), MAX(DISTINCT tax) FROM orders",
"SELECT MIN(amount), MAX(tax) FROM orders"),
("r2-exists-limit-1", "SELECT COUNT(*) FROM users u WHERE EXISTS (SELECT 1 FROM orders o WHERE o.user_id = u.id LIMIT 1)",
"SELECT COUNT(*) FROM users u WHERE EXISTS (SELECT 1 FROM orders o WHERE o.user_id = u.id)"),
("r2-in-subquery-distinct", "SELECT COUNT(*) FROM orders WHERE user_id IN (SELECT DISTINCT user_id FROM refunds)",
"SELECT COUNT(*) FROM orders WHERE user_id IN (SELECT user_id FROM refunds)"),
("r2-using-vs-on-select", "SELECT user_id FROM orders o LEFT JOIN refunds r USING (user_id)",
"SELECT o.user_id FROM orders o LEFT JOIN refunds r ON o.user_id = r.user_id"),
("r2-multi-use-cte-correlated", "WITH p AS (SELECT * FROM orders WHERE status = 'paid') SELECT COUNT(*) FROM p "
"WHERE EXISTS (SELECT 1 FROM p AS p2 WHERE p2.parent_id = p.id)",
"SELECT COUNT(*) FROM orders o WHERE o.status = 'paid' AND EXISTS (SELECT 1 FROM orders c "
"WHERE c.parent_id = o.id AND c.status = 'paid')"),
("r2-outer-where-into-having", "WITH t AS (SELECT user_id, SUM(amount) AS s FROM orders GROUP BY user_id "
"HAVING SUM(amount) > 100) SELECT COUNT(*) FROM t",
"SELECT COUNT(*) FROM (SELECT user_id, SUM(amount) AS s FROM orders GROUP BY user_id) t WHERE t.s > 100"),
]
#: 不许判等价的(第 2 轮复验报的 blocker 改写到这个库上;在这几组数据上大多结果不同)
_DIFF_R2 = [
# 数字常量不折叠:SQLite 按浮点数算,0.1 + 0.2 ≠ 0.3;三项以上的加乘不换结合
("r2-float-fold", "SELECT COUNT(*) FROM orders WHERE amount = 0.1 + 0.2", "SELECT COUNT(*) FROM orders WHERE amount = 0.3"),
("r2-float-fold-chain", "SELECT COUNT(*) FROM orders WHERE amount + 0.1 + 0.2 = 0.3",
"SELECT COUNT(*) FROM orders WHERE amount + 0.3 = 0.3"),
("r2-float-fold-mul", "SELECT id, amount * 0.1 * 3 FROM orders", "SELECT id, amount * 0.3 FROM orders"),
("r2-float-fold-compare", "SELECT COUNT(*) FROM orders WHERE amount < 3 * 0.1",
"SELECT COUNT(*) FROM orders WHERE amount < 0.3"),
("r2-float-fold-007", "SELECT COUNT(*) FROM orders WHERE amount >= 100 * 0.07",
"SELECT COUNT(*) FROM orders WHERE amount >= 7.00"),
# 取两次负会把文本转成数
("r2-double-negation", "SELECT id, -(-name) FROM users", "SELECT id, name FROM users"),
("r2-double-negation-compare", "SELECT COUNT(*) FROM users WHERE -(-name) = 100",
"SELECT COUNT(*) FROM users WHERE name = 100"),
# 列名表:CTE 自己写的列名决定了外面的名字指哪一列
("r2-cte-column-list-swap", "WITH p(uid, total) AS (SELECT user_id, SUM(amount) FROM orders GROUP BY user_id) "
"SELECT COUNT(*) FROM p WHERE total > 100",
"WITH p(total, uid) AS (SELECT user_id, SUM(amount) FROM orders GROUP BY user_id) "
"SELECT COUNT(*) FROM p WHERE total > 100"),
("r2-cte-column-list-swap-2", "WITH t(user_id, amount) AS (SELECT amount, user_id FROM orders) SELECT SUM(amount) FROM t",
"WITH t(amount, user_id) AS (SELECT amount, user_id FROM orders) SELECT SUM(amount) FROM t"),
# SQLite 不写 RECURSIVE 也是递归:A 引用的是自己,B 引用的是实表 nums
("r2-recursive-without-keyword", "WITH nums(n) AS (SELECT 1 UNION ALL SELECT n + 1 FROM nums WHERE n < 5) "
"SELECT COUNT(*) FROM nums",
"WITH seq(n) AS (SELECT 1 UNION ALL SELECT n + 1 FROM nums WHERE n < 5) SELECT COUNT(*) FROM seq"),
# ORDER BY 有并列再取行、拼串、窗口函数:结果看行出来的先后,调换来源、DISTINCT 改 GROUP BY 都会变
("r2-distinct-group-limit-ties", "SELECT DISTINCT user_id, status FROM orders ORDER BY user_id LIMIT 4",
"SELECT user_id, status FROM orders GROUP BY user_id, status ORDER BY user_id LIMIT 4"),
("r2-group-key-order-limit-ties", "SELECT user_id, store_id, COUNT(*) FROM orders GROUP BY user_id, store_id "
"ORDER BY COUNT(*) DESC LIMIT 2",
"SELECT user_id, store_id, COUNT(*) FROM orders GROUP BY store_id, user_id ORDER BY COUNT(*) DESC LIMIT 2"),
("r2-cross-join-swap-limit-ties", "SELECT o.id, u.id FROM orders o CROSS JOIN users u WHERE u.id = o.user_id "
"ORDER BY o.amount LIMIT 3",
"SELECT o.id, u.id FROM users u CROSS JOIN orders o WHERE u.id = o.user_id ORDER BY o.amount LIMIT 3"),
("r2-group-concat-join-order", "SELECT u.city, GROUP_CONCAT(o.id) FROM users u CROSS JOIN orders o "
"WHERE o.user_id = u.id GROUP BY u.city",
"SELECT u.city, GROUP_CONCAT(o.id) FROM orders o CROSS JOIN users u WHERE o.user_id = u.id GROUP BY u.city"),
("r2-group-concat-cross-vs-comma", "SELECT u.city, GROUP_CONCAT(o.id) FROM users u CROSS JOIN orders o "
"WHERE o.user_id = u.id GROUP BY u.city",
"SELECT u.city, GROUP_CONCAT(o.id) FROM users u, orders o WHERE o.user_id = u.id GROUP BY u.city"),
("r2-row-number-join-order", "SELECT o.id, ROW_NUMBER() OVER () AS rn FROM users u CROSS JOIN orders o "
"WHERE o.user_id = u.id",
"SELECT o.id, ROW_NUMBER() OVER () AS rn FROM orders o CROSS JOIN users u WHERE o.user_id = u.id"),
("r2-row-number-ties-join-order", "SELECT o.id, ROW_NUMBER() OVER (ORDER BY o.status) AS rn FROM users u "
"JOIN orders o ON o.user_id = u.id",
"SELECT o.id, ROW_NUMBER() OVER (ORDER BY o.status) AS rn FROM orders o JOIN users u ON o.user_id = u.id"),
("r2-group-concat-subquery-order", "SELECT GROUP_CONCAT(id) FROM (SELECT id FROM orders ORDER BY amount DESC, id) t",
"SELECT GROUP_CONCAT(id) FROM (SELECT id FROM orders) t"),
# SQLite 里 a IN (b) 是 a = +b:右边那一列不带类型亲和
("r2-in-single-column", "SELECT COUNT(*) FROM orders WHERE status IN (store_id)",
"SELECT COUNT(*) FROM orders WHERE status = store_id"),
("r2-not-in-single-column", "SELECT COUNT(*) FROM orders WHERE status NOT IN (store_id)",
"SELECT COUNT(*) FROM orders WHERE status <> store_id"),
# 解析时丢了写法的:类型名(STRING 是数值亲和)、0x10 和 x'10'
("r2-cast-string", "SELECT store_id, CAST(store_id AS STRING) FROM orders",
"SELECT store_id, CAST(store_id AS TEXT) FROM orders"),
("r2-cast-bytea", "SELECT id, CAST(status AS BLOB) FROM orders", "SELECT id, CAST(status AS BYTEA) FROM orders"),
("r2-hex-literal", "SELECT COUNT(*) FROM orders WHERE id = 0x10", "SELECT COUNT(*) FROM orders WHERE id = x'10'"),
# SELECT * 的列先后
("r2-star-cte-column-order", "WITH c AS (SELECT user_id, amount FROM orders) SELECT * FROM c JOIN users "
"ON users.id = c.user_id",
"WITH c AS (SELECT amount, user_id FROM orders) SELECT * FROM c JOIN users ON users.id = c.user_id"),
("r2-star-join-reorder", "SELECT * FROM orders o LEFT JOIN refunds r ON r.order_id = o.id JOIN users u ON u.id = o.user_id",
"SELECT * FROM orders o JOIN users u ON u.id = o.user_id LEFT JOIN refunds r ON r.order_id = o.id"),
# EXISTS 里:ORDER BY 有聚合就是聚合查询(总出一行);DISTINCT 在 OFFSET 之前算(SQLite 恰好不管这个 DISTINCT)
("r2-exists-order-by-aggregate", "SELECT COUNT(*) FROM orders o WHERE EXISTS (SELECT 1 FROM refunds r "
"WHERE r.order_id = o.id ORDER BY COUNT(*))",
"SELECT COUNT(*) FROM orders o WHERE EXISTS (SELECT 1 FROM refunds r WHERE r.order_id = o.id)"),
("r2-exists-distinct-offset", "SELECT COUNT(*) FROM orders o WHERE EXISTS (SELECT DISTINCT r.state FROM refunds r "
"WHERE r.amount > 0 LIMIT 1 OFFSET 1)",
"SELECT COUNT(*) FROM orders o WHERE EXISTS (SELECT r.state FROM refunds r WHERE r.amount > 0 LIMIT 1 OFFSET 1)"),
# HAVING 不往 WHERE 挪:不分大小写的排序规则下同一组里的值各不一样
("r2-having-key-vs-where", "SELECT city, COUNT(*) FROM users GROUP BY city HAVING city = 'SH'",
"SELECT city, COUNT(*) FROM users WHERE city = 'SH' GROUP BY city"),
# 两边对调、子查询配错位置(复验说成自相矛盾的话的几对)
("r2-except-sides-swapped", "SELECT user_id FROM orders WHERE paid_at >= '2026-09-01' EXCEPT SELECT user_id FROM refunds",
"SELECT user_id FROM refunds EXCEPT SELECT user_id FROM orders WHERE created_at >= '2026-09-01'"),
("r2-in-not-in-swapped", "WITH p AS (SELECT user_id FROM orders WHERE status = 'paid' AND user_id IS NOT NULL), "
"v AS (SELECT user_id FROM orders WHERE status = 'void' AND user_id IS NOT NULL) SELECT COUNT(*) FROM users "
"WHERE id IN (SELECT user_id FROM p) AND id NOT IN (SELECT user_id FROM v)",
"WITH p AS (SELECT user_id FROM orders WHERE status = 'paid' AND user_id IS NOT NULL), "
"v AS (SELECT user_id FROM orders WHERE status = 'void' AND user_id IS NOT NULL) SELECT COUNT(*) FROM users "
"WHERE id IN (SELECT user_id FROM v) AND id NOT IN (SELECT user_id FROM p)"),
("r2-not-in-filter", "WITH p AS (SELECT user_id FROM orders WHERE status = 'paid'), v AS (SELECT user_id FROM orders "
"WHERE status = 'void' AND user_id IS NOT NULL) SELECT COUNT(*) FROM users WHERE id IN (SELECT user_id FROM p) "
"AND id NOT IN (SELECT user_id FROM v)",
"WITH p AS (SELECT user_id FROM orders WHERE status = 'paid'), v AS (SELECT user_id FROM orders "
"WHERE status = 'open' AND user_id IS NOT NULL) SELECT COUNT(*) FROM users WHERE id IN (SELECT user_id FROM p) "
"AND id NOT IN (SELECT user_id FROM v)"),
("r2-exists-not-exists-swapped", "SELECT COUNT(*) FROM orders o WHERE EXISTS (SELECT 1 FROM refunds r "
"WHERE r.order_id = o.id AND r.state = 'done') AND NOT EXISTS (SELECT 1 FROM refunds r WHERE r.order_id = o.id "
"AND r.state = 'pending')",
"SELECT COUNT(*) FROM orders o WHERE EXISTS (SELECT 1 FROM refunds r WHERE r.order_id = o.id AND r.state = 'pending') "
"AND NOT EXISTS (SELECT 1 FROM refunds r WHERE r.order_id = o.id AND r.state = 'done')"),
("r2-in-left-column-swapped", "SELECT COUNT(*) FROM users WHERE id IN (SELECT user_id FROM orders WHERE status = 'paid') "
"AND referrer_id IN (SELECT user_id FROM orders WHERE status = 'void')",
"SELECT COUNT(*) FROM users WHERE id IN (SELECT user_id FROM orders WHERE status = 'void') "
"AND referrer_id IN (SELECT user_id FROM orders WHERE status = 'paid')"),
# 换了表:各自的列是各自表的(复验报的 detail 归错了表)
("r2-table-swap-time", "SELECT COUNT(*) FROM orders WHERE paid_at >= '2026-09-01'",
"SELECT COUNT(*) FROM users WHERE created_at >= '2026-09-01'"),
("r2-table-swap-join", "SELECT SUM(o.amount) FROM orders o JOIN stores s ON s.id = o.store_id WHERE s.city = 'SH'",
"SELECT SUM(o.amount) FROM orders o JOIN users u ON u.id = o.user_id WHERE u.city = 'SH'"),
("r2-table-swap-time-2", "SELECT SUM(amount) FROM refunds WHERE refunded_at >= '2026-09-01'",
"SELECT SUM(amount) FROM payments WHERE paid_at >= '2026-09-01'"),
]
#: 只在 PostgreSQL / MySQL 才有的写法(不执行,只查不判等价):第 2 轮复验在真实的库上跑出结果不同的
REGRESSIONS_R2: list[tuple[str, str, str, str]] = [
("having_binary_is_not_where", "mysql",
"SELECT city, COUNT(*) FROM users GROUP BY city HAVING BINARY city = 'SH'",
"SELECT city, COUNT(*) FROM users WHERE BINARY city = 'SH' GROUP BY city"),
("having_like_binary_is_not_where", "mysql",
"SELECT city, COUNT(*) FROM users GROUP BY city HAVING city LIKE BINARY 'S%'",
"SELECT city, COUNT(*) FROM users WHERE city LIKE BINARY 'S%' GROUP BY city"),
("having_collate_is_not_where", "mysql",
"SELECT city, COUNT(*) FROM users GROUP BY city HAVING city COLLATE utf8mb4_bin = 'SH'",
"SELECT city, COUNT(*) FROM users WHERE city COLLATE utf8mb4_bin = 'SH' GROUP BY city"),
("distinct_city_join_order_ci", "mysql",
"SELECT DISTINCT u.city FROM users u JOIN orders o ON o.user_id = u.id",
"SELECT DISTINCT u.city FROM orders o JOIN users u ON o.user_id = u.id"),
("group_city_join_order_ci", "mysql",
"SELECT u.city, COUNT(*) FROM users u JOIN orders o ON o.user_id = u.id GROUP BY u.city",
"SELECT u.city, COUNT(*) FROM orders o JOIN users u ON o.user_id = u.id GROUP BY u.city"),
("order_by_aggregate_in_exists", "postgres",
"SELECT COUNT(*) FROM orders o WHERE EXISTS (SELECT 1 FROM refunds r WHERE r.order_id = o.id ORDER BY COUNT(*))",
"SELECT COUNT(*) FROM orders o WHERE EXISTS (SELECT 1 FROM refunds r WHERE r.order_id = o.id)"),
("order_by_aggregate_in_in", "postgres",
"SELECT COUNT(*) FROM users WHERE vip IN (SELECT 1 FROM refunds WHERE amount > 1000 ORDER BY COUNT(*))",
"SELECT COUNT(*) FROM users WHERE vip IN (SELECT 1 FROM refunds WHERE amount > 1000)"),
("cte_column_list_swap", "postgres",
"WITH p(uid, total) AS (SELECT user_id, SUM(amount) FROM orders GROUP BY user_id) SELECT COUNT(*) FROM p WHERE total > 100",
"WITH p(total, uid) AS (SELECT user_id, SUM(amount) FROM orders GROUP BY user_id) SELECT COUNT(*) FROM p WHERE total > 100"),
("cte_column_list_swap", "mysql",
"WITH t(user_id, amount) AS (SELECT amount, user_id FROM orders) SELECT SUM(amount) FROM t",
"WITH t(amount, user_id) AS (SELECT amount, user_id FROM orders) SELECT SUM(amount) FROM t"),
("derived_column_list_swap", "postgres",
"SELECT SUM(t.x) FROM (SELECT amount, tax FROM orders) AS t(x, y)",
"SELECT SUM(t.x) FROM (SELECT amount, tax FROM orders) AS t(y, x)"),
("derived_column_list_swap", "mysql",
"SELECT t.b FROM (SELECT user_id, amount FROM orders) AS t(a, b) WHERE t.a > 3",
"SELECT t.b FROM (SELECT user_id, amount FROM orders) AS t(b, a) WHERE t.a > 3"),
("derived_column_list_renames", "postgres",
"SELECT amount, user_id FROM (SELECT amount, user_id FROM orders) AS t(user_id, amount)",
"SELECT amount, user_id FROM orders"),
("table_alias_column_list", "postgres",
"SELECT COUNT(*) FROM orders AS o(user_id, id) WHERE o.user_id > 5",
"SELECT COUNT(*) FROM orders AS o WHERE o.user_id > 5"),
("union_all_in_cte_alias_order", "postgres",
"WITH u AS (SELECT user_id AS a, amount AS b FROM orders UNION ALL SELECT amount AS b, user_id AS a FROM refunds) "
"SELECT SUM(b), SUM(a) FROM u",
"WITH u AS (SELECT amount AS b, user_id AS a FROM refunds UNION ALL SELECT user_id AS a, amount AS b FROM orders) "
"SELECT SUM(b), SUM(a) FROM u"),
("union_all_in_cte_alias_order", "mysql",
"WITH u AS (SELECT user_id AS a, amount AS b FROM orders UNION ALL SELECT amount AS b, user_id AS a FROM refunds) "
"SELECT SUM(b), SUM(a) FROM u",
"WITH u AS (SELECT amount AS b, user_id AS a FROM refunds UNION ALL SELECT user_id AS a, amount AS b FROM orders) "
"SELECT SUM(b), SUM(a) FROM u"),
("between_symmetric", "postgres",
"SELECT COUNT(*) FROM orders WHERE amount BETWEEN SYMMETRIC 100 AND 10",
"SELECT COUNT(*) FROM orders WHERE amount BETWEEN 100 AND 10"),
("group_key_order_with_limit", "postgres",
"SELECT user_id, store_id, COUNT(*) FROM orders GROUP BY user_id, store_id ORDER BY COUNT(*) DESC LIMIT 2",
"SELECT user_id, store_id, COUNT(*) FROM orders GROUP BY store_id, user_id ORDER BY COUNT(*) DESC LIMIT 2"),
("exists_distinct_offset", "postgres",
"SELECT COUNT(*) FROM orders o WHERE EXISTS (SELECT DISTINCT r.state FROM refunds r WHERE r.amount > 0 LIMIT 1 OFFSET 1)",
"SELECT COUNT(*) FROM orders o WHERE EXISTS (SELECT r.state FROM refunds r WHERE r.amount > 0 LIMIT 1 OFFSET 1)"),
("distinct_on_keeps_a_different_row", "postgres",
"SELECT DISTINCT ON (user_id) user_id, status FROM orders ORDER BY user_id, created_at DESC NULLS LAST, id",
"SELECT DISTINCT ON (user_id) user_id, status FROM orders ORDER BY user_id, paid_at DESC NULLS LAST, id"),
("float_folding", "postgres",
"SELECT COUNT(*) FROM orders WHERE amount = 0.1 + 0.2", "SELECT COUNT(*) FROM orders WHERE amount = 0.3"),
("double_negation", "mysql", "SELECT id, -(-name) FROM users", "SELECT id, name FROM users"),
]
#: 意思一样、规范化认得出的(PostgreSQL / MySQL 的写法)
DIALECT_SAME_R2: list[tuple[str, str, str, str]] = [
("fetch_first_is_limit", "postgres", "SELECT id FROM orders ORDER BY id FETCH FIRST 4 ROWS ONLY",
"SELECT id FROM orders ORDER BY id LIMIT 4"),
("offset_fetch_is_limit_offset", "postgres", "SELECT id FROM orders ORDER BY id OFFSET 2 ROWS FETCH NEXT 4 ROWS ONLY",
"SELECT id FROM orders ORDER BY id LIMIT 4 OFFSET 2"),
("mysql_column_names_ignore_case", "mysql", "SELECT SUM(amount) FROM orders WHERE is_deleted = 0",
"SELECT SUM(AMOUNT) FROM orders WHERE IS_DELETED = 0"),
("is_not_null_forms", "postgres", "SELECT COUNT(*) FROM orders WHERE NOT (paid_at IS NOT NULL)",
"SELECT COUNT(*) FROM orders WHERE paid_at IS NULL"),
("not_like_forms", "postgres", "SELECT COUNT(*) FROM orders WHERE status NOT LIKE 'p%'",
"SELECT COUNT(*) FROM orders WHERE NOT status LIKE 'p%'"),
("if_vs_case", "mysql", "SELECT SUM(IF(status = 'paid', amount, 0)) FROM orders",
"SELECT SUM(CASE WHEN status = 'paid' THEN amount ELSE 0 END) FROM orders"),
]
#: 意思一样、规范化故意不认的(认了就要假设「相等就是一样」,见模块说明):只给兜底说明,不给具体说法
KNOWN_UNRECOGNIZED: list[tuple[str, str, str, str]] = [
("having_on_group_key_vs_where", "sqlite",
"WITH t AS (SELECT user_id, SUM(amount) AS total FROM orders WHERE user_id > 100 GROUP BY user_id) SELECT SUM(total) FROM t",
"WITH t AS (SELECT user_id, SUM(amount) AS total FROM orders GROUP BY user_id) SELECT SUM(total) FROM t WHERE user_id > 100"),
("union_dedup_branch_order", "sqlite",
"SELECT id, amount FROM orders UNION SELECT id, amount FROM orders_archive",
"SELECT id, amount FROM orders_archive UNION SELECT id, amount FROM orders"),
("window_partition_key_order", "sqlite",
"SELECT id, SUM(amount) OVER (PARTITION BY user_id, store_id) AS s FROM orders",
"SELECT id, SUM(amount) OVER (PARTITION BY store_id, user_id) AS s FROM orders"),
("distinct_vs_group_mysql_strings", "mysql",
"SELECT DISTINCT city FROM users", "SELECT city FROM users GROUP BY city"),
]
PAIRS: list[Pair] = [Pair(f"same:{i}", a, b, "same") for i, a, b in _SAME] + \
[Pair(f"diff:{i}", a, b, "diff") for i, a, b in _DIFF] + \
[Pair(f"validator:{n}:{k}", a, b, "diff") for k, (n, a, b) in enumerate(VALIDATOR_DIFF)]
[Pair(f"validator:{n}:{k}", a, b, "diff") for k, (n, a, b) in enumerate(VALIDATOR_DIFF)] + \
[Pair(f"same:{i}", a, b, "same") for i, a, b in _SAME_R2] + \
[Pair(f"hard:{i}", a, b, "same") for i, a, b in _SAME_HARD] + \
[Pair(f"diff:{i}", a, b, "diff") for i, a, b in _DIFF_R2]
#: 按编号找语料里的一对(测试里引用第 2 轮的反例用)
PAIRS_BY_ID: dict[str, Pair] = {p.id: p for p in PAIRS}
+29 -8
View File
@@ -6,11 +6,13 @@ explain_sql_diff 判两条 SQL 等价,当且仅当两边经过只保持语义
- 判了等价的两条,在每组数据上结果都必须一样(结果集按行排序比较);
- 在某组数据上结果不一样的两条,绝不能判等价;
- 语料里标 diff 的(语义不同,或者只在某个方言、某种排序规则下才等价),一律不能判等价;
- 标 same 的(已知等价的改写),记下认出来的比例:目标是大多数都认得出,但不强求全部。
- 标 same 的(已知等价),没认出来时只许给兜底说明,不许给具体说法(具体说法说的是两边确实不同的地方);
- 等价改写(编号不以 hard: 开头的 same)记下认出来的比例:目标是大多数都认得出,但不强求全部。
库和语料见 tests/fixtures/sql_pairs.py:5 组按固定种子生成的数据加一组极端数据,带空值、重复、边界值、已删除的
行、退款;语料里有手写的等价改写和语义不同的对,也有复验者以前造的、在这几组数据上结果不同的对。每一对都在不给表
结构和给表结构(数据源的 schema_cache)两种情况下各判一次,两种都要守住上面的规矩。
库和语料见 tests/fixtures/sql_pairs.py:5 组按固定种子生成的数据加一组极端数据、一组专挑写法差异的数据(0.1 + 0.2、
像数字的文本、大小写不同的值),带空值、重复、边界值、已删除的行、退款;语料里有手写的等价改写和语义不同的对,也有
复验者以前造的、在这几组数据上结果不同的对,以及第 2 轮复验报的反例。每一对都在不给表结构和给表结构(数据源的
schema_cache)两种情况下各判一次,两种都要守住上面的规矩。
"""
from __future__ import annotations
@@ -59,18 +61,25 @@ def test_equivalence_is_guarded_by_execution(databases, pair):
assert not diff.equivalent, f"{pair.id}:第 {differs} 组数据上结果不同,却判了等价(schema={bool(schema)})"
if pair.expect == "diff":
assert not diff.equivalent, f"{pair.id} 不该判等价(schema={bool(schema)})"
if pair.expect == "same" and not diff.equivalent:
specific = [d.text for d in diff.items if d.aspect != "other"]
assert not specific, f"{pair.id} 意思一样,却说了具体的不同(schema={bool(schema)}):{specific}"
# 换个先后问,结论一样
assert explain_sql_diff(pair.b, pair.a, "sqlite", schema=schema).equivalent == diff.equivalent, pair.id
def test_most_known_equivalent_rewrites_are_recognized():
"""已知等价的改写里认出来的比例(给表结构时)。不强求全部认出来:认不出的给的是兜底说明,不是错误的结论。"""
same = [p for p in sql_pairs.PAIRS if p.expect == "same"]
"""已知等价的改写(别名、CTE 改名、关联先后、条件左右、子查询和 CTE 互换……)里认出来的比例。不强求全部认出来:
认不出的给的是兜底说明,不是错误的结论。要按语义推理才看得出的(hard:)另记,不算进比例。"""
same = [p for p in sql_pairs.PAIRS if p.expect == "same" and not p.id.startswith("hard:")]
hits = [p.id for p in same if explain_sql_diff(p.a, p.b, "sqlite", schema=SCHEMA).equivalent]
bare = [p.id for p in same if explain_sql_diff(p.a, p.b, "sqlite").equivalent]
ratio, bare_ratio = len(hits) / len(same), len(bare) / len(same)
print(f"\n已知等价的 {len(same)} 对里认出 {len(hits)} 对({ratio:.0%}),不给表结构时 {len(bare)} 对({bare_ratio:.0%})")
print(f"\n已知等价的改写 {len(same)} 对里认出 {len(hits)} 对({ratio:.0%}),不给表结构时 {len(bare)} 对({bare_ratio:.0%})")
print("没认出来的:", sorted(set(p.id for p in same) - set(hits)))
hard = [p for p in sql_pairs.PAIRS if p.id.startswith("hard:")]
hard_hits = [p.id for p in hard if explain_sql_diff(p.a, p.b, "sqlite", schema=SCHEMA).equivalent]
print(f"要按语义推理的 {len(hard)} 对里认出 {len(hard_hits)} 对(其余只给兜底说明)")
assert ratio >= 0.9 and bare_ratio >= 0.9
@@ -78,5 +87,17 @@ def test_the_corpus_is_large_and_varied_enough():
assert len(sql_pairs.PAIRS) >= 150 and len(sql_pairs.SEEDS) >= 5
text = " ".join(p.a + " " + p.b for p in sql_pairs.PAIRS).upper()
for construct in ("WITH ", "EXISTS", " IN (SELECT", "UNION", "OVER (", "DISTINCT", "LEFT JOIN", "HAVING",
"LIMIT", "ORDER BY", "RIGHT JOIN", "FULL JOIN", "NOT IN", "CROSS JOIN"):
"LIMIT", "ORDER BY", "RIGHT JOIN", "FULL JOIN", "NOT IN", "CROSS JOIN", "EXCEPT", "GROUP_CONCAT",
"USING (", "IIF("):
assert construct in text, construct
def test_the_tricky_dataset_exposes_the_round_two_counterexamples(databases):
"""第 2 轮复验的反例在专挑写法差异的那组数据上确实结果不同(不然执行比对守不住它们)。"""
tricky = databases[-1]
pairs = {p.id: p for p in sql_pairs.PAIRS}
for pid in ("diff:r2-float-fold", "diff:r2-float-fold-chain", "diff:r2-double-negation", "diff:r2-in-single-column",
"diff:r2-cast-string", "diff:r2-hex-literal", "diff:r2-recursive-without-keyword",
"diff:r2-cte-column-list-swap-2"):
pair = pairs[pid]
assert sql_pairs.run(tricky, pair.a) != sql_pairs.run(tricky, pair.b), pid
+250 -8
View File
@@ -604,8 +604,6 @@ def test_time_column_differs_with_catalog_names():
"SELECT SUM(r.amount) FROM orders o JOIN refunds r ON r.order_id = o.id",
[("aggregate", "A 对 orders.amount 求和,B 对 refunds.amount 求和")]),
("SELECT DISTINCT region FROM orders", "SELECT region FROM orders", [("group_by", "A 对 region 去重,B 没有去重")]),
("SELECT SUM(amount) FROM orders", "SELECT ROUND(SUM(amount), 2) FROM orders",
[("expression", "A 算的是 SUM(amount),B 算的是 ROUND(SUM(amount), 2)")]),
("SELECT user_id, SUM(amount) FROM orders GROUP BY user_id", "SELECT SUM(amount), user_id FROM orders GROUP BY user_id",
[("expression", "两边选出来的列一样,先后不同:A 是 user_id、SUM(amount),B 是 SUM(amount)、user_id")]),
# 分组、HAVING、取行
@@ -661,9 +659,9 @@ def test_specific_differences_are_said_in_one_sentence_each(a, b, expected):
def test_a_difference_inside_a_cte_used_only_in_a_condition_subquery_is_reported():
"""第 5 轮回退的例子:只在 IN 子查询里用到的 CTE 里的条件不同,以前整个漏报(返回空列表)。现在 CTE 并进了 IN
子查询,往里比,说得出是哪个条件。EXISTS、标量子查询一样。"""
子查询,往里比,说得出是哪个条件,位置带上 IN 左边的列(两个 IN 子查询时才分得清)。EXISTS、标量子查询一样。"""
head = "WITH p AS (SELECT * FROM orders WHERE status = '{}') SELECT COUNT(*) FROM users u WHERE "
for tail, place in (("u.id IN (SELECT user_id FROM p)", "在 IN 子查询里"),
for tail, place in (("u.id IN (SELECT user_id FROM p)", "在 id IN 的子查询里"),
("EXISTS (SELECT 1 FROM p WHERE p.user_id = u.id)", "在 EXISTS 子查询里"),
("(SELECT COUNT(*) FROM p WHERE p.user_id = u.id) > 0", "在条件的子查询里")):
a, b = head.format("paid") + tail, head.format("open") + tail
@@ -728,10 +726,10 @@ def test_filters_on_real_columns_carry_the_columns_for_the_catalog():
def test_a_displayed_condition_means_what_the_sql_means():
"""给人看的条件按方言生成;方言生成的写法读回来不是同一个意思时(SQLite 把 CAST(x AS DATE) 生成 DATE(x))改用
通用写法,不拿 DATE('2026-09-01') 冒充原文。几个条件连起来时 OR 带上括号。"""
[item] = explain_sql_diff("SELECT COUNT(*) FROM orders WHERE paid_at >= '2026-09-01'",
"SELECT COUNT(*) FROM orders WHERE paid_at >= CAST('2026-09-01' AS DATE)").items
assert "CAST('2026-09-01' AS DATE)" in item.text and "DATE('2026-09-01')" not in item.text
通用写法,不拿 DATE(paid_at) 冒充原文。几个条件连起来时 OR 带上括号。"""
[item] = explain_sql_diff("SELECT COUNT(*) FROM orders WHERE CAST(paid_at AS DATE) >= '2026-09-01'",
"SELECT COUNT(*) FROM orders WHERE CAST(paid_at AS DATE) >= '2026-10-01'", "sqlite").items
assert item.aspect == "time_range" and "CAST(paid_at AS DATE)" in item.text and "DATE(paid_at)" not in item.text
a = "SELECT SUM(amount) FROM orders"
b = "SELECT SUM(o.amount) FROM orders o JOIN stores s ON s.id = o.store_id AND (s.city = 'SH' OR s.city = 'BJ')"
[item] = explain_sql_diff(a, b).items
@@ -779,6 +777,19 @@ def test_columns_inside_a_cte_are_not_compared_because_canonical_forms_prune_the
assert diff.fallback and not [d for d in diff.items if "选出" in d.text]
def test_differences_that_cannot_be_checked_get_only_the_fallback():
"""两边算法不同、又判断不了是不是真的不同的(ROUND 包了一层、CASE 和 COALESCE、两种写法的时间常量),不说具体的:
「A 算的是 X,B 算的是 Y」读起来就是两边不同,说错了比不说更糟。"""
for a, b in (("SELECT SUM(amount) FROM orders", "SELECT ROUND(SUM(amount), 2) FROM orders"),
("SELECT SUM(COALESCE(discount, 0)) FROM orders",
"SELECT SUM(CASE WHEN discount IS NULL THEN 0 ELSE discount END) FROM orders"),
("SELECT COUNT(*) FROM orders WHERE paid_at >= '2026-09-01'",
"SELECT COUNT(*) FROM orders WHERE paid_at >= DATE('2026-09-01')")):
diff = explain_sql_diff(a, b, "sqlite")
check_shape(diff)
assert diff.fallback and diff.items == [FacetDiff("other", None, None, FALLBACK)], (a, b, diff.items)
def test_text_diff_lists_at_most_forty_lines():
cols_a = ", ".join(f"SUM(amount * {i}) AS c{i}" for i in range(60))
cols_b = ", ".join(f"SUM(amount * {i + 100}) AS c{i}" for i in range(60))
@@ -857,3 +868,234 @@ def test_catalog_labels_come_from_visible_catalog_items():
def test_a_facets_object_compares_with_itself_cleanly():
f = facets("WITH v AS (SELECT * FROM orders WHERE is_deleted = 0) SELECT COUNT(DISTINCT order_id) FROM v")
assert isinstance(f, Facets) and diff_facets(f, f) == []
# --------------------------------------------------------------------------
# 第 2 轮复验的反例:等价的结论、具体说法的可靠性
# --------------------------------------------------------------------------
@pytest.mark.parametrize("name,dialect,a,b", sql_pairs.REGRESSIONS_R2,
ids=[f"{n}-{d}" for n, d, _, _ in sql_pairs.REGRESSIONS_R2])
def test_round_two_counterexamples_are_never_equivalent(name, dialect, a, b):
"""第 2 轮复验在 PostgreSQL / MySQL 上跑出结果不同的对:常量折叠(Decimal 和浮点数)、取两次负、HAVING 挪进 WHERE
(不分大小写的排序规则下同组的值各不一样)、ORDER BY 里有聚合的 EXISTS / IN、列名表、合并的各支调换、BETWEEN
SYMMETRIC、有并列的取行、DISTINCT ON。不管给不给表结构、谁先谁后,一律不判等价。"""
for schema in (None, sql_pairs.schema_cache()):
for x, y in ((a, b), (b, a)):
diff = explain_sql_diff(x, y, dialect, schema=schema)
check_shape(diff)
assert not diff.equivalent, name
@pytest.mark.parametrize("name,dialect,a,b", sql_pairs.DIALECT_SAME_R2,
ids=[f"{n}-{d}" for n, d, _, _ in sql_pairs.DIALECT_SAME_R2])
def test_round_two_rewrites_are_recognized(name, dialect, a, b):
"""FETCH FIRST 和 LIMIT、MySQL 列名的大小写、各方言 IS NOT NULL / NOT LIKE 的不同解析形状、MySQL 的 IF 和 CASE:
认得出是一回事(以前把 FETCH 读成「不限行数」)。"""
diff = explain_sql_diff(a, b, dialect)
check_shape(diff)
assert diff.equivalent, (name, diff.items)
@pytest.mark.parametrize("name,dialect,a,b", sql_pairs.KNOWN_UNRECOGNIZED,
ids=[f"{n}-{d}" for n, d, _, _ in sql_pairs.KNOWN_UNRECOGNIZED])
def test_equivalences_left_unrecognized_on_purpose_get_only_the_fallback(name, dialect, a, b):
"""意思一样、规范化故意不认的(要假设「相等就是一样」才认得出):只给兜底说明,不说具体的不同。"""
for schema in (None, sql_pairs.schema_cache()):
diff = explain_sql_diff(a, b, dialect, schema=schema)
check_shape(diff)
assert diff.equivalent or all(d.aspect == "other" for d in diff.items), (name, diff.items)
@pytest.mark.parametrize("dialect", DIALECTS)
@pytest.mark.parametrize("a,b", [
("SELECT COUNT(*) FROM orders o WHERE o.paid_at >= '2026-09-01' AND EXISTS "
"(SELECT 1 FROM refunds r WHERE r.order_id = o.id)",
"SELECT COUNT(*) FROM orders o WHERE EXISTS (SELECT 1 FROM refunds r WHERE r.order_id = o.id "
"AND o.paid_at >= '2026-09-01')"),
("SELECT COUNT(*) FROM orders o WHERE o.status = 'paid' AND EXISTS (SELECT 1 FROM refunds r WHERE r.order_id = o.id)",
"SELECT COUNT(*) FROM orders o WHERE EXISTS (SELECT 1 FROM refunds r WHERE r.order_id = o.id AND o.status = 'paid')"),
("SELECT COUNT(*) FROM orders WHERE status = 'paid' AND id IN (SELECT order_id FROM refunds)",
"SELECT COUNT(*) FROM orders WHERE id IN (SELECT order_id FROM refunds WHERE status = 'paid')"),
("SELECT COUNT(*) FROM users u WHERE u.city = 'BJ' AND EXISTS (SELECT 1 FROM orders o WHERE o.user_id = u.id)",
"SELECT COUNT(*) FROM users u WHERE EXISTS (SELECT 1 FROM orders o WHERE o.user_id = u.id AND u.city = 'BJ')"),
], ids=["exists-time", "exists-status", "in-outer-column", "exists-city"])
def test_a_condition_moved_into_a_correlated_subquery_is_not_called_missing(dialect, a, b):
"""条件挪进了相关子查询(引用的还是外层那一行):两条意思一样,B 是有这个条件的。以前说「B 没有按时间筛选」
「B 没有这个条件」,现在说不清就只给兜底说明。"""
for schema in (None, sql_pairs.schema_cache()):
for x, y in ((a, b), (b, a)):
diff = explain_sql_diff(x, y, dialect, schema=schema)
check_shape(diff)
assert all(d.aspect == "other" for d in diff.items), diff.items
@pytest.mark.parametrize("dialect", DIALECTS)
def test_time_filters_written_another_way_are_never_called_no_time_filter(dialect):
"""时间条件换了写法(拆成两段、IN 和 OR、多一个下界、LIKE 和区间):另一边是按时间筛了的,不能说「没有按时间筛选」,
也不能说成两个范围不同。"""
base = "SELECT COUNT(*) FROM orders WHERE paid_at >= '2026-09-01' AND paid_at < '2026-10-01'"
for other in ("SELECT COUNT(*) FROM orders WHERE (paid_at >= '2026-09-01' AND paid_at < '2026-09-16') OR "
"(paid_at >= '2026-09-16' AND paid_at < '2026-10-01')",
"SELECT COUNT(*) FROM orders WHERE paid_at >= '2026-09-01' AND paid_at < '2026-10-01' "
"AND paid_at > '2026-08-01'",
"SELECT COUNT(*) FROM orders WHERE paid_at LIKE '2026-09%'"):
diff = explain_sql_diff(base, other, dialect)
check_shape(diff)
assert not any("没有按时间筛选" in d.text or d.aspect == "time_range" for d in diff.items), diff.items
diff = explain_sql_diff("SELECT COUNT(*) FROM orders WHERE paid_at IN ('2026-09-01', '2026-09-30')",
"SELECT COUNT(*) FROM orders WHERE paid_at = '2026-09-01' OR paid_at = '2026-09-30'", dialect)
assert all(d.aspect == "other" for d in diff.items)
def test_except_with_its_sides_swapped_is_not_one_time_difference():
"""EXCEPT 两边对调,外加一边换了时间列:以前只说时间列不同、还说全了(会写进数据目录)。EXCEPT 按先后逐支比,对不上
就只给兜底说明;子查询、CTE、IN 子查询里套着的也一样。"""
a = "SELECT user_id FROM orders WHERE paid_at >= '2026-09-01' EXCEPT SELECT user_id FROM refunds"
b = "SELECT user_id FROM refunds EXCEPT SELECT user_id FROM orders WHERE created_at >= '2026-09-01'"
for x, y in ((a, b), (f"SELECT COUNT(*) FROM ({a}) t", f"SELECT COUNT(*) FROM ({b}) t"),
(f"WITH e AS ({a}) SELECT COUNT(*) FROM e", f"WITH e AS ({b}) SELECT COUNT(*) FROM e"),
(f"SELECT COUNT(*) FROM users WHERE id IN ({a})", f"SELECT COUNT(*) FROM users WHERE id IN ({b})")):
for dialect in ("sqlite", "postgres"):
diff = explain_sql_diff(x, y, dialect)
check_shape(diff)
assert diff.fallback and all(d.aspect == "other" for d in diff.items), (x, diff.items)
@pytest.mark.parametrize("a,b", [
(sql_pairs.PAIRS_BY_ID["diff:r2-in-not-in-swapped"].a, sql_pairs.PAIRS_BY_ID["diff:r2-in-not-in-swapped"].b),
(sql_pairs.PAIRS_BY_ID["diff:r2-exists-not-exists-swapped"].a,
sql_pairs.PAIRS_BY_ID["diff:r2-exists-not-exists-swapped"].b),
(sql_pairs.PAIRS_BY_ID["diff:r2-in-left-column-swapped"].a, sql_pairs.PAIRS_BY_ID["diff:r2-in-left-column-swapped"].b),
], ids=["in-not-in", "exists-not-exists", "left-column"])
def test_subqueries_swapped_between_in_and_not_in_are_not_explained_both_ways(a, b):
"""IN 和 NOT IN(EXISTS 和 NOT EXISTS、id IN 和 referrer_id IN)两个子查询对调:以前配错了对,说出一对互相矛盾的话、
还把 NOT IN 说成「IN 子查询」。子查询要外面的写法(含 NOT、IN 左边的列)一模一样才配对,配不上就只给兜底。"""
for schema in (None, sql_pairs.schema_cache()):
diff = explain_sql_diff(a, b, "sqlite", schema=schema, labels=LABELS)
check_shape(diff)
assert all(d.aspect == "other" for d in diff.items), diff.items
def test_a_difference_inside_a_not_in_subquery_says_not_in():
"""NOT IN 子查询里的条件不同,说的是「NOT IN 的子查询」(以前说成「IN 子查询」,读的人会以为是保留这些用户)。子查询
里不带表名的列,没给表结构时分不清是子查询里的表的还是外层的(users 也可能有 status),不说具体的;给了表结构、
或者写了表名,就说得出。"""
a = ("SELECT COUNT(*) FROM users WHERE id NOT IN (SELECT user_id FROM orders WHERE status = 'void' "
"AND user_id IS NOT NULL)")
b = a.replace("'void'", "'open'")
expected = [("filter", "原流程在 id NOT IN 的子查询里按 status = 'void' 筛选,盲算在 id NOT IN 的子查询里按 "
"status = 'open' 筛选")]
diff = explain_sql_diff(a, b, "sqlite", labels=LABELS, schema=sql_pairs.schema_cache())
check_shape(diff)
assert [(d.aspect, d.text) for d in diff.items] == expected
assert explain_sql_diff(a, b, "sqlite", labels=LABELS).items == [FacetDiff("other", None, None, FALLBACK)]
qa, qb = a.replace("FROM orders WHERE status", "FROM orders o WHERE o.status"), \
b.replace("FROM orders WHERE status", "FROM orders o WHERE o.status")
assert [(d.aspect, d.text) for d in explain_sql_diff(qa, qb, "sqlite", labels=LABELS).items] == expected
diff = explain_sql_diff(a.replace("NOT IN", "IN"), b.replace("NOT IN", "IN"), "sqlite", labels=LABELS,
schema=sql_pairs.schema_cache())
assert "id IN 的子查询" in diff.items[0].text and "NOT IN" not in diff.items[0].text
def test_a_swapped_table_keeps_each_sides_own_columns():
"""换了一张表:盲算的 created_at 是 users 的(注册时间),以前把 B 的表改名成 A 的表再比,中文名和 detail 都归到了
orders。现在两边各用各的表说。"""
names = {"orders.created_at": "下单时间", "users.created_at": "注册时间", "orders.paid_at": "支付时间"}
diff = explain_sql_diff("SELECT COUNT(*) FROM orders WHERE paid_at >= '2026-09-01'",
"SELECT COUNT(*) FROM users WHERE created_at >= '2026-09-01'", "sqlite", names=names,
labels=LABELS)
check_shape(diff)
assert [(d.aspect, d.text) for d in diff.items] == [
("tables", "原流程查的是 orders 表,盲算查的是 users 表"),
("time", "原流程按支付时间 paid_at 筛时间,盲算按注册时间 created_at")]
assert diff.items[1].detail == {"a": [{"table": "orders", "column": "paid_at"}],
"b": [{"table": "users", "column": "created_at"}]}
diff = explain_sql_diff("SELECT SUM(o.amount) FROM orders o JOIN stores s ON s.id = o.store_id WHERE s.city = 'SH'",
"SELECT SUM(o.amount) FROM orders o JOIN users u ON u.id = o.user_id WHERE u.city = 'SH'",
"sqlite")
check_shape(diff)
assert [d.text for d in diff.items] == [
"A 查的是 stores 表,B 查的是 users 表",
"A 关联的条件是 orders.store_id = stores.id,B 是 orders.user_id = users.id"]
def test_ordering_that_decides_which_row_distinct_on_keeps_is_not_just_ordering():
"""DISTINCT ON 留哪一行由 ORDER BY 决定:排序不同就是留下的行不同,不能说成「只是排序不同」(aspect=order)。"""
a = "SELECT DISTINCT ON (user_id) user_id, status FROM orders ORDER BY user_id, created_at DESC NULLS LAST, id"
b = "SELECT DISTINCT ON (user_id) user_id, status FROM orders ORDER BY user_id, paid_at DESC NULLS LAST, id"
diff = explain_sql_diff(a, b, "postgres")
check_shape(diff)
assert not diff.equivalent and all(d.aspect != "order" for d in diff.items)
def test_a_table_name_differing_only_in_case_is_not_called_another_table_in_mysql():
"""MySQL 的表名在 Linux 上分大小写、在 macOS / Windows 上不分:BILLS 和 bills 不判等价,也不说「查的是另一张表」。"""
diff = explain_sql_diff("SELECT store_id, SUM(amount) AS s FROM orders WHERE is_deleted = 0 GROUP BY store_id",
"select STORE_ID, sum( AMOUNT ) as s from ORDERS where IS_DELETED = 0 group by store_id",
"mysql")
check_shape(diff)
assert all(d.aspect == "other" for d in diff.items)
def test_redundant_or_constant_conditions_are_not_claimed():
"""多写一个本来就成立的条件(1 = 1、已经被 > 筛掉的空值、关联键上的 IS NOT NULL、分组后 COUNT(*) > 0):两条意思一样,
不说「A 只保留 … 的行,B 没有这个条件」。1 = 1 直接认成等价。"""
assert explain_sql_diff("SELECT COUNT(*) FROM orders WHERE 1 = 1 AND status = 'paid'",
"SELECT COUNT(*) FROM orders WHERE status = 'paid'", "sqlite").equivalent
for dialect in DIALECTS:
for a, b in (("SELECT SUM(tax) FROM orders WHERE tax > 1 AND tax IS NOT NULL", "SELECT SUM(tax) FROM orders WHERE tax > 1"),
("SELECT SUM(o.amount) FROM orders o JOIN users u ON u.id = o.user_id WHERE o.user_id IS NOT NULL",
"SELECT SUM(o.amount) FROM orders o JOIN users u ON u.id = o.user_id"),
("SELECT store_id, SUM(amount) FROM orders GROUP BY store_id HAVING COUNT(*) > 0",
"SELECT store_id, SUM(amount) FROM orders GROUP BY store_id"),
("SELECT user_id FROM orders GROUP BY user_id HAVING COUNT(*) > 1",
"SELECT user_id FROM orders GROUP BY user_id HAVING COUNT(*) >= 2"),
("SELECT COUNT(tax) FROM orders", "SELECT COUNT(*) FROM orders WHERE tax IS NOT NULL"),
("SELECT COUNT(r.id) FROM orders o LEFT JOIN refunds r ON r.order_id = o.id",
"SELECT COUNT(r.id) FROM orders o JOIN refunds r ON r.order_id = o.id")):
diff = explain_sql_diff(a, b, dialect)
check_shape(diff)
assert all(d.aspect == "other" for d in diff.items), (dialect, a, diff.items)
def test_single_item_in_list_becomes_equality_only_for_a_constant():
"""IN 列表只有一项:是常量才写成 =;是一列的话 SQLite 里 a IN (b) 是 a = +b(右边不带类型亲和),和 a = b 不同。"""
assert explain_sql_diff("SELECT COUNT(*) FROM orders WHERE status IN ('paid')",
"SELECT COUNT(*) FROM orders WHERE status = 'paid'", "sqlite").equivalent
assert not explain_sql_diff("SELECT id FROM t WHERE a IN (b)", "SELECT id FROM t WHERE a = b", "sqlite").equivalent
@pytest.mark.parametrize("dialect", DIALECTS)
@pytest.mark.parametrize("a,b", [
("SELECT id FROM orders ORDER BY amount DESC LIMIT 5 OFFSET 10", "SELECT id FROM orders ORDER BY amount DESC LIMIT 20 OFFSET 0"),
("WITH p(uid, total) AS (SELECT user_id, SUM(amount) FROM orders WHERE amount > 10 GROUP BY user_id) "
"SELECT COUNT(*) FROM p WHERE total > 100",
"WITH p(uid, total) AS (SELECT user_id, SUM(amount) FROM orders WHERE amount > 50 GROUP BY user_id) "
"SELECT COUNT(*) FROM p WHERE total > 999"),
("SELECT COUNT(*) FROM orders WHERE amount = 0.1 + 0.2 AND status IN ('paid', 'done')",
"SELECT COUNT(*) FROM orders WHERE amount = 0.5 + 0.25 AND status IN ('open', 'void')"),
("SELECT COUNT(*) FROM users WHERE id NOT IN (SELECT user_id FROM orders WHERE created_at >= '2026-09-01')",
"SELECT COUNT(*) FROM users WHERE id NOT IN (SELECT user_id FROM orders WHERE created_at >= '2026-10-01')"),
], ids=["limit-offset", "cte-column-list", "arith-and-in-list", "not-in"])
def test_only_literals_changed_stays_the_same_template_after_the_rewrite(dialect, a, b):
"""normalize_sql「只改了参数」的判断不受这次改动影响:只改字面量的照旧同一个模板(等价判定照样说不等价)。"""
na, nb = normalize_sql(a, dialect), normalize_sql(b, dialect)
assert na.parse_error is None and na.same_shape(nb) and na.literals != nb.literals
assert not explain_sql_diff(a, b, dialect).equivalent
@pytest.mark.parametrize("dialect", DIALECTS)
@pytest.mark.parametrize("a,b", [
("WITH p(uid, total) AS (SELECT user_id, SUM(amount) FROM orders GROUP BY user_id) SELECT COUNT(*) FROM p WHERE total > 1",
"WITH p(total, uid) AS (SELECT user_id, SUM(amount) FROM orders GROUP BY user_id) SELECT COUNT(*) FROM p WHERE total > 1"),
("SELECT COUNT(*) FROM users WHERE id IN (SELECT user_id FROM orders)",
"SELECT COUNT(*) FROM users WHERE id NOT IN (SELECT user_id FROM orders)"),
("SELECT COUNT(*) FROM orders WHERE amount = 0.1 + 0.2", "SELECT COUNT(*) FROM orders WHERE amount = 0.3"),
("SELECT u.city, COUNT(*) FROM users u JOIN orders o ON o.user_id = u.id GROUP BY u.city",
"SELECT u.city, COUNT(*) FROM users u LEFT JOIN orders o ON o.user_id = u.id GROUP BY u.city"),
], ids=["cte-column-list-order", "in-vs-not-in", "folded-constant", "join-kind"])
def test_a_structural_change_is_still_a_different_template(dialect, a, b):
"""结构变了的(列名表的先后、IN 和 NOT IN、常量写成一个数、连接类型)照旧不是同一个模板。"""
assert not normalize_sql(a, dialect).same_shape(normalize_sql(b, dialect))