"""Build CANONICAL planner dev prompts. After empirical comparison (BM25 hurt by ~2pp), the canonical format is: - Static representative values (first 1-2 DISTINCT non-NULL DB values per column) - meaning (column_description from BIRD CSV) when available - value description (value_description from BIRD CSV) when available - has None (when column has NULL values) - primary key, type - PRUNED schema (only tables/columns selected by the schema-classifier filter) This produces the prompt format that gave the highest greedy EX (52.80% on Qwen-Coder-3B combined-3ep, +0.65pp over paper's checkpoint at 52.15%). """ import json, os, re, sqlite3, argparse, sys sys.path.insert(0, '/home/datht/mats-sql-tist') from utils.bird_csv_utils import load_all_db_descriptions def detect_special_char(s): return bool(re.search(r'[^a-zA-Z0-9_]', s)) def add_quotation_mark(s): return f"`{s}`" def sample_static_values(cur, table, col, n=2): """Return up to n DISTINCT non-NULL values from the column (paper-style static).""" try: qcol = f'`{col}`' qtab = f'`{table}`' cur.execute(f"SELECT DISTINCT {qcol} FROM {qtab} WHERE {qcol} IS NOT NULL LIMIT {n}") vals = [str(r[0]).strip() for r in cur.fetchall()] return [v for v in vals if v and len(v) <= 50][:n] except Exception: return [] def build_schema_seq(db_path, db_id, db_descriptions, table_filter=None, col_filter_per_table=None): """Build schema sequence with static values + meaning + VD + has None. Args: table_filter: set of table names to keep (case-insensitive). None = keep all. col_filter_per_table: dict {tname_lower: set(col_names_lower)} — keep only these cols. """ conn = sqlite3.connect(db_path) conn.text_factory = lambda b: b.decode(errors='ignore') cur = conn.cursor() cur.execute("SELECT name FROM sqlite_master WHERE type='table';") table_names = [r[0] for r in cur.fetchall() if r[0].lower() != 'sqlite_sequence'] descs = db_descriptions.get(db_id, {}) if db_descriptions else {} schema_seq = "database schema:\n" foreign_keys = [] kept_tables = set() for tn in table_names: if table_filter is not None and tn.lower() not in table_filter: continue cur.execute(f"SELECT name, type, pk FROM PRAGMA_TABLE_INFO('{tn}')") rows = cur.fetchall() cn_list = [r[0] for r in rows] ct_list = [r[1].lower() for r in rows] pk_list = [r[2] for r in rows] # apply col filter if col_filter_per_table is not None: keep_cols_lc = col_filter_per_table.get(tn.lower(), set()) keep_idx = [i for i, c in enumerate(cn_list) if c.lower() in keep_cols_lc] if not keep_idx: continue cn_list = [cn_list[i] for i in keep_idx] ct_list = [ct_list[i] for i in keep_idx] pk_list = [pk_list[i] for i in keep_idx] kept_tables.add(tn.lower()) # FKs cur.execute(f"SELECT * FROM pragma_foreign_key_list('{tn}')") for r in cur.fetchall(): if None not in [r[3], r[2], r[4]]: foreign_keys.append([tn.lower(), r[3].lower(), r[2].lower(), r[4].lower()]) # find table description tdesc = None for k, v in descs.items(): if k.lower() == tn.lower(): tdesc = v break col_lines = [] qtab = add_quotation_mark(tn) if detect_special_char(tn) else tn for cn, ct, pk in zip(cn_list, ct_list, pk_list): qcn = add_quotation_mark(cn) if detect_special_char(cn) else cn try: cur.execute(f"SELECT COUNT(*) FROM `{tn}` WHERE `{cn}` IS NULL") has_none = cur.fetchone()[0] > 0 except Exception: has_none = False meaning = "" vd = "" if tdesc: for col_key, col_info in tdesc.items(): if col_key.lower() == cn.lower(): meaning = (col_info.get('column_description') or "").strip() vd = (col_info.get('value_description') or "").strip() break vals = sample_static_values(cur, tn, cn, n=2) parts = [] if pk: parts.append("primary key") parts.append(f"type: {ct}") if meaning: parts.append("meaning: " + " ".join(meaning.split())) if vd: parts.append("value description: " + " ".join(vd.split())) if has_none: parts.append("has None") if vals: parts.append("values: " + " , ".join(str(v) for v in vals if v)) col_lines.append(f" {qtab}.{qcn} | " + " ; ".join(parts)) schema_seq += "table " + qtab + " , columns = [\n" + "\n".join(col_lines) + "\n]\n" if foreign_keys: # Filter FKs to only kept tables filt_fks = [fk for fk in foreign_keys if fk[0] in kept_tables and fk[2] in kept_tables] if filt_fks: schema_seq += "foreign keys:\n" for fk in filt_fks: for i in range(len(fk)): if detect_special_char(fk[i]): fk[i] = add_quotation_mark(fk[i]) schema_seq += f"{fk[0]}.{fk[1]} = {fk[2]}.{fk[3]}\n" else: schema_seq += "foreign keys: None\n" else: schema_seq += "foreign keys: None\n" conn.close() return schema_seq.strip() def main(): p = argparse.ArgumentParser() p.add_argument('--data', required=True) p.add_argument('--bird_dir', required=True) p.add_argument('--out', required=True) p.add_argument('--pruned_sel', default=None, help='optional: bird_dev_pruned_table_cols.json — schema-classifier pruning') args = p.parse_args() data = json.load(open(args.data)) print(f"Loaded {len(data)} samples") db_descriptions = load_all_db_descriptions(args.bird_dir) print(f"Loaded descriptions for {len(db_descriptions)} DBs") bird_dev_path = '/home/datht/mats-sql-tist/data/bird/dev/dev.json' bird_dev = json.load(open(bird_dev_path)) if os.path.exists(bird_dev_path) else [] diff_map = {(s['db_id'], s['question']): s.get('difficulty', 'unknown') for s in bird_dev} # Optional pruning selections — keyed by (db_id, question) pruned_map = {} if args.pruned_sel and os.path.exists(args.pruned_sel): psel = json.load(open(args.pruned_sel)) for p_item in psel: tables = {tn.lower(): set(c.lower() for c in cols) for tn, cols in p_item['tables'].items()} table_set = set(tables.keys()) pruned_map[(p_item['db_id'], p_item['question'])] = (table_set, tables) print(f"Loaded pruning selections for {len(pruned_map)} (db,question) pairs") out = [] from tqdm import tqdm for i, s in enumerate(tqdm(data)): q = s.get('question', s.get('text', '')) db_id = s['db_id'] db_path = '/home/datht/mats-sql-tist/' + s['db_path'].lstrip('./') if not s['db_path'].startswith('/') else s['db_path'] # Apply pruning if available table_filter = None col_filter = None sel = pruned_map.get((db_id, q)) if sel: table_filter, col_filter = sel schema_seq = build_schema_seq(db_path, db_id, db_descriptions, table_filter=table_filter, col_filter_per_table=col_filter) prompt = f"{schema_seq}\n\nQuestion: {q}\nExternal knowledge: {s.get('evidence','')}" out.append({ 'idx': i, 'db_id': db_id, 'db_path': db_path, 'question': q, 'evidence': s.get('evidence',''), 'gold_sql': s['sql'], 'difficulty': diff_map.get((db_id, q), 'unknown'), 'prompt_text': prompt, }) if i > 0 and i % 200 == 0: json.dump(out, open(args.out, 'w')) json.dump(out, open(args.out, 'w')) import statistics lens = [len(p['prompt_text']) for p in out] print(f"\nWrote {len(out)} → {args.out}") print(f"median len: {int(statistics.median(lens))}") n_meaning = sum(1 for p in out if 'meaning:' in p['prompt_text']) n_vd = sum(1 for p in out if 'value description:' in p['prompt_text']) n_vals = sum(1 for p in out if 'values:' in p['prompt_text']) print(f"with meaning: {n_meaning}/{len(out)}") print(f"with value description: {n_vd}/{len(out)}") print(f"with values: {n_vals}/{len(out)}") if __name__ == '__main__': main()