Datasets:

griffith-bigdata
/

GRAST-SL-evaluation-set

@@ -2,12 +2,10 @@
 license: cc-by-4.0
 language:
 - en
-task_categories:
-- table-question-answering
 tags:
 - text-to-sql
 - schema-linking
-pretty_name: GRAST-SL schema-linking evaluation sets (Spider, BIRD, Spider 2.0-Snow)
 configs:
 - config_name: spider_dev
   data_files: evaluation_set/spider_dev.csv
@@ -15,104 +13,33 @@ configs:
   data_files: evaluation_set/bird_dev.csv
 - config_name: spider2_snow_256
   data_files: evaluation_set/spider2_snow_256.csv
-- config_name: comparison_spider_case_by_case
   data_files: comparison_with_kasla/spider_dev_case_by_case.csv
-- config_name: comparison_bird_case_by_case
   data_files: comparison_with_kasla/bird_dev_case_by_case.csv
-- config_name: comparison_spider_label_errors
   data_files: comparison_with_kasla/spider_dev_label_errors.csv
-- config_name: comparison_bird_label_errors
   data_files: comparison_with_kasla/bird_dev_label_errors.csv
 - config_name: spider2_snow_case_by_case
   data_files: comparison_with_kasla/spider2_snow_case_by_case.csv
-- config_name: spider2_snow_parser_failures
-  data_files: comparison_with_kasla/spider2_snow_parser_failures.csv
-- config_name: spider2_snow_lexical_baseline
-  data_files: comparison_with_kasla/spider2_snow_lexical_baseline.csv
 - config_name: summary_statistics
   data_files: comparison_with_kasla/summary_statistics.csv
 ---
-# GRAST-SL — schema-linking evaluation sets and gold-label evidence
-Audited schema-linking gold labels (gold *used columns* per question) for three text-to-SQL
-benchmarks, plus the per-question, per-column evidence comparing them against the only released
-third-party label set (KaSLA's, which reuses CodeS's labels).
-| evaluation set | instances | databases | viewer config | full file |
-|---|---:|---:|---|---|
-| Spider dev | 1,034 | — | `spider_dev` | `full/spider_dev_gold_final.json` |
-| BIRD dev | 1,534 | — | `bird_dev` | `full/bird_dev_gold_final.json` |
-| Spider 2.0-Snow (paper set) | 256 | 105 | `spider2_snow_256` | `full/spider2_snow_eval_gold_256.json` |
-| Spider 2.0-Snow (maximal public-gold set) | 282 | 110 | — | `full/spider2_snow_eval_gold_282.json` |
-Gold definition: *the columns the released gold SQL actually uses*. Spider/BIRD labels are derived
-from the official dev-set gold SQL; Spider 2.0-Snow labels from the released public gold SQLs
-(120 Snow-native + 162 Lite-mapped; the 256-instance set is the subset whose Spider 2.0-Lite
-counterpart has public gold SQL, and is a strict subset of the 282-instance maximal set — flagged
-per row in `in_256_paper_set` of the case-by-case file). Instances whose gold SQL is
-leaderboard-held-out are excluded entirely rather than approximated.
-## Evaluation-set files
-- `evaluation_set/*.csv` — compact viewer-friendly version: question, gold SQL, gold columns.
-- `full/*.json` — complete records. Spider/BIRD rows additionally carry the full schema,
-  column/table meanings, PK/FK (declared + generated). Snow rows carry provenance
-  (`gold_sql_source` lite/snow, `gold_sql_id`), canonical `DB.SCHEMA.TABLE.COLUMN` gold columns
-  (shard families collapsed to `_*`), audit verdicts, and catalog sizes.
-- `full/SPIDER2_SNOW_README.md`, `full/SPIDER2_SNOW_VERIFICATION.md` — construction, audit
-  and verification record of the Snow sets (why 282 is the public-gold maximum, set relationship
-  233 ⊂ 256 ⊂ 282, audit history).
-## Label quality — headline numbers
-Referee: parse the **official** benchmark SQL with sqlglot (aliases expanded, sub-queries scoped,
-unqualified columns attributed via FROM/JOIN), schema-validate, then score **both** label sets with
-the identical script and conventions. All 2,568 Spider+BIRD dev queries parse with 0 failures.
-| | Spider: ours | Spider: KaSLA | BIRD: ours | BIRD: KaSLA |
-|---|---:|---:|---:|---:|
-| questions with a fully correct gold set | **1,030 (99.6 %)** | 758 (73.3 %) | **1,534 (100 %)** | 1,110 (72.4 %) |
-| gold columns faithful to the SQL | **99.86 %** | 90.00 % | **100.00 %** | 84.02 % |
-| ↳ labelled but not in the SQL | **4** | 316 | **0** | 1,278 |
-| ↳ in the SQL but not labelled | **0** | 42 | **0** | 178 |
-| JOIN-key completeness | **100 %** | 99.79 % | **100 %** | 98.00 % |
-| questions with an **empty** gold set | **0** | 42 (4.06 %) | **0** | 40 (2.61 %) |
-Where the two label sets disagree, ours is closer to the released SQL in **274/276** Spider and
-**424/424** BIRD questions; KaSLA's in **none** (2 ties). Our complete error list is 4 columns on
-Spider — all four traceable to defects in Spider's own `tables.json` PK declarations — and 0 on
-BIRD; both sides' errors are listed row-by-row in `comparison_with_kasla/*_label_errors.csv`.
-On Spider 2.0-Snow (no third-party labels exist) all **2,003** gold columns resolve against the
-official catalog with **0** invalid; a parser-only extractor drops to 54.3 % exact match
-(failure cases in `spider2_snow_parser_failures.csv`) and lexical name matching to precision
-0.189 (`spider2_snow_lexical_baseline.csv`), which is what the schema-aware LLM extraction +
-mechanical catalog post-validation is for.
-## Case-by-case comparison files
-| file | rows | content |
-|---|---:|---|
-| `comparison_with_kasla/{spider,bird}_dev_case_by_case.csv` | 1,034 / 1,534 | per question: both label sets, the SQL, the referee set, per-side verdict, wrong columns, written reason |
-| `comparison_with_kasla/{spider,bird}_dev_label_errors.csv` | 362 / 1,456 | one row per **wrong gold column** (either side) + category + explanation |
-| `comparison_with_kasla/spider2_snow_case_by_case.csv` | 282 | our gold, catalog check, parser-only output, name-matching output |
-| `comparison_with_kasla/spider2_snow_parser_failures.csv` | 1,049 | one row per column the parser-only extractor gets wrong |
-| `comparison_with_kasla/spider2_snow_lexical_baseline.csv` | 282 | per-instance breakdown of name-matching labelling |
-| `comparison_with_kasla/summary_statistics.csv` | 39 | every number above, machine-readable |
-| `comparison_with_kasla/gold_label_quality_comparison.xlsx` | — | all of the above as one workbook |
-Example:
-```python
-import pandas as pd
-df = pd.read_csv("comparison_with_kasla/bird_dev_case_by_case.csv")
-df[df.kasla_verdict != "CORRECT"][["question", "gold_sql", "ours_columns",
-                                   "kasla_columns", "kasla_error_explanation"]]
-```
-## Reproduction
-`scripts/` contains the full referee + comparison pipeline (`reproduce.sh`; needs `sqlglot`,
-`pandas`, `openpyxl`, ≈4 minutes on one CPU core). Inputs: the official Spider/BIRD dev releases,
-the released KaSLA data files, and the gold JSONs in `full/`.

 license: cc-by-4.0
 language:
 - en
 tags:
 - text-to-sql
 - schema-linking
+pretty_name: GRAST-SL evaluation sets
 configs:
 - config_name: spider_dev
   data_files: evaluation_set/spider_dev.csv
   data_files: evaluation_set/bird_dev.csv
 - config_name: spider2_snow_256
   data_files: evaluation_set/spider2_snow_256.csv
+- config_name: kasla_spider_case_by_case
   data_files: comparison_with_kasla/spider_dev_case_by_case.csv
+- config_name: kasla_bird_case_by_case
   data_files: comparison_with_kasla/bird_dev_case_by_case.csv
+- config_name: kasla_spider_label_errors
   data_files: comparison_with_kasla/spider_dev_label_errors.csv
+- config_name: kasla_bird_label_errors
   data_files: comparison_with_kasla/bird_dev_label_errors.csv
 - config_name: spider2_snow_case_by_case
   data_files: comparison_with_kasla/spider2_snow_case_by_case.csv
 - config_name: summary_statistics
   data_files: comparison_with_kasla/summary_statistics.csv
 ---
+# GRAST-SL evaluation sets
+Audited schema-linking gold labels (gold *used columns* per question, derived from the released
+gold SQL) for **Spider dev** (1,034), **BIRD dev** (1,534), and **Spider 2.0-Snow** (256
+instances, 105 databases), plus the per-question comparison with the released KaSLA/CodeS labels.
+- `evaluation_set/` — one row per question: question, gold SQL, gold columns.
+- `comparison_with_kasla/` — per-question verdicts for both label sets, one row per wrong gold
+  column with the reason, and `summary_statistics.csv` with the aggregate numbers.
+Gold columns faithful to the released SQL: **99.86 % (Spider) / 100.00 % (BIRD)** for our labels
+vs 90.00 % / 84.02 % for KaSLA's; on the 700 disagreement questions ours is closer to the SQL in
+698, KaSLA's in 0. All 2,003 Spider 2.0-Snow gold columns validate against the official catalog
+(0 invalid).
+Code and reproduction: https://github.com/thanhdath/grast-sql

comparison_with_kasla/gold_label_quality_comparison.xlsx DELETED Viewed

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:daad64a392220e05e0fb6b95c96191bb34f8faabaa977f53eeeff1b9106a2794
-size 1051767

comparison_with_kasla/parser_control_spider.json DELETED Viewed

@@ -1,10 +0,0 @@
-{
- "n": 1034,
- "parse_failures": 0,
- "exact_set_match": 0.8017,
- "exact_set_match_excluding_count_star_convention": 0.8357,
- "n_count_star_convention_instances": 42,
- "micro_precision": 0.9466,
- "micro_recall": 0.9744,
- "micro_f1": 0.9603
-}

comparison_with_kasla/spider2_snow_lexical_baseline.csv DELETED Viewed

The diff for this file is too large to render. See raw diff

comparison_with_kasla/spider2_snow_parser_failures.csv DELETED Viewed

The diff for this file is too large to render. See raw diff

comparison_with_kasla/summary_spider2_snow.json DELETED Viewed

@@ -1,68 +0,0 @@
-{
- "n_instances": 282,
- "n_instances_256_subset": 256,
- "n_databases": 110,
- "n_databases_256": 105,
- "dialects": {
-  "snowflake": 121,
-  "bigquery": 147,
-  "duckdb": 14
- },
- "gold_columns_total": 2003,
- "gold_columns_out_of_catalog": 0,
- "parser": {
-  "subset": 40,
-  "exact": 153,
-  "differs": 82,
-  "superset": 7
- },
- "parser_shard_normalized": {
-  "differs": 74,
-  "exact": 208
- },
- "parser_failure_classes": {
-  "other_dialect_or_scope": 14,
-  "shard_family_plus_column_error": 9,
-  "nested_struct_unnest_variant": 35,
-  "shard_family_node_naming": 55,
-  "select_star_expansion": 13,
-  "cte_or_alias_attribution": 3
- },
- "parser_micro": {
-  "precision": 0.7259,
-  "recall": 0.7654,
-  "f1": 0.7451,
-  "tp": 1533,
-  "pred": 2112,
-  "gold": 2003
- },
- "lexical_micro": {
-  "precision": 0.1892,
-  "recall": 0.7194,
-  "f1": 0.2996,
-  "tp": 1441,
-  "pred": 7615,
-  "gold": 2003
- },
- "catalog": {
-  "schema_nodes": 4631,
-  "columns": 151075,
-  "physical_tables": 19368
- },
- "parser_exact_match_rate": 0.5426,
- "catalog_per_database": {
-  "n_databases": 110,
-  "schema_nodes_total": 1963,
-  "physical_tables_total": 5976,
-  "columns_total": 58378,
-  "columns_median": 158,
-  "columns_max": 6063
- },
- "parser_shard_normalized_exact_rate": 0.7376,
- "sql_complexity": {
-  "median_chars": 1189,
-  "median_lines": 39,
-  "pct_with_cte": 75.2,
-  "pct_dialect_construct": 41.1
- }
-}

comparison_with_kasla/summary_spider_bird.json DELETED Viewed

