| """把问答对拼成训练用的 data/train.jsonl。 |
| |
| python scripts/build_sft.py |
| |
| - 读 data/pairs/*.jsonl（已经整理好的老数据，base.jsonl 就是之前那 7297 条） |
| 和 data/new/*.jsonl（teacher.py / teacher_hard.py 新出的、verify.py 复核过的） |
| - 测试库的题一律不要；SQL 在建表语句上跑不通的（表名、列名不存在）丢掉 |
| - 按 (库, 问题) 去重，问题过短的丢掉 |
| - 用 prompt.py 里的格式包装成 messages |
| - 顺手统计一下查询类型分布，看看数据偏不偏 |
| """ |
|
|
| import argparse |
| import hashlib |
| import json |
| import random |
| import re |
| import sqlite3 |
| from collections import Counter, defaultdict |
| from pathlib import Path |
|
|
| from prompt import build |
|
|
| |
| ROOT = Path(__file__).resolve().parent |
| if not (ROOT / "schemas").is_dir(): |
| ROOT = ROOT.parent |
| TEST_DBS = {"library", "gym", "hard_retail", "transit"} |
| OLD_SQLITE_UNSUPPORTED = re.compile(r"(?i)\b(?:right|full)\s+(?:outer\s+)?join\b") |
| NO_VALUES_SHARE = 0.2 |
|
|
| |
| NOT_CATEGORY_COL = re.compile(r"date|time|_at$|birth|since|name|title|phone|mobile|email|address|sku|code|_no$|_id$") |
| NOT_CATEGORY_LIT = re.compile(r"^(\d{4}(-\d\d){0,2}( [\d:]+)?|.*%.*|now|[+-]?\d+ \w+|start of \w+|-?\d+(\.\d+)?|)$", re.I) |
| NOT_ALIAS = {"on", "where", "join", "left", "right", "inner", "outer", "full", "cross", "natural", |
| "group", "order", "limit", "having", "union", "using", "as"} |
|
|
|
|
| def schema_path(db: str) -> Path: |
| for p in (ROOT / "schemas").rglob(f"{db}.sql"): |
| return p |
| raise FileNotFoundError(db) |
|
|
|
|
| def table_columns(ddl: str) -> dict[str, list[str]]: |
| """{表: [列, ...]}，都转小写，按建表顺序。""" |
| conn = sqlite3.connect(":memory:") |
| conn.executescript(ddl) |
| return {t.lower(): [c[1].lower() for c in conn.execute(f'pragma table_info("{t}")')] |
| for (t,) in conn.execute("select name from sqlite_master where type='table' order by rowid")} |
|
|
|
|
| def category_literals(sql: str, cols: dict[str, list[str]]): |
| """找出 SQL 里「分类列 = '值'」「分类列 IN ('值', ...)」，返回 [(表, 列, 值)]。别名按 FROM/JOIN 解析。""" |
| alias = {} |
| for t, a in re.findall(r"(?i)\b(?:from|join)\s+(\w+)(?:\s+(?:as\s+)?(\w+))?", sql): |
| if t.lower() in cols: |
| alias[t.lower()] = t.lower() |
| if a and a.lower() not in NOT_ALIAS: |
| alias[a.lower()] = t.lower() |
| pairs = re.findall(r"(?:(\w+)\.)?(\w+)\s*(?:=|!=|<>)\s*'([^']*)'", sql) |
| for a, col, body in re.findall(r"(?i)(?:(\w+)\.)?(\w+)\s+(?:not\s+)?in\s*\(([^()]*)\)", sql): |
| pairs += [(a, col, lit) for lit in re.findall(r"'([^']*)'", body)] |
| out = [] |
| for a, col, lit in pairs: |
| col = col.lower() |
| if NOT_CATEGORY_COL.search(col) or NOT_CATEGORY_LIT.match(lit): |
| continue |
| if a: |
| t = alias.get(a.lower()) |
| else: |
| owners = {t for t in alias.values() if col in cols[t]} |
| t = owners.pop() if len(owners) == 1 else None |
| if t and col in cols[t]: |
| out.append((t, col, lit)) |
| return out |
|
|
|
|
| def style(lit: str) -> str: |
| """值的写法：中文 / 全小写 / 全大写 / 首字母大写。真实库里一列只会用一种写法。""" |
| if re.search(r"[一-鿿]", lit): |
| return "zh" |
| if lit.islower(): |
| return "lower" |
| if lit.isupper(): |
| return "upper" |
| return "title" |
|
|
|
|
| class ValueHints: |
| """训练样本的「部分字段的取值」。训练库没有真实数据，取值只能从训练 SQL 的字面量里攒； |
| 同一列的写法混着用（有的写 'active'、有的写 'Active'、有的写 '已批准'），所以每条样本只列和它 |
| 标准答案同一种写法的值，等于每条样本看到的是一个「这列只用一种写法」的库。值太少的借同名列的凑数。""" |
|
|
| def __init__(self, rows: list[dict], cols_of: dict[str, dict[str, list[str]]]): |
| self.cols_of = cols_of |
| self.seen = defaultdict(Counter) |
| for r in rows: |
| for t, c, lit in category_literals(r["sql"], cols_of[r["db"]]): |
| self.seen[(r["db"], t, c)][lit] += 1 |
| |
| self.same_db = defaultdict(Counter) |
| self.by_name = defaultdict(Counter) |
| for (db, _t, c), cnt in self.seen.items(): |
| for lit, n in cnt.items(): |
| self.same_db[(db, c, style(lit))][lit] += n |
| self.by_name[(c, style(lit))][lit] += n |
|
|
| def for_row(self, r: dict) -> dict[str, list[str]] | None: |
| rng = random.Random(hashlib.md5(f"{r['db']}|{r['question']}".encode()).hexdigest()) |
| if rng.random() < NO_VALUES_SHARE: |
| return None |
| used = {(t, c): style(lit) for t, c, lit in category_literals(r["sql"], self.cols_of[r["db"]])} |
| out = {} |
| for t, cols in self.cols_of[r["db"]].items(): |
| for c in cols: |
| cnt = self.seen.get((r["db"], t, c)) |
| if not cnt or len(cnt) > 20: |
| continue |
| |
| by_style = Counter() |
| for lit, n in cnt.items(): |
| by_style[style(lit)] += n |
| want = used.get((t, c)) or by_style.most_common(1)[0][0] |
| vals = {lit for lit in cnt if style(lit) == want} |
| for pool, cap in ((self.same_db[(r["db"], c, want)], 5), (self.by_name[(c, want)], 3)): |
| for lit, _ in pool.most_common(): |
| if len(vals) >= cap: |
| break |
| vals.add(lit) |
| if vals: |
| out[f"{t}.{c}"] = sorted(vals) |
| return out or None |
|
|
|
|
| def sql_kind(sql: str) -> str: |
| s = sql.lower() |
| for key, pat in ( |
| ("CTE", r"^\s*with\b"), |
| ("窗口函数", r"\bover\s*\("), |
| ("子查询", r"\(\s*select\b"), |
| ("多表连接", r"\bjoin\b"), |
| ("分组", r"\bgroup by\b"), |
| ("排序", r"\border by\b"), |
| ("取前几", r"\blimit\b"), |
| ("聚合", r"\b(count|sum|avg|max|min)\s*\("), |
| ): |
| if re.search(pat, s): |
| return key |
| return "简单筛选" |
|
|
|
|
| def main() -> None: |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--out", default="data/train.jsonl") |
| |
| ap.add_argument("--skip", default="", help="正则，匹配文件名（不带 .jsonl）的不读，比如 '_r2_para$'") |
| ap.add_argument("--add", nargs="*", default=[], help="额外读的问答对 jsonl") |
| args = ap.parse_args() |
|
|
| files = sorted((ROOT / "data" / "pairs").glob("*.jsonl")) + sorted((ROOT / "data" / "new").glob("*.jsonl")) |
| files = [p for p in files if not (args.skip and re.search(args.skip, p.stem))] + [ROOT / a for a in args.add] |
| rows: list[dict] = [] |
| for p in files: |
| for line in p.read_text(encoding="utf-8").splitlines(): |
| if not line.strip(): |
| continue |
| r = json.loads(line) |
| if len(r.get("question", "")) < 4 or not r.get("sql") or r["db"] in TEST_DBS: |
| continue |
| rows.append(r) |
|
|
| |
| empty_dbs: dict[str, sqlite3.Connection] = {} |
| broken = 0 |
| seen = set() |
| keep = [] |
| for r in rows: |
| key = (r["db"], re.sub(r"\s+", "", r["question"])) |
| if key in seen: |
| continue |
| if r["db"] not in empty_dbs: |
| empty_dbs[r["db"]] = sqlite3.connect(":memory:") |
| empty_dbs[r["db"]].executescript(schema_path(r["db"]).read_text(encoding="utf-8")) |
| empty_dbs[r["db"]].execute("PRAGMA query_only = ON") |
| |
| if OLD_SQLITE_UNSUPPORTED.search(r["sql"]): |
| broken += 1 |
| continue |
| try: |
| empty_dbs[r["db"]].execute(r["sql"].rstrip(";")).fetchall() |
| except sqlite3.Error: |
| broken += 1 |
| continue |
| seen.add(key) |
| keep.append(r) |
|
|
| ddls = {db: schema_path(db).read_text(encoding="utf-8") for db in {r["db"] for r in keep}} |
| hints = ValueHints(keep, {db: table_columns(ddl) for db, ddl in ddls.items()}) |
| with_values = 0 |
| out = ROOT / args.out |
| out.parent.mkdir(parents=True, exist_ok=True) |
| with out.open("w", encoding="utf-8") as f: |
| for r in keep: |
| values = hints.for_row(r) |
| with_values += values is not None |
| msgs = build(ddls[r["db"]], r["question"], values) |
| msgs.append({"role": "assistant", "content": r["sql"].rstrip(";") + ";"}) |
| f.write(json.dumps({"messages": msgs, "db": r["db"]}, ensure_ascii=False) + "\n") |
|
|
| kinds = Counter(sql_kind(r["sql"]) for r in keep) |
| dbs = Counter(r["db"] for r in keep) |
| print(f"写好了 {len(keep)} 条 → {out}（原始 {len(rows)} 条，跑不通 {broken}，去重 {len(rows)-len(keep)-broken}）") |
| print(f"带「部分字段的取值」的 {with_values} 条（{with_values / len(keep):.0%}）") |
| print("库分布：", dict(sorted(dbs.items(), key=lambda x: -x[1]))) |
| print("类型分布：", dict(kinds.most_common())) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
