Files
AgentLab/frontend/src/pages/runs/compare/sqlDiff.ts
T
ThearchyHelios c7a9116424 运行对比页复核修正(第 1 轮):照服务端的实际输出改查询编号、无法比较的原因、读不到的基准和未保存工作流的说法
- 查询区不再拿服务端的 (node_id, ordinal) 当键和编号:配上的一对取本次的序号、落单的基准查询取基准的序号,
  Agent 换了查询先后时两者会撞上,React 报键冲突,「第 N 条」重复或缺号。改按同一节点在列表里出现的先后编号,
  键是「节点:第几」。
- 「拆分或原因」一栏:无法比较、新增、移除的指标,服务端只把原因放在 reasons 里,这一栏原来只剩「—」,现在写
  reasons 的第一句。不能拆的「为什么没拆」也写进展开的明细,窄屏上那一格横着滚也看不全。服务端有意不做维度归因
  的几类,写明为什么不做。检查夹具改成服务端的实际形状(decomposition_note 为 null):原来那一项是靠编出来的字段
  通过的。
- 换基准下拉:当前的基准读不到时单列一项,写短 id 和「记录不存在」或「无法读取」,不再显示成另一次运行被选中、
  选它又没反应。本次的记录读不到时写明原因并给重试,不再一直停在「正在读取」。运行卡读取失败也给重试,记录不存在
  的照实写。
- 不属于已保存工作流的运行(没保存过,或工作流已删除):「与上一次对比」不可点并写明原因,对比页也不再叫人去上方
  选基准。服务端对这两种运行都不比。
- 错误说明:409 按机读码分「尚未结束并封存」和「封存核对不一致」,去掉界面上没有的「封存凭证条」。基准不存在时
  提示在上方另选。找不到默认基准时,下拉里有能选的运行才说「可在上方选择」。
- 菜单查找基准超过 300 毫秒就挂一条提示;离开运行详情时取消请求,晚到的答复不再把人拽到对比页。
- 一边的 SQL 拿不到时不做逐词比较,另一边不再整条标成「独有」。SQL 注释整段算一个词,注释里的撇号不再吞掉后面的
  语句。
- 分类、结构的悬停说明照服务端的分类口径改写;查询按「条」计数,和「第 N 条」一致。
- check-compare 按服务端的实际输出补上这些场景,并加段过滤 COMPARE_ONLY;check-all 里 compare 的耗时估计按实测
  改为 45 秒。
2026-10-05 10:16:15 +08:00