@@ -1,171 +0,0 @@
-{
- "spider": {
-  "dataset": "spider",
-  "n_instances": 1034,
-  "n_aligned_by_question_text": 1034,
-  "parse_failures": 0,
-  "per_set": {
-   "ours": {
-    "labelled_columns": 2891,
-    "distinct_columns": 2891,
-    "faithful_columns": 2887,
-    "unfaithful_columns": 4,
-    "missing_columns": 0,
-    "empty_gold_instances": 0,
-    "instances_with_extra": 4,
-    "instances_with_missing": 0
-   },
-   "kasla": {
-    "labelled_columns": 3161,
-    "distinct_columns": 3161,
-    "faithful_columns": 2845,
-    "unfaithful_columns": 316,
-    "missing_columns": 42,
-    "empty_gold_instances": 42,
-    "instances_with_extra": 234,
-    "instances_with_missing": 42
-   }
-  },
-  "error_categories": {
-   "ours": {
-    "unused_column_star_table": 2,
-    "star_table_pk_not_declared": 2
-   },
-   "kasla": {
-    "missing_referenced_column": 40,
-    "empty_gold": 42,
-    "phantom_table_name_collision": 286,
-    "unused_column_in_used_table": 16,
-    "unused_column_star_table": 14,
-    "missing_join_key": 2
-   }
-  },
-  "verdicts": {
-   "ours": {
-    "CORRECT": 1030,
-    "WRONG_extra": 4
-   },
-   "kasla": {
-    "UNEVALUABLE_EMPTY_GOLD": 42,
-    "WRONG_extra": 232,
-    "CORRECT": 758,
-    "WRONG_extra_and_missing": 2
-   }
-  },
-  "join_keys_total": 952,
-  "join_keys_covered": {
-   "ours": 952,
-   "kasla": 950
-  },
-  "micro": {
-   "ours": {
-    "precision_vs_sql": 0.9986,
-    "recall_vs_sql": 1.0,
-    "f1_vs_sql": 0.9993,
-    "tp_precision": 2887,
-    "tp_recall": 2887,
-    "pred": 2891,
-    "gold": 2887
-   },
-   "kasla": {
-    "precision_vs_sql": 0.9,
-    "recall_vs_sql": 0.9855,
-    "f1_vs_sql": 0.9408,
-    "tp_precision": 2845,
-    "tp_recall": 2845,
-    "pred": 3161,
-    "gold": 2887
-   }
-  },
-  "parser_artefact_refs_dropped": 409,
-  "closer_counts": {
-   "ours": 274,
-   "tie": 760
-  },
-  "n_disagree_instances": 276
- },
- "bird": {
-  "dataset": "bird",
-  "n_instances": 1534,
-  "n_aligned_by_question_text": 1534,
-  "parse_failures": 0,
-  "per_set": {
-   "ours": {
-    "labelled_columns": 6897,
-    "distinct_columns": 6897,
-    "faithful_columns": 6897,
-    "unfaithful_columns": 0,
-    "missing_columns": 0,
-    "empty_gold_instances": 0,
-    "instances_with_extra": 0,
-    "instances_with_missing": 0
-   },
-   "kasla": {
-    "labelled_columns": 7997,
-    "distinct_columns": 7997,
-    "faithful_columns": 6719,
-    "unfaithful_columns": 1278,
-    "missing_columns": 178,
-    "empty_gold_instances": 40,
-    "instances_with_extra": 367,
-    "instances_with_missing": 90
-   }
-  },
-  "error_categories": {
-   "ours": {},
-   "kasla": {
-    "phantom_table_name_collision": 1050,
-    "missing_referenced_column": 123,
-    "unused_column_in_used_table": 90,
-    "phantom_table_token_match": 124,
-    "missing_join_key": 55,
-    "empty_gold": 40,
-    "phantom_table": 11,
-    "unused_column_star_table": 3
-   }
-  },
-  "verdicts": {
-   "ours": {
-    "CORRECT": 1534
-   },
-   "kasla": {
-    "CORRECT": 1110,
-    "WRONG_extra": 334,
-    "WRONG_extra_and_missing": 33,
-    "WRONG_missing": 17,
-    "UNEVALUABLE_EMPTY_GOLD": 40
-   }
-  },
-  "join_keys_total": 2756,
-  "join_keys_covered": {
-   "ours": 2756,
-   "kasla": 2701
-  },
-  "micro": {
-   "ours": {
-    "precision_vs_sql": 1.0,
-    "recall_vs_sql": 1.0,
-    "f1_vs_sql": 1.0,
-    "tp_precision": 6897,
-    "tp_recall": 6897,
-    "pred": 6897,
-    "gold": 6897
-   },
-   "kasla": {
-    "precision_vs_sql": 0.8402,
-    "recall_vs_sql": 0.9742,
-    "f1_vs_sql": 0.9022,
-    "tp_precision": 6719,
-    "tp_recall": 6719,
-    "pred": 7997,
-    "gold": 6897
-   }
-  },
-  "parser_artefact_refs_dropped": 103,
-  "closer_counts": {
-   "tie": 1110,
-   "ours": 424
-  },
-  "n_disagree_instances": 424
- }
-}

full/SPIDER2_SNOW_README.md DELETED Viewed

@@ -1,107 +0,0 @@
-# Spider 2.0-Snow — canonical GRAST-SL evaluation set
-Canonical, audited schema-linking evaluation set for Spider 2.0-Snow.
-This directory is the single source of truth; other copies (e.g.
-`grast-sql-public/data/spider2_snow_282_enriched.pkl`) are synced from here.
-## Files
-| file | what it is |
-|---|---|
-| `spider2_snow_eval_gold.json` | **v3 (canonical, maximal)**: 282 instances with audited gold used-columns. `{"metadata": {...}, "data": [...]}`. Gold columns in canonical `DB.SCHEMA.TABLE.COLUMN` form (shard families collapsed to `_*`). Built 2026-06-14 via deterministic sqlglot extraction from public gold SQL + per-instance Sonnet audit (224 ok / 58 fixed / 0 validation errors). |
-| `spider2_snow_282_enriched.pkl` | **v3 runnable**: pickle list of **282** tuples `(question, networkx.DiGraph, gold_nodes, sample_id)` — the contract `evaluate_on_the_fly.py` / `reproduce.sh spider2` consume. Graphs are the deployed Stage-I top-M(500) pool graphs enriched with column/table meanings, generated PK/FK flags (+FK edges only for originally edge-less graphs), and sample values. Ordered identically to the gold JSON's `data` list. |
-| `spider2_snow_eval_gold_256.json` + `spider2_snow_256_enriched.pkl` | **v2 (paper-claimed set)**: the 256 instances whose spider2-lite counterpart has public gold SQL — the "lite transformed to snow" set the paper's "256 evaluable instances" text refers to. Strict subset of v3 (drops the 26 snow-only-gold instances). 162 golds audited from the lite SQL, 94 from the byte-exact snow rewrite of the same query. |
-| `spider2_snow_eval_gold_233fixed.json` + `spider2_snow_233fixed_enriched.pkl` | **v1 (fixed operational set)**: the 233 instances of the historical `data/spider2_lite_samples.json` (o4-mini-era gold) with gold REPLACED by the audited values; `old_used_columns` kept per entry for diffing (116/233 differ at table.column level). Strict subset of v2. |
-| `SHA256SUMS` | checksums of all data files. |
-| `VERIFICATION.md` | full 2026-08-11 audit report (3 independent audits + fixes). |
-| `legacy/eval_snow256.py` | stale scorer for an older 256-sample variant; kept for reference only. |
-Set relationship: **233-fixed ⊂ 256 ⊂ 282** (verified). All three share the same audited
-gold; they differ only in which instances are included.
-Load the pkl with the CPU shim (node attrs may contain torch tensors):
-```python
-import io, pickle, torch
-old = torch.storage._load_from_bytes
-torch.storage._load_from_bytes = lambda b: torch.load(io.BytesIO(b), map_location="cpu")
-data = pickle.load(open("spider2_snow_282_enriched.pkl", "rb"))  # 282 items
-torch.storage._load_from_bytes = old
-```
-## Why 282 is the maximum
-Spider 2.0-Snow has 547 instances, but gold SQL is public for only some
-(the rest are leaderboard-held-out). Public gold: 120 snow-native SQLs +
-256 lite SQLs. Snow = Lite migrated to Snowflake with a direct id mapping
-(`sf_` + lite id; lite ids already starting `sf` map unchanged), so lite
-golds transfer. Union = 120 ∪ (256 lite-mapped, of which 94 overlap snow)
-= **282** — verified exactly maximal against `/home/datht/Spider2`
-(nothing with public gold is missing; every entry is backed by a public
-gold file byte-for-byte). On the 94 overlaps the native snow SQL is used.
-## Known properties (not bugs)
-- **Stage-I coverage ceiling**: gold-tail coverage of the pool graphs is
-  mean **0.9098**; 228/282 instances at 1.0, 46 partial, **8 at 0.0**
-  (`sf_bq087/088/089/102/103/338/402/406`). **CORRECTED 2026-08-15:** these
-  are NOT retrieval failures but a gold↔pool name-canonicalization mismatch —
-  see §v4 below; the v4 pkls repair the mapping (zero-coverage 8→0). Rankers
-  evaluated on the v3 pkl remain bounded by this ceiling; on v3, report it
-  alongside results and consider excluding the 8 ids.
-- **Year-sharded BigQuery tables** (`GITHUB_REPOS_DATE` etc.): gold columns
-  carry literal shard years (`2023_*`) while pool graphs collapse shards to
-  `_*`, so a few instances (`sf_bq182/224/295`) have structurally partial
-  gold-tail coverage.
-- **Identical graphs across db_ids**: `SQLITE_SAKILA`/`PAGILA` and the two
-  `CENSUS_GALAXY__*_SAMPLE` dbs genuinely have identical (table, column)
-  schemas in the official Spider2 resources — shared node sets are faithful,
-  not a mis-assignment.
-- **Shard fan-out in gold_nodes**: on 4 Ethereum-blockchain instances one
-  canonical gold column maps to up to 7 shard nodes by design.
-- Questions match the pre-2025-07-13 `spider2-snow.jsonl` (the vintage the
-  pool and gold were built from), not the reworded `spider2-snow-0713` one.
-## Provenance of the 2 recovered samples (280 → 282)
-The originally shipped pkl had 280 items: `sf_bq182` and `sf_bq363` were
-dropped because the Stage-I pool cached pre-audit question wording. They
-were recovered 2026-08-11 from the pool by sid (40, 205) with the audited
-gold question text, and enriched to parity with their same-db neighbors
-(meanings/PK/FK already saturated in the pool; sample values injected from
-Spider2 resource JSONs — final `similar_values` coverage 54%/96% vs 49%/96%
-for Mongo-enriched neighbors). See `VERIFICATION.md`.
-## v4 (2026-08-15): repaired gold→pool mapping — full-N evaluation, zero exclusions
-The 8 "Stage-I zero-coverage" instances (`sf_bq087/088/089/102/103/338/402/406`) were **not**
-retrieval failures: their pools contain the correct DB and gold tables, but the audited gold
-uses a different shard-collapse convention than the pool node names (e.g. gold
-`CENSUSTRACT_*` vs pool `censustract_*_*yr`, gold `V_2_1_1_GENOMES_*` vs pool
-`v2_1_1_genomes__chrx`). Verified identical on the gte-modernbert-149m pool — no Stage-I
-checkpoint change fixes it; it is a name-canonicalization defect.
-`spider2_snow_{233fixed,256,282}_enriched_v4.pkl` = same tuples as v3 with `gold_nodes`
-re-resolved by the audited cascade in
-`experiments/pkfk_accuracy/36_fix_zero_coverage_mapping.py` (exact-suffix rule first; a
-canonicalized table match — alpha-token subset + digit-run check, boundary-safe — only for
-columns the exact rule missed; every relaxed mapping logged in
-`snow_gold_pool_mapping_v4.json`). 31/37 gold columns of the 8 instances were already in
-their pools; residual true misses: sf_bq087 3/4 cols, sf_bq089 3/6 cols.
-Result: zero-coverage 8→0; mean gold-coverage ceiling 233/256/282 = 0.9563/0.9556/0.9575
-(all ≥ 0.937), so macro R=0.937 is attainable at FULL N with no exclusions.
-Reference numbers (current_best ckpt, raw global-τ + table-aware Steiner, PYTHONHASHSEED=0,
-`experiments/pkfk_accuracy/37_build_v4_and_eval.py`):
-| set | N (full) | P@R0.937 | P@R0.90 | v3 (with exclusions) |
-|---|---|---|---|---|
-| 233fixed | 233 | 0.2455 | 0.2919 | 0.2548 @ N=228 |
-| 256 | 256 | **0.2451** | 0.2859 | 0.2537 @ N=248 |
-| 282 | 282 | 0.2590 | 0.3022 | 0.2715 @ N=274 |
-v4 P is ~0.9–1.3pp below v3 because the repaired instances are hard (two have partial
-ceilings) and holding macro-R at full N lowers the global τ (sel 55→61 cols). v3 pkls remain
-unchanged for comparability with all previously reported numbers; state N and version
-explicitly whenever quoting either.

full/SPIDER2_SNOW_VERIFICATION.md DELETED Viewed

