mirror of
https://github.com/ThearchyHelios/AgentLab.git
synced 2026-11-16 08:52:00 +00:00
c7a9116424
- 查询区不再拿服务端的 (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 秒。
124 lines
5.1 KiB
TypeScript
124 lines
5.1 KiB
TypeScript
/**
|
||
* 两条 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 }
|
||
}
|