Blame for scripts/eval.py

"""执行准确率评测：模型生成的 SQL 和标准 SQL 在灌了假数据的 SQLite 上比结果。

    python scripts/eval.py --model Qwen/Qwen3-4B-Instruct-2507 --data data/test_library.jsonl

只比结果，不比 SQL 文本；标准 SQL 最外层带 ORDER BY 时才算顺序，否则按多重集比较。
数据用 seed_suite.py 现生成 5 份，每份上结果都一样才算对（一份数据上碰巧对上的错 SQL 不少）。
prompt 用 prompt.py 里那一份，和训练完全一致。
"""

import argparse
import itertools
import json
import re
import sqlite3
import time
from collections import Counter
from pathlib import Path

from prompt import build, values_from_db
from seed_suite import make_suite

# 包里脚本在 scripts/，schemas/ seeds/ 在上一级；GitHub 仓库是平铺的，两种都认
ROOT = Path(__file__).resolve().parent
if not (ROOT / "schemas").is_dir():
    ROOT = ROOT.parent
# CTE（WITH x AS (...)）也算查询开头，不然 WITH 那段会被截掉
SQL_START_RE = re.compile(
    r"(?is)\bwith\s+(?:recursive\s+)?[\w\"`\[\]]+\s*(?:\([^)]*\)\s*)?as\s*\(|\bselect\b"
)

# 模型写出没条件的多表连接（笛卡尔积）会跑很久，5 份数据乘起来能卡死评测；超时算跑不通
QUERY_TIMEOUT = 5.0


def extract_sql(text: str) -> str:
    text = text.strip()
    text = re.sub(r"^```(?:sql)?|```$", "", text, flags=re.M).strip()
    m = SQL_START_RE.search(text)
    if not m:
        return ""
    # 只要第一条语句
    return text[m.start():].split(";")[0].strip()


def rows_of(conn: sqlite3.Connection, sql: str):
    deadline = time.monotonic() + QUERY_TIMEOUT
    conn.set_progress_handler(lambda: time.monotonic() > deadline, 10_000)
    try:
        return conn.execute(sql).fetchall()
    finally:
        conn.set_progress_handler(None, 0)


def ordered_by(sql: str) -> bool:
    """只看最外层的 ORDER BY；窗口函数、子查询、CTE 里的不算。"""
    depth, flat = 0, []
    for ch in sql:
        if ch == "(":
            depth += 1
        elif ch == ")":
            depth -= 1
        elif depth == 0:
            flat.append(ch)
    return re.search(r"(?i)\border\s+by\b", "".join(flat)) is not None


NUMERIC = re.compile(r"-?\d+(?:\.\d+)?")


def _canon(rows):
    """数字样子的字符串当数字比：strftime('%Y') 给的是 '2024'，模型 CAST 成 2024 也算一样。"""
    def one(v):
        if isinstance(v, str) and NUMERIC.fullmatch(v):
            f = float(v)
            return int(f) if f.is_integer() else f
        return v
    return [tuple(one(v) for v in r) for r in rows]


def _tolerances(pred) -> list[float]:
    """每一列数字允许差多少。模型这一列的小数都只有 d 位（它自己 ROUND 过）就允许差半个末位：
    SQLite 的 ROUND 是四舍五入、Python 的 round 是银行家舍入，0.28125 一个给 0.2813 一个给 0.2812，
    只能按误差比。其余允许差 0.0001（AVG 和 SUM/COUNT 末位会差一点，julianday('now') 两次执行之间时间也在走）。"""
    tols = []
    for j in range(len(pred[0])):
        vals = [r[j] for r in pred if isinstance(r[j], float)]
        d = next((d for d in (1, 2, 3, 4) if vals and all(round(v, d) == v for v in vals)), None)
        tols.append(0.5 * 10 ** -d + 1e-9 if d else 1e-4)
    return tols


def _row_eq(g, p, tols) -> bool:
    for a, b, tol in zip(g, p, tols):
        if isinstance(a, (int, float)) and isinstance(b, (int, float)):
            if abs(a - b) > tol:
                return False
        elif a != b:
            return False
    return True


def _equal(gold, pred, ordered: bool) -> bool:
    """gold、pred 已经 _canon 过、行数列数都一样。数字按误差比，其余按值比。"""
    tols = _tolerances(pred)
    if ordered:
        return all(_row_eq(g, p, tols) for g, p in zip(gold, pred))
    # 不用 sorted：结果里 NULL 和数字混在一起时 sorted 会抛 TypeError。先试完全一样，再逐行按误差配对
    if Counter(gold) == Counter(pred):
        return True
    left = list(pred)
    for g in gold:
        for i, p in enumerate(left):
            if _row_eq(g, p, tols):
                del left[i]
                break
        else:
            return False
    return True


def same_result(gold, pred, ordered: bool) -> bool:
    if len(gold) != len(pred):
        return False
    if not gold:
        return True
    gold, pred = _canon(gold), _canon(pred)
    return len(gold[0]) == len(pred[0]) and _equal(gold, pred, ordered)


def superset_result(gold, pred, ordered: bool) -> bool:
    """宽松口径：模型多返回了几列（SELECT *、多带个 ID）也算对——能从它的结果里挑出几列和标准答案一样就行。
    少返回列不算对，因为可能漏了问题要的东西。"""
    if len(gold) != len(pred) or not gold:
        return same_result(gold, pred, ordered)
    gold, pred = _canon(gold), _canon(pred)
    wg, wp = len(gold[0]), len(pred[0])
    if wp <= wg:
        return wp == wg and _equal(gold, pred, ordered)

    def sig(rows, j):  # 先粗筛候选列：非浮点列比值，浮点列只要求也是浮点
        col = [r[j] for r in rows]
        return "float" if any(isinstance(v, float) for v in col) else Counter(col)

    cands = [[k for k in range(wp) if sig(pred, k) == sig(gold, j)] for j in range(wg)]
    for combo in itertools.product(*cands):
        if len(set(combo)) == wg and _equal(gold, [tuple(r[k] for k in combo) for r in pred], ordered):
            return True
    return False


