{"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"name":"python","version":"3.13.15","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat_minor":5,"nbformat":4,"cells":[{"id":"cell-00","cell_type":"markdown","source":"# SynSQL-2.5M subset selection\n\nProfiles, validates and selects a subset of SynSQL-2.5M to join BIRD + Spider in the v2 fine-tune of Qwen3.5-4B and Qwen3.5-9B. SynSQL is compared against the BIRD and Spider train sets. The selection has two parts: size bands with large schemas that still fit `MAX_SEQ_LENGTH` for both models, and an extra pool with the queries that use names needing quotes, which in SynSQL are mostly reserved words and leading digits.\n\n- **Runs on:** Kaggle, CPU session with Internet enabled and an `HF_TOKEN` secret (no GPU needed)\n- **Python:** 3.11\n- **Last adjusted:** 2026","metadata":{}},{"id":"cell-01","cell_type":"code","source":"%pip install -q -U ijson \"transformers>=5.5\" datasets","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T00:48:15.667000Z","iopub.execute_input":"2026-10-20T00:48:15.667508Z","iopub.status.idle":"2026-10-20T00:48:53.577732Z","shell.execute_reply.started":"2026-10-20T00:48:15.667456Z","shell.execute_reply":"2026-10-20T00:48:53.576204Z"}},"outputs":[{"name":"stdout","text":"\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m150.2/150.2 kB\u001b[0m \u001b[31m3.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0mta \u001b[36m0:00:01\u001b[0m\n\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m12.8/12.8 MB\u001b[0m \u001b[31m51.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0mm\n\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m604.4/604.4 kB\u001b[0m \u001b[31m13.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m\n\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m53.9/53.9 MB\u001b[0m \u001b[31m25.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m:00:01\u001b[0m00:01\u001b[0m\n\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m846.4/846.4 kB\u001b[0m \u001b[31m7.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m:00:01\u001b[0m\n\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\nbigframes 2.48.0 requires google-cloud-bigquery-storage<3.0.0,>=2.30.0, which is not installed.\u001b[0m\u001b[31m\n\u001b[0mNote: you may need to restart the kernel to use updated packages.\n","output_type":"stream"}],"execution_count":1},{"id":"cell-02","cell_type":"code","source":"import hashlib\nimport os\nimport re\nimport shutil\nimport sqlite3\nimport subprocess\nimport sys\nimport time\nimport zipfile\nfrom collections import Counter\nfrom functools import lru_cache\nfrom pathlib import Path\n\nimport ijson\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nfrom datasets import load_dataset\nfrom huggingface_hub import hf_hub_download\nfrom IPython.display import display\nfrom kaggle_secrets import UserSecretsClient\nfrom tqdm.auto import tqdm\nfrom transformers import AutoTokenizer\n\nPath(\"requirements.txt\").write_text(\n    subprocess.run([sys.executable, \"-m\", \"pip\", \"freeze\"], capture_output=True, text=True).stdout\n)\npd.set_option(\"display.max_colwidth\", 120)\nos.environ[\"HF_TOKEN\"] = UserSecretsClient().get_secret(\"HF_TOKEN\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T00:48:53.580988Z","iopub.execute_input":"2026-10-20T00:48:53.581921Z","iopub.status.idle":"2026-10-20T00:49:30.843781Z","shell.execute_reply.started":"2026-10-20T00:48:53.581869Z","shell.execute_reply":"2026-10-20T00:49:30.842424Z"}},"outputs":[],"execution_count":2},{"id":"cell-03","cell_type":"code","source":"SYNSQL_REPO = \"seeklhy/SynSQL-2.5M\"\nBIRD_TRAIN_REPO = \"EuricoGVP/birdsql_complete_trainset\"\nSPIDER_REPO = \"EuricoGVP/spider_sql_complete\"\nSPIDER_EXCLUDED_DBS = [\"formula_1\"]\nTOKENIZER_NAMES = [\"Qwen/Qwen3.5-4B\", \"Qwen/Qwen3.5-9B\"]\n\nDATA_DIR = Path(\"/tmp/synsql\")\nOUTPUT_DIR = Path(\"/kaggle/working\")\n\nMAX_SEQ_LENGTH = 4096\nBAND_START_QUANTILE = 0.75\nN_BANDS = 4\nTARGET_SIZE = 2000\nCANDIDATES_PER_DB = 5\nEXCLUDED_STYLES = [\"Multi-turn Dialogue\"]\nQUOTED_EXTRA_PER_DB = 3\nSQL_TIMEOUT_SECONDS = 5\nSEED = 42\n\nQUOTING_REASONS = [\"space\", \"special_character\", \"leading_digit\", \"reserved_word\"]\nQUOTE_PATTERNS = {\"backtick\": \"`{}`\", \"double_quote\": '\"{}\"', \"bracket\": r\"\\[{}\\]\"}\nDATASET_COLORS = {\"BIRD\": \"#2a78d6\", \"Spider\": \"#eb6834\", \"SynSQL\": \"#1baf7a\"}\n\nSYSTEM_PROMPT = (\n    \"You are an expert SQLite data analyst.\\n\"\n    \"Rules:\\n\"\n    \"- Use only the tables and columns that exist in the schema.\\n\"\n    \"- If a hint is provided, use it.\\n\"\n    \"- Return exactly the columns the question asks for.\\n\"\n    \"- Output only the SQL query inside a single ```sql code block, with no explanation.\"\n)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T00:49:30.845658Z","iopub.execute_input":"2026-10-20T00:49:30.846692Z","iopub.status.idle":"2026-10-20T00:49:30.856121Z","shell.execute_reply.started":"2026-10-20T00:49:30.846650Z","shell.execute_reply":"2026-10-20T00:49:30.854970Z"}},"outputs":[],"execution_count":3},{"id":"cell-04","cell_type":"markdown","source":"## 1. Download\n\nThe repo has `data.json` (9.4 GB, one JSON array), `tables.json` and `databases.zip`. Only `data.json` and the databases are needed, since the schemas are read straight from the SQLite files. Files go to `/tmp` so they are not saved as notebook output.","metadata":{}},{"id":"cell-05","cell_type":"code","source":"DATA_DIR.mkdir(parents=True, exist_ok=True)\nprint(f\"Free disk at {DATA_DIR}: {shutil.disk_usage(DATA_DIR).free / 1e9:.1f} GB\")\n\ndata_path = Path(hf_hub_download(SYNSQL_REPO, \"data.json\", repo_type=\"dataset\", local_dir=DATA_DIR))\nzip_path = Path(hf_hub_download(SYNSQL_REPO, \"databases.zip\", repo_type=\"dataset\", local_dir=DATA_DIR))\n\nwith zipfile.ZipFile(zip_path) as archive:\n    archive.extractall(DATA_DIR / \"databases\")\n\ndb_paths = {path.stem: path for path in (DATA_DIR / \"databases\").rglob(\"*.sqlite\")}\nprint(f\"{len(db_paths):,} SQLite databases extracted\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T00:49:30.858686Z","iopub.execute_input":"2026-10-20T00:49:30.859596Z","iopub.status.idle":"2026-10-20T00:50:44.218036Z","shell.execute_reply.started":"2026-10-20T00:49:30.859556Z","shell.execute_reply":"2026-10-20T00:50:44.216301Z"}},"outputs":[{"name":"stdout","text":"Free disk at /tmp/synsql: 1145.6 GB\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"data.json: reconstructing file:   0%|          |  0.00B / 9.36GB            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"5caf4cad97774b4dad46a7b7db9d1831"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"data.json: downloading bytes:           |  0.00B            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"2cc17db5e6794c818ac89002088c04da"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"databases.zip: reconstructing file:   0%|          |  0.00B / 54.5MB            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"fe55c3d9cbb842ccafaee57320b809e0"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"databases.zip: downloading bytes:           |  0.00B            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"6737a804bd574cecb7f2cf3778a182ee"}},"metadata":{}},{"name":"stdout","text":"16,583 SQLite databases extracted\n","output_type":"stream"}],"execution_count":4},{"id":"cell-06","cell_type":"markdown","source":"## 2. Load the samples\n\n`data.json` is streamed with `ijson` and the chain-of-thought field is dropped, since training uses only the final SQL. The overview shows the complexity and question-style mix of the whole dataset.","metadata":{}},{"id":"cell-07","cell_type":"code","source":"fields = [\"db_id\", \"sql_complexity\", \"question_style\", \"question\", \"external_knowledge\", \"sql\"]\nrecords = {field: [] for field in fields}\n\n# the pure-Python ijson backend would take hours on a 9.4 GB file\nparser = ijson.get_backend(\"yajl2_c\")\nwith open(data_path, \"rb\") as file:\n    for item in tqdm(parser.items(file, \"item\"), total=2_544_390, desc=\"Parsing data.json\"):\n        for field in fields:\n            records[field].append(item.get(field) or \"\")\n\nsamples = pd.DataFrame(records).astype({\"db_id\": \"category\", \"sql_complexity\": \"category\", \"question_style\": \"category\"})\ndel records","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T00:50:44.222127Z","iopub.execute_input":"2026-10-20T00:50:44.222861Z","iopub.status.idle":"2026-10-20T00:52:20.704578Z","shell.execute_reply.started":"2026-10-20T00:50:44.222821Z","shell.execute_reply":"2026-10-20T00:52:20.702389Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"Parsing data.json:   0%|          | 0/2544390 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"e2cffd98bcc446b6bdce2fa29e204423"}},"metadata":{}}],"execution_count":5},{"id":"cell-08","cell_type":"code","source":"samples[\"has_external_knowledge\"] = samples[\"external_knowledge\"].str.strip() != \"\"\nsamples[\"n_joins\"] = samples[\"sql\"].str.count(r\"(?i)\\bJOIN\\b\")\nsamples[\"has_cte\"] = samples[\"sql\"].str.contains(r\"(?i)^\\s*WITH\\b\")\n\ndisplay(pd.DataFrame({\n    \"samples\": [len(samples)],\n    \"databases\": [samples[\"db_id\"].nunique()],\n    \"missing_database_file\": [(~samples[\"db_id\"].isin(list(db_paths))).sum()],\n    \"with_external_knowledge\": [samples[\"has_external_knowledge\"].mean()],\n    \"avg_joins\": [samples[\"n_joins\"].mean()],\n    \"with_cte\": [samples[\"has_cte\"].mean()],\n}).round(3))\n\nfig, axes = plt.subplots(1, 2, figsize=(13, 4))\nfor axis, column in zip(axes, [\"sql_complexity\", \"question_style\"]):\n    samples[column].value_counts().plot.bar(ax=axis, color=DATASET_COLORS[\"SynSQL\"], title=column)\n    axis.tick_params(axis=\"x\", rotation=45)\nplt.tight_layout()\nplt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T00:52:20.707562Z","iopub.execute_input":"2026-10-20T00:52:20.708153Z","iopub.status.idle":"2026-10-20T00:53:18.840210Z","shell.execute_reply.started":"2026-10-20T00:52:20.708111Z","shell.execute_reply":"2026-10-20T00:53:18.838876Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"   samples  databases  missing_database_file  with_external_knowledge  \\\n0  2544390      16583                      0                    0.221   \n\n   avg_joins  with_cte  \n0      2.169     0.413  ","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>samples</th>\n      <th>databases</th>\n      <th>missing_database_file</th>\n      <th>with_external_knowledge</th>\n      <th>avg_joins</th>\n      <th>with_cte</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>2544390</td>\n      <td>16583</td>\n      <td>0</td>\n      <td>0.221</td>\n      <td>2.169</td>\n      <td>0.413</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 1300x400 with 2 Axes>","image/png":"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\n"},"metadata":{}}],"execution_count":6},{"id":"cell-09","cell_type":"markdown","source":"## 3. Database profile\n\nEach database is opened to get its DDL (column descriptions removed, matching the plain BIRD prompt), its size, and the identifiers that need quotes. An identifier needs quotes when SQLite itself fails to read it unquoted, so spaces, special characters and reserved words are all caught without a hand-made list.","metadata":{}},{"id":"cell-10","cell_type":"code","source":"quote_check_connection = sqlite3.connect(\":memory:\")\n\n\ndef quote_name(name):\n    return '\"' + name.replace('\"', '\"\"') + '\"'\n\n\n@lru_cache(maxsize=None)\ndef needs_quoting(identifier):\n    try:\n        row = quote_check_connection.execute(\n            f\"SELECT {identifier} FROM (SELECT 'sentinel' AS {quote_name(identifier)})\"\n        ).fetchone()\n    except (sqlite3.Error, sqlite3.Warning):\n        return True\n    return row[0] != \"sentinel\"\n\n\ndef quoting_reason(identifier):\n    if not needs_quoting(identifier):\n        return None\n    if \" \" in identifier:\n        return \"space\"\n    if re.search(r\"[^A-Za-z0-9_]\", identifier):\n        return \"special_character\"\n    if identifier[:1].isdigit():\n        return \"leading_digit\"\n    return \"reserved_word\"\n\n\ndef profile_database(db_id, db_path):\n    connection = sqlite3.connect(f\"file:{db_path}?mode=ro\", uri=True)\n    tables = connection.execute(\n        \"SELECT name, sql FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'\"\n    ).fetchall()\n    identifiers = []\n    n_columns = 0\n    max_rows = 0\n    for table_name, _ in tables:\n        escaped = table_name.replace('\"', '\"\"')\n        columns = [row[1] for row in connection.execute(f'PRAGMA table_info(\"{escaped}\")')]\n        identifiers.extend([table_name, *columns])\n        n_columns += len(columns)\n        max_rows = max(max_rows, connection.execute(f'SELECT COUNT(*) FROM \"{escaped}\"').fetchone()[0])\n    connection.close()\n    return {\n        \"db_id\": db_id,\n        \"ddl\": \"\\n\\n\".join(re.sub(r\"\\s*/\\*.*?\\*/\", \"\", sql, flags=re.DOTALL) for _, sql in tables),\n        \"n_tables\": len(tables),\n        \"n_columns\": n_columns,\n        \"max_rows_per_table\": max_rows,\n        \"quoted_identifiers\": sorted({name for name in identifiers if needs_quoting(name)}),\n    }\n\n\ndatabases = pd.DataFrame(\n    [profile_database(db_id, path) for db_id, path in tqdm(db_paths.items(), desc=\"Profiling databases\")]\n).set_index(\"db_id\")\ndatabases[\"n_quoted_identifiers\"] = databases[\"quoted_identifiers\"].str.len()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T00:53:18.841652Z","iopub.execute_input":"2026-10-20T00:53:18.842220Z","iopub.status.idle":"2026-10-20T00:53:55.551216Z","shell.execute_reply.started":"2026-10-20T00:53:18.842181Z","shell.execute_reply":"2026-10-20T00:53:55.549887Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"Profiling databases:   0%|          | 0/16583 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"123cb0ed7337478f88b1e2b8ed0b48c8"}},"metadata":{}}],"execution_count":7},{"id":"cell-11","cell_type":"code","source":"display(databases[[\"n_tables\", \"n_columns\", \"max_rows_per_table\", \"n_quoted_identifiers\"]].describe().round(1))\nprint(f\"Databases with at least one identifier that needs quotes: {(databases['n_quoted_identifiers'] > 0).mean():.1%}\")\n\nquoted_counts = Counter(name for names in databases[\"quoted_identifiers\"] for name in names)\ndisplay(pd.DataFrame(\n    [(name, quoting_reason(name), count) for name, count in quoted_counts.most_common(20)],\n    columns=[\"identifier\", \"reason\", \"databases\"],\n))","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T00:53:55.552760Z","iopub.execute_input":"2026-10-20T00:53:55.553168Z","iopub.status.idle":"2026-10-20T00:53:55.642909Z","shell.execute_reply.started":"2026-10-20T00:53:55.553133Z","shell.execute_reply":"2026-10-20T00:53:55.641902Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"       n_tables  n_columns  max_rows_per_table  n_quoted_identifiers\ncount   16583.0    16583.0             16583.0               16583.0\nmean       10.1       74.1                 1.8                   0.1\nstd         3.5       23.2                 1.0                   0.4\nmin         0.0        0.0                 0.0                   0.0\n25%         8.0       58.0                 2.0                   0.0\n50%        10.0       72.0                 2.0                   0.0\n75%        12.0       89.0                 2.0                   0.0\nmax        29.0      185.0                31.0                  19.0","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>n_tables</th>\n      <th>n_columns</th>\n      <th>max_rows_per_table</th>\n      <th>n_quoted_identifiers</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>count</th>\n      <td>16583.0</td>\n      <td>16583.0</td>\n      <td>16583.0</td>\n      <td>16583.0</td>\n    </tr>\n    <tr>\n      <th>mean</th>\n      <td>10.1</td>\n      <td>74.1</td>\n      <td>1.8</td>\n      <td>0.1</td>\n    </tr>\n    <tr>\n      <th>std</th>\n      <td>3.5</td>\n      <td>23.2</td>\n      <td>1.0</td>\n      <td>0.4</td>\n    </tr>\n    <tr>\n      <th>min</th>\n      <td>0.0</td>\n      <td>0.0</td>\n      <td>0.0</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>25%</th>\n      <td>8.0</td>\n      <td>58.0</td>\n      <td>2.0</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>50%</th>\n      <td>10.0</td>\n      <td>72.0</td>\n      <td>2.0</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>75%</th>\n      <td>12.0</td>\n      <td>89.0</td>\n      <td>2.0</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>max</th>\n      <td>29.0</td>\n      <td>185.0</td>\n      <td>31.0</td>\n      <td>19.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}},{"name":"stdout","text":"Databases with at least one identifier that needs quotes: 3.9%\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"      identifier             reason  databases\n0          order      reserved_word        128\n1     references      reserved_word         90\n2           cast      reserved_word         59\n3          group      reserved_word         36\n4   52_week_high      leading_digit         31\n5    52_week_low      leading_digit         31\n6          index      reserved_word         19\n7         values      reserved_word         19\n8          limit      reserved_word         16\n9        default      reserved_word         14\n10            to      reserved_word         14\n11       primary      reserved_word         12\n12   is Tradable              space          5\n13  current_time      reserved_word          4\n14    constraint      reserved_word          4\n15        unique      reserved_word          3\n16            as      reserved_word          3\n17      run-outs  special_character          3\n18           3pa      leading_digit          3\n19           3pm      leading_digit          3","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>identifier</th>\n      <th>reason</th>\n      <th>databases</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>order</td>\n      <td>reserved_word</td>\n      <td>128</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>references</td>\n      <td>reserved_word</td>\n      <td>90</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>cast</td>\n      <td>reserved_word</td>\n      <td>59</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>group</td>\n      <td>reserved_word</td>\n      <td>36</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>52_week_high</td>\n      <td>leading_digit</td>\n      <td>31</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>52_week_low</td>\n      <td>leading_digit</td>\n      <td>31</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>index</td>\n      <td>reserved_word</td>\n      <td>19</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>values</td>\n      <td>reserved_word</td>\n      <td>19</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>limit</td>\n      <td>reserved_word</td>\n      <td>16</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>default</td>\n      <td>reserved_word</td>\n      <td>14</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>to</td>\n      <td>reserved_word</td>\n      <td>14</td>\n    </tr>\n    <tr>\n      <th>11</th>\n      <td>primary</td>\n      <td>reserved_word</td>\n      <td>12</td>\n    </tr>\n    <tr>\n      <th>12</th>\n      <td>is Tradable</td>\n      <td>space</td>\n      <td>5</td>\n    </tr>\n    <tr>\n      <th>13</th>\n      <td>current_time</td>\n      <td>reserved_word</td>\n      <td>4</td>\n    </tr>\n    <tr>\n      <th>14</th>\n      <td>constraint</td>\n      <td>reserved_word</td>\n      <td>4</td>\n    </tr>\n    <tr>\n      <th>15</th>\n      <td>unique</td>\n      <td>reserved_word</td>\n      <td>3</td>\n    </tr>\n    <tr>\n      <th>16</th>\n      <td>as</td>\n      <td>reserved_word</td>\n      <td>3</td>\n    </tr>\n    <tr>\n      <th>17</th>\n      <td>run-outs</td>\n      <td>special_character</td>\n      <td>3</td>\n    </tr>\n    <tr>\n      <th>18</th>\n      <td>3pa</td>\n      <td>leading_digit</td>\n      <td>3</td>\n    </tr>\n    <tr>\n      <th>19</th>\n      <td>3pm</td>\n      <td>leading_digit</td>\n      <td>3</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}],"execution_count":8},{"id":"cell-12","cell_type":"markdown","source":"Each gold query is then checked for quoted references (backticks, double quotes or brackets) to the names of its database that need quotes. These rows feed the extra pool in section 9.","metadata":{}},{"id":"cell-13","cell_type":"code","source":"def quoted_references(sql, identifiers):\n    names = set()\n    styles = set()\n    for name in identifiers:\n        for style, pattern in QUOTE_PATTERNS.items():\n            if re.search(\"(?i)\" + pattern.format(re.escape(name)), sql):\n                names.add(name)\n                styles.add(style)\n    return sorted(names), sorted(styles)\n\n\nquoted_by_db = databases[\"quoted_identifiers\"].to_dict()\nreferences = [\n    quoted_references(sql, quoted_by_db.get(db_id, []))\n    for db_id, sql in tqdm(zip(samples[\"db_id\"], samples[\"sql\"]), total=len(samples), desc=\"Matching quoted names\")\n]\nsamples[\"quoted_identifiers\"] = [names for names, _ in references]\nsamples[\"quote_styles\"] = [styles for _, styles in references]\nsamples[\"quoting_reasons\"] = samples[\"quoted_identifiers\"].apply(lambda names: sorted({quoting_reason(name) for name in names}))\ndel references\n\nuses_quotes = samples[\"quoted_identifiers\"].str.len() > 0\nprint(f\"Rows using a name that needs quotes: {uses_quotes.sum():,} from {samples.loc[uses_quotes, 'db_id'].nunique():,} databases\")\ndisplay(samples.loc[uses_quotes, \"quoting_reasons\"].explode().value_counts().rename(\"rows\").to_frame())","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T00:53:55.644498Z","iopub.execute_input":"2026-10-20T00:53:55.645039Z","iopub.status.idle":"2026-10-20T00:54:21.760277Z","shell.execute_reply.started":"2026-10-20T00:53:55.644983Z","shell.execute_reply":"2026-10-20T00:54:21.759139Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"Matching quoted names:   0%|          | 0/2544390 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"3ac258f62b5a4157b0fd428454b36549"}},"metadata":{}},{"name":"stdout","text":"Rows using a name that needs quotes: 812 from 115 databases\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"                   rows\nquoting_reasons        \nspace               277\nleading_digit       228\nreserved_word       199\nspecial_character   108","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>rows</th>\n    </tr>\n    <tr>\n      <th>quoting_reasons</th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>space</th>\n      <td>277</td>\n    </tr>\n    <tr>\n      <th>leading_digit</th>\n      <td>228</td>\n    </tr>\n    <tr>\n      <th>reserved_word</th>\n      <td>199</td>\n    </tr>\n    <tr>\n      <th>special_character</th>\n      <td>108</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}],"execution_count":9},{"id":"cell-14","cell_type":"markdown","source":"## 4. Tokenizers\n\nThe v2 trains both Qwen3.5-4B and Qwen3.5-9B, so every size check must hold for both. The tokenizer files of each model are hashed: models with identical files share one tokenizer and are counted once, otherwise every count takes the maximum across tokenizers.\n\nExamples are rendered like `birdsql-fine-tunning.ipynb`: system prompt, `Database schema / Hint / Question` user message, and the SQL in a code block as the answer. `SYSTEM_PROMPT` is a reconstruction, so paste the exact training text for exact counts.","metadata":{}},{"id":"cell-15","cell_type":"code","source":"def tokenizer_fingerprint(model_name):\n    files = [\"tokenizer.json\", \"tokenizer_config.json\", \"chat_template.jinja\"]\n    return tuple(hashlib.sha256(Path(hf_hub_download(model_name, file)).read_bytes()).hexdigest() for file in files)\n\n\nfingerprints = {name: tokenizer_fingerprint(name) for name in TOKENIZER_NAMES}\ntokenizer_groups = {}\nfor name, fingerprint in fingerprints.items():\n    tokenizer_groups.setdefault(fingerprint, []).append(name)\ntokenizers = {\" + \".join(names): AutoTokenizer.from_pretrained(names[0]) for names in tokenizer_groups.values()}\n\ndisplay(pd.DataFrame({\n    \"model\": list(fingerprints),\n    \"tokenizer_group\": [\" + \".join(tokenizer_groups[fingerprint]) for fingerprint in fingerprints.values()],\n}))\nprint(f\"{len(tokenizers)} distinct tokenizer(s) to count with\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T00:54:21.761850Z","iopub.execute_input":"2026-10-20T00:54:21.762318Z","iopub.status.idle":"2026-10-20T00:54:27.395226Z","shell.execute_reply.started":"2026-10-20T00:54:21.762287Z","shell.execute_reply":"2026-10-20T00:54:27.393886Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"tokenizer.json: reconstructing file:   0%|          |  0.00B / 12.8MB            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"95fe908bc8de43d8917ea10aec3c6a37"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"tokenizer.json: downloading bytes:           |  0.00B            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"1051bc2b05894e678c7cfa2ecfd557b0"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"tokenizer_config.json:   0%|          | 0.00/16.7k [00:00<?, ?B/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"427cd09b65604a2c9bf5a5dd8d499514"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"chat_template.jinja:   0%|          | 0.00/7.76k [00:00<?, ?B/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"1fb78f8e9e844f8f81a70a3664698429"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"tokenizer_config.json:   0%|          | 0.00/16.7k [00:00<?, ?B/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"1920df7aa7f04a8080c702afa85da345"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"chat_template.jinja:   0%|          | 0.00/7.76k [00:00<?, ?B/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"9ba0078064b642cf98949948a773c93e"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"config.json:   0%|          | 0.00/3.16k [00:00<?, ?B/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"adaccb281e6f4f789ff1b05454883239"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"             model                    tokenizer_group\n0  Qwen/Qwen3.5-4B  Qwen/Qwen3.5-4B + Qwen/Qwen3.5-9B\n1  Qwen/Qwen3.5-9B  Qwen/Qwen3.5-4B + Qwen/Qwen3.5-9B","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>model</th>\n      <th>tokenizer_group</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>Qwen/Qwen3.5-4B</td>\n      <td>Qwen/Qwen3.5-4B + Qwen/Qwen3.5-9B</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>Qwen/Qwen3.5-9B</td>\n      <td>Qwen/Qwen3.5-4B + Qwen/Qwen3.5-9B</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}},{"name":"stdout","text":"1 distinct tokenizer(s) to count with\n","output_type":"stream"}],"execution_count":10},{"id":"cell-16","cell_type":"code","source":"def render_example(tokenizer, ddl, hint, question, sql):\n    hint = hint if hint and hint.strip() else \"None\"\n    messages = [\n        {\"role\": \"system\", \"content\": SYSTEM_PROMPT},\n        {\"role\": \"user\", \"content\": f\"Database schema:\\n{ddl}\\n\\nHint: {hint}\\n\\nQuestion: {question}\"},\n    ]\n    prompt = tokenizer.apply_chat_template(\n        messages, tokenize=False, add_generation_prompt=True, enable_thinking=False\n    )\n    return f\"{prompt}```sql\\n{sql}\\n```<|im_end|>\"\n\n\ndef count_tokens(tokenizer, texts, batch_size=2048):\n    lengths = []\n    for start in tqdm(range(0, len(texts), batch_size), desc=\"Tokenizing\", leave=False):\n        batch = tokenizer(texts[start:start + batch_size], add_special_tokens=False)[\"input_ids\"]\n        lengths.extend(len(ids) for ids in batch)\n    return np.array(lengths)\n\n\ndef count_text_tokens(texts):\n    return np.max([count_tokens(tokenizer, list(texts)) for tokenizer in tokenizers.values()], axis=0)\n\n\ndef count_example_tokens(ddls, hints, questions, sqls):\n    rows = list(zip(ddls, hints, questions, sqls))\n    return np.max(\n        [count_tokens(tokenizer, [render_example(tokenizer, *row) for row in rows]) for tokenizer in tokenizers.values()],\n        axis=0,\n    )\n\n\ndef token_summary(name, lengths):\n    return {\n        \"dataset\": name,\n        \"rows\": len(lengths),\n        \"p50\": np.median(lengths),\n        \"p75\": np.quantile(lengths, 0.75),\n        \"p95\": np.quantile(lengths, 0.95),\n        \"max\": lengths.max(),\n        \"over_max_seq_length\": (lengths > MAX_SEQ_LENGTH).mean(),\n    }\n\n\ndef quoting_summary(name, quoted_identifiers, quote_styles):\n    has_quoted = quoted_identifiers.str.len() > 0\n    reasons = quoted_identifiers.apply(lambda names: {quoting_reason(identifier) for identifier in names})\n    return {\n        \"dataset\": name,\n        \"rows\": len(quoted_identifiers),\n        \"with_quoted_identifier\": has_quoted.mean(),\n        **{f\"with_{reason}\": reasons.apply(lambda found: reason in found).mean() for reason in QUOTING_REASONS},\n        **{f\"uses_{style}\": quote_styles[has_quoted].apply(lambda found: style in found).mean() for style in QUOTE_PATTERNS},\n    }\n\n\ndef schema_quoted_identifiers(ddl):\n    connection = sqlite3.connect(\":memory:\")\n    statements = [statement.strip().rstrip(\";\") for statement in re.split(r\"(?i)(?=\\bCREATE\\s+TABLE\\b)\", ddl) if statement.strip()]\n    for statement in statements:\n        try:\n            connection.execute(statement)\n        except (sqlite3.Error, sqlite3.Warning):\n            continue\n    table_names = [row[0] for row in connection.execute(\"SELECT name FROM sqlite_master WHERE type = 'table'\")]\n    identifiers = set(table_names) | {\n        row[1] for table in table_names for row in connection.execute(f\"PRAGMA table_info({quote_name(table)})\")\n    }\n    connection.close()\n    return sorted(name for name in identifiers if needs_quoting(name))\n\n\ndef sql_style(name, sqls, hints):\n    joins = sqls.str.count(r\"(?i)\\bJOIN\\b\")\n    return {\n        \"dataset\": name,\n        \"rows\": len(sqls),\n        \"avg_joins\": joins.mean(),\n        \"with_join\": (joins > 0).mean(),\n        \"with_2plus_joins\": (joins >= 2).mean(),\n        \"with_cte\": sqls.str.contains(r\"(?i)^\\s*WITH\\b\").mean(),\n        \"with_hint\": (hints.str.strip() != \"\").mean(),\n    }","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T00:54:27.397144Z","iopub.execute_input":"2026-10-20T00:54:27.397688Z","iopub.status.idle":"2026-10-20T00:54:27.423330Z","shell.execute_reply.started":"2026-10-20T00:54:27.397622Z","shell.execute_reply":"2026-10-20T00:54:27.421782Z"}},"outputs":[],"execution_count":11},{"id":"cell-17","cell_type":"markdown","source":"## 5. Reference: BIRD and Spider train\n\nBIRD train and Spider train (without `SPIDER_EXCLUDED_DBS`, as planned for v2) are the base mix SynSQL will join. Their prompt sizes, SQL style and use of names that need quotes are measured the same way (their DDLs are loaded into an in-memory SQLite to list tables and columns), and the bands start at the `BAND_START_QUANTILE` of the base mix, counting only the examples that fit `MAX_SEQ_LENGTH`.","metadata":{}},{"id":"cell-18","cell_type":"code","source":"bird = load_dataset(BIRD_TRAIN_REPO, \"questions\", split=\"train\").to_pandas()\nbird_schemas = {row[\"db_id\"]: row[\"schema\"] for row in load_dataset(BIRD_TRAIN_REPO, \"schemas\", split=\"train\")}\nbird[\"schema\"] = bird[\"db_id\"].map(bird_schemas)\nbird[\"evidence\"] = bird[\"evidence\"].fillna(\"\")\n\nspider = load_dataset(SPIDER_REPO, \"questions\", split=\"train\").to_pandas()\nspider = spider[~spider[\"db_id\"].isin(SPIDER_EXCLUDED_DBS)].copy()\nspider_schemas = {row[\"db_id\"]: row[\"schema_raw\"] for row in load_dataset(SPIDER_REPO, \"schemas\", split=\"train\")}\nspider[\"schema\"] = spider[\"db_id\"].map(spider_schemas)\nspider[\"evidence\"] = \"\"\n\nfor frame, schemas in [(bird, bird_schemas), (spider, spider_schemas)]:\n    quoted_by_reference_db = {db_id: schema_quoted_identifiers(ddl) for db_id, ddl in schemas.items()}\n    references = [quoted_references(sql, quoted_by_reference_db[db_id]) for db_id, sql in zip(frame[\"db_id\"], frame[\"sql\"])]\n    frame[\"quoted_identifiers\"] = [names for names, _ in references]\n    frame[\"quote_styles\"] = [styles for _, styles in references]\n    frame[\"total_tokens\"] = count_example_tokens(frame[\"schema\"], frame[\"evidence\"], frame[\"question\"], frame[\"sql\"])\n\ntemplate_overhead = max(count_tokens(tokenizer, [render_example(tokenizer, \"\", \"\", \"\", \"\")])[0] for tokenizer in tokenizers.values())\ndatabases[\"schema_tokens\"] = count_text_tokens(databases[\"ddl\"])\nsynsql_db_size = databases[\"schema_tokens\"] + template_overhead\n\nbase_mix_tokens = np.concatenate([bird[\"total_tokens\"], spider[\"total_tokens\"]])\nbase_mix_tokens = base_mix_tokens[base_mix_tokens <= MAX_SEQ_LENGTH]\nband_start = int(np.quantile(base_mix_tokens, BAND_START_QUANTILE)) // 100 * 100\n\ndisplay(pd.DataFrame([\n    token_summary(\"BIRD train\", bird[\"total_tokens\"].to_numpy()),\n    token_summary(\"Spider train\", spider[\"total_tokens\"].to_numpy()),\n    token_summary(\"Base mix (fits MAX_SEQ_LENGTH)\", base_mix_tokens),\n    token_summary(\"SynSQL databases (schema + template)\", synsql_db_size.to_numpy()),\n]).round(3))\ndisplay(pd.DataFrame([\n    sql_style(\"BIRD train\", bird[\"sql\"], bird[\"evidence\"]),\n    sql_style(\"Spider train\", spider[\"sql\"], spider[\"evidence\"]),\n    sql_style(\"SynSQL (all)\", samples[\"sql\"], samples[\"external_knowledge\"]),\n]).round(3))\ndisplay(pd.DataFrame([\n    quoting_summary(\"BIRD train\", bird[\"quoted_identifiers\"], bird[\"quote_styles\"]),\n    quoting_summary(\"Spider train\", spider[\"quoted_identifiers\"], spider[\"quote_styles\"]),\n    quoting_summary(\"SynSQL (all)\", samples[\"quoted_identifiers\"], samples[\"quote_styles\"]),\n]).round(3))\nprint(f\"Template overhead: {template_overhead} tokens | band start: {band_start}\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T00:54:27.425162Z","iopub.execute_input":"2026-10-20T00:54:27.425666Z","iopub.status.idle":"2026-10-20T00:56:45.489936Z","shell.execute_reply.started":"2026-10-20T00:54:27.425618Z","shell.execute_reply":"2026-10-20T00:56:45.488598Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"README.md:   0%|          | 0.00/4.07k [00:00<?, ?B/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"3d1259e402694fafaa874226acdbc161"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"questions/train-00000-of-00001.parquet: reconstructing file:   0%|          |  0.00B /  922kB            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"0817486d9c83462788fced62ae41b312"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"questions/train-00000-of-00001.parquet: downloading bytes:           |  0.00B            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"b0ffab08d01340b69cab5a2aa5cce0e4"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"Generating train split:   0%|          | 0/6597 [00:00<?, ? examples/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"5bfd87ed6f104324846673a0ea8896d1"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"schemas/train-00000-of-00001.parquet: reconstructing file:   0%|          |  0.00B / 49.0kB            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"845b6b23e1b54cf1948ee23ad4d54ea1"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"schemas/train-00000-of-00001.parquet: downloading bytes:           |  0.00B            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"0b3dd8ddac1f4b54a503d3e6af3fa57a"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"Generating train split:   0%|          | 0/69 [00:00<?, ? examples/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"3b250f46ecc14816a5fa4212360a395a"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"README.md:   0%|          | 0.00/5.58k [00:00<?, ?B/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"4cdfee3ec2cd499dac14e54c08d12e5b"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"questions/train-00000-of-00001.parquet: reconstructing file:   0%|          |  0.00B / 1.31MB            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"d0b98e55c9bb4a4e91373a9463d14b30"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"questions/train-00000-of-00001.parquet: downloading bytes:           |  0.00B            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"c00518ad353549d7b29d1abc455318eb"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"questions/validation-00000-of-00001.parq(…): reconstructing file:   0%|          |  0.00B /  162kB            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"249a51e832a24e129121a60630ca9381"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"questions/validation-00000-of-00001.parq(…): downloading bytes:           |  0.00B            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"1b68c3da6c51461ba0811d34a5dd4a7d"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"questions/test-00000-of-00001.parquet: reconstructing file:   0%|          |  0.00B /  327kB            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"3c2d8f6fe2ab4b288cb8b3d5bce7e7c8"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"questions/test-00000-of-00001.parquet: downloading bytes:           |  0.00B            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"180f84cefe154073bc2a4a83cf530ead"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"Generating train split:   0%|          | 0/8656 [00:00<?, ? examples/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"60a7aaff6a6b44c8abf226209a01c884"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"Generating validation split:   0%|          | 0/1034 [00:00<?, ? examples/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"8b997143609a469d98223678e2efdc8a"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"Generating test split:   0%|          | 0/2147 [00:00<?, ? examples/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"2e5c88cff38c40d38de90e72bf57dc59"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"schemas/train-00000-of-00001.parquet: reconstructing file:   0%|          |  0.00B /  150kB            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"7cf60d17256c47c8af169b5a73ef16ec"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"schemas/train-00000-of-00001.parquet: downloading bytes:           |  0.00B            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"17296488ea8c4e56b4e0d26e807c804d"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"schemas/validation-00000-of-00001.parque(…): reconstructing file:   0%|          |  0.00B / 30.7kB            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"986e9f9afb194897bf18256edf96b901"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"schemas/validation-00000-of-00001.parque(…): downloading bytes:           |  0.00B            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"1898cb5d3aa240b0a835b4b8225dbf1d"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"schemas/test-00000-of-00001.parquet: reconstructing file:   0%|          |  0.00B / 48.4kB            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"3b008c27b59c4485bc52329b2ba7ab93"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"schemas/test-00000-of-00001.parquet: downloading bytes:           |  0.00B            ","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"6e018df8d61a43289575529feb0eea0d"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"Generating train split:   0%|          | 0/146 [00:00<?, ? examples/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"967439b88d1445179290c5b4bab83ad3"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"Generating validation split:   0%|          | 0/20 [00:00<?, ? examples/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"fc36898304694775a8859f4d0ecbff81"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"Generating test split:   0%|          | 0/40 [00:00<?, ? examples/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"01ec829a96b84aa9a57fd3d3ea989f1f"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"Tokenizing:   0%|          | 0/4 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":""}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"Tokenizing:   0%|          | 0/5 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":""}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"Tokenizing:   0%|          | 0/1 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":""}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"Tokenizing:   0%|          | 0/9 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":""}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"                                dataset   rows     p50     p75     p95   max  \\\n0                            BIRD train   6597   824.0  1232.0  7267.0  7428   \n1                          Spider train   8576   555.0   795.0  1440.0  2757   \n2        Base mix (fits MAX_SEQ_LENGTH)  14790   629.0   938.0  1663.0  3628   \n3  SynSQL databases (schema + template)  16583  1069.0  1294.0  1635.9  2646   \n\n   over_max_seq_length  \n0                0.058  \n1                0.000  \n2                0.000  \n3                0.000  ","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>dataset</th>\n      <th>rows</th>\n      <th>p50</th>\n      <th>p75</th>\n      <th>p95</th>\n      <th>max</th>\n      <th>over_max_seq_length</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>BIRD train</td>\n      <td>6597</td>\n      <td>824.0</td>\n      <td>1232.0</td>\n      <td>7267.0</td>\n      <td>7428</td>\n      <td>0.058</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>Spider train</td>\n      <td>8576</td>\n      <td>555.0</td>\n      <td>795.0</td>\n      <td>1440.0</td>\n      <td>2757</td>\n      <td>0.000</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>Base mix (fits MAX_SEQ_LENGTH)</td>\n      <td>14790</td>\n      <td>629.0</td>\n      <td>938.0</td>\n      <td>1663.0</td>\n      <td>3628</td>\n      <td>0.000</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>SynSQL databases (schema + template)</td>\n      <td>16583</td>\n      <td>1069.0</td>\n      <td>1294.0</td>\n      <td>1635.9</td>\n      <td>2646</td>\n      <td>0.000</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"        dataset     rows  avg_joins  with_join  with_2plus_joins  with_cte  \\\n0    BIRD train     6597      0.992      0.760             0.192     0.000   \n1  Spider train     8576      0.707      0.439             0.182     0.000   \n2  SynSQL (all)  2544390      2.169      0.893             0.629     0.413   \n\n   with_hint  \n0      0.928  \n1      0.000  \n2      0.221  ","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>dataset</th>\n      <th>rows</th>\n      <th>avg_joins</th>\n      <th>with_join</th>\n      <th>with_2plus_joins</th>\n      <th>with_cte</th>\n      <th>with_hint</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>BIRD train</td>\n      <td>6597</td>\n      <td>0.992</td>\n      <td>0.760</td>\n      <td>0.192</td>\n      <td>0.000</td>\n      <td>0.928</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>Spider train</td>\n      <td>8576</td>\n      <td>0.707</td>\n      <td>0.439</td>\n      <td>0.182</td>\n      <td>0.000</td>\n      <td>0.000</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>SynSQL (all)</td>\n      <td>2544390</td>\n      <td>2.169</td>\n      <td>0.893</td>\n      <td>0.629</td>\n      <td>0.413</td>\n      <td>0.221</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"        dataset     rows  with_quoted_identifier  with_space  \\\n0    BIRD train     6597                   0.074       0.047   \n1  Spider train     8576                   0.000       0.000   \n2  SynSQL (all)  2544390                   0.000       0.000   \n\n   with_special_character  with_leading_digit  with_reserved_word  \\\n0                   0.019                 0.0               0.008   \n1                   0.000                 0.0               0.000   \n2                   0.000                 0.0               0.000   \n\n   uses_backtick  uses_double_quote  uses_bracket  \n0          0.992              0.010         0.000  \n1            NaN                NaN           NaN  \n2          0.456              0.531         0.014  ","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>dataset</th>\n      <th>rows</th>\n      <th>with_quoted_identifier</th>\n      <th>with_space</th>\n      <th>with_special_character</th>\n      <th>with_leading_digit</th>\n      <th>with_reserved_word</th>\n      <th>uses_backtick</th>\n      <th>uses_double_quote</th>\n      <th>uses_bracket</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>BIRD train</td>\n      <td>6597</td>\n      <td>0.074</td>\n      <td>0.047</td>\n      <td>0.019</td>\n      <td>0.0</td>\n      <td>0.008</td>\n      <td>0.992</td>\n      <td>0.010</td>\n      <td>0.000</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>Spider train</td>\n      <td>8576</td>\n      <td>0.000</td>\n      <td>0.000</td>\n      <td>0.000</td>\n      <td>0.0</td>\n      <td>0.000</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>SynSQL (all)</td>\n      <td>2544390</td>\n      <td>0.000</td>\n      <td>0.000</td>\n      <td>0.000</td>\n      <td>0.0</td>\n      <td>0.000</td>\n      <td>0.456</td>\n      <td>0.531</td>\n      <td>0.014</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}},{"name":"stdout","text":"Template overhead: 98 tokens | band start: 900\n","output_type":"stream"}],"execution_count":12},{"id":"cell-19","cell_type":"code","source":"fig, axis = plt.subplots(figsize=(11, 4))\nbins = np.arange(0, 8001, 100)\nfor label, color, lengths in [\n    (\"BIRD train examples\", DATASET_COLORS[\"BIRD\"], bird[\"total_tokens\"]),\n    (\"Spider train examples\", DATASET_COLORS[\"Spider\"], spider[\"total_tokens\"]),\n    (\"SynSQL databases (schema + template)\", DATASET_COLORS[\"SynSQL\"], synsql_db_size),\n]:\n    axis.hist(lengths, bins=bins, density=True, alpha=0.5, color=color, label=label)\naxis.axvline(band_start, color=\"#52514e\", linestyle=\"--\", linewidth=1, label=\"band start\")\naxis.axvline(MAX_SEQ_LENGTH, color=\"#0b0b0b\", linestyle=\":\", linewidth=1, label=\"MAX_SEQ_LENGTH\")\naxis.set(title=\"Prompt size: BIRD and Spider examples vs SynSQL databases\", xlabel=\"tokens\", ylabel=\"density\")\naxis.legend()\nplt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T00:56:45.491683Z","iopub.execute_input":"2026-10-20T00:56:45.492431Z","iopub.status.idle":"2026-10-20T00:56:46.111452Z","shell.execute_reply.started":"2026-10-20T00:56:45.492394Z","shell.execute_reply":"2026-10-20T00:56:46.110078Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 1100x400 with 1 Axes>","image/png":"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\n"},"metadata":{}}],"execution_count":13},{"id":"cell-20","cell_type":"markdown","source":"## 6. Candidate rows and bands\n\nOnly databases whose schema lands near the band start are kept, and multi-turn dialogues are dropped. The size of each row is estimated as schema + template + question + hint + SQL tokens (each part takes the maximum across tokenizers, so the estimate is an upper bound up to a couple of boundary tokens), and a sample is checked against the exact count.","metadata":{}},{"id":"cell-21","cell_type":"code","source":"candidate_db_ids = synsql_db_size[synsql_db_size.between(band_start - 500, MAX_SEQ_LENGTH)].index\n\ncandidates = samples[\n    samples[\"db_id\"].isin(candidate_db_ids) & ~samples[\"question_style\"].isin(EXCLUDED_STYLES)\n].copy()\ncandidates[\"db_id\"] = candidates[\"db_id\"].astype(str)\ncandidates[\"total_tokens\"] = (\n    candidates[\"db_id\"].map(databases[\"schema_tokens\"]).to_numpy()\n    + template_overhead\n    + count_text_tokens(candidates[\"question\"])\n    + count_text_tokens(candidates[\"external_knowledge\"])\n    + count_text_tokens(candidates[\"sql\"])\n)\nprint(f\"{candidates['db_id'].nunique():,} candidate databases, {len(candidates):,} rows\")\n\ncheck = candidates.sample(min(300, len(candidates)), random_state=SEED)\nexact_tokens = count_example_tokens(\n    check[\"db_id\"].map(databases[\"ddl\"]), check[\"external_knowledge\"], check[\"question\"], check[\"sql\"]\n)\nestimate_errors = exact_tokens - check[\"total_tokens\"].to_numpy()\nprint(f\"Estimate error (exact - estimated): mean {estimate_errors.mean():+.1f}, \"\n      f\"min {estimate_errors.min()}, max {estimate_errors.max()}\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T00:56:46.115531Z","iopub.execute_input":"2026-10-20T00:56:46.116000Z","iopub.status.idle":"2026-10-20T01:16:15.254020Z","shell.execute_reply.started":"2026-10-20T00:56:46.115960Z","shell.execute_reply":"2026-10-20T01:16:15.252645Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"Tokenizing:   0%|          | 0/1094 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":""}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"Tokenizing:   0%|          | 0/1094 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":""}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"Tokenizing:   0%|          | 0/1094 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":""}},"metadata":{}},{"name":"stdout","text":"16,416 candidate databases, 2,240,271 rows\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"Tokenizing:   0%|          | 0/1 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":""}},"metadata":{}},{"name":"stdout","text":"Estimate error (exact - estimated): mean +1.7, min 0, max 3\n","output_type":"stream"}],"execution_count":14},{"id":"cell-22","cell_type":"markdown","source":"The bands go from `band_start` to the largest SynSQL row that fits, since SynSQL has nothing close to 4096 tokens. Inside each database and band, rows are ranked by: uses an identifier that needs quotes, at least 2 JOINs (capped, so very long join chains get no extra credit), no CTE (closer to BIRD and Spider), then a random tie-break. The top `CANDIDATES_PER_DB` per database and band go to execution.","metadata":{}},{"id":"cell-23","cell_type":"code","source":"safety_margin = max(0, int(estimate_errors.max()))\ncandidates = candidates[candidates[\"total_tokens\"].between(band_start, MAX_SEQ_LENGTH - safety_margin)].copy()\nband_edges = np.linspace(band_start, candidates[\"total_tokens\"].max(), N_BANDS + 1).round().astype(int)\ncandidates[\"band\"] = pd.cut(candidates[\"total_tokens\"], band_edges, labels=False, include_lowest=True).astype(int)\ncandidates[\"uses_quoted_identifier\"] = candidates[\"quoted_identifiers\"].str.len() > 0\ncandidates[\"n_joins_capped\"] = candidates[\"n_joins\"].clip(upper=2)\ncandidates[\"random_key\"] = np.random.default_rng(SEED).random(len(candidates))\n\npriority = [\"uses_quoted_identifier\", \"n_joins_capped\", \"has_cte\", \"random_key\"]\npriority_ascending = [False, False, True, True]\nshortlist = (\n    candidates.sort_values(priority, ascending=priority_ascending)\n    .groupby([\"db_id\", \"band\"])\n    .head(CANDIDATES_PER_DB)\n    .copy()\n)\n\nband_overview = candidates.groupby(\"band\").agg(databases=(\"db_id\", \"nunique\"), rows=(\"db_id\", \"size\"))\nband_overview.insert(0, \"token_range\", [f\"{band_edges[band]}-{band_edges[band + 1]}\" for band in band_overview.index])\ndisplay(band_overview)\nprint(f\"{len(shortlist):,} shortlisted rows | rows using quoted identifiers: {candidates['uses_quoted_identifier'].sum():,}\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T01:16:15.256013Z","iopub.execute_input":"2026-10-20T01:16:15.256580Z","iopub.status.idle":"2026-10-20T01:16:36.092899Z","shell.execute_reply.started":"2026-10-20T01:16:15.256547Z","shell.execute_reply":"2026-10-20T01:16:36.091637Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"     token_range  databases     rows\nband                                \n0       900-1685      15627  1673516\n1      1685-2470       9857   287352\n2      2470-3254       1028     5425\n3      3254-4039         50       77","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>token_range</th>\n      <th>databases</th>\n      <th>rows</th>\n    </tr>\n    <tr>\n      <th>band</th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>900-1685</td>\n      <td>15627</td>\n      <td>1673516</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1685-2470</td>\n      <td>9857</td>\n      <td>287352</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2470-3254</td>\n      <td>1028</td>\n      <td>5425</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>3254-4039</td>\n      <td>50</td>\n      <td>77</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}},{"name":"stdout","text":"117,519 shortlisted rows | rows using quoted identifiers: 534\n","output_type":"stream"}],"execution_count":15},{"id":"cell-24","cell_type":"markdown","source":"## 7. Execution validation\n\nEach shortlisted SQL runs on its database (read-only, with a timeout). A query that fails is discarded; an empty result is allowed but ranked lower, since SynSQL tables hold very few rows (see `max_rows_per_table` above).","metadata":{}},{"id":"cell-25","cell_type":"code","source":"def execute_sql(db_path, sql):\n    connection = sqlite3.connect(f\"file:{db_path}?mode=ro\", uri=True)\n    deadline = time.monotonic() + SQL_TIMEOUT_SECONDS\n    connection.set_progress_handler(lambda: int(time.monotonic() > deadline), 10_000)\n    try:\n        return True, len(connection.execute(sql).fetchall())\n    except (sqlite3.Error, sqlite3.Warning):\n        return False, 0\n    finally:\n        connection.close()\n\n\nresults = [\n    execute_sql(db_paths[db_id], sql)\n    for db_id, sql in tqdm(zip(shortlist[\"db_id\"], shortlist[\"sql\"]), total=len(shortlist), desc=\"Executing gold SQL\")\n]\nshortlist[\"executes\"] = [is_ok for is_ok, _ in results]\nshortlist[\"n_result_rows\"] = [n_rows for _, n_rows in results]\nshortlist[\"is_non_empty\"] = shortlist[\"n_result_rows\"] > 0\n\ndisplay(shortlist.groupby(\"sql_complexity\", observed=True)[[\"executes\", \"is_non_empty\"]].mean().round(3))\nprint(f\"Executes: {shortlist['executes'].mean():.1%} | non-empty result: {shortlist['is_non_empty'].mean():.1%}\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T01:16:36.094708Z","iopub.execute_input":"2026-10-20T01:16:36.095218Z","iopub.status.idle":"2026-10-20T01:18:16.607623Z","shell.execute_reply.started":"2026-10-20T01:16:36.095174Z","shell.execute_reply":"2026-10-20T01:18:16.606463Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"Executing gold SQL:   0%|          | 0/117519 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"68e6522f90234b81a7e1da181013e597"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"                executes  is_non_empty\nsql_complexity                        \nComplex              1.0         0.410\nHighly Complex       1.0         0.538\nModerate             1.0         0.339\nSimple               1.0         0.537","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>executes</th>\n      <th>is_non_empty</th>\n    </tr>\n    <tr>\n      <th>sql_complexity</th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Complex</th>\n      <td>1.0</td>\n      <td>0.410</td>\n    </tr>\n    <tr>\n      <th>Highly Complex</th>\n      <td>1.0</td>\n      <td>0.538</td>\n    </tr>\n    <tr>\n      <th>Moderate</th>\n      <td>1.0</td>\n      <td>0.339</td>\n    </tr>\n    <tr>\n      <th>Simple</th>\n      <td>1.0</td>\n      <td>0.537</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}},{"name":"stdout","text":"Executes: 100.0% | non-empty result: 42.4%\n","output_type":"stream"}],"execution_count":16},{"id":"cell-26","cell_type":"markdown","source":"## 8. Selection\n\nEach database is used once. Bands are filled from the largest down: each band takes an equal share of what is left of `TARGET_SIZE`, so a band without enough databases passes its shortfall to the smaller ones. The final token counts are exact, not estimated.","metadata":{}},{"id":"cell-27","cell_type":"code","source":"valid = shortlist[shortlist[\"executes\"]].sort_values(\n    [\"is_non_empty\", *priority], ascending=[False, *priority_ascending]\n)\n\nselected_parts = []\nused_db_ids = set()\nremaining = TARGET_SIZE\nfor band in reversed(range(N_BANDS)):\n    band_rows = (\n        valid[(valid[\"band\"] == band) & ~valid[\"db_id\"].isin(used_db_ids)]\n        .groupby(\"db_id\")\n        .head(1)\n        .head(remaining // (band + 1))\n    )\n    selected_parts.append(band_rows)\n    used_db_ids.update(band_rows[\"db_id\"])\n    remaining -= len(band_rows)\nselected = pd.concat(selected_parts)\n\nselected[\"schema\"] = selected[\"db_id\"].map(databases[\"ddl\"])\nselected[\"total_tokens\"] = count_example_tokens(\n    selected[\"schema\"], selected[\"external_knowledge\"], selected[\"question\"], selected[\"sql\"]\n)\nselected = selected[selected[\"total_tokens\"] <= MAX_SEQ_LENGTH].assign(subset=\"size_band\")\nprint(f\"Selected {len(selected):,} rows from {selected['db_id'].nunique():,} databases (target {TARGET_SIZE:,})\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T01:18:16.609590Z","iopub.execute_input":"2026-10-20T01:18:16.610197Z","iopub.status.idle":"2026-10-20T01:18:26.880615Z","shell.execute_reply.started":"2026-10-20T01:18:16.610164Z","shell.execute_reply":"2026-10-20T01:18:26.878532Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"Tokenizing:   0%|          | 0/1 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":""}},"metadata":{}},{"name":"stdout","text":"Selected 2,000 rows from 2,000 databases (target 2,000)\n","output_type":"stream"}],"execution_count":17},{"id":"cell-28","cell_type":"markdown","source":"## 9. Extra pool: queries with names that need quotes\n\nThe size bands only reach the few quoted rows that fall inside them. Here every non-dialogue row that uses a name needing quotes is considered, whatever its size: it must fit `MAX_SEQ_LENGTH` (exact count), run on its database, and not already be selected. Up to `QUOTED_EXTRA_PER_DB` rows per database are kept, non-empty results first.","metadata":{}},{"id":"cell-29","cell_type":"code","source":"quoted_pool = samples[\n    (samples[\"quoted_identifiers\"].str.len() > 0)\n    & ~samples[\"question_style\"].isin(EXCLUDED_STYLES)\n    & ~samples.index.isin(selected.index)\n].copy()\nquoted_pool[\"db_id\"] = quoted_pool[\"db_id\"].astype(str)\nquoted_pool[\"schema\"] = quoted_pool[\"db_id\"].map(databases[\"ddl\"])\nquoted_pool[\"total_tokens\"] = count_example_tokens(\n    quoted_pool[\"schema\"], quoted_pool[\"external_knowledge\"], quoted_pool[\"question\"], quoted_pool[\"sql\"]\n)\nquoted_pool = quoted_pool[quoted_pool[\"total_tokens\"] <= MAX_SEQ_LENGTH].copy()\n\nresults = [\n    execute_sql(db_paths[db_id], sql)\n    for db_id, sql in tqdm(zip(quoted_pool[\"db_id\"], quoted_pool[\"sql\"]), total=len(quoted_pool), desc=\"Executing quoted SQL\")\n]\nquoted_pool[\"executes\"] = [is_ok for is_ok, _ in results]\nquoted_pool[\"n_result_rows\"] = [n_rows for _, n_rows in results]\nquoted_pool[\"is_non_empty\"] = quoted_pool[\"n_result_rows\"] > 0\nquoted_pool[\"uses_quoted_identifier\"] = True\nquoted_pool[\"random_key\"] = np.random.default_rng(SEED).random(len(quoted_pool))\n\nquoted_extra = (\n    quoted_pool[quoted_pool[\"executes\"]]\n    .sort_values([\"is_non_empty\", \"random_key\"], ascending=[False, True])\n    .groupby(\"db_id\")\n    .head(QUOTED_EXTRA_PER_DB)\n    .assign(subset=\"quoted_extra\", band=-1)\n)\nprint(f\"Quoted pool: {len(quoted_pool):,} rows that fit | executes: {quoted_pool['executes'].mean():.1%} \"\n      f\"| kept: {len(quoted_extra):,} rows from {quoted_extra['db_id'].nunique():,} databases\")\ndisplay(quoted_extra[\"quoting_reasons\"].explode().value_counts().rename(\"rows\").to_frame())\n\nselected = pd.concat([selected, quoted_extra])\nprint(f\"Total selected: {len(selected):,} rows\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T01:18:26.884261Z","iopub.execute_input":"2026-10-20T01:18:26.884924Z","iopub.status.idle":"2026-10-20T01:18:31.337664Z","shell.execute_reply.started":"2026-10-20T01:18:26.884861Z","shell.execute_reply":"2026-10-20T01:18:31.336521Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"Tokenizing:   0%|          | 0/1 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":""}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"Executing quoted SQL:   0%|          | 0/680 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"6afc9684abee45c6816f3705a78f5dd8"}},"metadata":{}},{"name":"stdout","text":"Quoted pool: 680 rows that fit | executes: 100.0% | kept: 218 rows from 103 databases\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"                   rows\nquoting_reasons        \nleading_digit        94\nreserved_word        70\nspecial_character    33\nspace                21","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>rows</th>\n    </tr>\n    <tr>\n      <th>quoting_reasons</th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>leading_digit</th>\n      <td>94</td>\n    </tr>\n    <tr>\n      <th>reserved_word</th>\n      <td>70</td>\n    </tr>\n    <tr>\n      <th>special_character</th>\n      <td>33</td>\n    </tr>\n    <tr>\n      <th>space</th>\n      <td>21</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}},{"name":"stdout","text":"Total selected: 2,218 rows\n","output_type":"stream"}],"execution_count":18},{"id":"cell-30","cell_type":"markdown","source":"## 10. Selection vs BIRD and Spider\n\nThe band table shows what each size range and the quoted extra pool (band -1) contributed. The comparison tables put the selection next to BIRD, Spider and the full SynSQL, both in prompt size and in SQL style, to show what the subset adds to the base mix and how far its style drifts from it.","metadata":{}},{"id":"cell-31","cell_type":"code","source":"band_summary = selected.groupby([\"subset\", \"band\"]).agg(\n    rows=(\"db_id\", \"size\"),\n    min_tokens=(\"total_tokens\", \"min\"),\n    max_tokens=(\"total_tokens\", \"max\"),\n    avg_joins=(\"n_joins\", \"mean\"),\n    with_cte=(\"has_cte\", \"mean\"),\n    uses_quoted_identifier=(\"uses_quoted_identifier\", \"mean\"),\n    is_non_empty=(\"is_non_empty\", \"mean\"),\n    with_external_knowledge=(\"has_external_knowledge\", \"mean\"),\n)\nband_summary.insert(0, \"token_range\", [\n    f\"{band_edges[band]}-{band_edges[band + 1]}\" if band >= 0 else f\"up to {MAX_SEQ_LENGTH}\"\n    for _, band in band_summary.index\n])\ndisplay(band_summary.round(3))\n\ndisplay(pd.DataFrame([\n    token_summary(\"BIRD train\", bird[\"total_tokens\"].to_numpy()),\n    token_summary(\"Spider train\", spider[\"total_tokens\"].to_numpy()),\n    token_summary(\"SynSQL selected\", selected[\"total_tokens\"].to_numpy()),\n]).round(3))\ndisplay(pd.DataFrame([\n    sql_style(\"BIRD train\", bird[\"sql\"], bird[\"evidence\"]),\n    sql_style(\"Spider train\", spider[\"sql\"], spider[\"evidence\"]),\n    sql_style(\"SynSQL (all)\", samples[\"sql\"], samples[\"external_knowledge\"]),\n    sql_style(\"SynSQL selected\", selected[\"sql\"], selected[\"external_knowledge\"]),\n]).round(3))\ndisplay(pd.DataFrame([\n    quoting_summary(\"BIRD train\", bird[\"quoted_identifiers\"], bird[\"quote_styles\"]),\n    quoting_summary(\"Spider train\", spider[\"quoted_identifiers\"], spider[\"quote_styles\"]),\n    quoting_summary(\"SynSQL (all)\", samples[\"quoted_identifiers\"], samples[\"quote_styles\"]),\n    quoting_summary(\"SynSQL selected\", selected[\"quoted_identifiers\"], selected[\"quote_styles\"]),\n]).round(3))\n\nfor column in [\"sql_complexity\", \"question_style\"]:\n    display(pd.concat({\n        \"full_dataset\": samples[column].value_counts(normalize=True),\n        \"selected\": selected[column].value_counts(normalize=True),\n    }, axis=1).round(3))\n\ndisplay(selected[[\"db_id\", \"question\", \"external_knowledge\", \"sql\", \"total_tokens\"]].head(5))","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T01:18:31.339859Z","iopub.execute_input":"2026-10-20T01:18:31.340328Z","iopub.status.idle":"2026-10-20T01:19:38.241088Z","shell.execute_reply.started":"2026-10-20T01:18:31.340295Z","shell.execute_reply":"2026-10-20T01:19:38.239766Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"                  token_range  rows  min_tokens  max_tokens  avg_joins  \\\nsubset       band                                                        \nquoted_extra -1    up to 4096   218         523        2660      2.821   \nsize_band     0      900-1685   650         902        1684      2.682   \n              1     1685-2470   650        1687        2405      3.463   \n              2     2470-3254   650        2472        3239      6.895   \n              3     3254-4039    50        3257        4040      8.080   \n\n                   with_cte  uses_quoted_identifier  is_non_empty  \\\nsubset       band                                                   \nquoted_extra -1       0.523                   1.000         0.179   \nsize_band     0       0.014                   0.026         1.000   \n              1       0.008                   0.012         1.000   \n              2       0.792                   0.003         0.909   \n              3       0.900                   0.000         0.520   \n\n                   with_external_knowledge  \nsubset       band                           \nquoted_extra -1                      0.229  \nsize_band     0                      0.238  \n              1                      0.332  \n              2                      0.358  \n              3                      0.320  ","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th></th>\n      <th>token_range</th>\n      <th>rows</th>\n      <th>min_tokens</th>\n      <th>max_tokens</th>\n      <th>avg_joins</th>\n      <th>with_cte</th>\n      <th>uses_quoted_identifier</th>\n      <th>is_non_empty</th>\n      <th>with_external_knowledge</th>\n    </tr>\n    <tr>\n      <th>subset</th>\n      <th>band</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>quoted_extra</th>\n      <th>-1</th>\n      <td>up to 4096</td>\n      <td>218</td>\n      <td>523</td>\n      <td>2660</td>\n      <td>2.821</td>\n      <td>0.523</td>\n      <td>1.000</td>\n      <td>0.179</td>\n      <td>0.229</td>\n    </tr>\n    <tr>\n      <th rowspan=\"4\" valign=\"top\">size_band</th>\n      <th>0</th>\n      <td>900-1685</td>\n      <td>650</td>\n      <td>902</td>\n      <td>1684</td>\n      <td>2.682</td>\n      <td>0.014</td>\n      <td>0.026</td>\n      <td>1.000</td>\n      <td>0.238</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1685-2470</td>\n      <td>650</td>\n      <td>1687</td>\n      <td>2405</td>\n      <td>3.463</td>\n      <td>0.008</td>\n      <td>0.012</td>\n      <td>1.000</td>\n      <td>0.332</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2470-3254</td>\n      <td>650</td>\n      <td>2472</td>\n      <td>3239</td>\n      <td>6.895</td>\n      <td>0.792</td>\n      <td>0.003</td>\n      <td>0.909</td>\n      <td>0.358</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>3254-4039</td>\n      <td>50</td>\n      <td>3257</td>\n      <td>4040</td>\n      <td>8.080</td>\n      <td>0.900</td>\n      <td>0.000</td>\n      <td>0.520</td>\n      <td>0.320</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"           dataset  rows     p50     p75      p95   max  over_max_seq_length\n0       BIRD train  6597   824.0  1232.0  7267.00  7428                0.058\n1     Spider train  8576   555.0   795.0  1440.00  2757                0.000\n2  SynSQL selected  2218  1758.0  2509.0  2838.75  4040                0.000","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>dataset</th>\n      <th>rows</th>\n      <th>p50</th>\n      <th>p75</th>\n      <th>p95</th>\n      <th>max</th>\n      <th>over_max_seq_length</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>BIRD train</td>\n      <td>6597</td>\n      <td>824.0</td>\n      <td>1232.0</td>\n      <td>7267.00</td>\n      <td>7428</td>\n      <td>0.058</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>Spider train</td>\n      <td>8576</td>\n      <td>555.0</td>\n      <td>795.0</td>\n      <td>1440.00</td>\n      <td>2757</td>\n      <td>0.000</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>SynSQL selected</td>\n      <td>2218</td>\n      <td>1758.0</td>\n      <td>2509.0</td>\n      <td>2838.75</td>\n      <td>4040</td>\n      <td>0.000</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"           dataset     rows  avg_joins  with_join  with_2plus_joins  with_cte  \\\n0       BIRD train     6597      0.992      0.760             0.192     0.000   \n1     Spider train     8576      0.707      0.439             0.182     0.000   \n2     SynSQL (all)  2544390      2.169      0.893             0.629     0.413   \n3  SynSQL selected     2218      4.281      0.986             0.961     0.310   \n\n   with_hint  \n0      0.928  \n1      0.000  \n2      0.221  \n3      0.302  ","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>dataset</th>\n      <th>rows</th>\n      <th>avg_joins</th>\n      <th>with_join</th>\n      <th>with_2plus_joins</th>\n      <th>with_cte</th>\n      <th>with_hint</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>BIRD train</td>\n      <td>6597</td>\n      <td>0.992</td>\n      <td>0.760</td>\n      <td>0.192</td>\n      <td>0.000</td>\n      <td>0.928</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>Spider train</td>\n      <td>8576</td>\n      <td>0.707</td>\n      <td>0.439</td>\n      <td>0.182</td>\n      <td>0.000</td>\n      <td>0.000</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>SynSQL (all)</td>\n      <td>2544390</td>\n      <td>2.169</td>\n      <td>0.893</td>\n      <td>0.629</td>\n      <td>0.413</td>\n      <td>0.221</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>SynSQL selected</td>\n      <td>2218</td>\n      <td>4.281</td>\n      <td>0.986</td>\n      <td>0.961</td>\n      <td>0.310</td>\n      <td>0.302</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"           dataset     rows  with_quoted_identifier  with_space  \\\n0       BIRD train     6597                   0.074       0.047   \n1     Spider train     8576                   0.000       0.000   \n2     SynSQL (all)  2544390                   0.000       0.000   \n3  SynSQL selected     2218                   0.110       0.013   \n\n   with_special_character  with_leading_digit  with_reserved_word  \\\n0                   0.019               0.000               0.008   \n1                   0.000               0.000               0.000   \n2                   0.000               0.000               0.000   \n3                   0.017               0.046               0.035   \n\n   uses_backtick  uses_double_quote  uses_bracket  \n0          0.992              0.010         0.000  \n1            NaN                NaN           NaN  \n2          0.456              0.531         0.014  \n3          0.433              0.543         0.024  ","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>dataset</th>\n      <th>rows</th>\n      <th>with_quoted_identifier</th>\n      <th>with_space</th>\n      <th>with_special_character</th>\n      <th>with_leading_digit</th>\n      <th>with_reserved_word</th>\n      <th>uses_backtick</th>\n      <th>uses_double_quote</th>\n      <th>uses_bracket</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>BIRD train</td>\n      <td>6597</td>\n      <td>0.074</td>\n      <td>0.047</td>\n      <td>0.019</td>\n      <td>0.000</td>\n      <td>0.008</td>\n      <td>0.992</td>\n      <td>0.010</td>\n      <td>0.000</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>Spider train</td>\n      <td>8576</td>\n      <td>0.000</td>\n      <td>0.000</td>\n      <td>0.000</td>\n      <td>0.000</td>\n      <td>0.000</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>SynSQL (all)</td>\n      <td>2544390</td>\n      <td>0.000</td>\n      <td>0.000</td>\n      <td>0.000</td>\n      <td>0.000</td>\n      <td>0.000</td>\n      <td>0.456</td>\n      <td>0.531</td>\n      <td>0.014</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>SynSQL selected</td>\n      <td>2218</td>\n      <td>0.110</td>\n      <td>0.013</td>\n      <td>0.017</td>\n      <td>0.046</td>\n      <td>0.035</td>\n      <td>0.433</td>\n      <td>0.543</td>\n      <td>0.024</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"                full_dataset  selected\nsql_complexity                        \nComplex                0.344     0.176\nModerate               0.305     0.312\nHighly Complex         0.255     0.469\nSimple                 0.097     0.042","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>full_dataset</th>\n      <th>selected</th>\n    </tr>\n    <tr>\n      <th>sql_complexity</th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Complex</th>\n      <td>0.344</td>\n      <td>0.176</td>\n    </tr>\n    <tr>\n      <th>Moderate</th>\n      <td>0.305</td>\n      <td>0.312</td>\n    </tr>\n    <tr>\n      <th>Highly Complex</th>\n      <td>0.255</td>\n      <td>0.469</td>\n    </tr>\n    <tr>\n      <th>Simple</th>\n      <td>0.097</td>\n      <td>0.042</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"                     full_dataset  selected\nquestion_style                             \nFormal                      0.112     0.116\nDescriptive                 0.111     0.119\nConcise                     0.111     0.100\nColloquial                  0.111     0.125\nMetaphorical                0.111     0.171\nImperative                  0.111     0.131\nInterrogative               0.111     0.105\nVague                       0.111     0.133\nMulti-turn Dialogue         0.111     0.000","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>full_dataset</th>\n      <th>selected</th>\n    </tr>\n    <tr>\n      <th>question_style</th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Formal</th>\n      <td>0.112</td>\n      <td>0.116</td>\n    </tr>\n    <tr>\n      <th>Descriptive</th>\n      <td>0.111</td>\n      <td>0.119</td>\n    </tr>\n    <tr>\n      <th>Concise</th>\n      <td>0.111</td>\n      <td>0.100</td>\n    </tr>\n    <tr>\n      <th>Colloquial</th>\n      <td>0.111</td>\n      <td>0.125</td>\n    </tr>\n    <tr>\n      <th>Metaphorical</th>\n      <td>0.111</td>\n      <td>0.171</td>\n    </tr>\n    <tr>\n      <th>Imperative</th>\n      <td>0.111</td>\n      <td>0.131</td>\n    </tr>\n    <tr>\n      <th>Interrogative</th>\n      <td>0.111</td>\n      <td>0.105</td>\n    </tr>\n    <tr>\n      <th>Vague</th>\n      <td>0.111</td>\n      <td>0.133</td>\n    </tr>\n    <tr>\n      <th>Multi-turn Dialogue</th>\n      <td>0.111</td>\n      <td>0.000</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"                                                   db_id  \\\n432310             league_of_legends_match_data_analysis   \n957670       weather_data_collection_and_analysis_492266   \n471994                     used_car_sales_and_management   \n2542815      city_comparison_and_quality_of_life_metrics   \n1169668  baseball_team_performance_and_player_statistics   \n\n                                                                                                                        question  \\\n432310   Could you please calculate and compare the average performance metrics of the blue team in both winning and losing m...   \n957670   Could you please generate a report that includes the daily averages and 7-day moving averages for wind speed, temper...   \n471994   Could you generate a comprehensive report that includes the top 5 fuel types, body types, states, sources, makes, mo...   \n2542815  What are the top three cities with the highest overall composite scores based on their cost of living, quality of li...   \n1169668  What is the comprehensive summary of each player's seasonal performance, including their team, average and cumulativ...   \n\n                                                                                                              external_knowledge  \\\n432310                                                                                                                             \n957670                                                                                                                             \n471994                                                                                                                             \n2542815                                                                                                                            \n1169668  This query is likely used in a professional sports context to monitor player health, track performance over time, an...   \n\n                                                                                                                             sql  \\\n432310   -- Step 1: Select performance metrics for blue team in winning and losing matches\\nWITH BlueTeamWins AS (\\n    SELEC...   \n957670   WITH DailyData AS (\\n    SELECT \\n        ds.dataset_id,\\n        ws.wind_speed_2m,\\n        ws.wind_speed_10m,\\n   ...   \n471994   WITH Top5FuelTypes AS (\\n  SELECT ft.fuel_type_name, COUNT(c.car_id) as total_cars\\n  FROM fuel_types ft\\n  INNER JO...   \n2542815  WITH CostOfLiving AS (\\n    SELECT \\n        col.city_id,\\n        AVG(col.mcmeal_price) AS avg_mcmeal_price,\\n     ...   \n1169668  WITH PlayerSeasonStats AS (\\n    SELECT \\n        p.player_id,\\n        p.name,\\n        t.team_name,\\n        ss.ye...   \n\n         total_tokens  \n432310           3317  \n957670           3296  \n471994           3468  \n2542815          3578  \n1169668          3574  ","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>db_id</th>\n      <th>question</th>\n      <th>external_knowledge</th>\n      <th>sql</th>\n      <th>total_tokens</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>432310</th>\n      <td>league_of_legends_match_data_analysis</td>\n      <td>Could you please calculate and compare the average performance metrics of the blue team in both winning and losing m...</td>\n      <td></td>\n      <td>-- Step 1: Select performance metrics for blue team in winning and losing matches\\nWITH BlueTeamWins AS (\\n    SELEC...</td>\n      <td>3317</td>\n    </tr>\n    <tr>\n      <th>957670</th>\n      <td>weather_data_collection_and_analysis_492266</td>\n      <td>Could you please generate a report that includes the daily averages and 7-day moving averages for wind speed, temper...</td>\n      <td></td>\n      <td>WITH DailyData AS (\\n    SELECT \\n        ds.dataset_id,\\n        ws.wind_speed_2m,\\n        ws.wind_speed_10m,\\n   ...</td>\n      <td>3296</td>\n    </tr>\n    <tr>\n      <th>471994</th>\n      <td>used_car_sales_and_management</td>\n      <td>Could you generate a comprehensive report that includes the top 5 fuel types, body types, states, sources, makes, mo...</td>\n      <td></td>\n      <td>WITH Top5FuelTypes AS (\\n  SELECT ft.fuel_type_name, COUNT(c.car_id) as total_cars\\n  FROM fuel_types ft\\n  INNER JO...</td>\n      <td>3468</td>\n    </tr>\n    <tr>\n      <th>2542815</th>\n      <td>city_comparison_and_quality_of_life_metrics</td>\n      <td>What are the top three cities with the highest overall composite scores based on their cost of living, quality of li...</td>\n      <td></td>\n      <td>WITH CostOfLiving AS (\\n    SELECT \\n        col.city_id,\\n        AVG(col.mcmeal_price) AS avg_mcmeal_price,\\n     ...</td>\n      <td>3578</td>\n    </tr>\n    <tr>\n      <th>1169668</th>\n      <td>baseball_team_performance_and_player_statistics</td>\n      <td>What is the comprehensive summary of each player's seasonal performance, including their team, average and cumulativ...</td>\n      <td>This query is likely used in a professional sports context to monitor player health, track performance over time, an...</td>\n      <td>WITH PlayerSeasonStats AS (\\n    SELECT \\n        p.player_id,\\n        p.name,\\n        t.team_name,\\n        ss.ye...</td>\n      <td>3574</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}],"execution_count":19},{"id":"cell-32","cell_type":"code","source":"fig, axis = plt.subplots(figsize=(11, 4))\nfor label, color, lengths in [\n    (\"BIRD train examples\", DATASET_COLORS[\"BIRD\"], bird[\"total_tokens\"]),\n    (\"Spider train examples\", DATASET_COLORS[\"Spider\"], spider[\"total_tokens\"]),\n    (\"SynSQL selected\", DATASET_COLORS[\"SynSQL\"], selected[\"total_tokens\"]),\n]:\n    axis.hist(lengths, bins=bins, density=True, alpha=0.5, color=color, label=label)\naxis.set(title=\"Example size after selection\", xlabel=\"tokens\", ylabel=\"density\", xlim=(0, MAX_SEQ_LENGTH + 200))\naxis.legend()\nplt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T01:19:38.242926Z","iopub.execute_input":"2026-10-20T01:19:38.243690Z","iopub.status.idle":"2026-10-20T01:19:38.857189Z","shell.execute_reply.started":"2026-10-20T01:19:38.243654Z","shell.execute_reply":"2026-10-20T01:19:38.854781Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 1100x400 with 1 Axes>","image/png":"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\n"},"metadata":{}}],"execution_count":20},{"id":"cell-33","cell_type":"code","source":"def plot_reason_shares(frames):\n    reason_shares = pd.DataFrame({\n        label: [\n            frame[\"quoted_identifiers\"].apply(lambda names: any(quoting_reason(name) == reason for name in names)).mean()\n            for reason in QUOTING_REASONS\n        ]\n        for label, (frame, _) in frames.items()\n    }, index=QUOTING_REASONS)\n    fig, axis = plt.subplots(figsize=(11, 4))\n    reason_shares.plot.bar(ax=axis, color=[color for _, color in frames.values()], width=0.8)\n    axis.set(title=\"Share of rows referencing a name that needs quotes, by reason\", xlabel=\"\", ylabel=\"share of rows\")\n    axis.tick_params(axis=\"x\", rotation=0)\n    plt.show()\n    return reason_shares\n\n\ndisplay(plot_reason_shares({\n    \"BIRD train\": (bird, DATASET_COLORS[\"BIRD\"]),\n    \"Spider train\": (spider, DATASET_COLORS[\"Spider\"]),\n    \"SynSQL selected\": (selected, DATASET_COLORS[\"SynSQL\"]),\n}).round(3))","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T01:19:38.858877Z","iopub.execute_input":"2026-10-20T01:19:38.859524Z","iopub.status.idle":"2026-10-20T01:19:39.153419Z","shell.execute_reply.started":"2026-10-20T01:19:38.859487Z","shell.execute_reply":"2026-10-20T01:19:39.151951Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 1100x400 with 1 Axes>","image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"                   BIRD train  Spider train  SynSQL selected\nspace                   0.047           0.0            0.013\nspecial_character       0.019           0.0            0.017\nleading_digit           0.000           0.0            0.046\nreserved_word           0.008           0.0            0.035","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>BIRD train</th>\n      <th>Spider train</th>\n      <th>SynSQL selected</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>space</th>\n      <td>0.047</td>\n      <td>0.0</td>\n      <td>0.013</td>\n    </tr>\n    <tr>\n      <th>special_character</th>\n      <td>0.019</td>\n      <td>0.0</td>\n      <td>0.017</td>\n    </tr>\n    <tr>\n      <th>leading_digit</th>\n      <td>0.000</td>\n      <td>0.0</td>\n      <td>0.046</td>\n    </tr>\n    <tr>\n      <th>reserved_word</th>\n      <td>0.008</td>\n      <td>0.0</td>\n      <td>0.035</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}],"execution_count":21},{"id":"cell-34","cell_type":"markdown","source":"## 11. Save\n\nThe rows use the same column names as the BIRD trainset (`db_id`, `question`, `evidence`, `sql`, `schema`) plus the metadata used in the selection. The SQLite files of the selected databases are zipped next to them, ready for execution checks in the v2 pipeline.","metadata":{}},{"id":"cell-35","cell_type":"code","source":"output_columns = [\n    \"db_id\", \"question\", \"evidence\", \"sql\", \"schema\", \"total_tokens\", \"subset\", \"band\",\n    \"sql_complexity\", \"question_style\", \"n_joins\", \"has_cte\", \"quoted_identifiers\", \"quoting_reasons\", \"n_result_rows\",\n]\nselected = selected.rename(columns={\"external_knowledge\": \"evidence\"})\nselected[output_columns].to_parquet(OUTPUT_DIR / \"synsql_selected.parquet\", index=False)\n\nwith zipfile.ZipFile(OUTPUT_DIR / \"synsql_selected_databases.zip\", \"w\", zipfile.ZIP_DEFLATED) as archive:\n    for db_id in tqdm(selected[\"db_id\"].unique(), desc=\"Zipping databases\"):\n        archive.write(db_paths[db_id], f\"{db_id}/{db_id}.sqlite\")\n\nprint(f\"Saved {len(selected):,} rows and {selected['db_id'].nunique():,} databases to {OUTPUT_DIR}\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-10-20T01:19:39.155134Z","iopub.execute_input":"2026-10-20T01:19:39.155664Z","iopub.status.idle":"2026-10-20T01:19:41.592270Z","shell.execute_reply.started":"2026-10-20T01:19:39.155615Z","shell.execute_reply":"2026-10-20T01:19:41.591124Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"Zipping databases:   0%|          | 0/2078 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"9559c7e38736499b8b8dfa1241ac2d03"}},"metadata":{}},{"name":"stdout","text":"Saved 2,218 rows and 2,078 databases to /kaggle/working\n","output_type":"stream"}],"execution_count":22},{"id":"cell-36","cell_type":"markdown","source":"## Conclusion\n\nSection 10 holds the result: the size bands (one validated question per database, filled from the largest band down) plus the extra pool of validated queries that use names needing quotes, all with sizes checked against both Qwen3.5 tokenizers.\n\n- SynSQL schemas are about as large as BIRD's in tokens and stop well below 4096, so the subset widens the middle of the size range rather than adding very long prompts.\n- Names that need quotes exist in only a few percent of SynSQL databases, mostly reserved words such as `order` and `references` and leading digits such as `52_week_high`. That complements LLMSQL, where almost all quoted names have spaces.\n- The longest rows reach their size through long SQL (many JOINs and CTEs), not larger schemas, so they pull the output style away from BIRD and Spider.\n- Execution only proves the query runs and references real tables and columns. With about two rows per table it does not prove the answer is right.\n- Exact token counts depend on `SYSTEM_PROMPT` matching the training prompt.","metadata":{}}]}