124 lines
5.1 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/**
* 两条 SQL 逐词对比:并排显示时标出各自独有的部分(结构变了的那条查询,差在哪一眼能看到)。
*
* 按词(名字、关键字、数、字符串、运算符、注释)而不是按字符比:按字符比会把 created_at 和 paid_at 里碰巧相同的「_at」
* 当成没变,读起来支离破碎;按行比又太粗,模型写的 SQL 常常一整条写在一行里。关键字和不加引号的名字不分大小写
* (服务端的规范化也不算它们不同),字符串、加引号的名字照原样比。空白不参与比较,只是两个变了的词之间的空白也
* 跟着标,免得一段新加的条件被切成好几截。
*
* 先去掉两头相同的部分,中间再求最长公共子序列。中间太长(两边词数之积超过 CELL_LIMIT)时不逐词算,整段标出——
* 页面不能为一条超长的 SQL 卡住,coarse 为 true,界面照实说只标了大致范围。
*/
export interface DiffPart {
text: string
/** 这一段只在自己这边有 */
changed: boolean
}
export interface SqlDiff {
base: DiffPart[]
target: DiffPart[]
/** 中间太长、没有逐词比,整段标出 */
coarse: boolean
}
/** 逐词比较时动态规划表的格数上限(Uint32Array,4 MB) */
const CELL_LIMIT = 1_000_000
// 空白、注释(-- 到行尾、/* … */,没收尾的到末尾)、字符串('' 转义)、加引号的名字("…"、`…`、[…])、名字和关键字、
// 数、两个字符的运算符、其余单个字符。注释整段算一个词,而且排在字符串前面:模型写的英文注释里常有 it's、user's,
// 把里面的撇号当成字符串的开头,会一直吞到下一个引号,后面没改的语句全被标成不同
const TOKEN = /\s+|--[^\n]*|\/\*[\s\S]*?(?:\*\/|$)|'(?:[^']|'')*'?|"(?:[^"]|"")*"?|`[^`]*`?|\[[^\]\s]*\]?|[\p{L}_][\p{L}\p{N}_$]*|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?|<=|>=|<>|!=|\|\||::|[\s\S]/gu
interface Token {
text: string
space: boolean
/** 比较用的写法 */
key: string
}
export function tokenize(sql: string): Token[] {
const out: Token[] = []
for (const m of sql.matchAll(TOKEN)) {
const text = m[0]
const space = /^\s+$/.test(text)
const word = /^[\p{L}_]/u.test(text)
out.push({ text, space, key: word ? text.toLowerCase() : text })
}
return out
}
/** 非空白的词里,哪些和对面配上了(最长公共子序列)。返回两个布尔数组:true 是配上了 */
function matchWords(a: string[], b: string[]): { a: boolean[]; b: boolean[]; coarse: boolean } {
const ma = a.map(() => false)
const mb = b.map(() => false)
let lo = 0
while (lo < a.length && lo < b.length && a[lo] === b[lo]) { ma[lo] = true; mb[lo] = true; lo++ }
let ea = a.length
let eb = b.length
while (ea > lo && eb > lo && a[ea - 1] === b[eb - 1]) { ea--; eb--; ma[ea] = true; mb[eb] = true }
const n = ea - lo
const m = eb - lo
if (n === 0 || m === 0) return { a: ma, b: mb, coarse: false }
if ((n + 1) * (m + 1) > CELL_LIMIT) return { a: ma, b: mb, coarse: true }
// dp[i][j]:a 从 lo+i、b 从 lo+j 起到中段末尾的最长公共子序列长度,从后往前填,回溯时从前往后走
const w = m + 1
const dp = new Uint32Array((n + 1) * w)
for (let i = n - 1; i >= 0; i--) {
for (let j = m - 1; j >= 0; j--) {
dp[i * w + j] = a[lo + i] === b[lo + j]
? dp[(i + 1) * w + j + 1] + 1
: Math.max(dp[(i + 1) * w + j], dp[i * w + j + 1])
}
}
let i = 0
let j = 0
while (i < n && j < m) {
if (a[lo + i] === b[lo + j]) {
ma[lo + i] = true
mb[lo + j] = true
i++
j++
} else if (dp[(i + 1) * w + j] >= dp[i * w + j + 1]) {
i++
} else {
j++
}
}
return { a: ma, b: mb, coarse: false }
}
/** 词和配对结果 → 一段段文字。夹在两个变了的词之间的空白也算变了,相邻同类的段并成一段 */
function parts(tokens: Token[], matched: boolean[]): DiffPart[] {
const flags: (boolean | null)[] = []
let w = 0
for (const t of tokens) flags.push(t.space ? null : !matched[w++])
// 每个位置往后最近的一个词变没变(空白看前后两个词),从后往前扫一遍,不在每个空白处再各找一次
const next: boolean[] = new Array(tokens.length).fill(false)
let ahead = false
for (let i = tokens.length - 1; i >= 0; i--) {
next[i] = ahead
if (flags[i] !== null) ahead = flags[i] as boolean
}
const out: DiffPart[] = []
let behind = false
tokens.forEach((t, i) => {
const flag = flags[i]
const changed = flag ?? (behind && next[i])
if (flag !== null) behind = flag
const last = out[out.length - 1]
if (last && last.changed === changed) last.text += t.text
else out.push({ text: t.text, changed })
})
return out
}
export function diffSql(base: string, target: string): SqlDiff {
const tb = tokenize(base)
const tt = tokenize(target)
const words = (ts: Token[]) => ts.filter((t) => !t.space).map((t) => t.key)
const { a, b, coarse } = matchWords(words(tb), words(tt))
return { base: parts(tb, a), target: parts(tt, b), coarse }
}