def load_dbs(db: str, scripts: list[str]) -> tuple[str, list[sqlite3.Connection]]:
    """建表 + 灌假数据，每份数据一个库。scripts 为空就用 seeds/ 里那一份老数据。
    空表上大部分查询都返回空，对错分不出来。"""
    ddl = next((ROOT / "schemas").rglob(f"{db}.sql")).read_text(encoding="utf-8")
    conns = []
    for script in scripts or [(ROOT / "seeds" / f"{db}.sql").read_text(encoding="utf-8")]:
        conn = sqlite3.connect(":memory:")
        conn.executescript(ddl)
        conn.executescript(script)
        conn.execute("PRAGMA query_only = ON")  # 模型吐个 WITH ... DELETE 也改不了库
        conns.append(conn)
    return ddl, conns


def judge(gold_sql: str, pred: str, conns: list[sqlite3.Connection]) -> tuple[bool, bool, bool]:
    """返回 (可执行, 答对, 宽松答对)。要在每一份数据上结果都和标准答案一样才算对；宽松口径允许多返回几列。"""
    if not pred:
        return False, False, False
    try:
        pred_rows = [rows_of(c, pred) for c in conns]
    except Exception:  # noqa: BLE001
        return False, False, False
    ordered = ordered_by(gold_sql)
    gold_rows = [rows_of(c, gold_sql) for c in conns]
    hit = all(same_result(g, p, ordered) for g, p in zip(gold_rows, pred_rows))
    loose = hit or all(superset_result(g, p, ordered) for g, p in zip(gold_rows, pred_rows))
    return True, hit, loose


def main() -> None:
    ap = argparse.ArgumentParser()
    ap.add_argument("--model", required=True)
    ap.add_argument("--data", required=True)
    ap.add_argument("--limit", type=int, default=0)
    ap.add_argument("--out", default="")
    ap.add_argument("--adapter", default="", help="LoRA 目录（比如 out/checkpoint-456），叠在 --model 上评")
    # 第二轮训练数据里最长的 SQL 有一千多字符，512 token 会把模型写的长 CTE 截断；生成到结束符就停，给大了不费时间
    ap.add_argument("--max-new-tokens", type=int, default=1024)
    ap.add_argument("--no-values", action="store_true",
                    help="prompt 里不附「部分字段的取值」，测模型在调用方不给取值时的表现")
    ap.add_argument("--suite", type=int, default=5,
                    help="用 seed_suite 现生成几份数据；0 = 用 seeds/ 里的老数据（只为和旧结果对比）")
    ap.add_argument("--batch-size", type=int, default=8,
                    help="一次生成几题，比一题一题快好几倍；显存不够就调小。1 = 一题一题来，结果最稳")
    ap.add_argument("--repair", type=int, default=0,
                    help="SQL 跑不通就把报错发回去让模型改，最多改几次（见 infer.py）。0 = 不改，和以前的分数可比")
    ap.add_argument("--vote", type=int, default=1,
                    help="每题写几条、按执行结果投票（见 infer.py）。1 = 只要贪心那条")
    args = ap.parse_args()

    from infer import Generator, answer

    gen = Generator(args.model, adapter=args.adapter, batch_size=args.batch_size,
                    max_new_tokens=args.max_new_tokens)

    items = [json.loads(l) for l in Path(args.data).read_text(encoding="utf-8").splitlines() if l.strip()]
    # 字面量从整个测试集的标准 SQL 里抠，--limit 不影响生成的数据
    suites = {db: make_suite(db, [it["sql"] for it in items if it["db"] == db], args.suite) if args.suite else []
              for db in {it["db"] for it in items}}
    if args.limit:
        items = items[: args.limit]
    # 每个库建一次：库是只读的（query_only），各题共用没问题
    dbs = {db: load_dbs(db, scripts) for db, scripts in suites.items()}
    values = {db: None if args.no_values else values_from_db(conns) for db, (_, conns) in dbs.items()}

    convs = [build(dbs[it["db"]][0], it["question"], values[it["db"]]) for it in items]
    # repair、vote 只能看「自己的库」：5 份数据里的第一份；判分还是在 5 份上都要对
    outs = answer(gen, convs, [dbs[it["db"]][1][0] for it in items], repair=args.repair, vote=args.vote)

    ok = valid = loose = 0
    records = []
    for it, o in zip(items, outs):
        runs, hit, hit_loose = judge(it["sql"], o["sql"], dbs[it["db"]][1])
        valid += int(runs)
        ok += int(hit)
        loose += int(hit_loose)
        records.append({"db": it["db"], "question": it["question"], "gold": it["sql"],
                        "pred": o["sql"], "hit": hit, "hit_loose": hit_loose, "raw": o["raw"],
                        "first_pred": o["first_sql"], "votes": o["votes"], "repairs": o["repairs"]})

    n = len(items)
    print(f"\n总数 {n}｜可执行 {valid}（{valid/n:.1%}）｜执行准确率 {ok/n:.1%}"
          f"｜宽松准确率 {loose/n:.1%}（多返回几列也算对）")
    if args.out:
        # 先写临时文件再改名：评测跑到一半被打断，也不会留下半截的 json 让汇总脚本读错
        tmp = Path(args.out + ".tmp")
        tmp.write_text(json.dumps(records, ensure_ascii=False, indent=1), encoding="utf-8")
        tmp.replace(args.out)
        print("明细写到", args.out)


if __name__ == "__main__":
    main()