@@ -1,218 +0,0 @@
-# Verification report — Spider 2.0-Snow eval set (2026-08-11)
-Three independent audits (Sonnet sub-agents) + main-session fixes. Scope:
-`spider2_snow_eval_gold.json` (282) and `spider2_snow_282_enriched.pkl`
-(280 at audit time → 282 after repair).
-## Audit A — gold JSON vs official Spider2 repo: PASS (all 5 checks)
-1. **Ids/questions**: 282 unique instance_ids, all in `spider2-snow.jsonl`;
-   question text is an exact string match to both snow `instruction` and
-   (via id mapping) lite `question` for all 282. Id convention verified
-   bijective over all 547: snow = `sf_`+lite unless lite id starts `sf`.
-2. **SQL provenance**: `gold_sql` byte-for-byte equals the public gold file
-   for all 282 (120 snow-native, 162 lite) — 0 diffs at any level.
-3. **Maximality**: union of public snow gold (120) and lite-mapped gold
-   (256 → 94 overlap) is exactly the file's 282 ids; 0 missing, 0 extra.
-   All 94 overlaps use `gold_sql_source="snow"` consistently.
-4. **Internal integrity**: n_gold_columns, column format (4+ dot parts),
-   short-form consistency (as multisets — both lists independently sorted),
-   db_id prefixes, dialect/source/audit-verdict breakdowns vs metadata:
-   0 mismatches anywhere; 0 empty/duplicate gold lists.
-5. **Gold vs SQL**: every gold column leaf appears in its gold SQL
-   (full 282 scan); 10-entry stratified sqlglot parse check across all
-   dialect×source strata — all columns identifiable as Column nodes.
-Cosmetic note: 16 entries have `audit_verdict="fix"` with
-`auto_corrected=False` — manual-fix path, field semantics only.
-## Audit B — enriched pkl: PASS (after resolving 2 flags)
-- Structure: well-typed 4-tuples, unique questions and sids.
-- Join: every item matches exactly one gold entry by normalized question;
-  sid→instance_id mapping (`spider2_snow_547_sid2inst.json`) consistent for
-  all items; the only unmatched gold entries were `sf_bq182`/`sf_bq363`
-  (repaired, see below).
-- gold_nodes: all exist in their graph, no duplicates.
-- Graph sanity: 0 zero-node graphs, 0 NaN tensors; meanings 99.2% of
-  nodes, table_meanings 100%, values 67%; 57 zero-edge graphs (dbs with no
-  generated FKs — by design).
-- Flag 1 resolved — **identical node sets across different db_ids**
-  (`SQLITE_SAKILA`≡`PAGILA`, 89 cols; two `CENSUS_GALAXY__*_SAMPLE`, 57
-  cols): verified against `/home/datht/Spider2/spider2-snow/resource/`
-  schemas — genuinely identical (table, column) sets in the source. Benign.
-- Flag 2 (informational) — Stage-I coverage ceiling: mean gold-tail
-  coverage 0.9098; 46 partial; 8 instances at 0.0 (wrong-domain pool
-  retrieval): `sf_bq087, sf_bq088, sf_bq089, sf_bq102, sf_bq103,
-  sf_bq338, sf_bq402, sf_bq406`. Property of the deployed Stage-I
-  retriever, faithfully preserved — not a data bug.
-## Audit C + repair — the 2 dropped samples: RECOVERED
-- Root cause: pool cached pre-audit question wording (`sf_bq182`: "at
-  least 100" vs corrected "at least 5" PullRequestEvents; `sf_bq363`:
-  reworded quantile-grouping clause) → exact-match join failed.
-- Recovery: pool items sid 40/205 (identical node sets to what the original
-  build would have used), gold question text, enrichment reproduced from
-  on-disk sources (v5 dump `data/source_dumps/mongo_dumps/
-  spider2_lite_samples_v5.json` + Spider2 resource JSON sample_rows; the
-  original Mongo step was verified on same-db neighbors to be values-only
-  for these dbs). Final values coverage 54.1%/95.6% ≈ neighbors' 49%/96%.
-- Gold alignment: `sf_bq363` 1.0; `sf_bq182` 0.4 — pre-existing year-shard
-  `tail()` artifact, identical to its already-shipped siblings
-  `sf_bq224` (0.4) / `sf_bq295` (0.667).
-## Merge validation (final 282 pkl)
-282 items ordered as the gold JSON; unique sids; every item joins to its
-gold entry; all gold_nodes present in graphs; coverage mean 0.9098,
-228/282 full, 8 zero. Synced to
-`/home/datht/grast-sql-public/data/spider2_snow_282_enriched.pkl`
-(previous 280-item version recoverable via git in that repo).
-## End-to-end evaluation of the 3 versions (2026-08-13)
-Canonical pipeline: frozen 547 enriched-nested embedding pool + GNN + single
-global-τ swept to macro recall target + table-aware Steiner (always on).
-Control gate PASSED: OLD gold (222) × current-best ckpt → P@R0.937 = 0.2606
-vs README reference 0.2603 (two independent harnesses agree). Note: the
-"paper ckpt 0.251" folklore is a goal-label in eval_macro.py's printout, not
-that checkpoint's score — its real OLD-gold number is 0.212–0.214, matching
-the script's own inline baseline comment.
-Ckpts: paper = hybrid_attnpost2_warm_l3_h2048/best_pr_auc_epoch_02.pt;
-current_best = stage3_gnn/all3-final-kdsoup__ALL3PASS/grast_all3_final_sLGA433.pt.
-Final numbers AFTER the 2026-08-13 schema-attribution fix (see section
-below; pre-fix numbers in scratch report.json history):
-| Version | Ckpt | N eval (excl.) | Ceiling | P@R0.937 | P@R0.90 |
-|---|---|---|---|---|---|
-| OLD gold 222 | paper | 222 | — | 0.2148 | 0.2435 |
-| OLD gold 222 | current_best | 222 | — | 0.2599 | 0.2979 |
-| 233fixed | paper | 228 (5) | 0.9591 | 0.2113 | 0.2398 |
-| 233fixed | current_best | 228 (5) | 0.9591 | 0.2548 | 0.2869 |
-| 256 | paper | 248 (8) | 0.9480 | 0.2071 | 0.2357 |
-| 256 | current_best | 248 (8) | 0.9480 | 0.2537 | 0.2804 |
-| 282 | paper | 274 (8) | 0.9514 | 0.2216 | 0.2559 |
-| 282 | current_best | 274 (8) | 0.9514 | 0.2715 | 0.2965 |
-(Excluded = gold∩pool empty; the 8 = the documented zero-coverage ids.
-Ceiling here = gold∩frozen-embedding-pool per sample — higher than the
-0.9098 in the audit section, which was computed against the enriched pkl's
-own bundled graphs; different denominators, both correct.)
-Reading: ckpt ranking is stable across all gold revisions (current_best >
-paper everywhere); the audited sets score within ~1pp of the OLD gold, with
-282 highest (0.2715@R0.937). The 256 (paper-claimed) set evaluates cleanly
-end-to-end: N=248 evaluated, P@R0.937 = 0.2537 (+Steiner, current_best).
-Note: the current pool file
-`data/spider2_snow_547_stage1pool_graphs_enrichednested.pkl` has grown for
-some sids since the shipped pkl was built (e.g. sid 531: 349 vs 440 nodes)
-— the enriched pkl is the frozen eval artifact; do not rebuild it from the
-current pool expecting bit-identity. Sids 40/205 were verified unaffected.
-## Schema-attribution fix (2026-08-13)
-**Bug**: for a homonym-collision subset of instances, `gold_columns` SCHEMA
-segments named a schema that appears nowhere in that instance's `gold_sql`.
-Root cause: the original deterministic extraction matched candidate schema
-columns by (table, column) name only; when several same-DB schemas share
-identical table/column layouts, it could pick a schema never referenced by
-the query. Two homonym families were hit: **CRYPTO_\*** (7 near-identical
-blockchain schemas — `CRYPTO_BAND/BITCOIN/BITCOIN_CASH/DASH/ETHEREUM/
-ETHEREUM_CLASSIC/ZILLIQA` all ship `transactions`/`blocks`/`inputs`/
-`outputs`/`logs`/`token_transfers` tables with overlapping column names) and
-**WORLD_BANK_\*** (4 schemas — `WORLD_BANK_WDI/INTL_DEBT/INTL_EDUCATION/
-HEALTH_POPULATION` all ship a `COUNTRY_SUMMARY` table with `country_code`/
-`region`).
-**Method**: deterministic, whole-file scan of all 282 entries. For each
-entry, parsed `gold_sql` with sqlglot (dialect-aware: snowflake/bigquery/
-duckdb), extracted schema-qualified base-table references (CTE aliases
-excluded), and cross-checked every `gold_columns` SCHEMA segment against
-those references — with escape valves for two legitimate non-bug patterns
-that would otherwise false-positive: (a) Snowflake identifiers that can't
-start with a digit are prefixed with `_` (e.g. `_1000_GENOMES`), and (b) a
-single BigQuery dataset can fan out into several concretely-named Snowflake
-schemas that are not themselves independently real schemas (e.g.
-`san_francisco` → `SAN_FRANCISCO_SFPD_INCIDENTS` / `SAN_FRANCISCO_BIKESHARE`
-/ ...; verified via the official Spider2 resource catalog, 7,860 table
-JSONs under `spider2-snow/resource/databases/`, that these two patterns are
-not the homonym-collision bug). Genuinely-flagged columns were reassigned to
-the single SQL-referenced schema whose catalog entry actually contains that
-(table, column) — ambiguous or catalog-unconfirmed cases would have been
-left as needs-review, but none occurred (0 needs-review). A spurious `_*`
-shard suffix on TABLE was collapsed to the literal table name when the
-corrected schema's table is verifiably not sharded (all touched CRYPTO/
-WORLD_BANK tables are single, non-sharded tables), and duplicate columns
-produced by the reassignment (e.g. the same real column previously present
-under two different wrong schemas) were deduped.
-**Result**: **10 of 282 entries changed** (53 of 2,006 gold columns
-reassigned; 0 needs-review): `sf_bq057, sf_bq068, sf_bq083, sf_bq093,
-sf_bq327, sf_bq334, sf_bq341, sf_bq398, sf_bq424, sf_bq444`. All 4
-originally-reported instances landed on the expected schema exactly as
-specified: `sf_bq093` → `CRYPTO_ETHEREUM_CLASSIC` only (15→12 cols after
-dedup); `sf_bq057`, `sf_bq334` → `CRYPTO_BITCOIN`; `sf_bq341` →
-`CRYPTO_ETHEREUM`. The scan additionally caught 6 more instances of the same
-class: `sf_bq068`→`CRYPTO_BITCOIN_CASH`, `sf_bq083`/`sf_bq444`→
-`CRYPTO_ETHEREUM`, and `sf_bq327`/`sf_bq398`/`sf_bq424`→
-`WORLD_BANK_INTL_DEBT` (2 `COUNTRY_SUMMARY` columns each; those 3 instances'
-other 4 columns, on `INTERNATIONAL_DEBT`/`international_debt`, were already
-correctly schema'd and untouched). Applied identically to
-`spider2_snow_eval_gold.json` (282), `spider2_snow_eval_gold_256.json`
-(256) and `spider2_snow_eval_gold_233fixed.json` (233fixed) — the same 10
-instance_ids in all three, `lite_instance_id`/`old_used_columns` preserved;
-all other 272/246/223 entries byte-identical (diffed against pre-fix
-backups). `gold_columns_per_instance.mean` moved 7.11→7.1 (282); metadata
-gained a `schema_attribution_fix` block with date, changed-id list and this
-note.
-**pkl `gold_nodes` regeneration**: for the same 10 instances (by sid, via
-`data/spider2_snow_547_sid2inst.json`), recomputed `gold_nodes` from the
-corrected `gold_columns` against each instance's already-bundled pool graph
-`G` (schema-aware match: node id's last 3 dot-segments taken as
-(schema, table, column), canon-compared case/underscore/shard-insensitively;
-falls back to (table, column)-only when a node id has fewer segments — e.g.
-the CRYPTO graphs use 3-segment `SCHEMA.table.column` ids with no DB/project
-prefix, the WORLD_BANK graphs use 4-segment `project.dataset.table.column`
-ids). This directly fixed the previously-documented over-matching: gold-tail
-lookups by (table, column) alone had pulled in nodes from every homonym
-schema in the graph, not just the correct one.
-| sid | instance | gold_nodes before → after | gold-tail coverage before → after |
-|---|---|---|---|
-| 114 | sf_bq057 | 25 → 7  | 1.0 → 1.0 |
-| 115 | sf_bq068 | 24 → 8  | 1.0 → 1.0 |
-| 102 | sf_bq083 | 11 → 3  | 1.0 → 1.0 |
-| 117 | sf_bq093 | 40 → 12 | 1.0 → 1.0 |
-| 112 | sf_bq334 | 22 → 6  | 1.0 → 1.0 |
-| 108 | sf_bq341 | 8 → 4   | 1.0 → 1.0 |
-| 109 | sf_bq444 | 14 → 6  | 1.0 → 1.0 |
-| 352 | sf_bq327 | 8 → 6   | 0.333 → 1.0 |
-| 342 | sf_bq398 | 8 → 6   | 0.333 → 1.0 |
-| 351 | sf_bq424 | 8 → 6   | 0.333 → 1.0 |
-For the CRYPTO instances, gold_nodes shrank (over-matched wrong-schema nodes
-removed) with coverage unchanged at 1.0 (the correct-schema nodes were
-already present in the over-matched set). For the 3 WORLD_BANK instances,
-coverage actually **rose** 0.333→1.0: the old (buggy) gold_nodes for these
-contained only `COUNTRY_SUMMARY` nodes (across all 4 wrong-and-right
-homonym schemas) and were entirely missing the `INTERNATIONAL_DEBT.
-international_debt` nodes for the other 4 gold columns — a second,
-independent gap in the original gold_nodes build that this whole-list
-recomputation also fixed as a byproduct. Identical results across all three
-pkls (`_282_enriched`, `_256_enriched`, `_233fixed_enriched`). Verified:
-same touched-10/untouched-N split in all three; every untouched item's
-`(question, sid, gold_nodes)` and full graph node/edge set are unchanged
-from the pre-fix pkl; every corrected gold column matched exactly one node
-(no residual multi-schema ambiguity); 0 needs-review.
-**Needs-review list**: empty (0 entries) — every flagged column resolved to
-exactly one catalog-confirmed SQL-referenced schema.
-**Sync**: `spider2_snow_282_enriched.pkl` copied (plain `cp`) to
-`/home/datht/grast-sql-public/data/spider2_snow_282_enriched.pkl`;
-`SHA256SUMS` regenerated for all 6 data files.

full/bird_dev_gold_final.json DELETED Viewed

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:869252ccc36012b484809c4ac66146e8e1b7bcc3c3bc361415e4e3865e58b683
-size 38312141

full/spider2_snow_eval_gold_256.json DELETED Viewed

The diff for this file is too large to render. See raw diff

full/spider2_snow_eval_gold_282.json DELETED Viewed

The diff for this file is too large to render. See raw diff

full/spider_dev_gold_final.json DELETED Viewed

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3714009b0391624b5a7c536f6ca79e21cc698313adfd6077ef160b385654f048
-size 10822085

scripts/build_spider2_snow.py DELETED Viewed

@@ -1,411 +0,0 @@
-"""
-Spider 2.0-Snow gold-label quality evidence (no third-party labels exist for
-this benchmark, so this is a *validation* rather than a head-to-head):
-  1. per-instance record of our 282 audited gold label sets, with the released
-     gold SQL, the database, the catalog size, and the schema-validity check;
-  2. what a strong PARSER-ONLY extractor (sqlglot, alias/CTE/UNNEST/FLATTEN
-     aware) recovers from the same SQL, per instance and per column, with a
-     mechanical classification of *why* it fails -- the reviewer question
-     "why is an LLM needed when SQLGlot exists?";
-  3. what the lexical / name-matching labelling rule (the rule whose error
-     signature we measured on Spider and BIRD) would produce on Snow schemas.
-Outputs (hf_dataset/data/):
-  spider2_snow_case_by_case.csv
-  spider2_snow_parser_failures.csv
-  spider2_snow_lexical_baseline.csv
-  summary_spider2_snow.json
-"""
-import json
-import os
-import re
-import signal
-import sys
-from collections import Counter, defaultdict
-import pandas as pd
-HERE = os.path.dirname(os.path.abspath(__file__))
-sys.path.insert(0, HERE)
-from extractor import extract  # noqa: E402  (the parser-only reference extractor)
-OUT = os.environ.get("OUT_DIR", os.path.join(HERE, "..", "data"))
-SNOW_GOLD_DIR = os.environ.get(
-    "SNOW_GOLD_DIR",
-    os.path.abspath(os.path.join(HERE, "..", "..", "..", "data", "eval",
-                                 "spider2_snow_final_versions")))
-GOLD = os.path.join(SNOW_GOLD_DIR, "spider2_snow_eval_gold.json")
-GOLD256 = os.path.join(SNOW_GOLD_DIR, "spider2_snow_eval_gold_256.json")
-CATALOG = os.environ.get("SPIDER2_RESOURCE_DIR", "spider2_snow_resource/databases")
-JOIN = "; "
-class TimeoutErr(Exception):
-    pass
-signal.signal(signal.SIGALRM, lambda *a: (_ for _ in ()).throw(TimeoutErr()))
-# --------------------------------------------------------------------------- #
-# schema catalog
-# --------------------------------------------------------------------------- #
-DIGITS_RE = re.compile(r"\d+")
-def family_key(table_name):
-    """Group per-shard physical tables into one schema node by replacing every
-    digit run with `#`:  GA_SESSIONS_20160801 -> GA_SESSIONS_#,
-    COUNTY_2007_1YR / COUNTY_2008_3YR -> COUNTY_#_#YR.  Spider 2.0 exposes such
-    a family as ONE node; the released gold labels write it `PREFIX_*`."""
-    return DIGITS_RE.sub("#", table_name.upper())
-def load_catalog(db_id):
-    """Returns (families, phys, n_physical_tables).
-    families : {FAMILY_KEY: {col,...}} -- one entry per schema node (shard
-               families merged), the granularity a labeller actually faces.
-    phys     : {PHYSICAL_TABLE_NAME: {col,...}} -- used to check that a gold
-               label names a real catalog column (gold writes shard families as
-               `PREFIX_*`, resolved here by prefix match).
-    """
-    families, phys = defaultdict(set), {}
-    root = os.path.join(CATALOG, db_id)
-    for dirpath, _, files in os.walk(root):
-        for f in files:
-            if not f.endswith(".json"):
-                continue
-            try:
-                j = json.load(open(os.path.join(dirpath, f), encoding="utf-8"))
-            except Exception:
-                continue
-            if "column_names" not in j:
-                continue
-            tname = (j.get("table_fullname") or j.get("table_name") or f[:-5]).split(".")[-1].upper()
-            cols = {c.upper() for c in j["column_names"]}
-            phys.setdefault(tname, set()).update(cols)
-            families[family_key(tname)] |= cols
-    return dict(families), phys, len(phys)
-def catalog_columns_for(node, phys):
-    """Columns available under a gold table node, resolving `PREFIX_*` shard
-    families against the physical catalog by prefix."""
-    node = node.upper()
-    if node in phys:
-        return phys[node]
-    if node.endswith("_*") or node.endswith("*"):
-        pref = node.rstrip("*").rstrip("_")
-        cols = set()
-        for name, c in phys.items():
-            if name == pref or name.startswith(pref + "_") or name.startswith(pref):
-                cols |= c
-        if cols:
-            return cols
-    # Node ids are canonicalised (digit runs separated by `_`, masked as `#`):
-    # `PM25_DAILY_SUMMARY_2020` -> `pm_25_daily_summary_*`, `ICD10CODE` ->
-    # `icd_10_code_*`, `GSOD2022` -> `gsod#2_*`.  Match on the separator-free
-    # form before declaring a gold column out-of-catalog.
-    def squash(s):
-        return re.sub(r"[_#*]", "", s).lower()
-    sq = squash(node)
-    cols = set()
-    for name, c in phys.items():
-        n = squash(name)
-        if n == sq or n.startswith(sq) or sq.startswith(n):
-            cols |= c
-    return cols
-# --------------------------------------------------------------------------- #
-# mechanical evidence flags on the SQL text
-# --------------------------------------------------------------------------- #
-EVIDENCE = [
-    ("wildcard_or_shard_table", re.compile(r"`[^`]*\*[^`]*`|\.[A-Za-z0-9_]*\*(?!\w)|_TABLE_SUFFIX", re.I)),
-    ("literal_year_shard_table", re.compile(r"[`.\"][A-Za-z0-9_]*_(19|20)\d{2}(_\d{2})?(_\*)?[`.\"\s]", re.I)),
-    ("unnest_or_flatten", re.compile(r"\bUNNEST\s*\(|\bFLATTEN\s*\(", re.I)),
-    ("struct_or_variant_access", re.compile(r'["\w\]\)]\s*:\s*["\w]|\bSTRUCT\s*<|\bSTRUCT\s*\(', re.I)),
-    ("select_star", re.compile(r"SELECT\s+(DISTINCT\s+)?\*|\.\*", re.I)),
-    ("select_star_except", re.compile(r"SELECT\s+\*\s+EXCEPT", re.I)),
-    ("cte", re.compile(r"\bWITH\b[\s\S]{0,200}?\bAS\s*\(", re.I)),
-    ("declare_script", re.compile(r"^\s*DECLARE\b", re.I | re.M)),
-    ("qualify", re.compile(r"\bQUALIFY\b", re.I)),
-]
-def evidence_flags(sql):
-    return [name for name, pat in EVIDENCE if pat.search(sql)]
-def squash_table(t):
-    return re.sub(r"[_#*]", "", t.lower())
-def same_node(a, b):
-    """Two table node names denote the same catalog node up to shard/canonical
-    naming (`incidents_2016` ~ `incidents_*`, `_2023` ~ `2023_*`)."""
-    sa, sb = squash_table(a), squash_table(b)
-    return sa == sb or sa.startswith(sb) or sb.startswith(sa)
-def shard_normalized_diff(gold, pred):
-    """Residual disagreement after allowing shard/canonical table-name variants."""
-    def covered(x, other):
-        tx, cx = x.split(".", 1)
-        return any(cx == c and same_node(tx, t) for t, c in (y.split(".", 1) for y in other))
-    missed = sorted(g for g in gold if not covered(g, pred))
-    extra = sorted(p for p in pred if not covered(p, gold))
-    return missed, extra
-def classify_parser_failure(missed, hallucinated, flags, sql, gold_tables, pred_tables):
-    """Assign ONE mechanical failure class + a human-readable reason."""
-    if not missed and not hallucinated:
-        return ("shard_family_node_naming",
-                "the parser recovers the right columns but names their table the way the SQL "
-                "writes it (a literal shard such as `incidents_2016`, or `_2023`), while the "
-                "catalog -- and therefore the schema graph a system is scored against -- "
-                "represents the whole shard family as ONE node (`INCIDENTS_*`). Resolving the "
-                "written name to the catalog node is catalog knowledge that is nowhere in the "
-                "SQL text, so a parser-only label cannot even be scored.")
-    if "unnest_or_flatten" in flags or "struct_or_variant_access" in flags:
-        return ("nested_struct_unnest_variant",
-                "the query reads nested STRUCT/VARIANT fields (UNNEST / LATERAL FLATTEN / `:` "
-                "access). `a.b` inside such a query is syntactically indistinguishable from "
-                "table `a`, column `b`; only the catalog reveals that `a` is a STRUCT column "
-                "of the base table.")
-    if "select_star_except" in flags or "select_star" in flags:
-        return ("select_star_expansion",
-                "the query pulls columns through `SELECT *` / `SELECT * EXCEPT(...)`, so the "
-                "columns it really uses are only recoverable by expanding `*` against the "
-                "table's real column list in the catalog.")
-    if any("*" in t or re.search(r"\d", t) for t in gold_tables) and (missed or hallucinated):
-        return ("shard_family_plus_column_error",
-                "the query addresses a shard family (one catalog node standing for many "
-                "physical per-day/per-year tables) AND the parser also gets the column set "
-                "wrong; neither the node identity nor the missing columns are recoverable "
-                "from the SQL text alone.")
-    if hallucinated and not missed:
-        return ("cte_or_alias_attribution",
-                "the parser attributed columns to a CTE / derived-table / alias name instead of "
-                "the underlying base table.")
-    return ("other_dialect_or_scope",
-            "residual dialect- or scope-specific resolution failure (see the missed/extra "
-            "columns and the SQL).")
-# --------------------------------------------------------------------------- #
-def main():
-    gold = json.load(open(GOLD, encoding="utf-8"))
-    data = gold["data"]
-    ids256 = {x["instance_id"] for x in json.load(open(GOLD256, encoding="utf-8"))["data"]}
-    catalogs = {}
-    rows, fail_rows, lex_rows = [], [], []
-    stats = {
-        "n_instances": len(data),
-        "n_instances_256_subset": len(ids256),
-        "n_databases": len({x["db_id"] for x in data}),
-        "n_databases_256": len({x["db_id"] for x in data if x["instance_id"] in ids256}),
-        "dialects": Counter(x["dialect"] for x in data),
-        "gold_columns_total": 0,
-        "gold_columns_out_of_catalog": 0,
-        "parser": Counter(),
-        "parser_shard_normalized": Counter(),
-        "parser_failure_classes": Counter(),
-        "parser_micro": Counter(),
-        "lexical_micro": Counter(),
-        "catalog": Counter(),
-    }
-    for x in data:
-        db = x["db_id"]
-        if db not in catalogs:
-            catalogs[db] = load_catalog(db)
-        families, phys, n_physical = catalogs[db]
-        cat_lower = {t.lower(): {c.lower() for c in cols} for t, cols in families.items()}
-        n_cat_cols = sum(len(v) for v in cat_lower.values())
-        n_cat_tables = len(cat_lower)
-        sql = x["gold_sql"]
-        g_short = [c.lower() for c in x["gold_columns_short"]]
-        gset = set(g_short)
-        gold_tables = {c.split(".")[0] for c in gset}
-        # ---- schema validity of our gold against the official catalog -------
-        invalid = []
-        for c in gset:
-            t, col = c.split(".", 1)
-            avail = {x.lower() for x in catalog_columns_for(t, phys)}
-            if col not in avail:
-                invalid.append(c)
-        stats["gold_columns_total"] += len(gset)
-        stats["gold_columns_out_of_catalog"] += len(invalid)
-        # ---- parser-only extractor -----------------------------------------
-        signal.alarm(20)
-        try:
-            r = extract(sql, x["dialect"])
-            status = r["status"]
-            pred = {p.lower() for p in r["predicted"]}
-        except TimeoutErr:
-            status, pred, r = "timeout", set(), {"unresolved": []}
-        except Exception as e:  # noqa: BLE001
-            status, pred, r = f"exception:{type(e).__name__}", set(), {"unresolved": []}
-        finally:
-            signal.alarm(0)
-        missed = sorted(gset - pred)
-        halluc = sorted(pred - gset)
-        if status != "ok":
-            cmp_ = "parse_fail"
-        elif pred == gset:
-            cmp_ = "exact"
-        elif pred < gset:
-            cmp_ = "subset"
-        elif gset < pred:
-            cmp_ = "superset"
-        else:
-            cmp_ = "differs"
-        stats["parser"][cmp_] += 1
-        stats["parser_micro"]["tp"] += len(gset & pred)
-        stats["parser_micro"]["pred"] += len(pred)
-        stats["parser_micro"]["gold"] += len(gset)
-        flags = evidence_flags(sql)
-        n_missed, n_extra = shard_normalized_diff(gset, pred)
-        norm_cmp = "exact" if (not n_missed and not n_extra) else "differs"
-        if status == "ok":
-            stats["parser_shard_normalized"][norm_cmp] += 1
-        if cmp_ == "exact":
-            fclass, freason = "", ""
-        else:
-            fclass, freason = classify_parser_failure(
-                n_missed, n_extra, flags, sql, gold_tables, {p.split(".")[0] for p in pred})
-            stats["parser_failure_classes"][fclass] += 1
-            for c in missed:
-                fail_rows.append({
-                    "instance_id": x["instance_id"], "db_id": db, "dialect": x["dialect"],
-                    "direction": "parser_MISSED_gold_column", "column": c,
-                    "failure_class": fclass, "why_the_parser_fails": freason,
-                    "question": " ".join(x["question"].split()),
-                    "gold_sql": " ".join(sql.split()),
-                })
-            for c in halluc:
-                fail_rows.append({
-                    "instance_id": x["instance_id"], "db_id": db, "dialect": x["dialect"],
-                    "direction": "parser_INVENTED_column", "column": c,
-                    "failure_class": fclass, "why_the_parser_fails": freason,
-                    "question": " ".join(x["question"].split()),
-                    "gold_sql": " ".join(sql.split()),
-                })
-        # ---- lexical / name-matching labelling rule -------------------------
-        toks = set(re.findall(r"[A-Za-z_][A-Za-z_0-9]*", sql.lower()))
-        lex = {f"{t}.{c}" for t, cols in cat_lower.items() for c in cols if c in toks}
-        ltp = len(lex & gset)
-        lp = ltp / len(lex) if lex else 0.0
-        lr = ltp / len(gset) if gset else 0.0
-        stats["lexical_micro"]["tp"] += ltp
-        stats["lexical_micro"]["pred"] += len(lex)
-        stats["lexical_micro"]["gold"] += len(gset)
-        stats["catalog"]["schema_nodes"] += n_cat_tables
-        stats["catalog"]["columns"] += n_cat_cols
-        stats["catalog"]["physical_tables"] += n_physical
-        lex_rows.append({
-            "instance_id": x["instance_id"], "db_id": db,
-            "n_catalog_schema_nodes": n_cat_tables, "n_catalog_columns": n_cat_cols,
-            "n_physical_tables": n_physical,
-            "n_our_gold_columns": len(gset),
-            "n_lexical_labels": len(lex),
-            "lexical_precision_vs_our_gold": round(lp, 4),
-            "lexical_recall_vs_our_gold": round(lr, 4),
-            "lexical_false_positives": len(lex) - ltp,
-            "example_false_positives": JOIN.join(sorted(lex - gset)[:10]),
-            "question": " ".join(x["question"].split()),
-        })
-        pp = len(gset & pred) / len(pred) if pred else 0.0
-        pr = len(gset & pred) / len(gset) if gset else 0.0
-        rows.append({
-            "instance_id": x["instance_id"],
-            "in_256_paper_set": "yes" if x["instance_id"] in ids256 else "no",
-            "db_id": db,
-            "dialect": x["dialect"],
-            "gold_sql_source": x["gold_sql_source"],
-            "question": " ".join(x["question"].split()),
-            "gold_sql": " ".join(sql.split()),
-            "sql_chars": len(sql),
-            "sql_lines": sql.count("\n") + 1,
-            "sql_constructs": JOIN.join(flags),
-            "n_catalog_tables": n_cat_tables,
-            "n_catalog_columns": n_cat_cols,
-            "our_gold_columns": JOIN.join(sorted(x["gold_columns_short"])),
-            "our_gold_columns_canonical": JOIN.join(sorted(x["gold_columns"])),
-            "n_our_gold_columns": len(gset),
-            "our_gold_columns_out_of_catalog": JOIN.join(invalid),
-            "parser_only_columns": JOIN.join(sorted(pred)),
-            "n_parser_only_columns": len(pred),
-            "parser_status": status,
-            "parser_vs_our_gold": cmp_,
-            "parser_missed_gold_columns": JOIN.join(missed),
-            "parser_invented_columns": JOIN.join(halluc),
-            "parser_precision": round(pp, 4),
-            "parser_recall": round(pr, 4),
-            "parser_vs_our_gold_shard_normalized": norm_cmp if status == "ok" else "parse_fail",
-            "parser_missed_after_shard_normalization": JOIN.join(n_missed),
-            "parser_invented_after_shard_normalization": JOIN.join(n_extra),
-            "parser_failure_class": fclass,
-            "why_the_parser_fails": freason,
-            "n_lexical_labels": len(lex),
-            "lexical_precision_vs_our_gold": round(lp, 4),
-            "lexical_recall_vs_our_gold": round(lr, 4),
-        })
-    pd.DataFrame(rows).to_csv(os.path.join(OUT, "spider2_snow_case_by_case.csv"), index=False)
-    pd.DataFrame(fail_rows).to_csv(os.path.join(OUT, "spider2_snow_parser_failures.csv"), index=False)
-    pd.DataFrame(lex_rows).to_csv(os.path.join(OUT, "spider2_snow_lexical_baseline.csv"), index=False)
-    for key in ("parser_micro", "lexical_micro"):
-        m = stats[key]
-        p = m["tp"] / m["pred"] if m["pred"] else 0.0
-        r = m["tp"] / m["gold"] if m["gold"] else 0.0
-        stats[key] = {"precision": round(p, 4), "recall": round(r, 4),
-                      "f1": round(2 * p * r / (p + r), 4) if (p + r) else 0.0,
-                      "tp": m["tp"], "pred": m["pred"], "gold": m["gold"]}
-    stats["parser_exact_match_rate"] = round(stats["parser"]["exact"] / len(data), 4)
-    per_db_cols = [sum(len(v) for v in n.values()) for n, _, _ in catalogs.values()]
-    per_db_nodes = [len(n) for n, _, _ in catalogs.values()]
-    per_db_phys = [p for _, _, p in catalogs.values()]
-    stats["catalog_per_database"] = {
-        "n_databases": len(catalogs),
-        "schema_nodes_total": sum(per_db_nodes),
-        "physical_tables_total": sum(per_db_phys),
-        "columns_total": sum(per_db_cols),
-        "columns_median": int(pd.Series(per_db_cols).median()),
-        "columns_max": int(max(per_db_cols)),
-    }
-    stats["parser_shard_normalized_exact_rate"] = round(
-        stats["parser_shard_normalized"]["exact"] / len(data), 4)
-    for k in ("dialects", "parser", "parser_shard_normalized", "parser_failure_classes", "catalog"):
-        stats[k] = dict(stats[k])
-    stats["sql_complexity"] = {
-        "median_chars": int(pd.Series([len(x["gold_sql"]) for x in data]).median()),
-        "median_lines": int(pd.Series([x["gold_sql"].count("\n") + 1 for x in data]).median()),
-        "pct_with_cte": round(100 * sum("cte" in evidence_flags(x["gold_sql"]) for x in data) / len(data), 1),
-        "pct_dialect_construct": round(100 * sum(
-            bool({"unnest_or_flatten", "struct_or_variant_access", "wildcard_or_shard_table",
-                  "qualify", "declare_script"} & set(evidence_flags(x["gold_sql"])))
-            for x in data) / len(data), 1),
-    }
-    with open(os.path.join(HERE, "..", "summary_spider2_snow.json"), "w") as f:
-        json.dump(stats, f, indent=1)
-    print(json.dumps(stats, indent=1))
-if __name__ == "__main__":
-    main()

scripts/build_spider_bird.py DELETED Viewed

@@ -1,450 +0,0 @@
-"""
-Case-by-case comparison of schema-linking GOLD LABELS on Spider dev (1034) and
-BIRD dev (1534):
-    OURS  (LLM extraction from the released gold SQL + deterministic validation)
-      vs
-    KaSLA (== CodeS lexical/name-matching labels, kasla/data/*_dev_full.json)
-Referee: an INDEPENDENT deterministic sqlglot extractor (scripts/gold_from_sql.py)
-run on the OFFICIAL benchmark SQL (from the original Spider / BIRD dev release,
-not our copy).  The same script, the same conventions and the same 1:1 question
-alignment are applied to both label sets, so any parser imperfection penalises
-both sides equally.
-Convention (stated in the paper): a label is FAITHFUL if
-  (a) the fully alias-resolved SQL literally references (table, column), or
-  (b) the query star-references the table (`SELECT *`, `SELECT t.*`, `COUNT(*)`)
-      and the column is that table's declared PRIMARY KEY  ("represent the table").
-Outputs (hf_dataset/data/):
-  spider_dev_case_by_case.csv   one row per dev question
-  bird_dev_case_by_case.csv
-  spider_dev_kasla_errors.csv   one row per WRONG gold column (either side)
-  bird_dev_kasla_errors.csv
-  summary_spider_bird.json      aggregate statistics for the README
-"""
-import json
-import os
-import re
-import sys
-from collections import Counter, defaultdict
-import pandas as pd
-import sqlglot
-import sqlglot.expressions as exp
-from sqlglot.optimizer.qualify import qualify
-HERE = os.path.dirname(os.path.abspath(__file__))
-sys.path.insert(0, HERE)
-from schema_utils import load_official_schemas  # noqa: E402
-from gold_from_sql import extract_refs  # noqa: E402
-OUT = os.environ.get("OUT_DIR", os.path.join(HERE, "..", "data"))
-# Inputs.  Third-party releases must be pointed at with environment variables;
-# our own gold labels default to their location inside this bundle.
-def _first_existing(*cands):
-    for c in cands:
-        if c and os.path.exists(c):
-            return c
-    return cands[-1]
-BUNDLE = os.path.abspath(os.path.join(HERE, "..", "..", ".."))
-SPIDER_DEV_DIR = os.environ.get("SPIDER_DEV_DIR", "spider_dev")
-BIRD_DEV_DIR = os.environ.get("BIRD_DEV_DIR", "bird_dev")
-KASLA_DATA_DIR = os.environ.get("KASLA_DATA_DIR", "kasla_data")
-OUR_GOLD_DIR = os.environ.get("OUR_GOLD_DIR",
-                              os.path.join(BUNDLE, "data", "eval", "gold_labels"))
-def _our_gold(ds, fn):
-    return _first_existing(os.path.join(OUR_GOLD_DIR, ds, fn), os.path.join(OUR_GOLD_DIR, fn))
-CFG = {
-    "spider": {
-        "tables": f"{SPIDER_DEV_DIR}/tables.json",
-        "official_dev": f"{SPIDER_DEV_DIR}/dev.json",
-        "sql_field": "query",
-        "ours": _our_gold("spider", "spider_dev_gold_final.json"),
-        "kasla": f"{KASLA_DATA_DIR}/spider_dev_full.json",
-    },
-    "bird": {
-        "tables": f"{BIRD_DEV_DIR}/dev_tables.json",
-        "official_dev": f"{BIRD_DEV_DIR}/dev.json",
-        "sql_field": "SQL",
-        "ours": _our_gold("bird", "bird_dev_gold_final.json"),
-        "kasla": f"{KASLA_DATA_DIR}/bird_dev_full.json",
-    },
-}
-JOIN = "; "
-def fmt(cols):
-    return JOIN.join(f"{t}.{c}" for t, c in sorted(cols))
-# --------------------------------------------------------------------------- #
-# SQL structure helpers
-# --------------------------------------------------------------------------- #
-def parse_structure(sql, sqlglot_schema, dialect="sqlite"):
-    """Return (tables_in_sql, join_on_keys, ok).
-    tables_in_sql : real base-table names (lower) appearing in any FROM/JOIN
-    join_on_keys  : (table, col) pairs on either side of a JOIN ... ON equality
-    """
-    try:
-        tree = sqlglot.parse_one(sql, read=dialect)
-        q = qualify(tree, schema=sqlglot_schema, dialect=dialect,
-                    validate_qualify_columns=False, expand_stars=False,
-                    infer_schema=True)
-    except Exception:
-        return set(), set(), False
-    own_alias_map = {}
-    for sel in q.find_all(exp.Select):
-        m = {}
-        for t in sel.find_all(exp.Table):
-            if t.find_ancestor(exp.Select) is sel:
-                m[(t.alias or t.name).lower()] = t.name.lower()
-        own_alias_map[sel] = m
-    tables = set()
-    for m in own_alias_map.values():
-        tables |= set(m.values())
-    def resolve(sel, alias):
-        node = sel
-        while node is not None:
-            if alias in own_alias_map.get(node, {}):
-                return own_alias_map[node][alias]
-            node = node.find_ancestor(exp.Select)
-        return None
-    keys = set()
-    for sel in q.find_all(exp.Select):
-        for j in sel.find_all(exp.Join):
-            if j.find_ancestor(exp.Select) is not sel:
-                continue
-            on = j.args.get("on")
-            if on is None:
-                continue
-            for eq in on.find_all(exp.EQ):
-                l, r = eq.this, eq.expression
-                if isinstance(l, exp.Column) and isinstance(r, exp.Column):
-                    lt = resolve(sel, (l.table or "").lower())
-                    rt = resolve(sel, (r.table or "").lower())
-                    if lt and rt:
-                        keys.add((lt, l.name.lower()))
-                        keys.add((rt, r.name.lower()))
-    return tables, keys, True
-def name_tokens(sql):
-    return set(re.findall(r"[A-Za-z_][A-Za-z_0-9]*", sql.lower()))
-# --------------------------------------------------------------------------- #
-# label readers
-# --------------------------------------------------------------------------- #
-def kasla_cols(entry):
-    tnames = [t["table_name"] for t in entry["schema"]["schema_items"]]
-    cnames = [t["column_names"] for t in entry["schema"]["schema_items"]]
-    out = []
-    for ti, _ in enumerate(entry["table_labels"]):
-        for ci, lab in enumerate(entry["column_labels"][ti]):
-            if lab == 1:
-                out.append((tnames[ti].lower(), cnames[ti][ci].lower()))
-    return out
-def our_cols(entry):
-    out = []
-    for c in entry["used_columns"]:
-        t, col = c.split(".", 1)
-        out.append((t.lower(), col.lower()))
-    return out
-# --------------------------------------------------------------------------- #
-# per-column adjudication
-# --------------------------------------------------------------------------- #
-def classify_extra(tbl, col, sch, tables_in_sql, refs, star_tables, sql, sql_lower_tokens):
-    """Classify a labelled column that the SQL does NOT justify.
-    Returns (category, explanation) or (None, None) if it is in fact excusable.
-    """
-    in_schema = tbl in sch["col_by_table_lower"] and col in sch["col_by_table_lower"][tbl]
-    if not in_schema:
-        return ("not_in_schema",
-                f"`{tbl}.{col}` is not a column of database schema `{tbl}` "
-                f"(label cannot be scored).")
-    tables_str = ", ".join(sorted(tables_in_sql)) or "(none)"
-    if tbl not in tables_in_sql:
-        # the classic lexical name-match failure
-        other = sorted({t for (t, c) in refs if c == col and t != tbl})
-        if other:
-            return ("phantom_table_name_collision",
-                    f"labels `{tbl}.{col}`, but table `{tbl}` never appears in the "
-                    f"SQL (tables used: {tables_str}). The column name `{col}` occurs "
-                    f"in the SQL only through {', '.join('`%s.%s`' % (t, col) for t in other)} "
-                    f"-> label produced by name matching across an un-queried table.")
-        if col in sql_lower_tokens:
-            return ("phantom_table_token_match",
-                    f"labels `{tbl}.{col}`, but table `{tbl}` never appears in the SQL "
-                    f"(tables used: {tables_str}); the token `{col}` occurs in the SQL "
-                    f"text only as a literal/alias/function argument, not as a column of `{tbl}`.")
-        return ("phantom_table",
-                f"labels `{tbl}.{col}`, but table `{tbl}` never appears in the SQL "
-                f"(tables used: {tables_str}) and the SQL never mentions `{col}`.")
-    if tbl in star_tables:
-        pks = sorted(sch["pk_cols_lower"].get(tbl, set()))
-        if not pks:
-            return ("star_table_pk_not_declared",
-                    f"labels `{tbl}.{col}` to represent the star-referenced table `{tbl}` "
-                    f"(`SELECT *`/`COUNT(*)`), but `{tbl}` declares NO primary key in the "
-                    f"benchmark's own tables.json, so the referee cannot confirm the choice "
-                    f"(benchmark metadata defect, not a label defect).")
-        return ("unused_column_star_table",
-                f"labels `{tbl}.{col}`; `{tbl}` is star-referenced (`SELECT *`/`COUNT(*)`) "
-                f"so only its primary key ({', '.join(pks)}) represents it, and `{col}` is "
-                f"never referenced explicitly.")
-    return ("unused_column_in_used_table",
-            f"labels `{tbl}.{col}`; table `{tbl}` IS used by the SQL but the column "
-            f"`{col}` is never referenced anywhere in it.")
-def classify_missing(tbl, col, join_keys):
-    if (tbl, col) in join_keys:
-        return ("missing_join_key",
-                f"omits `{tbl}.{col}`, which the SQL uses as a JOIN ... ON key "
-                f"(a system that fails to retrieve it cannot reproduce the join).")
-    return ("missing_referenced_column",
-            f"omits `{tbl}.{col}`, which the SQL explicitly references.")
-# --------------------------------------------------------------------------- #
-def run(ds):
-    cfg = CFG[ds]
-    schemas = load_official_schemas(cfg["tables"])
-    ours = json.load(open(cfg["ours"], encoding="utf-8"))
-    kasla = json.load(open(cfg["kasla"], encoding="utf-8"))
-    official = json.load(open(cfg["official_dev"], encoding="utf-8"))
-    assert len(ours) == len(kasla) == len(official), (len(ours), len(kasla), len(official))
-    rows, err_rows = [], []
-    stats = {
-        "dataset": ds,
-        "n_instances": len(ours),
-        "n_aligned_by_question_text": 0,
-        "parse_failures": 0,
-        "per_set": {s: Counter() for s in ("ours", "kasla")},
-        "error_categories": {s: Counter() for s in ("ours", "kasla")},
-        "verdicts": {s: Counter() for s in ("ours", "kasla")},
-        "join_keys_total": 0,
-        "join_keys_covered": {"ours": 0, "kasla": 0},
-        "micro": {s: Counter() for s in ("ours", "kasla")},
-    }
-    for i in range(len(ours)):
-        e, k, o = ours[i], kasla[i], official[i]
-        db = e["db_id"]
-        sql = o[cfg["sql_field"]]
-        sch = schemas[db]
-        aligned = e["question"].strip() == o["question"].strip()
-        stats["n_aligned_by_question_text"] += int(aligned)
-        refs, star_tables, ok, err = extract_refs(sql, sch["sqlglot_schema"])
-        tables_in_sql, join_keys, ok2 = parse_structure(sql, sch["sqlglot_schema"])
-        if not (ok and ok2):
-            stats["parse_failures"] += 1
-            continue
-        toks = name_tokens(sql)
-        # Schema-validate the parser output.  Spider/BIRD gold SQL quotes string
-        # literals with double quotes (`WHERE Airline = "JetBlue Airways"`),
-        # which ANSI SQL -- and therefore sqlglot -- reads as an IDENTIFIER.
-        # Anything the parser resolves to a name that is not a real column of
-        # that table is a parser artefact and is dropped before adjudication.
-        def valid(tc):
-            t, c = tc
-            return c in sch["col_by_table_lower"].get(t, [])
-        n_before = len(refs)
-        refs = {tc for tc in refs if valid(tc)}
-        join_keys = {tc for tc in join_keys if valid(tc)}
-        stats.setdefault("parser_artefact_refs_dropped", 0)
-        stats["parser_artefact_refs_dropped"] += n_before - len(refs)
-        # Reference answer key derived purely from the SQL.
-        #   REQUIRED : every literally referenced column, plus -- for a table
-        #              the query only star-references (`SELECT *`, `COUNT(*)`)
-        #              and that is otherwise unrepresented -- its declared PK.
-        #   ALLOWED  : REQUIRED plus the declared PK of ANY star-referenced
-        #              table (labelling it is legitimate but not obligatory).
-        # Precision is judged against ALLOWED, recall against REQUIRED, so the
-        # star convention can never penalise either label set.
-        refs_tables = {t for (t, _) in refs}
-        required = set(refs)
-        allowed = set(refs)
-        for t in star_tables:
-            pks = sch["pk_cols_lower"].get(t, set())
-            allowed |= {(t, pk) for pk in pks}
-            if t not in refs_tables:
-                required |= {(t, pk) for pk in pks}
-        sql_truth = required
-        labels = {"ours": our_cols(e), "kasla": kasla_cols(k)}
-        rec = {
-            "dataset": ds,
-            "idx": i,
-            "question_id": o.get("question_id", i),
-            "db_id": db,
-            "question": e["question"].replace("\n", " ").strip(),
-            "gold_sql": " ".join(sql.split()),
-            "n_schema_columns": sum(len(v) for v in sch["col_by_table_lower"].values()),
-            "tables_used_by_sql": "; ".join(sorted(tables_in_sql)),
-            "sql_reference_columns": fmt(required),
-            "n_sql_reference_columns": len(required),
-            "sql_optional_pk_columns": fmt(allowed - required),
-        }
-        per = {}
-        for s in ("ours", "kasla"):
-            raw = labels[s]
-            st = set(raw)
-            extra_bad, extra_expl, cats = [], [], []
-            for (t, c) in sorted(st - allowed):
-                cat, expl = classify_extra(t, c, sch, tables_in_sql, refs, star_tables, sql, toks)
-                if cat is None:
-                    continue
-                extra_bad.append(f"{t}.{c}")
-                extra_expl.append(f"[{cat}] {expl}")
-                cats.append(cat)
-                err_rows.append({
-                    "dataset": ds, "idx": i, "question_id": o.get("question_id", i),
-                    "db_id": db, "label_set": s, "error_side": "extra_column",
-                    "column": f"{t}.{c}", "error_category": cat,
-                    "explanation": expl,
-                    "question": e["question"].replace("\n", " ").strip(),
-                    "gold_sql": " ".join(sql.split()),
-                })
-            miss, miss_expl = [], []
-            for (t, c) in sorted(sql_truth - st):
-                cat, expl = classify_missing(t, c, join_keys)
-                miss.append(f"{t}.{c}")
-                miss_expl.append(f"[{cat}] {expl}")
-                cats.append(cat)
-                err_rows.append({
-                    "dataset": ds, "idx": i, "question_id": o.get("question_id", i),
-                    "db_id": db, "label_set": s, "error_side": "missing_column",
-                    "column": f"{t}.{c}", "error_category": cat,
-                    "explanation": expl,
-                    "question": e["question"].replace("\n", " ").strip(),
-                    "gold_sql": " ".join(sql.split()),
-                })
-            if len(st) == 0:
-                verdict = "UNEVALUABLE_EMPTY_GOLD"
-                cats.append("empty_gold")
-            elif not extra_bad and not miss:
-                verdict = "CORRECT"
-            elif extra_bad and miss:
-                verdict = "WRONG_extra_and_missing"
-            elif extra_bad:
-                verdict = "WRONG_extra"
-            else:
-                verdict = "WRONG_missing"
-            tp_p = len(st & allowed)
-            tp_r = len(st & required)
-            p = tp_p / len(st) if st else 0.0
-            r = tp_r / len(required) if required else 1.0
-            f1 = 2 * p * r / (p + r) if (p + r) else 0.0
-            per[s] = dict(cols=fmt(st), n=len(st), extra=extra_bad, miss=miss,
-                          expl=extra_expl + miss_expl, cats=cats, verdict=verdict, f1=f1)
-            ps = stats["per_set"][s]
-            ps["labelled_columns"] += len(raw)
-            ps["distinct_columns"] += len(st)
-            ps["faithful_columns"] += len(st) - len(extra_bad)
-            ps["unfaithful_columns"] += len(extra_bad)
-            ps["missing_columns"] += len(miss)
-            ps["empty_gold_instances"] += int(len(st) == 0)
-            ps["instances_with_extra"] += int(bool(extra_bad))
-            ps["instances_with_missing"] += int(bool(miss))
-            stats["error_categories"][s].update(cats)
-            stats["verdicts"][s][verdict] += 1
-            m = stats["micro"][s]
-            m["tp_precision"] += tp_p
-            m["tp_recall"] += tp_r
-            m["pred"] += len(st)
-            m["gold"] += len(required)
-            stats["join_keys_covered"][s] += len(join_keys & st)
-        stats["join_keys_total"] += len(join_keys)
-        rec.update({
-            "ours_columns": per["ours"]["cols"],
-            "n_ours_columns": per["ours"]["n"],
-            "kasla_columns": per["kasla"]["cols"],
-            "n_kasla_columns": per["kasla"]["n"],
-            "ours_only": fmt(set(labels["ours"]) - set(labels["kasla"])),
-            "kasla_only": fmt(set(labels["kasla"]) - set(labels["ours"])),
-            "agree": "yes" if set(labels["ours"]) == set(labels["kasla"]) else "no",
-            "ours_verdict": per["ours"]["verdict"],
-            "kasla_verdict": per["kasla"]["verdict"],
-            "ours_wrong_extra_columns": JOIN.join(per["ours"]["extra"]),
-            "kasla_wrong_extra_columns": JOIN.join(per["kasla"]["extra"]),
-            "ours_missing_columns": JOIN.join(per["ours"]["miss"]),
-            "kasla_missing_columns": JOIN.join(per["kasla"]["miss"]),
-            "kasla_error_categories": JOIN.join(sorted(set(per["kasla"]["cats"]))),
-            "kasla_error_explanation": " | ".join(per["kasla"]["expl"]),
-            "ours_error_categories": JOIN.join(sorted(set(per["ours"]["cats"]))),
-            "ours_error_explanation": " | ".join(per["ours"]["expl"]),
-            "ours_f1_vs_sql": round(per["ours"]["f1"], 4),
-            "kasla_f1_vs_sql": round(per["kasla"]["f1"], 4),
-            "closer_to_sql": ("tie" if abs(per["ours"]["f1"] - per["kasla"]["f1"]) < 1e-9
-                              else ("ours" if per["ours"]["f1"] > per["kasla"]["f1"] else "kasla")),
-            "question_text_aligned": "yes" if aligned else "no",
-        })
-        rows.append(rec)
-    df = pd.DataFrame(rows)
-    df.to_csv(os.path.join(OUT, f"{ds}_dev_case_by_case.csv"), index=False)
-    edf = pd.DataFrame(err_rows)
-    edf.to_csv(os.path.join(OUT, f"{ds}_dev_label_errors.csv"), index=False)
-    stats["closer_counts"] = dict(Counter(r["closer_to_sql"] for r in rows))
-    stats["n_disagree_instances"] = int(sum(1 for r in rows if r["agree"] == "no"))
-    for s in ("ours", "kasla"):
-        m = stats["micro"][s]
-        p = m["tp_precision"] / m["pred"] if m["pred"] else 0.0
-        r = m["tp_recall"] / m["gold"] if m["gold"] else 0.0
-        stats["micro"][s] = {
-            "precision_vs_sql": round(p, 4), "recall_vs_sql": round(r, 4),
-            "f1_vs_sql": round(2 * p * r / (p + r), 4) if (p + r) else 0.0,
-            "tp_precision": m["tp_precision"], "tp_recall": m["tp_recall"],
-            "pred": m["pred"], "gold": m["gold"],
-        }
-        stats["per_set"][s] = dict(stats["per_set"][s])
-        stats["error_categories"][s] = dict(stats["error_categories"][s])
-        stats["verdicts"][s] = dict(stats["verdicts"][s])
-    return stats, df, edf
-if __name__ == "__main__":
-    allstats = {}
-    for ds in ("spider", "bird"):
-        st, df, edf = run(ds)
-        allstats[ds] = st
-        print(f"=== {ds}: {len(df)} rows, {len(edf)} error rows")
-        print(json.dumps({k: v for k, v in st.items() if k != "diff"}, indent=1)[:3000])
-    with open(os.path.join(HERE, "..", "summary_spider_bird.json"), "w") as f:
-        json.dump(allstats, f, indent=1)
-    print("saved summary_spider_bird.json")

scripts/extractor.py DELETED Viewed

@@ -1,414 +0,0 @@
-#!/usr/bin/env python3
-"""
-Standalone sqlglot-based lineage/used-column extractor.
-No external DB schema is consulted (pure parser + scope resolution only) --
-this is the "best-effort deterministic parser baseline" the ICDE rebuttal
-compares against LLM-based extraction.
-Design (see accompanying notes):
-  - Uses sqlglot.optimizer.scope.build_scope for CTE / subquery / union / UDTF
-    (UNNEST, LATERAL FLATTEN) scope resolution (no external schema needed).
-  - For a Column node, resolves its immediate qualifier against the scope's
-    registered sources. If the source is a real base Table -> emit
-    (table_name, field). If it's a derived/CTE/subquery Scope -> recurse by
-    matching the requested output name against that scope's SELECT list
-    (also recursing through UNION branches). If it's a UDTF scope (UNNEST(...)
-    or LATERAL FLATTEN(...)) -> (heuristic) recursively resolve ALL column
-    refs found *inside* the UDTF's own argument expression, ignoring the
-    specific sub-field name asked for -- this mirrors what a human/LLM does
-    when collapsing "hits.product.v2ProductName" back to the single
-    top-level repeated/STRUCT column "hits", but is exactly the point where
-    a schema-blind parser cannot tell how deep to stop, so we log every
-    UDTF resolution as `used_udtf_heuristic=True` on the instance so we can
-    separately audit whether the *heuristic* -- not just plain parsing --
-    got the right answer.
-  - Unqualified (bare) columns: resolved only when the enclosing scope has
-    exactly one source, or when the bare name itself matches a registered
-    UDTF-source alias (self-reference to the exploded value). Otherwise
-    marked AMBIGUOUS_UNQUALIFIED (deliberately NOT guessed -- guessing was
-    tried by the project's internal pipeline and produced false positives).
-  - `SELECT *` / `t.*` anywhere in the scope tree cannot be expanded without
-    a schema -> flagged as NEEDS_SCHEMA_STAR.
-  - Multi-statement scripts (BigQuery DECLARE ... ; WITH ... SELECT ...;) are
-    split with sqlglot.parse() and every query-shaped statement is unioned.
-"""
-from __future__ import annotations
-import sys, re, json, traceback
-from dataclasses import dataclass, field as dc_field
-import sqlglot
-from sqlglot import exp
-from sqlglot.optimizer.scope import build_scope, Scope, ScopeType
-QUERY_TYPES = (exp.Select, exp.Union, exp.Except, exp.Intersect)
-UNRESOLVED_TAGS = {
-    "AMBIGUOUS_UNQUALIFIED",
-    "UNKNOWN_QUALIFIER",
-    "NEEDS_SCHEMA_STAR",
-    "UNRESOLVED_OUTPUT_NAME",
-    "UNRESOLVED_STRUCTURE",
-    "MAX_DEPTH",
-}
-class Unresolved:
-    __slots__ = ("tag", "detail")
-    def __init__(self, tag, detail=""):
-        self.tag = tag
-        self.detail = detail
-    def key(self):
-        return (self.tag, self.detail)
-    def __repr__(self):
-        return f"<{self.tag}:{self.detail}>"
-def _qual_parts(col: exp.Column):
-    """Return ordered qualifier strings (catalog, db, table) that are actually set."""
-    parts = []
-    for k in ("catalog", "db", "table"):
-        v = col.args.get(k)
-        if v:
-            parts.append(col.text(k) if hasattr(col, "text") else str(v))
-    return parts
-def _find_source(scope: Scope, alias: str):
-    """Search this scope and ancestor scopes (correlated refs) for `alias`.
-    Case-insensitive: quoted Snowflake/BigQuery identifiers preserve case in
-    sqlglot's source dict keys, but SQL identifier matching (outside a
-    case-sensitive quoted *column* comparison, which we don't attempt either)
-    should not depend on it here -- we only match alias tokens."""
-    alias_lower = alias.lower()
-    s = scope
-    seen = 0
-    while s is not None and seen < 50:
-        for k, v in s.sources.items():
-            if k.lower() == alias_lower:
-                return v, s
-        s = s.parent
-        seen += 1
-    return None, None
-def _collect_output_names(scope: Scope):
-    """Schema-free: the set of output column names a (non-UDTF) Scope could
-    produce, by reading its own SELECT list(s) (recursing through unions).
-    Returns (names:set[str] lowercased, has_star:bool)."""
-    names = set()
-    has_star = [False]
-    def rec(s):
-        if s.union_scopes:
-            for b in s.union_scopes:
-                rec(b)
-            return
-        sel = s.expression
-        if isinstance(sel, exp.Select):
-            for e in sel.selects:
-                on = e.output_name
-                if on == "*":
-                    has_star[0] = True
-                else:
-                    names.add(on.lower())
-    rec(scope)
-    return names, has_star[0]
-# BigQuery pseudo-columns: syntactically indistinguishable from a real bare
-# column reference, but never a schema column. Excluding these is still
-# "pure parsing" (fixed vocabulary of engine-reserved names, no DB access).
-BQ_PSEUDO_COLUMNS = {"_table_suffix", "_partitiontime", "_partitiondate", "_file_name", "_row_number"}
-class Extractor:
-    def __init__(self, max_depth=40, script_vars=None):
-        self.max_depth = max_depth
-        self.udtf_heuristic_used = False
-        self.star_used = False
-        self.unresolved_examples = []  # list[Unresolved]
-        self.script_vars = script_vars or set()  # DECLARE'd variable names (lowercase)
-        self.n_pseudocol_excluded = 0
-    def _add_unresolved(self, u: Unresolved):
-        if u.tag == "NEEDS_SCHEMA_STAR":
-            self.star_used = True
-        if len(self.unresolved_examples) < 200:
-            self.unresolved_examples.append(u)
-        return {u}
-    def resolve_column(self, scope: Scope, col: exp.Column, depth=0):
-        if depth > self.max_depth:
-            return self._add_unresolved(Unresolved("MAX_DEPTH", col.sql()))
-        parts = _qual_parts(col)
-        name = col.name
-        if not parts:
-            return self.resolve_unqualified(scope, name, col, depth)
-        # try leftmost qualifier first (struct-dot chains: alias.field1.field2...)
-        alias = parts[0].lower()
-        src, found_scope = _find_source(scope, alias)
-        remaining_field = parts[1] if len(parts) >= 2 else name
-        if src is None and len(parts) >= 2:
-            # fallback: try the qualifier immediately left of the column name
-            alias2 = parts[-1].lower()
-            src, found_scope = _find_source(scope, alias2)
-            remaining_field = name
-        if src is None:
-            return self._add_unresolved(
-                Unresolved("UNKNOWN_QUALIFIER", f"{'.'.join(parts)}.{name}")
-            )
-        return self.resolve_source(found_scope, src, remaining_field, depth)
-    def resolve_unqualified(self, scope: Scope, name: str, col: exp.Column, depth):
-        nl = name.lower()
-        if nl in BQ_PSEUDO_COLUMNS or nl in self.script_vars:
-            self.n_pseudocol_excluded += 1
-            return set()
-        # (a) GROUP BY / HAVING / QUALIFY reference to an output alias of this
-        # same scope -> not a base column at all.
-        ancestor = col.find_ancestor(exp.Group, exp.Having, exp.Qualify)
-        if ancestor is not None:
-            sel = scope.expression
-            if isinstance(sel, exp.Select):
-                named = {n.lower() for n in sel.named_selects}
-                if name.lower() in named:
-                    return set()
-        # (b) bare name that is itself a registered source alias (self-ref to
-        # an UNNEST/LATERAL-FLATTEN exploded value, e.g. `WHERE hits IS NOT NULL`)
-        direct_src, direct_scope = _find_source(scope, name)
-        if direct_src is not None and name.lower() in {k.lower() for k in scope.sources}:
-            return self.resolve_source(scope, direct_src, None, depth)
-        # (c) exactly one source in scope -> unambiguous
-        if len(scope.sources) == 1:
-            only_src = next(iter(scope.sources.values()))
-            return self.resolve_source(scope, only_src, name, depth)
-        # (c2) >1 sources, but only-parser-visible info (each derived/CTE
-        # source's own SELECT-list output names, still schema-free) rules out
-        # all but one candidate -- Table/UDTF sources are always "maybe"
-        # since their real columns are unknown to us.
-        candidates = []
-        for alias, src in scope.sources.items():
-            if isinstance(src, Scope) and src.scope_type != ScopeType.UDTF:
-                names, has_star = _collect_output_names(src)
-                if has_star or name.lower() in names:
-                    candidates.append((alias, src))
-            else:
-                candidates.append((alias, src))
-        if len(candidates) == 1:
-            return self.resolve_source(scope, candidates[0][1], name, depth)
-        # (d) ambiguous / needs schema to disambiguate among >1 sources, or
-        # zero sources (correlated ref we couldn't find) -> honest failure
-        return self._add_unresolved(
-            Unresolved(
-                "AMBIGUOUS_UNQUALIFIED",
-                f"{name} (n_sources={len(scope.sources)}, n_candidates={len(candidates)})",
-            )
-        )
-    def resolve_source(self, scope: Scope, src, field, depth):
-        if isinstance(src, exp.Table):
-            base = src.name  # last identifier, literal case & any '*' wildcard preserved
-            if field is None:
-                return self._add_unresolved(Unresolved("UNRESOLVED_STRUCTURE", f"bare table ref {base}"))
-            return {(base, field)}
-        if isinstance(src, Scope):
-            if src.scope_type == ScopeType.UDTF:
-                self.udtf_heuristic_used = True
-                out = set()
-                cols = list(src.columns)
-                if not cols:
-                    # literal array e.g. UNNEST([1,2,3]) -- no schema column involved
-                    return set()
-                for c in cols:
-                    out |= self.resolve_column(src, c, depth + 1)
-                return out
-            # CTE / DERIVED_TABLE / SUBQUERY / ROOT-as-subsource
-            if field is None:
-                return self._add_unresolved(Unresolved("UNRESOLVED_STRUCTURE", "bare derived-table ref"))
-            return self.resolve_output_name(src, field, depth)
-        return self._add_unresolved(Unresolved("UNRESOLVED_STRUCTURE", f"unknown source type {type(src)}"))
-    def resolve_output_name(self, scope: Scope, field: str, depth):
-        if depth > self.max_depth:
-            return self._add_unresolved(Unresolved("MAX_DEPTH", field))
-        if scope.union_scopes:
-            out = set()
-            for branch in scope.union_scopes:
-                out |= self.resolve_output_name(branch, field, depth + 1)
-            return out
-        sel = scope.expression
-        if not isinstance(sel, exp.Select):
-            return self._add_unresolved(Unresolved("UNRESOLVED_STRUCTURE", f"non-select scope for field {field}"))
-        target_expr = None
-        has_star = False
-        for e in sel.selects:
-            oname = e.output_name
-            if oname == "*":
-                has_star = True
-                continue
-            if oname.lower() == field.lower():
-                target_expr = e
-                break
-        if target_expr is None:
-            if has_star:
-                return self._add_unresolved(Unresolved("NEEDS_SCHEMA_STAR", f"field '{field}' via SELECT *"))
-            return self._add_unresolved(
-                Unresolved("UNRESOLVED_OUTPUT_NAME", f"field '{field}' not found in select list")
-            )
-        actual = target_expr.this if isinstance(target_expr, exp.Alias) else target_expr
-        col_ids = {id(c) for c in actual.find_all(exp.Column)}
-        if not col_ids:
-            # literal / constant projection (e.g. 'Daily' AS time_type) -> no base column
-            return set()
-        relevant = [c for c in scope.columns if id(c) in col_ids]
-        if not relevant:
-            # columns exist in the expr but scope.columns filtered them out
-            # (can happen for expressions only reachable via nested subquery);
-            # fall back to raw walk, best-effort.
-            relevant = list(actual.find_all(exp.Column))
-        out = set()
-        for c in relevant:
-            out |= self.resolve_column(scope, c, depth + 1)
-        return out
-    # ---- top-level scope tree walk: collect every Column reference in every
-    # scope (this is what "the SQL touches"), plus flag every bare `SELECT *`
-    def walk_query(self, root: Scope):
-        results = set()
-        seen_scope_ids = set()
-        def rec(scope):
-            if id(scope) in seen_scope_ids:
-                return
-            seen_scope_ids.add(id(scope))
-            if scope.stars:
-                self.star_used = True
-            for c in scope.columns:
-                results.update(self.resolve_column(scope, c, 0))
-            for child in (
-                scope.cte_scopes
-                + scope.derived_table_scopes
-                + scope.subquery_scopes
-                + scope.udtf_scopes
-                + scope.union_scopes
-            ):
-                rec(child)
-        rec(root)
-        return results
-def normalize_table_col(pair):
-    """Lowercase both sides; this is the comparison key vs gold_columns_short
-    (which is already 'TABLE.COLUMN', case varies by source dialect)."""
-    t, c = pair
-    return f"{t.lower()}.{c.lower()}"
-def extract(sql: str, dialect: str):
-    """Returns dict: status, predicted:set[str] (lower table.col), unresolved:list[(tag,detail)],
-    has_star, used_udtf_heuristic, error (if parse_error), n_statements."""
-    try:
-        stmts = sqlglot.parse(sql, dialect=dialect)
-    except Exception as e:
-        return {
-            "status": "parse_error",
-            "error": f"{type(e).__name__}: {e}",
-            "predicted": set(),
-            "unresolved": [],
-            "has_star": False,
-            "used_udtf_heuristic": False,
-        }
-    script_vars = set()
-    for stmt in stmts:
-        if isinstance(stmt, exp.Declare):
-            for item in stmt.expressions:
-                for ident in item.args.get("this") or []:
-                    nm = ident.name if hasattr(ident, "name") else str(ident)
-                    script_vars.add(nm.lower())
-    ex = Extractor(script_vars=script_vars)
-    predicted_pairs = set()
-    n_query_stmts = 0
-    hard_error = None
-    for stmt in stmts:
-        if stmt is None:
-            continue
-        # find any query-shaped sub-root (handles CREATE TABLE AS SELECT etc.)
-        query_nodes = []
-        if isinstance(stmt, QUERY_TYPES):
-            query_nodes.append(stmt)
-        else:
-            query_nodes.extend(stmt.find_all(*QUERY_TYPES))
-            # avoid double-descending into nested selects that are already
-            # reachable as subqueries of a top query node we already added
-        # de-dup: keep only outermost query nodes (no query_node has another
-        # query_node as an ancestor within this list)
-        outer = []
-        for q in query_nodes:
-            if not any(q is not other and q.find_ancestor(type(other)) is other for other in query_nodes):
-                outer.append(q)
-        if not outer and query_nodes:
-            outer = query_nodes[:1]
-        for q in outer:
-            n_query_stmts += 1
-            try:
-                root_scope = build_scope(q)
-                if root_scope is None:
-                    hard_error = "build_scope returned None"
-                    continue
-                predicted_pairs |= ex.walk_query(root_scope)
-            except Exception as e:
-                hard_error = f"{type(e).__name__}: {e}\n{traceback.format_exc(limit=3)}"
-    if n_query_stmts == 0:
-        return {
-            "status": "parse_error",
-            "error": "no query-shaped statement found (only DECLARE/SET/etc.)",
-            "predicted": set(),
-            "unresolved": [],
-            "has_star": ex.star_used,
-            "used_udtf_heuristic": ex.udtf_heuristic_used,
-        }
-    predicted = set()
-    real_pairs = set()
-    unresolved_tags = []
-    for item in predicted_pairs:
-        if isinstance(item, Unresolved):
-            unresolved_tags.append((item.tag, item.detail))
-        else:
-            real_pairs.add(item)
-            predicted.add(normalize_table_col(item))
-    status = "scope_error" if hard_error and not real_pairs and not unresolved_tags else "ok"
-    return {
-        "status": status,
-        "error": hard_error,
-        "predicted": predicted,
-        "predicted_pairs": real_pairs,
-        "unresolved": unresolved_tags,
-        "has_star": ex.star_used,
-        "used_udtf_heuristic": ex.udtf_heuristic_used,
-        "n_pseudocol_excluded": ex.n_pseudocol_excluded,
-    }
-if __name__ == "__main__":
-    # quick smoke test
-    tests = [
-        ("SELECT a, b.c FROM t1 AS b JOIN t2 ON b.c = t2.id", "bigquery"),
-        (
-            "WITH v AS (SELECT x, y FROM t) SELECT x FROM v",
-            "bigquery",
-        ),
-    ]
-    for sql, d in tests:
-        r = extract(sql, d)
-        print(sql, "->", r["status"], sorted(r["predicted"]), r["unresolved"])

scripts/gold_from_sql.py DELETED Viewed

@@ -1,131 +0,0 @@
-"""
-Extract the set of (table, column) references actually used in a gold SQL
-query, using sqlglot's schema-aware qualifier (alias resolution + unqualified
-column disambiguation). Applies the convention:
-  a column counts as "referenced" if:
-    (a) it appears literally as table.column somewhere in the (fully
-        alias-resolved) query, OR
-    (b) it is the declared PRIMARY KEY of a table that is star-referenced,
-        i.e. the query contains `SELECT *` / `SELECT t.*` / `COUNT(*)`
-        over that table's FROM-scope (handles BIRD/Spider's common
-        `SELECT COUNT(*) FROM t` -> gold includes t's PK convention).
-All matching is done case-insensitively (lower-cased table & column names).
-"""
-import sqlglot
-import sqlglot.expressions as exp
-from sqlglot.optimizer.qualify import qualify
-class SqlExtractionError(Exception):
-    pass
-def _scope_from_tables(select_node, alias_to_table):
-    """Real (lower-cased) table names directly in this SELECT's FROM/JOIN
-    (not walking into subqueries)."""
-    tables = set()
-    from_ = select_node.args.get("from")
-    if from_ is not None:
-        for t in from_.find_all(exp.Table):
-            if t.find_ancestor(exp.Select) is select_node:
-                tables.add(t.name.lower())
-    for j in select_node.args.get("joins") or []:
-        for t in j.find_all(exp.Table):
-            if t.find_ancestor(exp.Select) is select_node:
-                tables.add(t.name.lower())
-    return tables
-def extract_refs(sql, sqlglot_schema, dialect="sqlite"):
-    """
-    Returns (refs, star_tables, ok, err)
-      refs: set of (table_lower, column_lower) literally referenced
-      star_tables: set of table_lower that appear in a `SELECT *` / `t.*` /
-                   `COUNT(*)` construct (star-convention eligible)
-      ok: bool, whether parsing+qualification succeeded
-      err: exception message if not ok
-    """
-    try:
-        tree = sqlglot.parse_one(sql, read=dialect)
-        q = qualify(
-            tree,
-            schema=sqlglot_schema,
-            dialect=dialect,
-            validate_qualify_columns=False,
-            expand_stars=False,
-            infer_schema=True,
-        )
-    except Exception as e:  # noqa: BLE001
-        return set(), set(), False, f"{type(e).__name__}: {e}"
-    # Build a per-Select alias->real-table map (own FROM/JOIN tables only),
-    # then resolve a column's table alias by walking UP the chain of
-    # enclosing SELECTs -- required for correlated subqueries, e.g.
-    # `... WHERE EXISTS (SELECT 1 FROM b WHERE b.x = t1.y)` where `t1` is
-    # only defined in the OUTER select's FROM.
-    own_alias_map = {}
-    for select_node in q.find_all(exp.Select):
-        alias_to_table = {}
-        for t in select_node.find_all(exp.Table):
-            if t.find_ancestor(exp.Select) is select_node:
-                alias = (t.alias or t.name).lower()
-                alias_to_table[alias] = t.name.lower()
-        own_alias_map[select_node] = alias_to_table
-    def resolve_alias(select_node, alias):
-        node = select_node
-        while node is not None:
-            m = own_alias_map.get(node, {})
-            if alias in m:
-                return m[alias]
-            node = node.find_ancestor(exp.Select)
-        return None
-    refs = set()
-    star_tables = set()
-    for select_node in q.find_all(exp.Select):
-        alias_to_table = own_alias_map[select_node]
-        scope_tables = _scope_from_tables(select_node, alias_to_table)
-        for col in select_node.find_all(exp.Column):
-            # only count columns belonging to this scope (not nested selects)
-            owning_select = col.find_ancestor(exp.Select)
-            if owning_select is not select_node:
-                continue
-            cname = col.name
-            tbl_alias = (col.table or "").lower()
-            if cname == "*":
-                if tbl_alias:
-                    resolved = resolve_alias(select_node, tbl_alias)
-                    star_tables.add(resolved if resolved else tbl_alias)
-                else:
-                    star_tables |= scope_tables
-                continue
-            if tbl_alias:
-                resolved = resolve_alias(select_node, tbl_alias)
-                refs.add((resolved if resolved else tbl_alias, cname.lower()))
-            else:
-                # unqualified after qualify() should not normally happen,
-                # but fall back to crediting every scope table that has it
-                for tl in scope_tables:
-                    refs.add((tl, cname.lower()))
-        # bare Star directly in select-list (SELECT *) or inside COUNT(*)
-        for star in select_node.find_all(exp.Star):
-            owning_select = star.find_ancestor(exp.Select)
-            if owning_select is not select_node:
-                continue
-            if isinstance(star.parent, exp.Column):
-                continue  # handled above via Column(name='*')
-            star_tables |= scope_tables
-    return refs, star_tables, True, None
-def is_faithful(table_lower, column_lower, refs, star_tables, pk_cols_lower):
-    if (table_lower, column_lower) in refs:
-        return True, "literal"
-    if table_lower in star_tables and column_lower in pk_cols_lower.get(table_lower, set()):
-        return True, "star+pk"
-    return False, None

scripts/make_summary_and_xlsx.py DELETED Viewed

@@ -1,102 +0,0 @@
-"""Build summary_statistics.csv (machine-readable headline table) and one
-Excel workbook holding every case-by-case sheet."""
-import json
-import os
-import pandas as pd
-HERE = os.path.dirname(os.path.abspath(__file__))
-ROOT = os.path.join(HERE, "..")
-DATA = os.path.join(ROOT, "data")
-sb = json.load(open(os.path.join(ROOT, "summary_spider_bird.json")))
-sn = json.load(open(os.path.join(ROOT, "summary_spider2_snow.json")))
-rows = []
-def add(dataset, metric, ours, kasla="", note=""):
-    rows.append({"dataset": dataset, "metric": metric, "ours": ours,
-                 "kasla_codes_labels": kasla, "note": note})
-for ds, name in (("spider", "Spider dev (1034)"), ("bird", "BIRD dev (1534)")):
-    s = sb[ds]
-    o, k = s["per_set"]["ours"], s["per_set"]["kasla"]
-    n = s["n_instances"]
-    jt = s["join_keys_total"]
-    add(name, "questions", n, n)
-    add(name, "gold columns labelled", o["labelled_columns"], k["labelled_columns"])
-    add(name, "avg gold columns / question",
-        round(o["labelled_columns"] / n, 3), round(k["labelled_columns"] / n, 3))
-    add(name, "SQL-faithful gold columns (%)",
-        f'{100*o["faithful_columns"]/o["labelled_columns"]:.2f}% ({o["faithful_columns"]}/{o["labelled_columns"]})',
-        f'{100*k["faithful_columns"]/k["labelled_columns"]:.2f}% ({k["faithful_columns"]}/{k["labelled_columns"]})',
-        "column is provably referenced by the released gold SQL")
-    add(name, "gold columns NOT in the SQL", o["unfaithful_columns"], k["unfaithful_columns"])
-    add(name, "SQL-referenced columns MISSING from gold", o["missing_columns"], k["missing_columns"])
-    add(name, "questions with >=1 wrong gold column",
-        f'{o["instances_with_extra"]} ({100*o["instances_with_extra"]/n:.2f}%)',
-        f'{k["instances_with_extra"]} ({100*k["instances_with_extra"]/n:.2f}%)')
-    add(name, "questions with an EMPTY gold set",
-        f'{o["empty_gold_instances"]} ({100*o["empty_gold_instances"]/n:.2f}%)',
-        f'{k["empty_gold_instances"]} ({100*k["empty_gold_instances"]/n:.2f}%)',
-        "empty gold = the question cannot be scored at column level")
-    add(name, "JOIN-key completeness",
-        f'{100*s["join_keys_covered"]["ours"]/jt:.2f}% ({s["join_keys_covered"]["ours"]}/{jt})',
-        f'{100*s["join_keys_covered"]["kasla"]/jt:.2f}% ({s["join_keys_covered"]["kasla"]}/{jt})')
-    add(name, "micro precision vs the SQL", sb[ds]["micro"]["ours"]["precision_vs_sql"],
-        sb[ds]["micro"]["kasla"]["precision_vs_sql"])
-    add(name, "micro recall vs the SQL", sb[ds]["micro"]["ours"]["recall_vs_sql"],
-        sb[ds]["micro"]["kasla"]["recall_vs_sql"])
-    add(name, "questions whose gold set is fully correct",
-        f'{s["verdicts"]["ours"].get("CORRECT", 0)} ({100*s["verdicts"]["ours"].get("CORRECT", 0)/n:.1f}%)',
-        f'{s["verdicts"]["kasla"].get("CORRECT", 0)} ({100*s["verdicts"]["kasla"].get("CORRECT", 0)/n:.1f}%)')
-    add(name, "questions where the two label sets disagree", s["n_disagree_instances"],
-        s["n_disagree_instances"], "closer to the SQL: ours "
-        f'{s["closer_counts"].get("ours", 0)} / KaSLA {s["closer_counts"].get("kasla", 0)}')
-name = "Spider 2.0-Snow (282)"
-add(name, "questions", sn["n_instances"], "n/a", "KaSLA/CodeS release no labels for Spider 2.0")
-add(name, "databases", sn["n_databases"], "n/a")
-add(name, "gold columns labelled", sn["gold_columns_total"], "n/a")
-add(name, "gold columns not found in the official catalog",
-    sn["gold_columns_out_of_catalog"], "n/a", "0 = every label names a real catalog column")
-add(name, "median catalog columns / database", sn["catalog_per_database"]["columns_median"], "n/a")
-add(name, "max catalog columns / database", sn["catalog_per_database"]["columns_max"], "n/a")
-add(name, "parser-only extractor: exact set match",
-    f'{100*sn["parser_exact_match_rate"]:.1f}%', "n/a", "sqlglot, alias/CTE/UNNEST aware")
-add(name, "parser-only extractor: exact match after shard-name normalisation",
-    f'{100*sn["parser_shard_normalized_exact_rate"]:.1f}%', "n/a")
-add(name, "parser-only extractor: micro F1 vs our gold", sn["parser_micro"]["f1"], "n/a")
-add(name, "name-matching (lexical) labelling rule: micro precision",
-    sn["lexical_micro"]["precision"], "n/a", "the KaSLA/CodeS-style rule simulated on Snow")
-add(name, "name-matching (lexical) labelling rule: micro recall",
-    sn["lexical_micro"]["recall"], "n/a")
-add(name, "median gold SQL length (chars / lines)",
-    f'{sn["sql_complexity"]["median_chars"]} / {sn["sql_complexity"]["median_lines"]}', "n/a")
-add(name, "gold SQL using CTEs / dialect constructs (%)",
-    f'{sn["sql_complexity"]["pct_with_cte"]}% / {sn["sql_complexity"]["pct_dialect_construct"]}%', "n/a")
-pd.DataFrame(rows).to_csv(os.path.join(DATA, "summary_statistics.csv"), index=False)
-SHEETS = [
-    ("summary_statistics", "summary_statistics.csv"),
-    ("spider_case_by_case", "spider_dev_case_by_case.csv"),
-    ("spider_label_errors", "spider_dev_label_errors.csv"),
-    ("bird_case_by_case", "bird_dev_case_by_case.csv"),
-    ("bird_label_errors", "bird_dev_label_errors.csv"),
-    ("snow_case_by_case", "spider2_snow_case_by_case.csv"),
-    ("snow_parser_failures", "spider2_snow_parser_failures.csv"),
-    ("snow_lexical_baseline", "spider2_snow_lexical_baseline.csv"),
-]
-xlsx = os.path.join(ROOT, "gold_label_quality_comparison.xlsx")
-with pd.ExcelWriter(xlsx, engine="openpyxl") as w:
-    for sheet, fn in SHEETS:
-        df = pd.read_csv(os.path.join(DATA, fn))
-        for c in df.columns:
-            if df[c].dtype == object:
-                df[c] = df[c].astype(str).str.slice(0, 32000)
-        df.to_excel(w, sheet_name=sheet, index=False)
-print("wrote", xlsx, os.path.getsize(xlsx) / 1e6, "MB")
-print(pd.DataFrame(rows).to_string(max_colwidth=60))

scripts/parser_control_spider.py DELETED Viewed

@@ -1,69 +0,0 @@
-"""Control for the Spider 2.0-Snow parser study: run the SAME parser-only
-extractor on all 1,034 Spider dev queries against our Spider gold labels.  If
-the extractor is strong on conventional SQLite SQL, its collapse on Spider 2.0
-is a property of the benchmark, not of a weak extractor."""
-import json
-import os
-import signal
-import sys
-HERE = os.path.dirname(os.path.abspath(__file__))
-sys.path.insert(0, HERE)
-from extractor import extract  # noqa: E402
-BUNDLE = os.path.abspath(os.path.join(HERE, "..", "..", ".."))
-OUR_GOLD_DIR = os.environ.get("OUR_GOLD_DIR",
-                              os.path.join(BUNDLE, "data", "eval", "gold_labels"))
-SPIDER = next(p for p in (os.path.join(OUR_GOLD_DIR, "spider", "spider_dev_gold_final.json"),
-                          os.path.join(OUR_GOLD_DIR, "spider_dev_gold_final.json"))
-              if os.path.exists(p))
-class T(Exception):
-    pass
-signal.signal(signal.SIGALRM, lambda *a: (_ for _ in ()).throw(T()))
-data = json.load(open(SPIDER, encoding="utf-8"))
-n = exact = exact_excl_conv = fail = 0
-tp = pred_n = gold_n = 0
-n_conv = 0
-for x in data:
-    gold = {c.lower() for c in x["used_columns"]}
-    signal.alarm(15)
-    try:
-        r = extract(x["SQL"], "sqlite")
-        pred = {p.lower() for p in r["predicted"]}
-        ok = r["status"] == "ok"
-    except Exception:
-        pred, ok = set(), False
-    finally:
-        signal.alarm(0)
-    n += 1
-    if not ok:
-        fail += 1
-    conv = "count_star" in (x.get("label_source") or "") or "pk_injected" in (x.get("label_source") or "")
-    n_conv += int(conv)
-    if pred == gold:
-        exact += 1
-        exact_excl_conv += 0 if conv else 1
-    elif not conv:
-        pass
-    tp += len(pred & gold)
-    pred_n += len(pred)
-    gold_n += len(gold)
-p = tp / pred_n
-r_ = tp / gold_n
-print(json.dumps({
-    "n": n,
-    "parse_failures": fail,
-    "exact_set_match": round(exact / n, 4),
-    "exact_set_match_excluding_count_star_convention": round(
-        (exact - (exact - exact_excl_conv)) / (n - n_conv), 4),
-    "n_count_star_convention_instances": n_conv,
-    "micro_precision": round(p, 4),
-    "micro_recall": round(r_, 4),
-    "micro_f1": round(2 * p * r_ / (p + r_), 4),
-}, indent=1))

scripts/reproduce.sh DELETED Viewed

@@ -1,21 +0,0 @@
-#!/usr/bin/env bash
-# Rebuild every CSV / XLSX in this folder from the public inputs.
-#
-# Inputs (override with environment variables):
-#   SPIDER_DEV_DIR        official Spider dev release   (dev.json, tables.json)
-#   BIRD_DEV_DIR          official BIRD dev release     (dev.json, dev_tables.json)
-#   KASLA_DATA_DIR        KaSLA released labels         (spider_dev_full.json, bird_dev_full.json)
-#   OUR_GOLD_DIR          our gold labels               (spider/, bird/  -> *_dev_gold_final.json)
-#   SNOW_GOLD_DIR         our Spider 2.0-Snow gold      (spider2_snow_eval_gold*.json)
-#   SPIDER2_RESOURCE_DIR  official Spider 2.0-Snow catalog (resource/databases)
-#
-# Requires: python>=3.9, sqlglot, pandas, openpyxl.
-set -euo pipefail
-cd "$(dirname "$0")/scripts"
-python build_spider_bird.py          # Spider dev + BIRD dev, ours vs KaSLA
-python build_spider2_snow.py         # Spider 2.0-Snow validation + parser + lexical baseline
-python parser_control_spider.py > ../parser_control_spider.json   # parser control on Spider
-python make_summary_and_xlsx.py      # summary_statistics.csv + the Excel workbook
-echo "done -- outputs in ../data/ and ../gold_label_quality_comparison.xlsx"

scripts/schema_utils.py DELETED Viewed

@@ -1,68 +0,0 @@
-"""Load official Spider-format schema files (dev_tables.json / tables.json) into
-per-db lookup structures used by gold_from_sql.py."""
-import json
-def load_official_schemas(tables_json_path):
-    tables = json.load(open(tables_json_path, encoding="utf-8"))
-    schemas = {}
-    for t in tables:
-        db_id = t["db_id"]
-        tno = t["table_names_original"]
-        cno = t["column_names_original"]  # list of [table_idx, col_name], idx -1 = "*"
-        pk = t.get("primary_keys", [])
-        fk = t.get("foreign_keys", [])
-        tables_lower = [x.lower() for x in tno]
-        col_by_table_lower = {tl: [] for tl in tables_lower}
-        # global column index -> (table_lower, col_lower)
-        idx_to_tc = {}
-        for gi, (tidx, cname) in enumerate(cno):
-            if tidx == -1:
-                continue
-            tl = tables_lower[tidx]
-            cl = cname.lower()
-            col_by_table_lower[tl].append(cl)
-            idx_to_tc[gi] = (tl, cl)
-        pk_cols_lower = {tl: set() for tl in tables_lower}
-        for p in pk:
-            if isinstance(p, list):
-                for gi in p:
-                    if gi in idx_to_tc:
-                        tl, cl = idx_to_tc[gi]
-                        pk_cols_lower[tl].add(cl)
-            else:
-                if p in idx_to_tc:
-                    tl, cl = idx_to_tc[p]
-                    pk_cols_lower[tl].add(cl)
-        fk_pairs = []
-        for a, b in fk:
-            if a in idx_to_tc and b in idx_to_tc:
-                fk_pairs.append((idx_to_tc[a], idx_to_tc[b]))
-        # schema dict for sqlglot qualify: {table_name: {col_name: type}}
-        # use the ORIGINAL table name (not lowercased) as key since sqlglot
-        # lowercases identifiers internally when unquoted/lowercase already;
-        # we build using lower-cased keys throughout for robustness against
-        # case mismatches between SQL text and catalog.
-        sqlglot_schema = {}
-        for tl in tables_lower:
-            sqlglot_schema[tl] = {c: "TEXT" for c in col_by_table_lower[tl]}
-        # add rowid-ish alias columns some sqlite BIRD dbs implicitly allow (rare) -- skip
-        schemas[db_id] = {
-            "tables_lower": tables_lower,
-            "col_by_table_lower": col_by_table_lower,
-            "pk_cols_lower": pk_cols_lower,
-            "fk_pairs": fk_pairs,
-            "sqlglot_schema": sqlglot_schema,
-        }
-    return schemas
-if __name__ == "__main__":
-    import sys
-    s = load_official_schemas(sys.argv[1])   # e.g. .../bird/dev/dev_tables.json
-    print(len(s), list(s.keys())[:3])