Datasets:

YukiKaze1337
/

cn-sqlite-sft

"""执行准确率评测：模型生成的 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()

	"""执行准确率评测：模型生成的 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()