File size: 10,050 Bytes
d847043
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
"""把问答对拼成训练用的 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

# 包里脚本在 scripts/,schemas/ data/ 在上一级;GitHub 仓库是平铺的,两种都认
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)  # (db, 表, 列) -> 值的出现次数
        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
        # 凑数用:先借同一个库里同名列的值(account.status 借 loan.status),不够再借别的库的
        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")
    # 消融用(run_paper.sh):--skip 去掉文件名匹配的几份数据,--add 换上别的问答对文件
    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)

    # 库重新生成过而题没跟着重出,就会有引用不存在的表/列的 SQL,以前混进去过 36 条
    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")
        # RIGHT / FULL JOIN 要 SQLite 3.39+:Mac 上能跑,RunPod 镜像的 Python 带的是 3.37,评测和别人的环境都可能更老
        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()