data/dq300-00000-of-00001.jsonl

{"question_id": 0, "db_id": "debit_card_specializing", "SQL": "SELECT CAST(SUM(CASE WHEN Currency = 'EUR' THEN 1 ELSE 0 END) AS REAL) / NULLIF(SUM(CASE WHEN Currency = 'CZK' THEN 1 ELSE 0 END), 0) FROM customers", "pandas_query": "eur_count = customers[customers[\"Currency\"] == \"EUR\"].shape[0]\nczk_count = customers[customers[\"Currency\"] == \"CZK\"].shape[0]\nresult = float(eur_count) / czk_count"}
{"question_id": 1, "db_id": "debit_card_specializing", "SQL": "SELECT T1.CustomerID FROM customers AS T1 INNER JOIN yearmonth AS T2 ON T1.CustomerID = T2.CustomerID WHERE T1.Segment = 'LAM' AND SUBSTR(T2.Date, 1, 4) = '2012' GROUP BY T1.CustomerID ORDER BY SUM(T2.Consumption) ASC NULLS FIRST LIMIT 1", "pandas_query": "merged_df = pd.merge(customers, yearmonth, on=\"CustomerID\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"Segment\"] == \"LAM\") & (merged_df[\"Date\"].str[:4] == \"2012\")]\ngrouped_df = filtered_df.groupby(\"CustomerID\")[\"Consumption\"].sum()\nresult = grouped_df.idxmin()"}
{"question_id": 2, "db_id": "debit_card_specializing", "SQL": "SELECT AVG(T3.TotalConsumption) / NULLIF(12, 0) FROM (SELECT SUM(T2.Consumption) AS TotalConsumption FROM customers AS T1 INNER JOIN yearmonth AS T2 ON T1.CustomerID = T2.CustomerID WHERE SUBSTR(T2.Date, 1, 4) = '2013' AND T1.Segment = 'SME' GROUP BY T1.CustomerID) AS T3", "pandas_query": "merged_df = pd.merge(customers, yearmonth, on=\"CustomerID\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"Segment\"] == \"SME\") & (merged_df[\"Date\"].str[:4] == '2013')]\ngrouped_df = filtered_df.groupby(\"CustomerID\")[\"Consumption\"].sum()\nresult = grouped_df.mean() / 12"}
{"question_id": 4, "db_id": "debit_card_specializing", "SQL": "SELECT SUBSTR(T2.Date, 1, 4) FROM customers AS T1 INNER JOIN yearmonth AS T2 ON T1.CustomerID = T2.CustomerID WHERE T1.Currency = 'CZK' GROUP BY SUBSTR(T2.Date, 1, 4) ORDER BY SUM(T2.Consumption) DESC NULLS LAST LIMIT 1", "pandas_query": "merged_df = pd.merge(customers, yearmonth, on=\"CustomerID\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"Currency\"] == \"CZK\"]\nfiltered_df[\"Year\"] = filtered_df[\"Date\"].str[:4]\ngrouped_df = filtered_df.groupby(\"Year\")[\"Consumption\"].sum()\nresult = grouped_df.idxmax()"}
{"question_id": 5, "db_id": "debit_card_specializing", "SQL": "SELECT SUBSTR(T2.Date, 5, 2) FROM customers AS T1 INNER JOIN yearmonth AS T2 ON T1.CustomerID = T2.CustomerID WHERE SUBSTR(T2.Date, 1, 4) = '2013' AND T1.Segment = 'SME' GROUP BY SUBSTR(T2.Date, 5, 2) ORDER BY SUM(T2.Consumption) DESC NULLS LAST LIMIT 1", "pandas_query": "merged_df = pd.merge(customers, yearmonth, on=\"CustomerID\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"Segment\"] == \"SME\") & (merged_df[\"Date\"].str[:4] == \"2013\")]\ngrouped_df = filtered_df.groupby(filtered_df[\"Date\"].str[4:6])[\"Consumption\"].sum()\nresult = grouped_df.idxmax()"}
{"question_id": 6, "db_id": "debit_card_specializing", "SQL": "SELECT CAST(SUM(CASE WHEN T1.Segment = 'SME' THEN T2.Consumption ELSE 0 END) AS REAL) / NULLIF(COUNT(T1.CustomerID), 0) - CAST(SUM(CASE WHEN T1.Segment = 'LAM' THEN T2.Consumption ELSE 0 END) AS REAL) / NULLIF(COUNT(T1.CustomerID), 0), CAST(SUM(CASE WHEN T1.Segment = 'LAM' THEN T2.Consumption ELSE 0 END) AS REAL) / NULLIF(COUNT(T1.CustomerID), 0) - CAST(SUM(CASE WHEN T1.Segment = 'KAM' THEN T2.Consumption ELSE 0 END) AS REAL) / NULLIF(COUNT(T1.CustomerID), 0), CAST(SUM(CASE WHEN T1.Segment = 'KAM' THEN T2.Consumption ELSE 0 END) AS REAL) / NULLIF(COUNT(T1.CustomerID), 0) - CAST(SUM(CASE WHEN T1.Segment = 'SME' THEN T2.Consumption ELSE 0 END) AS REAL) / NULLIF(COUNT(T1.CustomerID), 0) FROM customers AS T1 INNER JOIN yearmonth AS T2 ON T1.CustomerID = T2.CustomerID WHERE T1.Currency = 'CZK' AND T2.Consumption = (SELECT MIN(Consumption) FROM yearmonth) AND T2.Date::text BETWEEN '201301' AND '201312'", "pandas_query": "merged_df = pd.merge(customers, yearmonth, on=\"CustomerID\", how=\"inner\")\n\n\nfiltered_df = merged_df[\n(merged_df[\"Currency\"] == \"CZK\") &\n(merged_df[\"Date\"].between(\"201301\", \"201312\"))\n]\n\n\n\nmin_consumption = filtered_df[\"Consumption\"].min()\n\nfiltered_df = filtered_df[filtered_df[\"Consumption\"] == min_consumption]\n\nsme_consumption = filtered_df[filtered_df[\"Segment\"] == \"SME\"][\"Consumption\"].sum()\nlam_consumption = filtered_df[filtered_df[\"Segment\"] == \"LAM\"][\"Consumption\"].sum()\nkam_consumption = filtered_df[filtered_df[\"Segment\"] == \"KAM\"][\"Consumption\"].sum()\n\nsme_count = filtered_df[filtered_df[\"Segment\"] == \"SME\"][\"CustomerID\"].nunique()\nlam_count = filtered_df[filtered_df[\"Segment\"] == \"LAM\"][\"CustomerID\"].nunique()\nkam_count = filtered_df[filtered_df[\"Segment\"] == \"KAM\"][\"CustomerID\"].nunique()\n\n\n\nsme_avg = sme_consumption / sme_count if sme_count > 0 else 0\nlam_avg = lam_consumption / lam_count if lam_count > 0 else 0\nkam_avg = kam_consumption / kam_count if kam_count > 0 else 0\n\n\n\nresult = (sme_avg - lam_avg, lam_avg - kam_avg, kam_avg - sme_avg)\n\n"}
{"question_id": 7, "db_id": "debit_card_specializing", "SQL": "SELECT CAST((SUM(CASE WHEN T1.Segment = 'SME' AND T2.Date LIKE '2013%' THEN T2.Consumption ELSE 0 END) - SUM(CASE WHEN T1.Segment = 'SME' AND T2.Date LIKE '2012%' THEN T2.Consumption ELSE 0 END)) AS REAL) * 100 / NULLIF(SUM(CASE WHEN T1.Segment = 'SME' AND T2.Date LIKE '2012%' THEN T2.Consumption ELSE 0 END), 0), CAST(SUM(CASE WHEN T1.Segment = 'LAM' AND T2.Date LIKE '2013%' THEN T2.Consumption ELSE 0 END) - SUM(CASE WHEN T1.Segment = 'LAM' AND T2.Date LIKE '2012%' THEN T2.Consumption ELSE 0 END) AS REAL) * 100 / NULLIF(SUM(CASE WHEN T1.Segment = 'LAM' AND T2.Date LIKE '2012%' THEN T2.Consumption ELSE 0 END), 0), CAST(SUM(CASE WHEN T1.Segment = 'KAM' AND T2.Date LIKE '2013%' THEN T2.Consumption ELSE 0 END) - SUM(CASE WHEN T1.Segment = 'KAM' AND T2.Date LIKE '2012%' THEN T2.Consumption ELSE 0 END) AS REAL) * 100 / NULLIF(SUM(CASE WHEN T1.Segment = 'KAM' AND T2.Date LIKE '2012%' THEN T2.Consumption ELSE 0 END), 0) FROM customers AS T1 INNER JOIN yearmonth AS T2 ON T1.CustomerID = T2.CustomerID WHERE T1.Currency = 'EUR'", "pandas_query": "merged_df = pd.merge(customers, yearmonth, on=\"CustomerID\", how=\"inner\")\n\nfiltered_df = merged_df[merged_df[\"Currency\"] == \"EUR\"]\n\nsme_2012 = filtered_df[(filtered_df[\"Segment\"] == \"SME\") & (filtered_df[\"Date\"].str.startswith(\"2012\"))][\"Consumption\"].sum()\nsme_2013 = filtered_df[(filtered_df[\"Segment\"] == \"SME\") & (filtered_df[\"Date\"].str.startswith(\"2013\"))][\"Consumption\"].sum()\nsme_percentage_increase = round(((sme_2013 - sme_2012) / sme_2012) * 100, 3) if sme_2012 != 0 else None\n\nlam_2012 = filtered_df[(filtered_df[\"Segment\"] == \"LAM\") & (filtered_df[\"Date\"].str.startswith(\"2012\"))][\"Consumption\"].sum()\nlam_2013 = filtered_df[(filtered_df[\"Segment\"] == \"LAM\") & (filtered_df[\"Date\"].str.startswith(\"2013\"))][\"Consumption\"].sum()\nlam_percentage_increase = round(((lam_2013 - lam_2012) / lam_2012) * 100, 3) if lam_2012 != 0 else None\n\nkam_2012 = filtered_df[(filtered_df[\"Segment\"] == \"KAM\") & (filtered_df[\"Date\"].str.startswith(\"2012\"))][\"Consumption\"].sum()\nkam_2013 = filtered_df[(filtered_df[\"Segment\"] == \"KAM\") & (filtered_df[\"Date\"].str.startswith(\"2013\"))][\"Consumption\"].sum()\nkam_percentage_increase = round(((kam_2013 - kam_2012) / kam_2012) * 100, 3) if kam_2012 != 0 else None\n\nresult = (sme_percentage_increase, lam_percentage_increase, kam_percentage_increase)"}
{"question_id": 10, "db_id": "debit_card_specializing", "SQL": "SELECT SUM(CASE WHEN Currency = 'CZK' THEN 1 ELSE 0 END) - SUM(CASE WHEN Currency = 'EUR' THEN 1 ELSE 0 END) FROM customers WHERE Segment = 'SME'", "pandas_query": "sme_customers = customers[customers[\"Segment\"] == \"SME\"]\nczk_count = (sme_customers[\"Currency\"] == \"CZK\").sum()\neur_count = (sme_customers[\"Currency\"] == \"EUR\").sum()\nresult = czk_count - eur_count"}
{"question_id": 11, "db_id": "debit_card_specializing", "SQL": "SELECT CAST(COUNT(DISTINCT CASE WHEN T2.Consumption > 46.73 THEN T1.CustomerID ELSE NULL END) AS REAL) * 100 / NULLIF(COUNT(DISTINCT T1.CustomerID), 0) FROM customers AS T1 INNER JOIN yearmonth AS T2 ON T1.CustomerID = T2.CustomerID WHERE T1.Segment = 'LAM'", "pandas_query": "merged_df = pd.merge(customers, yearmonth, on=\"CustomerID\", how=\"inner\")\nlam_customers = merged_df[merged_df[\"Segment\"] == \"LAM\"]\nconsumed_more_than_46_73 = lam_customers[lam_customers[\"Consumption\"] > 46.73][\"CustomerID\"].nunique()\ntotal_lam_customers = lam_customers[\"CustomerID\"].nunique()\nresult = (consumed_more_than_46_73 / total_lam_customers) * 100"}
{"question_id": 12, "db_id": "debit_card_specializing", "SQL": "SELECT CAST(SUM(CASE WHEN Consumption > 528.3 THEN 1 ELSE 0 END) AS REAL) * 100 / NULLIF(COUNT(CustomerID), 0) FROM yearmonth WHERE Date = '201202'", "pandas_query": "filtered_df = yearmonth[yearmonth[\"Date\"] == '201202']\ncount_above_528_3 = (filtered_df[\"Consumption\"] > 528.3).sum()\ntotal_customers = filtered_df[\"CustomerID\"].count()\nresult = (count_above_528_3 / total_customers) * 100"}
{"question_id": 13, "db_id": "debit_card_specializing", "SQL": "SELECT SUM(CAST(Consumption AS float)) FROM yearmonth WHERE SUBSTR(Date, 1, 4) = '2012' GROUP BY SUBSTR(Date, 5, 2) ORDER BY SUM(Consumption) DESC NULLS LAST LIMIT 1", "pandas_query": "yearmonth[\"Year\"] = yearmonth[\"Date\"].str[:4]\nyearmonth[\"Month\"] = yearmonth[\"Date\"].str[4:6]\n\n\nfiltered_df = yearmonth[yearmonth[\"Year\"] == \"2012\"]\n\n\ngrouped_df = filtered_df.groupby(\"Month\")[\"Consumption\"].sum()\n\n\nresult = grouped_df.max()\n\n\n\nresult = round(result, 1)\n\n\n"}
{"question_id": 14, "db_id": "debit_card_specializing", "SQL": "SELECT T3.Description FROM transactions_1k AS T1 INNER JOIN yearmonth AS T2 ON T1.CustomerID = T2.CustomerID INNER JOIN products AS T3 ON T1.ProductID = T3.ProductID WHERE T2.Date = '201309'", "pandas_query": "merged_df_1 = pd.merge(transactions_1k, yearmonth, left_on=\"CustomerID\", right_on=\"CustomerID\", how=\"inner\")\nmerged_df_2 = pd.merge(merged_df_1, products, left_on=\"ProductID\", right_on=\"ProductID\", how=\"inner\")\nfiltered_df = merged_df_2[merged_df_2[\"Date_y\"] == '201309']\nresult = filtered_df[\"Description\"]"}
{"question_id": 15, "db_id": "debit_card_specializing", "SQL": "SELECT DISTINCT T2.Country FROM transactions_1k AS T1 INNER JOIN gasstations AS T2 ON T1.GasStationID = T2.GasStationID WHERE CAST(T1.Date AS VARCHAR) LIKE '2012-08-%'", "pandas_query": "merged_df = pd.merge(transactions_1k, gasstations, left_on=\"GasStationID\", right_on=\"GasStationID\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"Date\"].str.startswith(\"2012-08\")]\nresult = filtered_df[\"Country\"].unique()"}
{"question_id": 17, "db_id": "debit_card_specializing", "SQL": "SELECT DISTINCT T3.Description FROM transactions_1k AS T1 INNER JOIN gasstations AS T2 ON T1.GasStationID = T2.GasStationID INNER JOIN products AS T3 ON T1.ProductID = T3.ProductID WHERE T2.Country = 'CZE'", "pandas_query": "merged_df_1 = pd.merge(transactions_1k, gasstations, on=\"GasStationID\", how=\"inner\")\nmerged_df_2 = pd.merge(merged_df_1, products, on=\"ProductID\", how=\"inner\")\nfiltered_df = merged_df_2[merged_df_2[\"Country\"] == \"CZE\"]\nresult = filtered_df[\"Description\"].unique()"}
{"question_id": 18, "db_id": "debit_card_specializing", "SQL": "SELECT DISTINCT T1.Time FROM transactions_1k AS T1 INNER JOIN gasstations AS T2 ON T1.GasStationID = T2.GasStationID WHERE T2.ChainID = 11", "pandas_query": "merged_df = pd.merge(transactions_1k, gasstations, left_on=\"GasStationID\", right_on=\"GasStationID\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"ChainID\"] == 11]\nresult = filtered_df[\"Time\"].unique()"}
{"question_id": 19, "db_id": "debit_card_specializing", "SQL": "SELECT COUNT(T1.TransactionID) FROM transactions_1k AS T1 INNER JOIN gasstations AS T2 ON T1.GasStationID = T2.GasStationID WHERE T2.Country = 'CZE' AND TO_CHAR(CAST(T1.Date AS TIMESTAMP), 'YYYY') >= '2012'", "pandas_query": "merged_df = pd.merge(transactions_1k, gasstations, left_on=\"GasStationID\", right_on=\"GasStationID\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"Country\"] == \"CZE\") & (pd.to_datetime(merged_df[\"Date\"]).dt.year >= 2012)]\nresult = filtered_df[\"TransactionID\"].count()"}
{"question_id": 22, "db_id": "debit_card_specializing", "SQL": "SELECT COUNT(T1.TransactionID) FROM transactions_1k AS T1 INNER JOIN gasstations AS T2 ON T1.GasStationID = T2.GasStationID WHERE T1.Date = '2012-08-26' AND T1.Time BETWEEN '08:00:00' AND '09:00:00' AND T2.Country = 'CZE'", "pandas_query": "merged_df = pd.merge(transactions_1k, gasstations, on=\"GasStationID\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"Date\"] == \"2012-08-26\") & (merged_df[\"Time\"] >= \"08:00:00\") & (merged_df[\"Time\"] <= \"09:00:00\") & (merged_df[\"Country\"] == \"CZE\")]\nresult = len(filtered_df)"}
{"question_id": 23, "db_id": "debit_card_specializing", "SQL": "SELECT T2.Country FROM transactions_1k AS T1 INNER JOIN gasstations AS T2 ON T1.GasStationID = T2.GasStationID WHERE T1.Date = '2012-08-24' AND T1.Price = '548.4'", "pandas_query": "merged_df = pd.merge(transactions_1k, gasstations, on=\"GasStationID\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"Date\"] == \"2012-08-24\") & (merged_df[\"Price\"] == 548.4)]\nresult = filtered_df[\"Country\"].iloc[0]"}
{"question_id": 24, "db_id": "debit_card_specializing", "SQL": "SELECT CAST(COUNT(DISTINCT CASE WHEN T2.Currency = 'EUR' THEN T1.CustomerID ELSE NULL END) AS REAL) * 100 / NULLIF(COUNT(DISTINCT T1.CustomerID), 0) FROM transactions_1k AS T1 INNER JOIN customers AS T2 ON T1.CustomerID = T2.CustomerID WHERE T1.Date = '2012-08-25'", "pandas_query": "merged_df = pd.merge(transactions_1k, customers, on=\"CustomerID\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"Date\"] == \"2012-08-25\"]\neur_customers = filtered_df[filtered_df[\"Currency\"] == \"EUR\"][\"CustomerID\"].nunique()\ntotal_customers = filtered_df[\"CustomerID\"].nunique()\nresult = (eur_customers / total_customers) * 100"}
{"question_id": 26, "db_id": "debit_card_specializing", "SQL": "SELECT CAST(SUM(CASE WHEN Country = 'SVK' AND Segment = 'Premium' THEN 1 ELSE 0 END) AS REAL) * 100 / NULLIF(SUM(CASE WHEN Country = 'SVK' THEN 1 ELSE 0 END), 0) FROM gasstations", "pandas_query": "total_svk = gasstations[gasstations[\"Country\"] == \"SVK\"]\npremium_count = total_svk[total_svk[\"Segment\"] == \"Premium\"].shape[0]\nresult = (premium_count / total_svk.shape[0]) * 100"}
{"question_id": 27, "db_id": "debit_card_specializing", "SQL": "SELECT SUM(T1.Price), SUM(CASE WHEN CAST(T1.Date AS VARCHAR) LIKE '2012-08%' THEN T1.Price ELSE 0 END) FROM transactions_1k AS T1 INNER JOIN gasstations AS T2 ON T1.GasStationID = T2.GasStationID WHERE T1.CustomerID = '38508'", "pandas_query": "merged_df = pd.merge(transactions_1k, gasstations, left_on=\"GasStationID\", right_on=\"GasStationID\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"CustomerID\"] == 38508]\ntotal_spent = filtered_df[\"Price\"].sum()\naugust_spent = filtered_df[filtered_df[\"Date\"].str.startswith(\"2012-08\")][\"Price\"].sum()\nresult = (total_spent, august_spent)"}
{"question_id": 29, "db_id": "debit_card_specializing", "SQL": "SELECT T2.Consumption FROM transactions_1k AS T1 INNER JOIN yearmonth AS T2 ON T1.CustomerID = T2.CustomerID WHERE T1.Price / NULLIF(T1.Amount, 0) > 29.00 AND T1.ProductID = 5 AND T2.Date = '201208'", "pandas_query": "merged_df = pd.merge(transactions_1k, yearmonth, on=\"CustomerID\", how=\"inner\")\n\nmerged_df = merged_df[merged_df[\"Amount\"] > 0]\n\nmerged_df[\"Price_per_unit\"] = merged_df[\"Price\"] / merged_df[\"Amount\"]\n\nfiltered_df = merged_df[\n(merged_df[\"Price_per_unit\"] > 29.00) &\n(merged_df[\"ProductID\"] == 5) &\n(merged_df[\"Date_y\"] == \"201208\")\n]\n\nfiltered_df = filtered_df.drop_duplicates(subset=[\"Consumption\"])\n\nresult = filtered_df[\"Consumption\"].tolist()"}
{"question_id": 30, "db_id": "student_club", "SQL": "SELECT T2.major_name FROM member AS T1 INNER JOIN major AS T2 ON T1.link_to_major = T2.major_id WHERE T1.first_name = 'Angela' AND T1.last_name = 'Sanders'", "pandas_query": "merged_df = pd.merge(member, major, left_on=\"link_to_major\", right_on=\"major_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"first_name\"] == \"Angela\") & (merged_df[\"last_name\"] == \"Sanders\")]\nresult = filtered_df[\"major_name\"].iloc[0]"}
{"question_id": 33, "db_id": "student_club", "SQL": "SELECT T1.event_name FROM event AS T1 INNER JOIN attendance AS T2 ON T1.event_id = T2.link_to_event GROUP BY T1.event_id HAVING COUNT(T2.link_to_event) > 20 EXCEPT SELECT T1.event_name FROM event AS T1 WHERE T1.type = 'Fundraiser'", "pandas_query": "merged_df = pd.merge(event, attendance, left_on=\"event_id\", right_on=\"link_to_event\", how=\"inner\")\n\ngrouped_df = merged_df.groupby(\"event_id\").filter(lambda x: len(x) > 20)\n\nnon_fundraiser_events = event[event[\"type\"] != \"Fundraiser\"]\n\nfiltered_df = grouped_df[grouped_df[\"event_id\"].isin(non_fundraiser_events[\"event_id\"])]\n\nresult = filtered_df[\"event_name\"].unique().tolist()"}
{"question_id": 34, "db_id": "student_club", "SQL": "SELECT T2.amount FROM member AS T1 INNER JOIN income AS T2 ON T1.member_id = T2.link_to_member WHERE T1.position = 'Vice President'", "pandas_query": "merged_df = pd.merge(member, income, left_on=\"member_id\", right_on=\"link_to_member\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"position\"] == \"Vice President\"]\nresult = filtered_df[\"amount\"].sum()"}
{"question_id": 35, "db_id": "student_club", "SQL": "SELECT T1.first_name, T1.last_name FROM member AS T1 INNER JOIN zip_code AS T2 ON T1.zip = T2.zip_code WHERE T2.state = 'Illinois'", "pandas_query": "merged_df = pd.merge(member, zip_code, left_on=\"zip\", right_on=\"zip_code\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"state\"] == \"Illinois\"]\nresult = filtered_df[[\"first_name\", \"last_name\"]]"}
{"question_id": 36, "db_id": "student_club", "SQL": "SELECT T3.approved FROM event AS T1 INNER JOIN budget AS T2 ON T1.event_id = T2.link_to_event INNER JOIN expense AS T3 ON T2.budget_id = T3.link_to_budget WHERE T1.event_name = 'October Meeting' AND T1.event_date LIKE '2019-10-08%'", "pandas_query": "merged_df1 = pd.merge(event, budget, left_on=\"event_id\", right_on=\"link_to_event\", how=\"inner\")\nmerged_df2 = pd.merge(merged_df1, expense, left_on=\"budget_id\", right_on=\"link_to_budget\", how=\"inner\")\nfiltered_df = merged_df2[(merged_df2[\"event_name\"] == \"October Meeting\") & (merged_df2[\"event_date\"].str.startswith(\"2019-10-08\"))]\nresult = filtered_df[\"approved\"]"}
{"question_id": 37, "db_id": "student_club", "SQL": "SELECT AVG(T2.cost) FROM member AS T1 INNER JOIN expense AS T2 ON T1.member_id = T2.link_to_member WHERE T1.last_name = 'Allen' AND T1.first_name = 'Elijah' AND (SUBSTR(T2.expense_date, 6, 2) = '09' OR SUBSTR(T2.expense_date, 6, 2) = '10')", "pandas_query": "merged_df = pd.merge(member, expense, left_on=\"member_id\", right_on=\"link_to_member\", how=\"inner\")\nfiltered_df = merged_df[\n(merged_df[\"last_name\"] == \"Allen\") &\n(merged_df[\"first_name\"] == \"Elijah\") &\n(merged_df[\"expense_date\"].str[5:7].isin([\"09\", \"10\"]))\n]\nresult = filtered_df[\"cost\"].mean()"}
{"question_id": 38, "db_id": "student_club", "SQL": "SELECT SUM(CASE WHEN SUBSTR(T1.event_date, 1, 4) = '2019' THEN T2.spent ELSE 0 END) - SUM(CASE WHEN SUBSTR(T1.event_date, 1, 4) = '2020' THEN T2.spent ELSE 0 END) AS num FROM event AS T1 INNER JOIN budget AS T2 ON T1.event_id = T2.link_to_event", "pandas_query": "merged_df = pd.merge(event, budget, left_on=\"event_id\", right_on=\"link_to_event\", how=\"inner\")\n\nmerged_df[\"spent\"] = pd.to_numeric(merged_df[\"spent\"], errors=\"coerce\")\n\nmerged_df[\"Year\"] = merged_df[\"event_date\"].str[:4]\n\n\nspent_2019 = merged_df.loc[merged_df[\"Year\"] == \"2019\", \"spent\"].sum()\nspent_2020 = merged_df.loc[merged_df[\"Year\"] == \"2020\", \"spent\"].sum()\n\n\n\nresult = (spent_2019 - spent_2020).round(2)\n\n\n"}
{"question_id": 39, "db_id": "student_club", "SQL": "SELECT notes FROM income WHERE source = 'Fundraising' AND date_received = '2019-09-14'", "pandas_query": "result = income[(income[\"source\"] == \"Fundraising\") & (income[\"date_received\"] == \"2019-09-14\")][\"notes\"]"}
{"question_id": 44, "db_id": "student_club", "SQL": "SELECT T2.department FROM member AS T1 INNER JOIN major AS T2 ON T1.link_to_major = T2.major_id WHERE T1.position = 'President'", "pandas_query": "merged_df = pd.merge(member, major, left_on=\"link_to_major\", right_on=\"major_id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"position\"] == \"President\"]\nresult = filtered_df[\"department\"]"}
{"question_id": 45, "db_id": "student_club", "SQL": "SELECT T2.date_received FROM member AS T1 INNER JOIN income AS T2 ON T1.member_id = T2.link_to_member WHERE T1.first_name = 'Connor' AND T1.last_name = 'Hilton' AND T2.source = 'Dues'", "pandas_query": "merged_df = pd.merge(member, income, left_on=\"member_id\", right_on=\"link_to_member\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"first_name\"] == \"Connor\") & (merged_df[\"last_name\"] == \"Hilton\") & (merged_df[\"source\"] == \"Dues\")]\nresult = filtered_df[\"date_received\"]"}
{"question_id": 46, "db_id": "student_club", "SQL": "SELECT CAST(SUM(CASE WHEN T2.event_name = 'Yearly Kickoff' THEN T1.amount ELSE 0 END) AS REAL) / NULLIF(SUM(CASE WHEN T2.event_name = 'October Meeting' THEN T1.amount ELSE 0 END), 0) FROM budget AS T1 INNER JOIN event AS T2 ON T1.link_to_event = T2.event_id WHERE T1.category = 'Advertisement' AND T2.type = 'Meeting'", "pandas_query": "merged_df = pd.merge(budget, event, left_on=\"link_to_event\", right_on=\"event_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"category\"] == \"Advertisement\") & (merged_df[\"type\"] == \"Meeting\")]\nyearly_kickoff_sum = filtered_df[filtered_df[\"event_name\"] == \"Yearly Kickoff\"][\"amount\"].sum()\noctober_meeting_sum = filtered_df[filtered_df[\"event_name\"] == \"October Meeting\"][\"amount\"].sum()\nresult = yearly_kickoff_sum / october_meeting_sum"}
{"question_id": 47, "db_id": "student_club", "SQL": "SELECT SUM(cost) FROM expense WHERE expense_description = 'Pizza'", "pandas_query": "filtered_df = expense[expense[\"expense_description\"] == \"Pizza\"]\nresult = filtered_df[\"cost\"].sum()"}
{"question_id": 49, "db_id": "student_club", "SQL": "SELECT T2.major_name FROM member AS T1 INNER JOIN major AS T2 ON T1.link_to_major = T2.major_id WHERE T1.phone = '809-555-3360'", "pandas_query": "merged_df = pd.merge(member, major, left_on=\"link_to_major\", right_on=\"major_id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"phone\"] == \"809-555-3360\"]\nresult = filtered_df[\"major_name\"].iloc[0]"}
{"question_id": 50, "db_id": "student_club", "SQL": "SELECT COUNT(T2.link_to_member) FROM event AS T1 INNER JOIN attendance AS T2 ON T1.event_id = T2.link_to_event WHERE T1.event_name = 'Women''s Soccer'", "pandas_query": "merged_df = pd.merge(event, attendance, left_on=\"event_id\", right_on=\"link_to_event\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"event_name\"] == \"Women's Soccer\"]\nresult = filtered_df[\"link_to_member\"].count()"}
{"question_id": 52, "db_id": "student_club", "SQL": "SELECT T2.event_name FROM budget AS T1 INNER JOIN event AS T2 ON T1.link_to_event = T2.event_id WHERE T2.status = 'Closed' ORDER BY T1.spent / NULLIF(T1.amount, 0) DESC NULLS LAST LIMIT 1", "pandas_query": "merged_df = pd.merge(budget, event, left_on=\"link_to_event\", right_on=\"event_id\", how=\"inner\")\nclosed_events_df = merged_df[merged_df[\"status\"] == \"Closed\"]\nclosed_events_df[\"spend_to_budget_ratio\"] = closed_events_df[\"spent\"] / closed_events_df[\"amount\"]\nhighest_ratio_event = closed_events_df.sort_values(by=\"spend_to_budget_ratio\", ascending=False).iloc[0]\nresult = highest_ratio_event[\"event_name\"]"}
{"question_id": 55, "db_id": "student_club", "SQL": "SELECT T1.first_name, T1.last_name FROM member AS T1 INNER JOIN attendance AS T2 ON T1.member_id = T2.link_to_member GROUP BY T1.member_id, T1.first_name, T1.last_name HAVING COUNT(T2.link_to_event) > 7", "pandas_query": "merged_df = pd.merge(member, attendance, left_on=\"member_id\", right_on=\"link_to_member\", how=\"inner\")\ngrouped_df = merged_df.groupby(\"link_to_member\").size().reset_index(name='event_count')\nfiltered_df = grouped_df[grouped_df[\"event_count\"] > 7]\nresult = member[member[\"member_id\"].isin(filtered_df[\"link_to_member\"])][[\"first_name\", \"last_name\"]]"}
{"question_id": 56, "db_id": "student_club", "SQL": "SELECT T4.first_name, T4.last_name FROM event AS T1 INNER JOIN budget AS T2 ON T1.event_id = T2.link_to_event INNER JOIN expense AS T3 ON T2.budget_id = T3.link_to_budget INNER JOIN member AS T4 ON T3.link_to_member = T4.member_id WHERE T1.event_name = 'Yearly Kickoff'", "pandas_query": "merged_df1 = pd.merge(event, budget, left_on=\"event_id\", right_on=\"link_to_event\", how=\"inner\")\nmerged_df2 = pd.merge(merged_df1, expense, left_on=\"budget_id\", right_on=\"link_to_budget\", how=\"inner\")\nmerged_df3 = pd.merge(merged_df2, member, left_on=\"link_to_member\", right_on=\"member_id\", how=\"inner\")\nfiltered_df = merged_df3[merged_df3[\"event_name\"] == \"Yearly Kickoff\"]\nresult = filtered_df[[\"first_name\", \"last_name\"]]"}
{"question_id": 59, "db_id": "student_club", "SQL": "SELECT source FROM income WHERE date_received BETWEEN '2019-09-01' AND '2019-09-30' ORDER BY source DESC NULLS LAST LIMIT 1", "pandas_query": "filtered_df = income[(income[\"date_received\"] >= '2019-09-01') & (income[\"date_received\"] <= '2019-09-30')]\nresult = filtered_df.sort_values(by=\"source\", ascending=False).iloc[0][\"source\"]"}
{"question_id": 60, "db_id": "student_club", "SQL": "SELECT COUNT(T2.member_id) FROM major AS T1 INNER JOIN member AS T2 ON T1.major_id = T2.link_to_major WHERE T1.major_name = 'Physics Teaching'", "pandas_query": "merged_df = pd.merge(major, member, left_on=\"major_id\", right_on=\"link_to_major\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"major_name\"] == \"Physics Teaching\"]\nresult = filtered_df[\"member_id\"].count()"}
{"question_id": 61, "db_id": "student_club", "SQL": "SELECT T2.event_name FROM budget AS T1 INNER JOIN event AS T2 ON T1.link_to_event = T2.event_id WHERE T1.category = 'Advertisement' ORDER BY T1.spent DESC NULLS LAST LIMIT 1", "pandas_query": "merged_df = pd.merge(budget, event, left_on=\"link_to_event\", right_on=\"event_id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"category\"] == \"Advertisement\"]\nsorted_df = filtered_df.sort_values(by=\"spent\", ascending=False)\nresult = sorted_df.iloc[0][\"event_name\"]"}
{"question_id": 63, "db_id": "student_club", "SQL": "SELECT T3.cost FROM event AS T1 INNER JOIN budget AS T2 ON T1.event_id = T2.link_to_event INNER JOIN expense AS T3 ON T2.budget_id = T3.link_to_budget WHERE T1.event_name = 'September Speaker' AND T3.expense_description = 'Posters'", "pandas_query": "merged_df1 = pd.merge(event, budget, left_on=\"event_id\", right_on=\"link_to_event\", how=\"inner\")\nmerged_df2 = pd.merge(merged_df1, expense, left_on=\"budget_id\", right_on=\"link_to_budget\", how=\"inner\")\nfiltered_df = merged_df2[(merged_df2[\"event_name\"] == \"September Speaker\") & (merged_df2[\"expense_description\"] == \"Posters\")]\nresult = filtered_df[\"cost\"].iloc[0]"}
{"question_id": 64, "db_id": "student_club", "SQL": "SELECT T2.event_name FROM budget AS T1 INNER JOIN event AS T2 ON T2.event_id = T1.link_to_event WHERE T1.event_status = 'Closed' AND T1.remaining < 0 ORDER BY T1.remaining NULLS FIRST LIMIT 1", "pandas_query": "merged_df = pd.merge(budget, event, left_on=\"link_to_event\", right_on=\"event_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"event_status\"] == \"Closed\") & (merged_df[\"remaining\"] < 0)]\nresult = filtered_df.sort_values(\"remaining\").iloc[0][\"event_name\"]"}
{"question_id": 65, "db_id": "student_club", "SQL": "SELECT T1.type, SUM(T3.cost) FROM event AS T1 INNER JOIN budget AS T2 ON T1.event_id = T2.link_to_event INNER JOIN expense AS T3 ON T2.budget_id = T3.link_to_budget WHERE T1.event_name = 'October Meeting' GROUP BY T1.type", "pandas_query": "merged_df = pd.merge(event, budget, left_on=\"event_id\", right_on=\"link_to_event\", how=\"inner\")\nmerged_df = pd.merge(merged_df, expense, left_on=\"budget_id\", right_on=\"link_to_budget\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"event_name\"] == \"October Meeting\"]\nresult = filtered_df.groupby(\"type\")[\"cost\"].sum().reset_index()"}
{"question_id": 66, "db_id": "student_club", "SQL": "SELECT T2.category, SUM(T2.amount) FROM event AS T1 INNER JOIN budget AS T2 ON T1.event_id = T2.link_to_event WHERE T1.event_name = 'April Speaker' GROUP BY T2.category ORDER BY SUM(T2.amount) ASC", "pandas_query": "merged_df = pd.merge(event, budget, left_on=\"event_id\", right_on=\"link_to_event\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"event_name\"] == \"April Speaker\"]\ngrouped_df = filtered_df.groupby(\"category\")[\"amount\"].sum().reset_index()\nresult = grouped_df.sort_values(by=\"amount\", ascending=True)"}
{"question_id": 69, "db_id": "student_club", "SQL": "SELECT T2.expense_description FROM member AS T1 INNER JOIN expense AS T2 ON T1.member_id = T2.link_to_member WHERE T1.first_name = 'Sacha' AND T1.last_name = 'Harrison'", "pandas_query": "merged_df = pd.merge(member, expense, left_on=\"member_id\", right_on=\"link_to_member\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"first_name\"] == \"Sacha\") & (merged_df[\"last_name\"] == \"Harrison\")]\nresult = filtered_df[\"expense_description\"]"}
{"question_id": 70, "db_id": "student_club", "SQL": "SELECT DISTINCT T2.category FROM event AS T1 INNER JOIN budget AS T2 ON T1.event_id = T2.link_to_event WHERE T1.location = 'MU 215'", "pandas_query": "merged_df = pd.merge(event, budget, left_on=\"event_id\", right_on=\"link_to_event\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"location\"] == \"MU 215\"]\nresult = filtered_df[\"category\"].unique()"}
{"question_id": 73, "db_id": "student_club", "SQL": "SELECT CAST(SUM(CASE WHEN T2.amount = 50 THEN 1.0 ELSE 0 END) AS REAL) * 100 / NULLIF(COUNT(T2.income_id), 0) FROM member AS T1 INNER JOIN income AS T2 ON T1.member_id = T2.link_to_member WHERE T1.position = 'Member' AND T1.t_shirt_size = 'Medium'", "pandas_query": "merged_df = pd.merge(member, income, left_on=\"member_id\", right_on=\"link_to_member\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"position\"] == \"Member\") & (merged_df[\"t_shirt_size\"] == \"Medium\")]\ncount_amount_50 = (filtered_df[\"amount\"] == 50).sum()\ntotal_count = filtered_df[\"income_id\"].count()\nresult = (count_amount_50 / total_count) * 100"}
{"question_id": 74, "db_id": "student_club", "SQL": "SELECT DISTINCT event_name FROM event WHERE type = 'Game' AND DATE(SUBSTR(event_date, 1, 10)) BETWEEN '2019-03-15' AND '2020-03-20' AND status = 'Closed'", "pandas_query": "event['event_date'] = pd.to_datetime(event['event_date'].str[:10])\nfiltered_events = event[(event['type'] == 'Game') &\n(event['event_date'] >= '2019-03-15') &\n(event['event_date'] <= '2020-03-20') &\n(event['status'] == 'Closed')]\nresult = filtered_events['event_name'].unique()"}
{"question_id": 75, "db_id": "student_club", "SQL": "SELECT DISTINCT T3.first_name, T3.last_name, T3.phone FROM expense AS T1 INNER JOIN budget AS T2 ON T1.link_to_budget = T2.budget_id INNER JOIN member AS T3 ON T3.member_id = T1.link_to_member WHERE T1.cost > (SELECT AVG(T1.cost) FROM expense AS T1 INNER JOIN budget AS T2 ON T1.link_to_budget = T2.budget_id INNER JOIN member AS T3 ON T3.member_id = T1.link_to_member)", "pandas_query": "average_cost = expense[\"cost\"].mean()\nmerged_df = pd.merge(expense, budget, left_on=\"link_to_budget\", right_on=\"budget_id\", how=\"inner\")\nmerged_df = pd.merge(merged_df, member, left_on=\"link_to_member\", right_on=\"member_id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"cost\"] > average_cost]\nresult = filtered_df[[\"first_name\", \"last_name\", \"phone\"]].drop_duplicates()"}
{"question_id": 77, "db_id": "student_club", "SQL": "SELECT DISTINCT T3.first_name, T3.last_name, T4.amount FROM event AS T1 INNER JOIN attendance AS T2 ON T1.event_id = T2.link_to_event INNER JOIN member AS T3 ON T3.member_id = T2.link_to_member INNER JOIN income AS T4 ON T4.link_to_member = T3.member_id WHERE T4.date_received = '2019-09-09'", "pandas_query": "merged_df1 = pd.merge(event, attendance, left_on=\"event_id\", right_on=\"link_to_event\", how=\"inner\")\nmerged_df2 = pd.merge(merged_df1, member, left_on=\"link_to_member\", right_on=\"member_id\", how=\"inner\")\nmerged_df3 = pd.merge(merged_df2, income, left_on=\"member_id\", right_on=\"link_to_member\", how=\"inner\")\nfiltered_df = merged_df3[merged_df3[\"date_received\"] == '2019-09-09']\nresult = filtered_df[[\"first_name\", \"last_name\", \"amount\"]].drop_duplicates()"}
{"question_id": 78, "db_id": "thrombosis_prediction", "SQL": "SELECT CAST(SUM(CASE WHEN Admission = '+' THEN 1 ELSE 0 END) AS REAL) * 100 / NULLIF(SUM(CASE WHEN Admission = '-' THEN 1 ELSE 0 END), 0) FROM Patient WHERE SEX = 'M'", "pandas_query": "male_patients = Patient[Patient[\"SEX\"] == \"M\"]\nin_patient_count = male_patients[male_patients[\"Admission\"] == \"+\"].shape[0]\nout_patient_count = male_patients[male_patients[\"Admission\"] == \"-\"].shape[0]\nresult = (in_patient_count * 100.0) / out_patient_count"}
{"question_id": 79, "db_id": "thrombosis_prediction", "SQL": "SELECT CAST(SUM(CASE WHEN TO_CHAR(CAST(Birthday AS TIMESTAMP), 'YYYY') > '1930' THEN 1 ELSE 0 END) AS REAL) * 100 / NULLIF(COUNT(*), 0) FROM Patient WHERE SEX = 'F'", "pandas_query": "female_patients = Patient[Patient[\"SEX\"] == \"F\"]\nborn_after_1930 = female_patients[female_patients[\"Birthday\"].apply(lambda x: int(x[:4]) > 1930)]\npercentage = (born_after_1930[\"ID\"].count() / female_patients[\"ID\"].count()) * 100\nresult = percentage"}
{"question_id": 80, "db_id": "thrombosis_prediction", "SQL": "SELECT SUM(CASE WHEN Admission = '+' THEN 1.0 ELSE 0 END) / NULLIF(SUM(CASE WHEN Admission = '-' THEN 1 ELSE 0 END), 0) FROM Patient WHERE Diagnosis = 'SLE'", "pandas_query": "sle_patients = Patient[Patient[\"Diagnosis\"] == \"SLE\"]\ninpatient_count = sle_patients[sle_patients[\"Admission\"] == \"+\"].shape[0]\noutpatient_count = sle_patients[sle_patients[\"Admission\"] == \"-\"].shape[0]\nresult = inpatient_count / outpatient_count"}
{"question_id": 81, "db_id": "thrombosis_prediction", "SQL": "SELECT T1.Diagnosis, T2.Date FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T1.ID = 30609", "pandas_query": "merged_df = pd.merge(Patient, Laboratory, left_on=\"ID\", right_on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"ID\"] == 30609]\nresult = filtered_df[[\"Diagnosis\", \"Date\"]]"}
{"question_id": 82, "db_id": "thrombosis_prediction", "SQL": "SELECT DISTINCT T1.ID, T1.SEX, T1.Birthday FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T2.LDH > 500", "pandas_query": "merged_df = pd.merge(Patient, Laboratory, on=\"ID\", how=\"inner\")\nfiltered_df = merged_df.loc[merged_df[\"LDH\"] > 500].copy()\nresult = filtered_df[[\"ID\", \"SEX\", \"Birthday\"]].drop_duplicates()"}
{"question_id": 83, "db_id": "thrombosis_prediction", "SQL": "SELECT DISTINCT T1.ID, EXTRACT(YEAR FROM CURRENT_TIMESTAMP) - EXTRACT(YEAR FROM T1.Birthday) AS Age FROM Patient AS T1 INNER JOIN Examination AS T2 ON T1.ID = T2.ID WHERE T2.RVVT = '+'", "pandas_query": "from datetime import datetime\n\ncurrent_year = datetime.now().year\nmerged_df = pd.merge(Patient, Examination, on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"RVVT\"] == \"+\"]\nfiltered_df[\"age\"] = current_year - pd.to_datetime(filtered_df[\"Birthday\"]).dt.year\nresult = filtered_df[[\"ID\", \"age\"]].drop_duplicates()"}
{"question_id": 84, "db_id": "thrombosis_prediction", "SQL": "SELECT DISTINCT T1.ID, T1.SEX, T1.Diagnosis FROM Patient AS T1 INNER JOIN Examination AS T2 ON T1.ID = T2.ID WHERE T2.Thrombosis = 2", "pandas_query": "merged_df = pd.merge(Patient, Examination, on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"Thrombosis\"] == 2]\nresult = filtered_df[[\"ID\", \"SEX\", \"Diagnosis_x\"]].drop_duplicates()"}
{"question_id": 85, "db_id": "thrombosis_prediction", "SQL": "SELECT COUNT(*) FROM Patient WHERE TO_CHAR(CAST(Description AS TIMESTAMP), 'YYYY') = '1997' AND SEX = 'F' AND Admission = '-'", "pandas_query": "Patient['Description'] = pd.to_datetime(Patient['Description'], errors='coerce')\n\nfiltered_df = Patient[(Patient[\"Description\"].dt.year == 1997) & (Patient[\"SEX\"] == \"F\") & (Patient[\"Admission\"] == \"-\")]\n\nresult = len(filtered_df)"}
{"question_id": 86, "db_id": "thrombosis_prediction", "SQL": "SELECT COUNT(*) FROM Patient AS T1 INNER JOIN Examination AS T2 ON T1.ID = T2.ID WHERE T1.SEX = 'F' AND TO_CHAR(CAST(T2.\"Examination Date\" AS TIMESTAMP), 'YYYY') = '1997' AND T2.Thrombosis = 1", "pandas_query": "Examination['Examination Date'] = pd.to_datetime(Examination['Examination Date'])\n\nmerged_df = pd.merge(Patient, Examination, on=\"ID\", how=\"inner\")\n\nfiltered_df = merged_df[\n(merged_df[\"SEX\"] == \"F\") &\n(merged_df[\"Examination Date\"].dt.year == 1997) &\n(merged_df[\"Thrombosis\"] == 1)\n]\n\nresult = len(filtered_df)"}
{"question_id": 87, "db_id": "thrombosis_prediction", "SQL": "SELECT T2.Symptoms, T1.Diagnosis FROM Patient AS T1 INNER JOIN Examination AS T2 ON T1.ID = T2.ID WHERE NOT T2.Symptoms IS NULL ORDER BY T1.Birthday DESC NULLS LAST LIMIT 1", "pandas_query": "merged_df = pd.merge(Patient, Examination, on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"Symptoms\"].notnull()]\nsorted_df = filtered_df.sort_values(by=\"Birthday\", ascending=False)\nresult = sorted_df[[\"Symptoms\", \"Diagnosis_x\"]].head(1)"}
{"question_id": 89, "db_id": "thrombosis_prediction", "SQL": "SELECT CAST(COUNT(DISTINCT CASE WHEN T2.UA <= 8.0 AND T1.SEX = 'M' THEN T1.ID ELSE NULL END) AS REAL) / NULLIF(COUNT(DISTINCT CASE WHEN T2.UA <= 6.5 AND T1.SEX = 'F' THEN T1.ID ELSE NULL END), 0) FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID", "pandas_query": "merged_df = pd.merge(Patient, Laboratory, on=\"ID\", how=\"inner\")\nmale_count = merged_df[(merged_df[\"UA\"] <= 8.0) & (merged_df[\"SEX\"] == 'M')][\"ID\"].nunique()\nfemale_count = merged_df[(merged_df[\"UA\"] <= 6.5) & (merged_df[\"SEX\"] == 'F')][\"ID\"].nunique()\nresult = male_count / female_count"}
{"question_id": 90, "db_id": "thrombosis_prediction", "SQL": "SELECT COUNT(T1.ID) FROM Patient AS T1 INNER JOIN Examination AS T2 ON T1.ID = T2.ID WHERE EXTRACT(YEAR FROM T2.\"Examination Date\") BETWEEN 1990 AND 1993 AND EXTRACT(YEAR FROM T2.\"Examination Date\") - EXTRACT(YEAR FROM T1.Birthday) < 18", "pandas_query": "merged_df = pd.merge(Patient, Examination, on=\"ID\", how=\"inner\")\nmerged_df[\"Examination Year\"] = pd.to_datetime(merged_df[\"Examination Date\"]).dt.year\nmerged_df[\"Birth Year\"] = pd.to_datetime(merged_df[\"Birthday\"]).dt.year\nfiltered_df = merged_df[(merged_df[\"Examination Year\"] >= 1990) & (merged_df[\"Examination Year\"] <= 1993) & ((merged_df[\"Examination Year\"] - merged_df[\"Birth Year\"]) < 18)]\nresult = filtered_df[\"ID\"].nunique()"}
{"question_id": 91, "db_id": "thrombosis_prediction", "SQL": "SELECT EXTRACT(YEAR FROM T2.Date) - EXTRACT(YEAR FROM T1.Birthday) AS age_difference, T1.Diagnosis FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T2.HGB IS NOT NULL ORDER BY T2.HGB DESC LIMIT 1", "pandas_query": "merged_df = pd.merge(Patient, Laboratory, on=\"ID\", how=\"inner\")\nmerged_df['Age'] = pd.to_datetime(merged_df['Date']).dt.year - pd.to_datetime(merged_df['Birthday']).dt.year\nhighest_hgb_row = merged_df.loc[merged_df['HGB'].idxmax()]\nresult = (highest_hgb_row['Age'], highest_hgb_row['Diagnosis'])"}
{"question_id": 92, "db_id": "thrombosis_prediction", "SQL": "SELECT \"aCL IgM\" FROM Examination WHERE ID IN (SELECT ID FROM Patient WHERE Diagnosis = 'SLE' AND Description = '1994-02-19') AND \"Examination Date\" = '1993-11-12'", "pandas_query": "patient_ids = Patient[(Patient[\"Diagnosis\"] == \"SLE\") & (Patient[\"Description\"] == \"1994-02-19\")][\"ID\"]\nresult = Examination[(Examination[\"ID\"].isin(patient_ids)) & (Examination[\"Examination Date\"] == \"1993-11-12\")][\"aCL IgM\"]"}
{"question_id": 93, "db_id": "thrombosis_prediction", "SQL": "SELECT CAST((SUM(CASE WHEN T2.date::text LIKE '1981-11-%' THEN T2.\"T-CHO\" ELSE 0 END) - SUM(CASE WHEN T2.date::text LIKE '1981-12-%' THEN T2.\"T-CHO\" ELSE 0 END)) AS REAL) / NULLIF(SUM(CASE WHEN T2.date::text LIKE '1981-12-%' THEN T2.\"T-CHO\" ELSE 0 END), 0) FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T1.Birthday = '1959-02-18'", "pandas_query": "merged_df = pd.merge(Patient, Laboratory, left_on=\"ID\", right_on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"Birthday\"] == \"1959-02-18\"]\nnovember_sum = filtered_df[filtered_df[\"Date\"].str.startswith(\"1981-11\")][\"T-CHO\"].sum()\ndecember_sum = filtered_df[filtered_df[\"Date\"].str.startswith(\"1981-12\")][\"T-CHO\"].sum()\nresult = (november_sum - december_sum) / december_sum"}
{"question_id": 94, "db_id": "thrombosis_prediction", "SQL": "SELECT DISTINCT ID FROM Laboratory WHERE Date BETWEEN '1987-07-06' AND '1996-01-31' AND GPT > 30 AND ALB < 4", "pandas_query": "filtered_df = Laboratory[(Laboratory[\"Date\"] >= '1987-07-06') & (Laboratory[\"Date\"] <= '1996-01-31') & (Laboratory[\"GPT\"] > 30) & (Laboratory[\"ALB\"] < 4)]\nresult = filtered_df[\"ID\"].unique()"}
{"question_id": 96, "db_id": "thrombosis_prediction", "SQL": "SELECT DISTINCT T1.ID FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T1.Admission = '-' AND T2.\"T-BIL\" < 2.0 AND T2.Date::text LIKE '1991-10-%'", "pandas_query": "merged_df = pd.merge(Patient, Laboratory, on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"Admission\"] == \"-\") & (merged_df[\"T-BIL\"] < 2.0) & (merged_df[\"Date\"].str.startswith(\"1991-10\"))]\nresult = filtered_df[\"ID\"].unique()"}
{"question_id": 97, "db_id": "thrombosis_prediction", "SQL": "SELECT AVG(T2.ALB) FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T2.PLT > 400 AND T1.Diagnosis = 'SLE' AND T1.SEX = 'F'", "pandas_query": "merged_df = pd.merge(Patient, Laboratory, left_on=\"ID\", right_on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"PLT\"] > 400) & (merged_df[\"Diagnosis\"] == \"SLE\") & (merged_df[\"SEX\"] == \"F\")]\nresult = filtered_df[\"ALB\"].mean()"}
{"question_id": 99, "db_id": "thrombosis_prediction", "SQL": "SELECT CAST(SUM(CASE WHEN SEX = 'F' THEN 1 ELSE 0 END) AS REAL) * 100 / NULLIF(COUNT(ID), 0) FROM Patient WHERE Diagnosis = 'RA' AND TO_CHAR(CAST(Birthday AS TIMESTAMP), 'YYYY') = '1980'", "pandas_query": "Patient['Birthday'] = pd.to_datetime(Patient['Birthday'], errors='coerce')\nfiltered_df = Patient[(Patient[\"Diagnosis\"] == \"RA\") & (Patient[\"Birthday\"].dt.year == 1980)]\nfemale_count = (filtered_df[\"SEX\"] == \"F\").sum()\ntotal_count = filtered_df[\"ID\"].count()\nresult = (female_count / total_count) * 100"}
{"question_id": 101, "db_id": "thrombosis_prediction", "SQL": "SELECT DISTINCT T1.ID FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T1.SEX = 'M' AND T2.GPT >= 60", "pandas_query": "merged_df = pd.merge(Patient, Laboratory, on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"SEX\"] == \"M\") & (merged_df[\"GPT\"] >= 60)]\nresult = filtered_df[\"ID\"].unique()"}
{"question_id": 102, "db_id": "thrombosis_prediction", "SQL": "SELECT DISTINCT ON (T1.Birthday) T1.Diagnosis FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T2.GPT > 60 ORDER BY T1.Birthday ASC", "pandas_query": "merged_df = pd.merge(Patient, Laboratory, left_on=\"ID\", right_on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"GPT\"] > 60]\nsorted_df = filtered_df.sort_values(by=\"Birthday\", ascending=True)\nresult = sorted_df[\"Diagnosis\"].drop_duplicates().reset_index(drop=True)"}
{"question_id": 103, "db_id": "thrombosis_prediction", "SQL": "SELECT DISTINCT T1.ID, T1.SEX, T1.Birthday FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T2.UN = 29", "pandas_query": "merged_df = pd.merge(Patient, Laboratory, on=\"ID\", how=\"inner\")\n\nfiltered_df = merged_df[merged_df[\"UN\"] == 29]\n\n\nresult = filtered_df[[\"ID\", \"SEX\", \"Birthday\"]].drop_duplicates()"}
{"question_id": 105, "db_id": "thrombosis_prediction", "SQL": "\nSELECT AVG(T3.age) FROM (SELECT DISTINCT T1.ID,EXTRACT(YEAR FROM CURRENT_DATE) - EXTRACT(YEAR FROM T1.Birthday) AS age FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T2.\"T-CHO\" >= 250 AND T1.SEX = 'M') AS T3\n", "pandas_query": "from datetime import datetime\n\ncurrent_year = datetime.now().year\nmerged_df = pd.merge(Patient, Laboratory, on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"T-CHO\"] >= 250) & (merged_df[\"SEX\"] == 'M')]\nfiltered_df[\"age\"] = current_year - pd.to_datetime(filtered_df[\"Birthday\"]).dt.year\ndistinct_ages = filtered_df.drop_duplicates(subset=[\"ID\"])[\"age\"]\nresult = distinct_ages.mean()"}
{"question_id": 106, "db_id": "thrombosis_prediction", "SQL": "SELECT COUNT(DISTINCT T1.ID) FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T2.TG >= 200 AND EXTRACT(YEAR FROM CURRENT_TIMESTAMP) - EXTRACT(YEAR FROM T1.Birthday) > 50", "pandas_query": "from datetime import datetime\n\ncurrent_year = datetime.now().year\nmerged_df = pd.merge(Patient, Laboratory, left_on=\"ID\", right_on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"TG\"] >= 200) & ((current_year - pd.to_datetime(merged_df[\"Birthday\"]).dt.year) > 50)]\nresult = filtered_df[\"ID\"].nunique()"}
{"question_id": 107, "db_id": "thrombosis_prediction", "SQL": "SELECT COUNT(DISTINCT T1.ID) FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE TO_CHAR(CAST(T1.Birthday AS TIMESTAMP), 'YYYY') BETWEEN '1936' AND '1956' AND T1.SEX = 'M' AND T2.CPK >= 250", "pandas_query": "Patient['Birthday'] = pd.to_datetime(Patient['Birthday'], errors='coerce')\n\nmerged_df = pd.merge(Patient, Laboratory, on=\"ID\", how=\"inner\")\n\nfiltered_df = merged_df[\n(merged_df[\"Birthday\"].dt.year.between(1936, 1956)) &\n(merged_df[\"SEX\"] == \"M\") &\n(merged_df[\"CPK\"] >= 250)\n]\n\nresult = filtered_df[\"ID\"].nunique()"}
{"question_id": 108, "db_id": "thrombosis_prediction", "SQL": "SELECT DISTINCT T1.ID, T1.SEX, EXTRACT(YEAR FROM CURRENT_TIMESTAMP) - EXTRACT(YEAR FROM T1.Birthday) AS Age FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T2.GLU >= 180 AND T2.\"T-CHO\" < 250", "pandas_query": "from datetime import datetime\n\ncurrent_year = datetime.now().year\nmerged_df = pd.merge(Patient, Laboratory, on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"GLU\"] >= 180) & (merged_df[\"T-CHO\"] < 250)]\nfiltered_df[\"Age\"] = current_year - pd.to_datetime(filtered_df[\"Birthday\"]).dt.year\nresult = filtered_df[[\"ID\", \"SEX\", \"Age\"]].drop_duplicates()"}
{"question_id": 109, "db_id": "thrombosis_prediction", "SQL": "SELECT DISTINCT T1.Diagnosis, T1.ID, EXTRACT(YEAR FROM CURRENT_TIMESTAMP) - EXTRACT(YEAR FROM T1.Birthday) AS Age FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T2.RBC < 3.5", "pandas_query": "from datetime import datetime\n\ncurrent_year = datetime.now().year\nmerged_df = pd.merge(Patient, Laboratory, left_on=\"ID\", right_on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"RBC\"] < 3.5]\nfiltered_df[\"Age\"] = current_year - pd.to_datetime(filtered_df[\"Birthday\"]).dt.year\nresult = filtered_df[[\"Diagnosis\", \"ID\", \"Age\"]].drop_duplicates()"}
{"question_id": 111, "db_id": "thrombosis_prediction", "SQL": "SELECT DISTINCT T1.ID, EXTRACT(YEAR FROM CURRENT_TIMESTAMP) - EXTRACT(YEAR FROM T1.Birthday) AS Age FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T1.ID IN (SELECT ID FROM Laboratory WHERE HCT >= 52 GROUP BY ID HAVING COUNT(ID) >= 2)", "pandas_query": "from datetime import datetime\n\ncurrent_year = datetime.now().year\nmerged_df = pd.merge(Patient, Laboratory, on=\"ID\", how=\"inner\")\nfiltered_lab = Laboratory[Laboratory[\"HCT\"] >= 52].groupby(\"ID\").filter(lambda x: len(x) >= 2)\nfiltered_df = merged_df[merged_df[\"ID\"].isin(filtered_lab[\"ID\"])]\nresult = filtered_df[[\"ID\", \"Birthday\"]].drop_duplicates()\nresult[\"Age\"] = current_year - pd.to_datetime(result[\"Birthday\"]).dt.year\nresult = result[[\"ID\", \"Age\"]]"}
{"question_id": 113, "db_id": "thrombosis_prediction", "SQL": "SELECT DISTINCT T1.ID FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T2.PLT BETWEEN 100 AND 400 AND EXTRACT(YEAR FROM CURRENT_TIMESTAMP) - EXTRACT(YEAR FROM T1.Birthday) < 50 AND EXTRACT(YEAR FROM T2.Date) = 1984", "pandas_query": "from datetime import datetime\n\ncurrent_year = datetime.now().year\nmerged_df = pd.merge(Patient, Laboratory, left_on=\"ID\", right_on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[\n(merged_df[\"PLT\"] >= 100) &\n(merged_df[\"PLT\"] <= 400) &\n(current_year - pd.to_datetime(merged_df[\"Birthday\"]).dt.year < 50) &\n(pd.to_datetime(merged_df[\"Date\"]).dt.year == 1984)\n]\nresult = filtered_df[\"ID\"].unique()"}
{"question_id": 115, "db_id": "thrombosis_prediction", "SQL": "SELECT COUNT(DISTINCT T1.ID) FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE (T2.FG <= 150 OR T2.FG >= 450) AND T2.WBC > 3.5 AND T2.WBC < 9.0 AND T1.SEX = 'M'", "pandas_query": "merged_df = pd.merge(Patient, Laboratory, on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"SEX\"] == \"M\") & (merged_df[\"WBC\"] > 3.5) & (merged_df[\"WBC\"] < 9.0) & ((merged_df[\"FG\"] <= 150) | (merged_df[\"FG\"] >= 450))]\nresult = filtered_df[\"ID\"].nunique()"}
{"question_id": 116, "db_id": "thrombosis_prediction", "SQL": "SELECT COUNT(DISTINCT T1.ID) FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T2.IGG >= 2000", "pandas_query": "merged_df = pd.merge(Patient, Laboratory, left_on=\"ID\", right_on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"IGG\"] >= 2000]\nresult = filtered_df[\"ID\"].nunique()"}
{"question_id": 117, "db_id": "thrombosis_prediction", "SQL": "SELECT COUNT(DISTINCT T1.ID) FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID INNER JOIN Examination AS T3 ON T3.ID = T2.ID WHERE T2.IGG BETWEEN 900 AND 2000 AND NOT T3.Symptoms IS NULL", "pandas_query": "merged_df_1 = pd.merge(Patient, Laboratory, on=\"ID\", how=\"inner\")\nmerged_df_2 = pd.merge(merged_df_1, Examination, on=\"ID\", how=\"inner\")\nfiltered_df = merged_df_2[(merged_df_2[\"IGG\"] > 900) & (merged_df_2[\"IGG\"] < 2000) & (merged_df_2[\"Symptoms\"].notnull())]\nresult = filtered_df[\"ID\"].nunique()"}
{"question_id": 118, "db_id": "thrombosis_prediction", "SQL": "SELECT COUNT(DISTINCT T1.ID) FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T2.IGA BETWEEN 80 AND 500 AND TO_CHAR(CAST(T1.\"First Date\" AS TIMESTAMP), 'YYYY') >= '1990'", "pandas_query": "merged_df = pd.merge(Patient, Laboratory, on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"IGA\"] > 80) & (merged_df[\"IGA\"] < 500) & (pd.to_datetime(merged_df[\"First Date\"]).dt.year >= 1990)]\nresult = filtered_df[\"ID\"].nunique()"}
{"question_id": 119, "db_id": "thrombosis_prediction", "SQL": "\nSELECT T3.Diagnosis FROM (SELECT DISTINCT T1.ID, T1.Diagnosis FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T2.IGM <= 40 OR T2.IGM >= 400) AS T3 GROUP BY Diagnosis ORDER BY COUNT(*) DESC NULLS LAST LIMIT 1\n", "pandas_query": "merged_df = pd.merge(Patient, Laboratory, on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"IGM\"] <= 40) | (merged_df[\"IGM\"] >= 400)]\ndistinct_df = filtered_df[[\"ID\", \"Diagnosis\"]].drop_duplicates()\nresult = distinct_df[\"Diagnosis\"].value_counts().idxmax()"}
{"question_id": 121, "db_id": "thrombosis_prediction", "SQL": "SELECT COUNT(DISTINCT T1.ID) FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T2.CRE >= 1.5 AND EXTRACT(YEAR FROM AGE(CURRENT_DATE, T1.Birthday)) < 70", "pandas_query": "from datetime import datetime\n\ncurrent_year = datetime.now().year\nmerged_df = pd.merge(Patient, Laboratory, left_on=\"ID\", right_on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"CRE\"] >= 1.5) & ((current_year - pd.to_datetime(merged_df[\"Birthday\"]).dt.year) < 70)]\nresult = filtered_df[\"ID\"].nunique()"}
{"question_id": 123, "db_id": "thrombosis_prediction", "SQL": "SELECT COUNT(DISTINCT T1.ID) FROM Examination AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T2.SM IN ('negative', '0') AND T1.Thrombosis = 0", "pandas_query": "merged_df = pd.merge(Examination, Laboratory, on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"SM\"].isin(['negative', '0'])) & (merged_df[\"Thrombosis\"] == 0)]\nresult = filtered_df[\"ID\"].nunique()"}
{"question_id": 124, "db_id": "thrombosis_prediction", "SQL": "SELECT COUNT(DISTINCT T1.ID) FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID INNER JOIN Examination AS T3 ON T3.ID = T2.ID WHERE (T2.SC170 = 'negative' OR T2.SC170 = '0') AND T1.SEX = 'F' AND T3.Symptoms IS NULL", "pandas_query": "merged_df_1 = pd.merge(Patient, Laboratory, on=\"ID\", how=\"inner\")\nmerged_df_2 = pd.merge(merged_df_1, Examination, on=\"ID\", how=\"inner\")\nfiltered_df = merged_df_2[((merged_df_2[\"SC170\"] == \"negative\") | (merged_df_2[\"SC170\"] == \"0\")) & (merged_df_2[\"SEX\"] == \"F\") & (merged_df_2[\"Symptoms\"].isnull())]\nresult = filtered_df[\"ID\"].nunique()"}
{"question_id": 126, "db_id": "thrombosis_prediction", "SQL": "SELECT T1.Birthday FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID WHERE T2.GOT >= 60 ORDER BY T1.Birthday DESC NULLS LAST LIMIT 1", "pandas_query": "merged_df = pd.merge(Patient, Laboratory, left_on=\"ID\", right_on=\"ID\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"GOT\"] >= 60]\nresult = filtered_df.sort_values(by=\"Birthday\", ascending=False).iloc[0][\"Birthday\"]"}
{"question_id": 127, "db_id": "thrombosis_prediction", "SQL": "SELECT COUNT(DISTINCT T1.ID) FROM Patient AS T1 INNER JOIN Laboratory AS T2 ON T1.ID = T2.ID INNER JOIN Examination AS T3 ON T1.ID = T3.ID WHERE T2.CPK < 250 AND (T3.KCT = '+' OR T3.RVVT = '+' OR T3.LAC = '+')", "pandas_query": "merged_df_1 = pd.merge(Patient, Laboratory, on=\"ID\", how=\"inner\")\nmerged_df_2 = pd.merge(merged_df_1, Examination, on=\"ID\", how=\"inner\")\nfiltered_df = merged_df_2[(merged_df_2[\"CPK\"] < 250) & ((merged_df_2[\"KCT\"] == '+') | (merged_df_2[\"RVVT\"] == '+') | (merged_df_2[\"LAC\"] == '+'))]\nresult = filtered_df[\"ID\"].nunique()"}
{"question_id": 128, "db_id": "european_football_2", "SQL": "SELECT t2.name FROM Match AS t1 INNER JOIN League AS t2 ON t1.league_id = t2.id WHERE t1.season = '2015/2016' GROUP BY t2.name ORDER BY SUM(t1.home_team_goal + t1.away_team_goal) DESC NULLS LAST LIMIT 1", "pandas_query": "merged_df = pd.merge(Match, League, left_on=\"league_id\", right_on=\"id\", how=\"inner\")\n\nfiltered_df = merged_df[merged_df[\"season\"] == \"2015/2016\"]\n\ngrouped_df = (\nfiltered_df.groupby(\"name\")\n.agg(\ntotal_home_goals=(\"home_team_goal\", \"sum\"),\ntotal_away_goals=(\"away_team_goal\", \"sum\")\n)\n)\n\ngrouped_df[\"total_goals\"] = grouped_df[\"total_home_goals\"] + grouped_df[\"total_away_goals\"]\n\nresult = grouped_df[\"total_goals\"].idxmax()\n"}
{"question_id": 130, "db_id": "european_football_2", "SQL": "SELECT t1.buildUpPlaySpeed FROM Team_Attributes AS t1 INNER JOIN Team AS t2 ON t1.team_api_id = t2.team_api_id ORDER BY t1.buildUpPlaySpeed DESC NULLS LAST LIMIT 4", "pandas_query": "merged_df = pd.merge(Team_Attributes, Team, left_on=\"team_api_id\", right_on=\"team_api_id\", how=\"inner\")\nsorted_df = merged_df.sort_values(by=\"buildUpPlaySpeed\", ascending=False)\nresult = sorted_df[\"buildUpPlaySpeed\"].head(4)"}
{"question_id": 131, "db_id": "european_football_2", "SQL": "SELECT t2.name FROM Match AS t1 INNER JOIN League AS t2 ON t1.league_id = t2.id WHERE t1.season = '2015/2016' AND t1.home_team_goal = t1.away_team_goal GROUP BY t2.name ORDER BY COUNT(t1.id) DESC NULLS LAST LIMIT 1", "pandas_query": "merged_df = pd.merge(Match, League, left_on=\"league_id\", right_on=\"id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"season\"] == \"2015/2016\") & (merged_df[\"home_team_goal\"] == merged_df[\"away_team_goal\"])]\ndraw_counts = filtered_df.groupby(\"name\").size()\nresult = draw_counts.idxmax()"}
{"question_id": 132, "db_id": "european_football_2", "SQL": "SELECT DISTINCT EXTRACT(YEAR FROM AGE(NOW(), t2.birthday::timestamp)) + (CASE WHEN EXTRACT(MONTH FROM AGE(NOW(), t2.birthday::timestamp)) > 0 OR EXTRACT(DAY FROM AGE(NOW(), t2.birthday::timestamp)) > 0 THEN 1 ELSE 0 END) AS age FROM Player_Attributes AS t1 INNER JOIN Player AS t2 ON t1.player_api_id = t2.player_api_id WHERE EXTRACT(YEAR FROM t1.date::date) BETWEEN 2013 AND 2015 AND t1.sprint_speed >= 97", "pandas_query": "from datetime import datetime\nmerged_df = pd.merge(Player_Attributes, Player, on=\"player_api_id\", how=\"inner\")\n\nmerged_df[\"date\"] = pd.to_datetime(merged_df[\"date\"], errors=\"coerce\")\n\nfiltered_df = merged_df[\n(merged_df[\"sprint_speed\"] >= 97) &\n(merged_df[\"date\"].dt.year >= 2013) &\n(merged_df[\"date\"].dt.year <= 2015)\n]\n\nfiltered_df[\"birthday\"] = pd.to_datetime(filtered_df[\"birthday\"], errors=\"coerce\")\n\nfiltered_df[\"age\"] = datetime.now().year - filtered_df[\"birthday\"].dt.year\nfiltered_df[\"age\"] += (\n(datetime.now().month > filtered_df[\"birthday\"].dt.month) |\n((datetime.now().month == filtered_df[\"birthday\"].dt.month) &\n(datetime.now().day >= filtered_df[\"birthday\"].dt.day))\n).astype(int)\n\nresult = filtered_df[\"age\"].unique()"}
{"question_id": 133, "db_id": "european_football_2", "SQL": "SELECT t2.name, t1.max_count FROM League AS t2 JOIN (SELECT league_id, MAX(cnt) AS max_count FROM (SELECT league_id, COUNT(id) AS cnt FROM Match GROUP BY league_id) AS subquery GROUP BY league_id ORDER BY MAX(cnt) DESC LIMIT 1) AS t1 ON t1.league_id = t2.id", "pandas_query": "match_counts = Match.groupby('league_id').size().reset_index(name='cnt')\nmax_count = match_counts['cnt'].max()\nmax_league_id = match_counts[match_counts['cnt'] == max_count]['league_id'].iloc[0]\nleague_name = League[League['id'] == max_league_id]['name'].iloc[0]\nresult = (league_name, max_count)"}
{"question_id": 134, "db_id": "european_football_2", "SQL": "SELECT DISTINCT team_fifa_api_id FROM Team_Attributes WHERE buildUpPlaySpeed > 50 AND buildUpPlaySpeed < 60", "pandas_query": "filtered_df = Team_Attributes[(Team_Attributes[\"buildUpPlaySpeed\"] > 50) & (Team_Attributes[\"buildUpPlaySpeed\"] < 60)]\nresult = filtered_df[\"team_fifa_api_id\"].unique()"}
{"question_id": 136, "db_id": "european_football_2", "SQL": "SELECT CAST(COUNT(DISTINCT CASE WHEN t2.preferred_foot = 'left' THEN t1.id ELSE NULL END) AS REAL) * 100 / NULLIF(COUNT(DISTINCT t1.id), 0) AS percent FROM Player AS t1 INNER JOIN Player_Attributes AS t2 ON t1.player_api_id = t2.player_api_id WHERE SUBSTR(t1.birthday, 1, 4) BETWEEN '1987' AND '1992'", "pandas_query": "merged_df = pd.merge(Player, Player_Attributes, left_on=\"player_api_id\", right_on=\"player_api_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"birthday\"].str[:4].astype(int) >= 1987) & (merged_df[\"birthday\"].str[:4].astype(int) <= 1992)]\nleft_foot_count = filtered_df[filtered_df[\"preferred_foot\"] == \"left\"][\"id_x\"].nunique()\ntotal_count = filtered_df[\"id_x\"].nunique()\nresult = (left_foot_count / total_count) * 100"}
{"question_id": 138, "db_id": "european_football_2", "SQL": "SELECT t1.player_name FROM Player AS t1 INNER JOIN Player_Attributes AS t2 ON t1.player_api_id = t2.player_api_id WHERE t1.height > 180 GROUP BY t1.id ORDER BY CAST(SUM(t2.heading_accuracy) AS REAL) / NULLIF(COUNT(t2.\"player_fifa_api_id\"), 0) DESC NULLS LAST LIMIT 10", "pandas_query": "merged_df = pd.merge(Player, Player_Attributes, on=\"player_api_id\", how=\"inner\")\n\nfiltered_df = merged_df[merged_df[\"height\"] > 180]\n\n\ngrouped_df = filtered_df.groupby(\"player_api_id\").agg(\nplayer_name=(\"player_name\", \"first\"),\navg_heading_accuracy=(\"heading_accuracy\", \"mean\")\n)\n\n\nsorted_df = grouped_df.sort_values(by=\"avg_heading_accuracy\", ascending=False)\n\nresult = sorted_df.head(10)[\"player_name\"].tolist()\n\n"}
{"question_id": 139, "db_id": "european_football_2", "SQL": "SELECT t1.name FROM League AS t1 INNER JOIN Match AS t2 ON t1.id = t2.league_id WHERE t2.season = '2009/2010' GROUP BY t1.name HAVING (CAST(SUM(t2.home_team_goal) AS REAL) / NULLIF(COUNT(DISTINCT t2.id), 0)) - (CAST(SUM(t2.away_team_goal) AS REAL) / NULLIF(COUNT(DISTINCT t2.id), 0)) > 0", "pandas_query": "merged_df = pd.merge(League, Match, left_on=\"id\", right_on=\"league_id\", how=\"inner\")\n\nfiltered_df = merged_df[merged_df[\"season\"] == \"2009/2010\"]\n\n\ngrouped_df = (\nfiltered_df.groupby(\"name\")\n.agg(\ntotal_home_goals=(\"home_team_goal\", \"sum\"),\ntotal_away_goals=(\"away_team_goal\", \"sum\"),\ndistinct_matches=(\"id_y\", \"nunique\")\n)\n)\n\ngrouped_df[\"home_goals_avg\"] = grouped_df[\"total_home_goals\"] / grouped_df[\"distinct_matches\"]\ngrouped_df[\"away_goals_avg\"] = grouped_df[\"total_away_goals\"] / grouped_df[\"distinct_matches\"]\n\n\n\nresult = grouped_df[grouped_df[\"home_goals_avg\"] > grouped_df[\"away_goals_avg\"]].index.tolist()\n\n"}
{"question_id": 140, "db_id": "european_football_2", "SQL": "SELECT player_name FROM Player WHERE SUBSTR(birthday, 1, 7) = '1970-10'", "pandas_query": "result = Player[Player['birthday'].str.startswith('1970-10')]['player_name']"}
{"question_id": 141, "db_id": "european_football_2", "SQL": "SELECT t2.overall_rating FROM Player AS t1 INNER JOIN Player_Attributes AS t2 ON t1.player_api_id = t2.player_api_id WHERE t1.player_name = 'Gabriel Tamas' AND TO_CHAR(CAST(t2.date AS TIMESTAMP), 'YYYY') = '2011'", "pandas_query": "merged_df = pd.merge(Player, Player_Attributes, on=\"player_api_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"player_name\"] == \"Gabriel Tamas\") & (merged_df[\"date\"].str[:4] == \"2011\")]\nresult = filtered_df[\"overall_rating\"]"}
{"question_id": 143, "db_id": "european_football_2", "SQL": "SELECT A FROM (SELECT AVG(finishing) AS result, 'highest' AS A FROM Player AS T1 INNER JOIN Player_Attributes AS T2 ON T1.player_api_id = T2.player_api_id WHERE T1.height = (SELECT MAX(height) FROM Player) UNION SELECT AVG(finishing) AS result, 'Min' AS A FROM Player AS T1 INNER JOIN Player_Attributes AS T2 ON T1.player_api_id = T2.player_api_id WHERE T1.height = (SELECT MIN(height) FROM Player)) AS subquery ORDER BY result DESC LIMIT 1", "pandas_query": "max_height = Player[\"height\"].max()\nmin_height = Player[\"height\"].min()\n\nhighest_df = Player[Player[\"height\"] == max_height]\nshortest_df = Player[Player[\"height\"] == min_height]\n\nhighest_merged = pd.merge(highest_df, Player_Attributes, on=\"player_api_id\", how=\"inner\")\nshortest_merged = pd.merge(shortest_df, Player_Attributes, on=\"player_api_id\", how=\"inner\")\n\nhighest_avg_finishing = highest_merged[\"finishing\"].mean()\nshortest_avg_finishing = shortest_merged[\"finishing\"].mean()\n\nresult = \"highest\" if highest_avg_finishing > shortest_avg_finishing else \"Min\""}
{"question_id": 144, "db_id": "european_football_2", "SQL": "SELECT CAST(SUM(t2.overall_rating) AS REAL) / NULLIF(COUNT(t2.id), 0) FROM Player AS t1 INNER JOIN Player_Attributes AS t2 ON t1.player_api_id = t2.player_api_id WHERE t1.height > 170 AND TO_CHAR(CAST(t2.\"date\" AS TIMESTAMP), 'YYYY') >= '2010' AND TO_CHAR(CAST(t2.\"date\" AS TIMESTAMP), 'YYYY') <= '2015'", "pandas_query": "merged_df = pd.merge(Player, Player_Attributes, left_on=\"player_api_id\", right_on=\"player_api_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"height\"] > 170) & (merged_df[\"date\"].str[:4] >= '2010') & (merged_df[\"date\"].str[:4] <= '2015')]\nresult = filtered_df[\"overall_rating\"].sum() / filtered_df[\"id_y\"].nunique()"}
{"question_id": 152, "db_id": "european_football_2", "SQL": "SELECT t1.name FROM League AS t1 JOIN Match AS t2 ON t1.id = t2.league_id WHERE t2.season = '2008/2009' GROUP BY t1.name HAVING COUNT(t2.id) = (SELECT MAX(match_count) FROM (SELECT COUNT(t2.id) AS match_count FROM Match AS t2 WHERE t2.season = '2008/2009' GROUP BY t2.league_id) AS subquery)", "pandas_query": "merged_df = pd.merge(League, Match, left_on=\"id\", right_on=\"league_id\", how=\"inner\")\n\nseason_df = merged_df[merged_df[\"season\"] == \"2008/2009\"]\n\nleague_match_counts = season_df.groupby(\"name\")[\"id_y\"].count()\n\nmax_matches = league_match_counts.max()\n\nresult = league_match_counts[league_match_counts == max_matches].index.tolist()"}
{"question_id": 153, "db_id": "european_football_2", "SQL": "SELECT (SUM(CASE WHEN t1.player_name = 'Ariel Borysiuk' THEN t2.overall_rating ELSE 0 END) * 1.0 - SUM(CASE WHEN t1.player_name = 'Paulin Puel' THEN t2.overall_rating ELSE 0 END)) * 100 / NULLIF(SUM(CASE WHEN t1.player_name = 'Paulin Puel' THEN t2.overall_rating ELSE 0 END), 0) FROM Player AS t1 INNER JOIN Player_Attributes AS t2 ON t1.player_api_id = t2.player_api_id", "pandas_query": "merged_df = pd.merge(Player, Player_Attributes, on=\"player_api_id\", how=\"inner\")\nariel_rating = merged_df.loc[merged_df[\"player_name\"] == \"Ariel Borysiuk\", \"overall_rating\"].sum()\npaulin_rating = merged_df.loc[merged_df[\"player_name\"] == \"Paulin Puel\", \"overall_rating\"].sum()\nresult = ((ariel_rating - paulin_rating) * 100) / paulin_rating"}
{"question_id": 155, "db_id": "european_football_2", "SQL": "SELECT t2.chanceCreationPassing, t2.chanceCreationPassingClass FROM Team AS t1 INNER JOIN Team_Attributes AS t2 ON t1.team_api_id = t2.team_api_id WHERE t1.team_long_name = 'Ajax' ORDER BY t2.chanceCreationPassing DESC NULLS LAST LIMIT 1", "pandas_query": "merged_df = pd.merge(Team, Team_Attributes, on=\"team_api_id\", how=\"inner\")\n\nfiltered_df = merged_df[merged_df[\"team_long_name\"] == \"Ajax\"]\n\nsorted_df = filtered_df.sort_values(by=\"chanceCreationPassing\", ascending=False)\n\nresult = sorted_df[[\"chanceCreationPassing\", \"chanceCreationPassingClass\"]].head(1)"}
{"question_id": 156, "db_id": "european_football_2", "SQL": "SELECT t1.player_name FROM Player AS t1 INNER JOIN Player_Attributes AS t2 ON t1.player_api_id = t2.player_api_id WHERE SUBSTR(t2.\"date\", 1, 10) = '2016-06-23' AND t2.overall_rating = 77 ORDER BY t1.birthday ASC NULLS FIRST LIMIT 1", "pandas_query": "merged_df = pd.merge(Player, Player_Attributes, on=\"player_api_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"date\"].str.startswith(\"2016-06-23\")) & (merged_df[\"overall_rating\"] == 77)]\noldest_player = filtered_df.sort_values(\"birthday\").iloc[0]\nresult = oldest_player[\"player_name\"]"}
{"question_id": 157, "db_id": "european_football_2", "SQL": "SELECT t2.overall_rating FROM Player AS t1 INNER JOIN Player_Attributes AS t2 ON t1.player_api_id = t2.player_api_id WHERE SUBSTR(t2.\"date\", 1, 10) = '2016-02-04' AND t1.player_name = 'Aaron Mooy'", "pandas_query": "merged_df = pd.merge(Player, Player_Attributes, on=\"player_api_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"date\"].str.startswith(\"2016-02-04\")) & (merged_df[\"player_name\"] == \"Aaron Mooy\")]\nresult = filtered_df[\"overall_rating\"].iloc[0]"}
{"question_id": 160, "db_id": "european_football_2", "SQL": "SELECT t2.buildUpPlayPassingClass FROM Team AS t1 INNER JOIN Team_Attributes AS t2 ON t1.team_api_id = t2.team_api_id WHERE t1.team_long_name = 'FC Lorient' AND t2.\"date\" LIKE '2010-02-22%'", "pandas_query": "merged_df = pd.merge(Team, Team_Attributes, on=\"team_api_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"team_long_name\"] == \"FC Lorient\") & (merged_df[\"date\"].str.startswith(\"2010-02-22\"))]\nresult = filtered_df[\"buildUpPlayPassingClass\"].iloc[0]"}
{"question_id": 161, "db_id": "european_football_2", "SQL": "SELECT t2.defenceAggressionClass FROM Team AS t1 INNER JOIN Team_Attributes AS t2 ON t1.team_api_id = t2.team_api_id WHERE t1.team_long_name = 'Hannover 96' AND t2.\"date\" LIKE '2015-09-10%'", "pandas_query": "merged_df = pd.merge(Team, Team_Attributes, on=\"team_api_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"team_long_name\"] == \"Hannover 96\") & (merged_df[\"date\"].str.startswith(\"2015-09-10\"))]\nresult = filtered_df[\"defenceAggressionClass\"].iloc[0]"}
{"question_id": 162, "db_id": "european_football_2", "SQL": "SELECT CAST(SUM(t2.overall_rating) AS REAL) / NULLIF(COUNT(t2.id), 0) FROM Player AS t1 INNER JOIN Player_Attributes AS t2 ON t1.player_fifa_api_id = t2.player_fifa_api_id WHERE t1.player_name = 'Marko Arnautovic' AND SUBSTR(t2.\"date\", 1, 10) BETWEEN '2007-02-22' AND '2016-04-21'", "pandas_query": "merged_df = pd.merge(Player, Player_Attributes, left_on=\"player_fifa_api_id\", right_on=\"player_fifa_api_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"player_name\"] == \"Marko Arnautovic\") & (merged_df[\"date\"].str[:10] >= \"2007-02-22\") & (merged_df[\"date\"].str[:10] <= \"2016-04-21\")]\nresult = filtered_df[\"overall_rating\"].mean()"}
{"question_id": 163, "db_id": "european_football_2", "SQL": "SELECT (SUM(CASE WHEN t1.player_name = 'Landon Donovan' THEN t2.overall_rating ELSE 0 END) * 1.0 - SUM(CASE WHEN t1.player_name = 'Jordan Bowery' THEN t2.overall_rating ELSE 0 END)) * 100 / NULLIF(SUM(CASE WHEN t1.player_name = 'Landon Donovan' THEN t2.overall_rating ELSE 0 END), 0) AS LvsJ_percent FROM Player AS t1 INNER JOIN Player_Attributes AS t2 ON t1.player_fifa_api_id = t2.player_fifa_api_id WHERE SUBSTR(t2.\"date\", 1, 10) = '2013-07-12'", "pandas_query": "merged_df = pd.merge(Player, Player_Attributes, on=\"player_fifa_api_id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"date\"].str[:10] == '2013-07-12']\nlandon_rating = filtered_df.loc[filtered_df[\"player_name\"] == 'Landon Donovan', \"overall_rating\"].sum()\njordan_rating = filtered_df.loc[filtered_df[\"player_name\"] == 'Jordan Bowery', \"overall_rating\"].sum()\nresult = ((landon_rating - jordan_rating) * 100) / landon_rating"}
{"question_id": 164, "db_id": "european_football_2", "SQL": "SELECT player_name FROM (SELECT player_name, height, DENSE_RANK() OVER (ORDER BY height DESC) AS rank FROM Player) AS subquery WHERE rank = 1", "pandas_query": "Player['rank'] = Player['height'].rank(method='dense', ascending=False)\nresult = Player[Player['rank'] == 1]['player_name'].tolist()"}
{"question_id": 166, "db_id": "european_football_2", "SQL": "SELECT DISTINCT t1.player_name FROM Player AS t1 INNER JOIN Player_Attributes AS t2 ON t1.player_api_id = t2.player_api_id WHERE t2.attacking_work_rate = 'high'", "pandas_query": "merged_df = pd.merge(Player, Player_Attributes, left_on=\"player_api_id\", right_on=\"player_api_id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"attacking_work_rate\"] == \"high\"]\nresult = filtered_df[\"player_name\"].unique()"}
{"question_id": 167, "db_id": "european_football_2", "SQL": "SELECT DISTINCT t1.team_short_name FROM Team AS t1 INNER JOIN Team_Attributes AS t2 ON t1.team_api_id = t2.team_api_id WHERE t2.chanceCreationPassingClass = 'Safe'", "pandas_query": "merged_df = pd.merge(Team, Team_Attributes, left_on=\"team_api_id\", right_on=\"team_api_id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"chanceCreationPassingClass\"] == \"Safe\"]\nresult = filtered_df[\"team_short_name\"].unique()"}
{"question_id": 169, "db_id": "european_football_2", "SQL": "SELECT SUM(CASE WHEN t1.id = 6 THEN t1.jumping ELSE 0 END) - SUM(CASE WHEN t1.id = 23 THEN t1.jumping ELSE 0 END) FROM Player_Attributes AS t1", "pandas_query": "jumping_6 = Player_Attributes.loc[Player_Attributes[\"id\"] == 6, \"jumping\"].sum()\njumping_23 = Player_Attributes.loc[Player_Attributes[\"id\"] == 23, \"jumping\"].sum()\nresult = jumping_6 - jumping_23"}
{"question_id": 170, "db_id": "european_football_2", "SQL": "SELECT id FROM Player_Attributes WHERE preferred_foot = 'right' ORDER BY potential ASC NULLS LAST LIMIT 4", "pandas_query": "filtered_df = Player_Attributes[Player_Attributes[\"preferred_foot\"] == \"right\"]\nsorted_df = filtered_df.sort_values(by=\"potential\", ascending=True)\nresult = sorted_df[\"id\"].head(4).tolist()"}
{"question_id": 171, "db_id": "european_football_2", "SQL": "SELECT COUNT(DISTINCT t1.player_api_id) FROM Player_Attributes AS t1 WHERE t1.preferred_foot = 'left' AND t1.crossing = (SELECT MAX(crossing) FROM Player_Attributes)", "pandas_query": "max_crossing = Player_Attributes[\"crossing\"].max()\nfiltered_df = Player_Attributes[(Player_Attributes[\"preferred_foot\"] == \"left\") & (Player_Attributes[\"crossing\"] == max_crossing)]\nresult = filtered_df[\"player_api_id\"].nunique()"}
{"question_id": 173, "db_id": "european_football_2", "SQL": "SELECT DISTINCT t1.buildUpPlaySpeedClass FROM Team_Attributes AS t1 INNER JOIN Team AS t2 ON t1.team_api_id = t2.team_api_id WHERE t2.team_long_name = 'KSV Cercle Brugge'", "pandas_query": "merged_df = pd.merge(Team_Attributes, Team, left_on=\"team_api_id\", right_on=\"team_api_id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"team_long_name\"] == \"KSV Cercle Brugge\"]\nresult = filtered_df[\"buildUpPlaySpeedClass\"].unique()"}
{"question_id": 174, "db_id": "european_football_2", "SQL": "SELECT id, finishing, curve FROM Player_Attributes WHERE player_api_id = (SELECT player_api_id FROM Player ORDER BY weight DESC NULLS LAST LIMIT 1) LIMIT 1", "pandas_query": "heaviest_player_id = Player.loc[Player['weight'].idxmax(), 'player_api_id']\nresult = Player_Attributes[Player_Attributes['player_api_id'] == heaviest_player_id][['id', 'finishing', 'curve']].head(1)"}
{"question_id": 175, "db_id": "european_football_2", "SQL": "SELECT t1.name FROM League AS t1 INNER JOIN Match AS t2 ON t1.id = t2.league_id WHERE t2.season = '2015/2016' GROUP BY t1.name ORDER BY COUNT(t2.id) DESC NULLS LAST LIMIT 4", "pandas_query": "merged_df = pd.merge(League, Match, left_on=\"id\", right_on=\"league_id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"season\"] == \"2015/2016\"]\ngrouped_df = filtered_df.groupby(\"name\").size().reset_index(name=\"game_count\")\nsorted_df = grouped_df.sort_values(by=\"game_count\", ascending=False)\nresult = sorted_df.head(4)[\"name\"].tolist()"}
{"question_id": 176, "db_id": "european_football_2", "SQL": "SELECT t2.team_long_name FROM Match AS t1 INNER JOIN Team AS t2 ON t1.away_team_api_id = t2.team_api_id ORDER BY t1.away_team_goal DESC NULLS LAST LIMIT 1", "pandas_query": "merged_df = pd.merge(Match, Team, left_on=\"away_team_api_id\", right_on=\"team_api_id\", how=\"inner\")\nresult = merged_df.loc[merged_df[\"away_team_goal\"].idxmax(), \"team_long_name\"]"}
{"question_id": 179, "db_id": "formula_1", "SQL": "SELECT T2.driverRef FROM qualifying AS T1 INNER JOIN drivers AS T2 ON T2.driverId = T1.driverId WHERE T1.raceId = 20 ORDER BY T1.q1 DESC NULLS LAST LIMIT 5", "pandas_query": "merged_df = pd.merge(qualifying, drivers, left_on=\"driverId\", right_on=\"driverId\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"raceId\"] == 20]\nsorted_df = filtered_df.sort_values(by=\"q1\", ascending=False)\nresult = sorted_df.head(5)[\"driverRef\"].tolist()"}
{"question_id": 180, "db_id": "formula_1", "SQL": "SELECT T2.surname FROM qualifying AS T1 INNER JOIN drivers AS T2 ON T2.driverId = T1.driverId WHERE T1.raceId = 19 ORDER BY T1.q2 ASC LIMIT 1", "pandas_query": "merged_df = pd.merge(qualifying, drivers, left_on=\"driverId\", right_on=\"driverId\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"raceId\"] == 19]\nsorted_df = filtered_df.sort_values(by=\"q2\", ascending=True, na_position='last')\nresult = sorted_df.iloc[0][\"surname\"]"}
{"question_id": 181, "db_id": "formula_1", "SQL": "SELECT DISTINCT T2.name FROM circuits AS T1 INNER JOIN races AS T2 ON T2.circuitID = T1.circuitId WHERE T1.country = 'Germany'", "pandas_query": "merged_df = pd.merge(circuits, races, left_on=\"circuitId\", right_on=\"circuitId\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"country\"] == \"Germany\"]\nresult = filtered_df[\"name_y\"].unique()"}
{"question_id": 182, "db_id": "formula_1", "SQL": "SELECT DISTINCT T1.lat, T1.lng FROM circuits AS T1 INNER JOIN races AS T2 ON T2.circuitID = T1.circuitId WHERE T2.name = 'Australian Grand Prix'", "pandas_query": "merged_df = pd.merge(circuits, races, left_on=\"circuitId\", right_on=\"circuitId\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"name_y\"] == \"Australian Grand Prix\"]\nresult = filtered_df[[\"lat\", \"lng\"]].drop_duplicates()"}
{"question_id": 187, "db_id": "formula_1", "SQL": "SELECT T1.forename, T1.surname FROM drivers AS T1 INNER JOIN results AS T2 ON T2.driverId = T1.driverId WHERE T2.raceId = 592 AND NOT T2.time IS NULL AND NOT T1.dob IS NULL ORDER BY T1.dob ASC NULLS FIRST LIMIT 1", "pandas_query": "merged_df = pd.merge(drivers, results, on=\"driverId\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"raceId\"] == 592) & (merged_df[\"time\"].notna()) & (merged_df[\"dob\"].notna())]\noldest_driver = filtered_df.sort_values(\"dob\").iloc[0]\nresult = (oldest_driver[\"forename\"], oldest_driver[\"surname\"])"}
{"question_id": 188, "db_id": "formula_1", "SQL": "SELECT DISTINCT T2.forename, T2.surname, T2.url FROM lapTimes AS T1 INNER JOIN drivers AS T2 ON T2.driverId = T1.driverId WHERE T1.raceId = 161 AND T1.time LIKE '1:27%'", "pandas_query": "merged_df = pd.merge(lapTimes, drivers, left_on=\"driverId\", right_on=\"driverId\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"raceId\"] == 161) & (merged_df[\"time\"].str.startswith('1:27'))]\nresult = filtered_df[[\"forename\", \"surname\", \"url\"]].drop_duplicates()"}
{"question_id": 190, "db_id": "formula_1", "SQL": "SELECT T2.url FROM constructorResults AS T1 INNER JOIN constructors AS T2 ON T2.constructorId = T1.constructorId WHERE T1.raceId = 9 ORDER BY T1.points DESC NULLS LAST LIMIT 1", "pandas_query": "merged_df = pd.merge(constructorResults, constructors, left_on=\"constructorId\", right_on=\"constructorId\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"raceId\"] == 9]\nsorted_df = filtered_df.sort_values(by=\"points\", ascending=False)\nresult = sorted_df.iloc[0][\"url\"]"}
{"question_id": 191, "db_id": "formula_1", "SQL": "SELECT T2.code FROM qualifying AS T1 INNER JOIN drivers AS T2 ON T2.driverId = T1.driverId WHERE T1.raceId = 45 AND T1.q3 LIKE '1:33%'", "pandas_query": "merged_df = pd.merge(qualifying, drivers, left_on=\"driverId\", right_on=\"driverId\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"raceId\"] == 45) & (merged_df[\"q3\"].str.startswith(\"1:33\"))]\nresult = filtered_df[\"code\"].iloc[0]"}
{"question_id": 194, "db_id": "formula_1", "SQL": "SELECT T1.nationality FROM drivers AS T1 INNER JOIN results AS T2 ON T2.driverId = T1.driverId ORDER BY CAST(T2.fastestLapSpeed AS REAL) DESC NULLS LAST LIMIT 1", "pandas_query": "merged_df = pd.merge(drivers, results, left_on=\"driverId\", right_on=\"driverId\", how=\"inner\")\nmerged_df[\"fastestLapSpeed\"] = pd.to_numeric(merged_df[\"fastestLapSpeed\"], errors='coerce')\nmax_speed_driver = merged_df.loc[merged_df[\"fastestLapSpeed\"].idxmax()]\nresult = max_speed_driver[\"nationality\"]"}
{"question_id": 195, "db_id": "formula_1", "SQL": "SELECT (SUM(CASE WHEN T2.raceId = 853 THEN T2.fastestLapSpeed::numeric ELSE 0 END) - SUM(CASE WHEN T2.raceId = 854 THEN T2.fastestLapSpeed::numeric ELSE 0 END)) * 100 / NULLIF(SUM(CASE WHEN T2.raceId = 853 THEN T2.fastestLapSpeed::numeric ELSE 0 END), 0) FROM drivers AS T1 INNER JOIN results AS T2 ON T2.driverId = T1.driverId WHERE T1.forename = 'Paul' AND T1.surname = 'di Resta'", "pandas_query": "merged_df = pd.merge(drivers, results, left_on=\"driverId\", right_on=\"driverId\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"forename\"] == \"Paul\") & (merged_df[\"surname\"] == \"di Resta\")]\n\nfiltered_df[\"fastestLapSpeed\"] = pd.to_numeric(filtered_df[\"fastestLapSpeed\"], errors='coerce')\n\nrace_853_speed = filtered_df[filtered_df[\"raceId\"] == 853][\"fastestLapSpeed\"].sum()\nrace_854_speed = filtered_df[filtered_df[\"raceId\"] == 854][\"fastestLapSpeed\"].sum()\n\nresult = ((race_853_speed - race_854_speed) * 100) / race_853_speed"}
{"question_id": 196, "db_id": "formula_1", "SQL": "SELECT CAST(COUNT(CASE WHEN NOT T2.time IS NULL THEN T2.driverId END) AS REAL) * 100 / NULLIF(COUNT(T2.driverId), 0) FROM races AS T1 INNER JOIN results AS T2 ON T2.raceId = T1.raceId WHERE T1.date = '1983-07-16'", "pandas_query": "merged_df = pd.merge(races, results, left_on=\"raceId\", right_on=\"raceId\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"date\"] == '1983-07-16']\ncompletion_count = filtered_df[\"time_y\"].notnull().sum()\ntotal_count = filtered_df[\"driverId\"].count()\nresult = (completion_count / total_count) * 100"}
{"question_id": 199, "db_id": "formula_1", "SQL": "SELECT T2.milliseconds, T1.forename, T1.surname, T3.name FROM drivers AS T1 INNER JOIN lapTimes AS T2 ON T1.driverId = T2.driverId INNER JOIN races AS T3 ON T2.raceId = T3.raceId ORDER BY T2.milliseconds ASC NULLS FIRST LIMIT 1", "pandas_query": "merged_df = pd.merge(drivers, lapTimes, on=\"driverId\", how=\"inner\")\n\nmerged_df = pd.merge(merged_df, races, on=\"raceId\", how=\"inner\")\n\nsorted_df = merged_df.sort_values(by=\"milliseconds\", ascending=True)\n\nbest_lap = sorted_df.iloc[0][[\"milliseconds\", \"forename\", \"surname\", \"name\"]]\n\nresult = best_lap.to_frame().T"}
{"question_id": 202, "db_id": "formula_1", "SQL": "SELECT T1.forename, T1.surname, T1.nationality, MAX(T2.points) FROM drivers AS T1 INNER JOIN driverStandings AS T2 ON T2.driverId = T1.driverId WHERE T2.wins >= 1 GROUP BY T1.forename, T1.surname, T1.nationality ORDER BY COUNT(T2.wins) DESC NULLS LAST LIMIT 1", "pandas_query": "merged_df = pd.merge(drivers, driverStandings, left_on=\"driverId\", right_on=\"driverId\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"wins\"] >= 1]\ngrouped_df = filtered_df.groupby([\"forename\", \"surname\", \"nationality\"]).agg({\"wins\": \"count\", \"points\": \"max\"})\nsorted_df = grouped_df.sort_values(by=\"wins\", ascending=False).head(1)\nresult = sorted_df.reset_index()[[\"forename\", \"surname\", \"nationality\", \"points\"]]"}
{"question_id": 204, "db_id": "formula_1", "SQL": "SELECT DISTINCT T2.name, T1.name, T1.location FROM circuits AS T1 INNER JOIN races AS T2 ON T2.circuitID = T1.circuitId WHERE T2.year = 2005 AND TO_CHAR(CAST(T2.date AS TIMESTAMP), 'MM') = '09'", "pandas_query": "merged_df = pd.merge(circuits, races, left_on=\"circuitId\", right_on=\"circuitId\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"year\"] == 2005) & (pd.to_datetime(merged_df[\"date\"]).dt.month == 9)]\nresult = filtered_df[[\"name_y\", \"name_x\", \"location\"]].drop_duplicates()"}
{"question_id": 208, "db_id": "formula_1", "SQL": "SELECT CAST(COUNT(CASE WHEN T1.country = 'Germany' THEN T2.circuitID END) AS REAL) * 100 / NULLIF(COUNT(T2.circuitId), 0) FROM circuits AS T1 INNER JOIN races AS T2 ON T2.circuitID = T1.circuitId WHERE T2.name = 'European Grand Prix'", "pandas_query": "merged_df = pd.merge(circuits, races, left_on=\"circuitId\", right_on=\"circuitId\", how=\"inner\")\neuropean_gp_df = merged_df[merged_df[\"name_y\"] == \"European Grand Prix\"]\ngermany_count = european_gp_df[european_gp_df[\"country\"] == \"Germany\"].shape[0]\ntotal_count = european_gp_df.shape[0]\nresult = (germany_count / total_count) * 100"}
{"question_id": 221, "db_id": "formula_1", "SQL": "SELECT T2.name FROM constructorStandings AS T1 INNER JOIN constructors AS T2 ON T1.constructorId = T2.constructorId WHERE T1.points = 0 AND T1.raceId = 291", "pandas_query": "merged_df = pd.merge(constructorStandings, constructors, left_on=\"constructorId\", right_on=\"constructorId\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"points\"] == 0) & (merged_df[\"raceId\"] == 291)]\nresult = filtered_df[\"name\"].tolist()"}
{"question_id": 222, "db_id": "formula_1", "SQL": "SELECT COUNT(DISTINCT T1.constructorId) FROM constructorStandings AS T1 INNER JOIN constructors AS T2 ON T1.constructorId = T2.constructorId WHERE T1.points = 0 AND T2.nationality = 'Japanese' GROUP BY T1.constructorId HAVING COUNT(raceId) = 2", "pandas_query": "merged_df = pd.merge(constructorStandings, constructors, on=\"constructorId\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"points\"] == 0) & (merged_df[\"nationality\"] == \"Japanese\")]\ngrouped_df = filtered_df.groupby(\"constructorId\").filter(lambda x: x[\"raceId\"].nunique() == 2)\nresult = grouped_df[\"constructorId\"].nunique()"}
{"question_id": 226, "db_id": "formula_1", "SQL": "SELECT AVG(CAST(T1.fastestLapSpeed AS NUMERIC)) FROM results AS T1 INNER JOIN races AS T2 ON T1.raceId = T2.raceId WHERE T2.year = 2009 AND T2.name = 'Spanish Grand Prix'", "pandas_query": "merged_df = pd.merge(results, races, left_on=\"raceId\", right_on=\"raceId\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"year\"] == 2009) & (merged_df[\"name\"] == \"Spanish Grand Prix\")]\nfiltered_df[\"fastestLapSpeed\"] = pd.to_numeric(filtered_df[\"fastestLapSpeed\"], errors='coerce')\nresult = filtered_df[\"fastestLapSpeed\"].mean()"}
{"question_id": 230, "db_id": "formula_1", "SQL": "SELECT COUNT(*) FROM (SELECT nationality FROM drivers ORDER BY dob DESC LIMIT 3) AS T3 WHERE nationality = 'Dutch'", "pandas_query": "sorted_drivers = drivers.sort_values(by=\"dob\", ascending=False)\nyoungest_drivers = sorted_drivers.head(3)\nresult = youngest_drivers[youngest_drivers[\"nationality\"] == \"Dutch\"].shape[0]"}
{"question_id": 236, "db_id": "formula_1", "SQL": "SELECT T2.forename, T2.surname FROM pitStops AS T1 INNER JOIN drivers AS T2 ON T1.driverId = T2.driverId WHERE T2.nationality = 'German' AND EXTRACT(YEAR FROM T2.dob) BETWEEN 1980 AND 1985 GROUP BY T2.forename, T2.surname ORDER BY AVG(CAST(T1.duration AS INTERVAL))  LIMIT 3", "pandas_query": "filtered_drivers = drivers[(drivers[\"nationality\"] == \"German\") & (drivers[\"dob\"].between(\"1980-01-01\", \"1985-12-31\"))]\nmerged_df = pd.merge(pitStops, filtered_drivers, on=\"driverId\", how=\"inner\")\nmerged_df[\"duration\"] = pd.to_numeric(merged_df[\"duration\"], errors=\"coerce\")\navg_duration = merged_df.groupby([\"forename\", \"surname\"])[\"duration\"].mean().reset_index()\nsorted_drivers = avg_duration.sort_values(by=\"duration\").head(3)\nresult = sorted_drivers[[\"forename\", \"surname\"]]"}
{"question_id": 240, "db_id": "formula_1", "SQL": "SELECT SUM(T1.points), T2.name, T2.nationality FROM constructorResults AS T1 INNER JOIN constructors AS T2 ON T1.constructorId = T2.constructorId INNER JOIN races AS T3 ON T3.raceid = T1.raceid WHERE T3.name = 'Monaco Grand Prix' AND T3.year BETWEEN 1980 AND 2010 GROUP BY T2.name, T2.nationality ORDER BY SUM(T1.points) DESC LIMIT 1", "pandas_query": "merged_df = pd.merge(constructorResults, constructors, on=\"constructorId\", how=\"inner\")\n\nmerged_df = pd.merge(merged_df, races, on=\"raceId\", how=\"inner\")\n\nfiltered_df = merged_df[(merged_df[\"name_y\"] == \"Monaco Grand Prix\") & (merged_df[\"year\"].between(1980, 2010))]\n\ngrouped_df = filtered_df.groupby([\"name_x\", \"nationality\"]).agg({\"points\": \"sum\"}).reset_index()\n\nsorted_df = grouped_df.sort_values(by=\"points\", ascending=False)\n\nresult = sorted_df.head(1)[[\"points\", \"name_x\", \"nationality\"]]"}
{"question_id": 241, "db_id": "formula_1", "SQL": "SELECT T2.forename, T2.surname FROM qualifying AS T1 INNER JOIN drivers AS T2 ON T1.driverId = T2.driverId INNER JOIN races AS T3 ON T1.raceid = T3.raceid WHERE q3 IS NOT NULL AND T3.year = 2008 AND T3.circuitId IN (SELECT circuitId FROM circuits WHERE name = 'Marina Bay Street Circuit') ORDER BY CAST(SPLIT_PART(q3, ':', 1) AS INTEGER) * 60 + CAST(SPLIT_PART(SPLIT_PART(q3, ':', 2), '.', 1) AS REAL) + CAST(SPLIT_PART(q3, '.', 2) AS REAL) / 1000 ASC LIMIT 1", "pandas_query": "circuit_id = circuits[circuits[\"name\"] == \"Marina Bay Street Circuit\"][\"circuitId\"].values[0]\nraces_2008 = races[(races[\"year\"] == 2008) & (races[\"circuitId\"] == circuit_id)]\nqualifying_races = qualifying[qualifying[\"raceId\"].isin(races_2008[\"raceId\"]) & qualifying[\"q3\"].notnull()]\nqualifying_races[\"q3_seconds\"] = qualifying_races[\"q3\"].apply(lambda x: int(x.split(':')[0]) * 60 + float(x.split(':')[1]))\nfastest_qualifying = qualifying_races.loc[qualifying_races[\"q3_seconds\"].idxmin()]\ndriver_id = fastest_qualifying[\"driverId\"]\nresult = drivers[drivers[\"driverId\"] == driver_id][[\"forename\", \"surname\"]]"}
{"question_id": 243, "db_id": "formula_1", "SQL": "SELECT COUNT(T1.driverId) FROM results AS T1 INNER JOIN races AS T2 ON T1.raceId = T2.raceId INNER JOIN status AS T3 ON T1.statusId = T3.statusId WHERE T3.statusId = 3 AND T2.name = 'Canadian Grand Prix' GROUP BY T1.driverId ORDER BY COUNT(T1.driverId) DESC NULLS LAST LIMIT 1", "pandas_query": "merged_df = pd.merge(results, races, left_on=\"raceId\", right_on=\"raceId\", how=\"inner\")\nmerged_df = pd.merge(merged_df, status, left_on=\"statusId\", right_on=\"statusId\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"statusId\"] == 3) & (merged_df[\"name\"] == \"Canadian Grand Prix\")]\naccidents_count = filtered_df.groupby(\"driverId\").size()\nresult = accidents_count.max()"}
{"question_id": 245, "db_id": "formula_1", "SQL": "WITH fastest_lap_times AS (SELECT T1.raceId, T1.FastestLapTime, (CAST(SPLIT_PART(T1.FastestLapTime, ':', 1) AS REAL) * 60) + (CAST(SPLIT_PART(SPLIT_PART(T1.FastestLapTime, ':', 2), '.', 1) AS REAL)) + (CAST(SPLIT_PART(T1.FastestLapTime, '.', 2) AS REAL) / 1000) AS time_in_seconds FROM results AS T1 WHERE T1.FastestLapTime IS NOT NULL) SELECT T1.FastestLapTime AS lap_record FROM results AS T1 INNER JOIN races AS T2 ON T1.raceId = T2.raceId INNER JOIN circuits AS T3 ON T2.circuitId = T3.circuitId INNER JOIN (SELECT MIN(fastest_lap_times.time_in_seconds) AS min_time_in_seconds FROM fastest_lap_times INNER JOIN races AS T2 ON fastest_lap_times.raceId = T2.raceId INNER JOIN circuits AS T3 ON T2.circuitId = T3.circuitId WHERE T3.country = 'Italy') AS T4 ON (CAST(SPLIT_PART(T1.FastestLapTime, ':', 1) AS REAL) * 60) + (CAST(SPLIT_PART(SPLIT_PART(T1.FastestLapTime, ':', 2), '.', 1) AS REAL)) + (CAST(SPLIT_PART(T1.FastestLapTime, '.', 2) AS REAL) / 1000) = T4.min_time_in_seconds LIMIT 1", "pandas_query": "results['time_in_seconds'] = results['fastestLapTime'].apply(\nlambda x: (int(x.split(':')[0]) * 60) + float(x.split(':')[1]) if x is not None else None\n)\n\nfastest_lap_times = results.dropna(subset=['fastestLapTime'])\n\nmerged_df = fastest_lap_times.merge(races, on='raceId', how='inner')\nmerged_df = merged_df.merge(circuits, on='circuitId', how='inner')\n\nitaly_laps = merged_df[merged_df['country'] == 'Italy']\n\nmin_time_in_seconds = italy_laps['time_in_seconds'].min()\n\nlap_record = italy_laps[italy_laps['time_in_seconds'] == min_time_in_seconds]['fastestLapTime'].iloc[0]\nresult = lap_record"}
{"question_id": 247, "db_id": "superhero", "SQL": "SELECT COUNT(T1.id) FROM superhero AS T1 INNER JOIN hero_power AS T2 ON T1.id = T2.hero_id INNER JOIN superpower AS T3 ON T2.power_id = T3.id INNER JOIN colour AS T4 ON T1.eye_colour_id = T4.id WHERE T3.power_name = 'Agility' AND T4.colour = 'Blue'", "pandas_query": "merged_df1 = pd.merge(superhero, hero_power, left_on=\"id\", right_on=\"hero_id\", how=\"inner\")\nmerged_df2 = pd.merge(merged_df1, superpower, left_on=\"power_id\", right_on=\"id\", how=\"inner\")\nmerged_df3 = pd.merge(merged_df2, colour, left_on=\"eye_colour_id\", right_on=\"id\", how=\"inner\")\nfiltered_df = merged_df3[(merged_df3[\"power_name\"] == \"Agility\") & (merged_df3[\"colour\"] == \"Blue\")]\nresult = filtered_df[\"id_x\"].nunique()"}
{"question_id": 248, "db_id": "superhero", "SQL": "SELECT T1.superhero_name FROM superhero AS T1 INNER JOIN colour AS T2 ON T1.eye_colour_id = T2.id INNER JOIN colour AS T3 ON T1.hair_colour_id = T3.id WHERE T2.colour = 'Blue' AND T3.colour = 'Blond'", "pandas_query": "merged_eye_colour = pd.merge(superhero, colour, left_on=\"eye_colour_id\", right_on=\"id\", how=\"inner\")\nmerged_hair_colour = pd.merge(merged_eye_colour, colour, left_on=\"hair_colour_id\", right_on=\"id\", how=\"inner\", suffixes=('_eye', '_hair'))\nfiltered_df = merged_hair_colour[(merged_hair_colour[\"colour_eye\"] == \"Blue\") & (merged_hair_colour[\"colour_hair\"] == \"Blond\")]\nresult = filtered_df[\"superhero_name\"]"}
{"question_id": 251, "db_id": "superhero", "SQL": "SELECT superhero_name FROM superhero AS T1 WHERE EXISTS(SELECT 1 FROM hero_power AS T2 INNER JOIN superpower AS T3 ON T2.power_id = T3.id WHERE T3.power_name = 'Super Strength' AND T1.id = T2.hero_id) AND EXISTS(SELECT 1 FROM publisher AS T4 WHERE T4.publisher_name = 'Marvel Comics' AND T1.publisher_id = T4.id)", "pandas_query": "marvel_heroes = publisher[publisher[\"publisher_name\"] == \"Marvel Comics\"]\nsuper_strength_power = superpower[superpower[\"power_name\"] == \"Super Strength\"]\n\nheroes_with_super_strength = hero_power[hero_power[\"power_id\"].isin(super_strength_power[\"id\"])]\nmarvel_heroes_ids = superhero[superhero[\"publisher_id\"].isin(marvel_heroes[\"id\"])]\n\nresult = superhero[(superhero[\"id\"].isin(heroes_with_super_strength[\"hero_id\"])) & (superhero[\"id\"].isin(marvel_heroes_ids[\"id\"]))][\"superhero_name\"]"}
{"question_id": 252, "db_id": "superhero", "SQL": "SELECT T2.publisher_name FROM superhero AS T1 INNER JOIN publisher AS T2 ON T1.publisher_id = T2.id INNER JOIN hero_attribute AS T3 ON T1.id = T3.hero_id INNER JOIN attribute AS T4 ON T3.attribute_id = T4.id WHERE T4.attribute_name = 'Speed' ORDER BY T3.attribute_value NULLS FIRST LIMIT 1", "pandas_query": "merged_df = pd.merge(superhero, publisher, left_on=\"publisher_id\", right_on=\"id\", how=\"inner\")\nmerged_df = pd.merge(merged_df, hero_attribute, left_on=\"id_x\", right_on=\"hero_id\", how=\"inner\")\nmerged_df = pd.merge(merged_df, attribute, left_on=\"attribute_id\", right_on=\"id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"attribute_name\"] == \"Speed\"]\nslowest_hero = filtered_df.loc[filtered_df[\"attribute_value\"].idxmin()]\nresult = slowest_hero[\"publisher_name\"]"}
{"question_id": 254, "db_id": "superhero", "SQL": "SELECT T1.superhero_name FROM superhero AS T1 INNER JOIN hero_attribute AS T2 ON T1.id = T2.hero_id INNER JOIN attribute AS T3 ON T2.attribute_id = T3.id WHERE T3.attribute_name = 'Intelligence' ORDER BY T2.attribute_value NULLS FIRST LIMIT 1", "pandas_query": "merged_df = pd.merge(superhero, hero_attribute, left_on=\"id\", right_on=\"hero_id\", how=\"inner\")\nmerged_df = pd.merge(merged_df, attribute, left_on=\"attribute_id\", right_on=\"id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"attribute_name\"] == \"Intelligence\"]\ndumbest_hero = filtered_df.loc[filtered_df[\"attribute_value\"].idxmin(), \"superhero_name\"]\nresult = dumbest_hero"}
{"question_id": 255, "db_id": "superhero", "SQL": "SELECT T2.race FROM superhero AS T1 INNER JOIN race AS T2 ON T1.race_id = T2.id WHERE T1.superhero_name = 'Copycat'", "pandas_query": "merged_df = pd.merge(superhero, race, left_on=\"race_id\", right_on=\"id\", how=\"inner\")\nresult = merged_df.loc[merged_df[\"superhero_name\"] == \"Copycat\", \"race\"].iloc[0]"}
{"question_id": 257, "db_id": "superhero", "SQL": "SELECT T1.superhero_name FROM superhero AS T1 INNER JOIN hero_power AS T2 ON T1.id = T2.hero_id INNER JOIN superpower AS T3 ON T2.power_id = T3.id WHERE T3.power_name = 'Death Touch'", "pandas_query": "merged_df = pd.merge(superhero, hero_power, left_on=\"id\", right_on=\"hero_id\", how=\"inner\")\nmerged_df = pd.merge(merged_df, superpower, left_on=\"power_id\", right_on=\"id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"power_name\"] == \"Death Touch\"]\nresult = filtered_df[\"superhero_name\"].unique()"}
{"question_id": 259, "db_id": "superhero", "SQL": "SELECT (CAST(COUNT(*) AS REAL) * 100 / NULLIF((SELECT COUNT(*) FROM superhero), 0)), CAST(SUM(CASE WHEN T2.publisher_name = 'Marvel Comics' THEN 1 ELSE 0 END) AS REAL) FROM superhero AS T1 INNER JOIN publisher AS T2 ON T1.publisher_id = T2.id INNER JOIN alignment AS T3 ON T3.id = T1.alignment_id WHERE T3.alignment = 'Bad'", "pandas_query": "merged_df = pd.merge(superhero, publisher, left_on=\"publisher_id\", right_on=\"id\", how=\"inner\")\nmerged_df = pd.merge(merged_df, alignment, left_on=\"alignment_id\", right_on=\"id\", how=\"inner\")\nbad_superheroes_df = merged_df[merged_df[\"alignment\"] == \"Bad\"]\ntotal_superheroes = superhero.shape[0]\npercentage_bad_superheroes = (bad_superheroes_df.shape[0] * 100) / total_superheroes\nmarvel_bad_superheroes = bad_superheroes_df[bad_superheroes_df[\"publisher_name\"] == \"Marvel Comics\"].shape[0]\nresult = (percentage_bad_superheroes, marvel_bad_superheroes)"}
{"question_id": 261, "db_id": "superhero", "SQL": "SELECT id FROM publisher WHERE publisher_name = 'Star Trek'", "pandas_query": "result = publisher.loc[publisher[\"publisher_name\"] == \"Star Trek\", \"id\"]"}
{"question_id": 265, "db_id": "superhero", "SQL": "SELECT DISTINCT T1.superhero_name FROM superhero AS T1 INNER JOIN colour AS T2 ON T1.eye_colour_id = T2.id WHERE T1.height_cm BETWEEN 170 AND 190 AND T2.colour = 'No Colour'", "pandas_query": "merged_df = pd.merge(superhero, colour, left_on=\"eye_colour_id\", right_on=\"id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"height_cm\"].between(170, 190)) & (merged_df[\"colour\"] == \"No Colour\")]\nresult = filtered_df[\"superhero_name\"].unique()"}
{"question_id": 266, "db_id": "superhero", "SQL": "SELECT DISTINCT T3.colour FROM superhero AS T1 INNER JOIN race AS T2 ON T1.race_id = T2.id INNER JOIN colour AS T3 ON T1.hair_colour_id = T3.id WHERE T1.height_cm = 185 AND T2.race = 'Human'", "pandas_query": "merged_df1 = pd.merge(superhero, race, left_on=\"race_id\", right_on=\"id\", how=\"inner\")\nmerged_df2 = pd.merge(merged_df1, colour, left_on=\"hair_colour_id\", right_on=\"id\", how=\"inner\")\nfiltered_df = merged_df2[(merged_df2[\"height_cm\"] == 185) & (merged_df2[\"race\"] == \"Human\")]\nresult = filtered_df[\"colour\"].unique()"}
{"question_id": 269, "db_id": "superhero", "SQL": "SELECT DISTINCT T2.power_name FROM hero_power AS T1 INNER JOIN superpower AS T2 ON T1.power_id = T2.id WHERE T1.hero_id = 1", "pandas_query": "merged_df = pd.merge(hero_power, superpower, left_on=\"power_id\", right_on=\"id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"hero_id\"] == 1]\nresult = filtered_df[\"power_name\"].unique()"}
{"question_id": 270, "db_id": "superhero", "SQL": "SELECT COUNT(T1.hero_id) FROM hero_power AS T1 INNER JOIN superpower AS T2 ON T1.power_id = T2.id WHERE T2.power_name = 'Stealth'", "pandas_query": "merged_df = pd.merge(hero_power, superpower, left_on=\"power_id\", right_on=\"id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"power_name\"] == \"Stealth\"]\nresult = filtered_df[\"hero_id\"].nunique()"}
{"question_id": 272, "db_id": "superhero", "SQL": "SELECT T1.superhero_name FROM superhero AS T1 INNER JOIN hero_attribute AS T2 ON T1.id = T2.hero_id INNER JOIN attribute AS T3 ON T3.id = T2.attribute_id INNER JOIN publisher AS T4 ON T4.id = T1.publisher_id WHERE T4.publisher_name = 'Dark Horse Comics' AND T3.attribute_name = 'Durability' ORDER BY T2.attribute_value DESC NULLS LAST LIMIT 1", "pandas_query": "merged_df = pd.merge(superhero, hero_attribute, left_on=\"id\", right_on=\"hero_id\", how=\"inner\")\nmerged_df = pd.merge(merged_df, attribute, left_on=\"attribute_id\", right_on=\"id\", how=\"inner\")\nmerged_df = pd.merge(merged_df, publisher, left_on=\"publisher_id\", right_on=\"id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"publisher_name\"] == \"Dark Horse Comics\") & (merged_df[\"attribute_name\"] == \"Durability\")]\nresult = filtered_df.sort_values(by=\"attribute_value\", ascending=False).iloc[0][\"superhero_name\"]"}
{"question_id": 274, "db_id": "superhero", "SQL": "SELECT T1.superhero_name, T2.publisher_name FROM superhero AS T1 INNER JOIN publisher AS T2 ON T1.publisher_id = T2.id WHERE T1.eye_colour_id = T1.hair_colour_id AND T1.eye_colour_id = T1.skin_colour_id", "pandas_query": "merged_df = pd.merge(superhero, publisher, left_on=\"publisher_id\", right_on=\"id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"eye_colour_id\"] == merged_df[\"hair_colour_id\"]) & (merged_df[\"eye_colour_id\"] == merged_df[\"skin_colour_id\"])]\nresult = filtered_df[[\"superhero_name\", \"publisher_name\"]]"}
{"question_id": 275, "db_id": "superhero", "SQL": "SELECT CAST(COUNT(CASE WHEN T3.colour = 'Blue' THEN T1.id ELSE NULL END) AS REAL) * 100 / NULLIF(COUNT(T1.id), 0) FROM superhero AS T1 INNER JOIN gender AS T2 ON T1.gender_id = T2.id INNER JOIN colour AS T3 ON T1.skin_colour_id = T3.id WHERE T2.gender = 'Female'", "pandas_query": "merged_df = pd.merge(superhero, gender, left_on=\"gender_id\", right_on=\"id\", how=\"inner\")\nmerged_df = pd.merge(merged_df, colour, left_on=\"skin_colour_id\", right_on=\"id\", how=\"inner\")\nfemale_superheroes = merged_df[merged_df[\"gender\"] == \"Female\"]\nblue_female_superheroes_count = female_superheroes[female_superheroes[\"colour\"] == \"Blue\"].shape[0]\ntotal_female_superheroes_count = female_superheroes.shape[0]\nresult = (blue_female_superheroes_count / total_female_superheroes_count) * 100"}
{"question_id": 276, "db_id": "superhero", "SQL": "SELECT COUNT(T1.power_id) FROM hero_power AS T1 INNER JOIN superhero AS T2 ON T1.hero_id = T2.id WHERE T2.superhero_name = 'Amazo'", "pandas_query": "merged_df = pd.merge(hero_power, superhero, left_on=\"hero_id\", right_on=\"id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"superhero_name\"] == \"Amazo\"]\nresult = filtered_df[\"power_id\"].count()"}
{"question_id": 278, "db_id": "superhero", "SQL": "SELECT T1.superhero_name FROM superhero AS T1 INNER JOIN colour AS T2 ON T1.eye_colour_id = T2.id AND T1.hair_colour_id = T2.id WHERE T2.colour = 'Black'", "pandas_query": "merged_df = pd.merge(superhero, colour, left_on=[\"eye_colour_id\", \"hair_colour_id\"], right_on=[\"id\", \"id\"], how=\"inner\")\nfiltered_df = merged_df[merged_df[\"colour\"] == \"Black\"]\nresult = filtered_df[\"superhero_name\"].tolist()"}
{"question_id": 279, "db_id": "superhero", "SQL": "SELECT T1.superhero_name FROM superhero AS T1 INNER JOIN alignment AS T2 ON T1.alignment_id = T2.id WHERE T2.alignment = 'Neutral'", "pandas_query": "merged_df = pd.merge(superhero, alignment, left_on=\"alignment_id\", right_on=\"id\", how=\"inner\")\nneutral_superheroes = merged_df[merged_df[\"alignment\"] == \"Neutral\"]\nresult = neutral_superheroes[\"superhero_name\"]"}
{"question_id": 280, "db_id": "superhero", "SQL": "SELECT COUNT(T1.hero_id) FROM hero_attribute AS T1 INNER JOIN attribute AS T2 ON T1.attribute_id = T2.id WHERE T2.attribute_name = 'Strength' AND T1.attribute_value = (SELECT MAX(attribute_value) FROM hero_attribute)", "pandas_query": "merged_df = pd.merge(hero_attribute, attribute, left_on=\"attribute_id\", right_on=\"id\", how=\"inner\")\nstrength_df = merged_df[merged_df[\"attribute_name\"] == \"Strength\"]\nmax_value = strength_df[\"attribute_value\"].max()\nresult = strength_df[strength_df[\"attribute_value\"] == max_value][\"hero_id\"].nunique()"}
{"question_id": 281, "db_id": "superhero", "SQL": "SELECT CAST(COUNT(CASE WHEN T3.gender = 'Female' AND T2.publisher_name = 'Marvel Comics' THEN 1 ELSE NULL END) AS REAL) / NULLIF(COUNT(CASE WHEN T3.gender = 'Female' THEN 1 ELSE NULL END), 0) * 100 FROM superhero AS T1 LEFT JOIN publisher AS T2 ON T1.publisher_id = T2.id INNER JOIN gender AS T3 ON T1.gender_id = T3.id", "pandas_query": "merged_df = pd.merge(superhero, publisher, left_on=\"publisher_id\", right_on=\"id\", how=\"left\")\nmerged_df = pd.merge(merged_df, gender, left_on=\"gender_id\", right_on=\"id\", how=\"inner\")\nfemale_heroes = merged_df[merged_df[\"gender\"] == \"Female\"]\nfemale_marvel_heroes = female_heroes[female_heroes[\"publisher_name\"] == \"Marvel Comics\"]\npercent_female_marvel_heroes = (female_marvel_heroes.shape[0] / female_heroes.shape[0]) * 100\nresult = percent_female_marvel_heroes"}
{"question_id": 283, "db_id": "superhero", "SQL": "SELECT CAST(SUM(height_cm) AS REAL) / NULLIF(COUNT(id), 0) FROM superhero", "pandas_query": "result = superhero[\"height_cm\"].sum() / superhero[\"id\"].count()"}
{"question_id": 284, "db_id": "superhero", "SQL": "SELECT T3.power_name FROM superhero AS T1 INNER JOIN hero_power AS T2 ON T1.id = T2.hero_id INNER JOIN superpower AS T3 ON T2.power_id = T3.id WHERE T1.superhero_name = 'Abomination'", "pandas_query": "merged_df_1 = pd.merge(superhero, hero_power, left_on=\"id\", right_on=\"hero_id\", how=\"inner\")\nmerged_df_2 = pd.merge(merged_df_1, superpower, left_on=\"power_id\", right_on=\"id\", how=\"inner\")\nresult = merged_df_2[merged_df_2[\"superhero_name\"] == \"Abomination\"][\"power_name\"]"}
{"question_id": 285, "db_id": "superhero", "SQL": "SELECT T1.superhero_name FROM superhero AS T1 INNER JOIN hero_attribute AS T2 ON T1.id = T2.hero_id INNER JOIN attribute AS T3 ON T2.attribute_id = T3.id WHERE T3.attribute_name = 'Speed' ORDER BY T2.attribute_value DESC NULLS LAST LIMIT 1", "pandas_query": "merged_df = pd.merge(superhero, hero_attribute, left_on=\"id\", right_on=\"hero_id\", how=\"inner\")\nmerged_df = pd.merge(merged_df, attribute, left_on=\"attribute_id\", right_on=\"id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"attribute_name\"] == \"Speed\"]\nresult = filtered_df.loc[filtered_df[\"attribute_value\"].idxmax(), \"superhero_name\"]"}
{"question_id": 286, "db_id": "superhero", "SQL": "SELECT T3.attribute_name, T2.attribute_value FROM superhero AS T1 INNER JOIN hero_attribute AS T2 ON T1.id = T2.hero_id INNER JOIN attribute AS T3 ON T2.attribute_id = T3.id WHERE T1.superhero_name = '3-D Man'", "pandas_query": "merged_df_1 = pd.merge(superhero, hero_attribute, left_on=\"id\", right_on=\"hero_id\", how=\"inner\")\nmerged_df_2 = pd.merge(merged_df_1, attribute, left_on=\"attribute_id\", right_on=\"id\", how=\"inner\")\nfiltered_df = merged_df_2[merged_df_2[\"superhero_name\"] == \"3-D Man\"]\nresult = filtered_df[[\"attribute_name\", \"attribute_value\"]]"}
{"question_id": 289, "db_id": "superhero", "SQL": "SELECT CAST(COUNT(CASE WHEN T2.colour = 'Blue' THEN 1 ELSE NULL END) AS REAL) * 100 / NULLIF(COUNT(T1.id), 0) FROM superhero AS T1 INNER JOIN colour AS T2 ON T1.eye_colour_id = T2.id", "pandas_query": "merged_df = pd.merge(superhero, colour, left_on=\"eye_colour_id\", right_on=\"id\", how=\"inner\")\nblue_eyes_count = merged_df[merged_df[\"colour\"] == \"Blue\"][\"superhero_name\"].count()\ntotal_superheroes = merged_df[\"superhero_name\"].count()\nresult = (blue_eyes_count / total_superheroes) * 100.0"}
{"question_id": 290, "db_id": "superhero", "SQL": "SELECT CAST(COUNT(CASE WHEN T2.gender = 'Male' THEN T1.id ELSE NULL END) AS REAL) / NULLIF(COUNT(CASE WHEN T2.gender = 'Female' THEN T1.id ELSE NULL END), 0) FROM superhero AS T1 INNER JOIN gender AS T2 ON T1.gender_id = T2.id", "pandas_query": "merged_df = pd.merge(superhero, gender, left_on=\"gender_id\", right_on=\"id\", how=\"inner\")\nmale_count = merged_df[merged_df[\"gender\"] == \"Male\"].shape[0]\nfemale_count = merged_df[merged_df[\"gender\"] == \"Female\"].shape[0]\nresult = float(male_count) / female_count"}
{"question_id": 291, "db_id": "superhero", "SQL": "SELECT T2.colour FROM superhero AS T1 INNER JOIN colour AS T2 ON T1.eye_colour_id = T2.id WHERE T1.full_name = 'Karen Beecher-Duncan'", "pandas_query": "merged_df = pd.merge(superhero, colour, left_on=\"eye_colour_id\", right_on=\"id\", how=\"inner\")\nresult = merged_df[merged_df[\"full_name\"] == \"Karen Beecher-Duncan\"][\"colour\"].iloc[0]"}
{"question_id": 292, "db_id": "superhero", "SQL": "SELECT SUM(CASE WHEN T2.id = 7 THEN 1 ELSE 0 END) - SUM(CASE WHEN T2.id = 1 THEN 1 ELSE 0 END) FROM superhero AS T1 INNER JOIN colour AS T2 ON T1.eye_colour_id = T2.id WHERE T1.weight_kg = 0 OR T1.weight_kg IS NULL", "pandas_query": "merged_df = pd.merge(superhero, colour, left_on=\"eye_colour_id\", right_on=\"id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"weight_kg\"] == 0) | (merged_df[\"weight_kg\"].isnull())]\nblue_eyes_count = (filtered_df[\"id_y\"] == 7).sum()\nno_eye_color_count = (filtered_df[\"id_y\"] == 1).sum()\nresult = blue_eyes_count - no_eye_color_count"}
{"question_id": 293, "db_id": "superhero", "SQL": "SELECT COUNT(T1.id) FROM superhero AS T1 INNER JOIN alignment AS T2 ON T1.alignment_id = T2.id INNER JOIN colour AS T3 ON T1.skin_colour_id = T3.id WHERE T2.alignment = 'Bad' AND T3.colour = 'Green'", "pandas_query": "merged_df = pd.merge(superhero, alignment, left_on=\"alignment_id\", right_on=\"id\", how=\"inner\")\nmerged_df = pd.merge(merged_df, colour, left_on=\"skin_colour_id\", right_on=\"id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"alignment\"] == \"Bad\") & (merged_df[\"colour\"] == \"Green\")]\nresult = filtered_df[\"id_x\"].count()"}
{"question_id": 294, "db_id": "superhero", "SQL": "SELECT T1.superhero_name FROM superhero AS T1 INNER JOIN hero_power AS T2 ON T1.id = T2.hero_id INNER JOIN superpower AS T3 ON T2.power_id = T3.id WHERE T3.power_name = 'Wind Control' ORDER BY T1.superhero_name NULLS FIRST", "pandas_query": "merged_df = pd.merge(superhero, hero_power, left_on=\"id\", right_on=\"hero_id\", how=\"inner\")\nmerged_df = pd.merge(merged_df, superpower, left_on=\"power_id\", right_on=\"id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"power_name\"] == \"Wind Control\"]\nresult = filtered_df[\"superhero_name\"].sort_values().unique()"}
{"question_id": 295, "db_id": "superhero", "SQL": "SELECT T4.gender FROM superhero AS T1 INNER JOIN hero_power AS T2 ON T1.id = T2.hero_id INNER JOIN superpower AS T3 ON T2.power_id = T3.id INNER JOIN gender AS T4 ON T1.gender_id = T4.id WHERE T3.power_name = 'Phoenix Force'", "pandas_query": "merged_df_1 = pd.merge(superhero, hero_power, left_on=\"id\", right_on=\"hero_id\", how=\"inner\")\nmerged_df_2 = pd.merge(merged_df_1, superpower, left_on=\"power_id\", right_on=\"id\", how=\"inner\")\nmerged_df_3 = pd.merge(merged_df_2, gender, left_on=\"gender_id\", right_on=\"id\", how=\"inner\")\nfiltered_df = merged_df_3[merged_df_3[\"power_name\"] == \"Phoenix Force\"]\nresult = filtered_df[\"gender\"]"}
{"question_id": 296, "db_id": "superhero", "SQL": "SELECT SUM(CASE WHEN T2.publisher_name = 'DC Comics' THEN 1 ELSE 0 END) - SUM(CASE WHEN T2.publisher_name = 'Marvel Comics' THEN 1 ELSE 0 END) FROM superhero AS T1 INNER JOIN publisher AS T2 ON T1.publisher_id = T2.id", "pandas_query": "merged_df = pd.merge(superhero, publisher, left_on=\"publisher_id\", right_on=\"id\", how=\"inner\")\ndc_count = (merged_df[\"publisher_name\"] == \"DC Comics\").sum()\nmarvel_count = (merged_df[\"publisher_name\"] == \"Marvel Comics\").sum()\nresult = dc_count - marvel_count"}
{"question_id": 298, "db_id": "codebase_community", "SQL": "SELECT DisplayName FROM users WHERE TO_CHAR(CAST(CreationDate AS TIMESTAMP), 'YYYY') = '2011'", "pandas_query": "users['CreationDate'] = pd.to_datetime(users['CreationDate'], errors='coerce')\nresult = users[users[\"CreationDate\"].dt.year == 2011][\"DisplayName\"]"}
{"question_id": 301, "db_id": "codebase_community", "SQL": "SELECT COUNT(T1.id) FROM posts AS T1 INNER JOIN users AS T2 ON T1.OwnerUserId = T2.Id WHERE T2.DisplayName = 'csgillespie'", "pandas_query": "merged_df = pd.merge(posts, users, left_on=\"OwnerUserId\", right_on=\"Id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"DisplayName\"] == \"csgillespie\"]\nresult = filtered_df[\"Id_x\"].count()"}
{"question_id": 306, "db_id": "codebase_community", "SQL": "SELECT CAST(SUM(CASE WHEN T2.Age > 65 THEN 1 ELSE 0 END) AS REAL) * 100 / NULLIF(COUNT(T1.Id), 0) FROM posts AS T1 INNER JOIN users AS T2 ON T1.OwnerUserId = T2.Id WHERE T1.Score > 5", "pandas_query": "merged_df = pd.merge(posts, users, left_on=\"OwnerUserId\", right_on=\"Id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"Score\"] > 5]\nelder_count = filtered_df[filtered_df[\"Age\"] > 65].shape[0]\ntotal_count = filtered_df.shape[0]\nresult = (elder_count / total_count) * 100"}
{"question_id": 307, "db_id": "codebase_community", "SQL": "SELECT T1.FavoriteCount FROM posts AS T1 INNER JOIN comments AS T2 ON T1.Id = T2.PostId WHERE T2.CreationDate = '2014-04-23 20:29:39.0' AND T2.UserId = 3025", "pandas_query": "merged_df = pd.merge(posts, comments, left_on=\"Id\", right_on=\"PostId\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"CreationDate\"] == \"2014-04-23 20:29:39.0\") & (merged_df[\"UserId\"] == 3025)]\nresult = filtered_df[\"FavoriteCount\"].iloc[0]"}
{"question_id": 308, "db_id": "codebase_community", "SQL": "SELECT CASE WHEN T2.ClosedDate IS NULL THEN 'NOT well-finished' ELSE 'well-finished' END AS resylt FROM comments AS T1 INNER JOIN posts AS T2 ON T1.PostId = T2.Id WHERE T1.UserId = 23853 AND T1.CreationDate = '2013-07-12 09:08:18.0'", "pandas_query": "merged_df = pd.merge(comments, posts, left_on=\"PostId\", right_on=\"Id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"UserId\"] == 23853) & (merged_df[\"CreationDate\"] == '2013-07-12 09:08:18.0')]\nresult = 'well-finished' if not filtered_df[\"ClosedDate\"].isnull().all() else 'NOT well-finished'"}
{"question_id": 309, "db_id": "codebase_community", "SQL": "SELECT COUNT(T1.Id) FROM users AS T1 INNER JOIN posts AS T2 ON T1.Id = T2.OwnerUserId WHERE T1.DisplayName = 'Tiago Pasqualini'", "pandas_query": "merged_df = pd.merge(users, posts, left_on=\"Id\", right_on=\"OwnerUserId\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"DisplayName\"] == \"Tiago Pasqualini\"]\nresult = filtered_df[\"Id_x\"].count()"}
{"question_id": 310, "db_id": "codebase_community", "SQL": "SELECT T1.DisplayName FROM users AS T1 INNER JOIN votes AS T2 ON T1.Id = T2.UserId WHERE T2.Id = 6347", "pandas_query": "merged_df = pd.merge(users, votes, left_on=\"Id\", right_on=\"UserId\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"Id_y\"] == 6347]\nresult = filtered_df[\"DisplayName\"].iloc[0]"}
{"question_id": 311, "db_id": "codebase_community", "SQL": "SELECT CAST(COUNT(DISTINCT T2.Id) AS REAL) / NULLIF(COUNT(DISTINCT T1.Id), 0) FROM votes AS T1 INNER JOIN posts AS T2 ON T1.UserId = T2.OwnerUserId WHERE T1.UserId = 24", "pandas_query": "merged_df = pd.merge(votes, posts, left_on=\"UserId\", right_on=\"OwnerUserId\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"UserId\"] == 24]\nresult = filtered_df[\"Id_y\"].nunique() / filtered_df[\"Id_x\"].nunique()"}
{"question_id": 312, "db_id": "codebase_community", "SQL": "SELECT ViewCount FROM posts WHERE Title = 'Integration of Weka and/or RapidMiner into Informatica PowerCenter/Developer'", "pandas_query": "result = posts.loc[posts[\"Title\"] == \"Integration of Weka and/or RapidMiner into Informatica PowerCenter/Developer\", \"ViewCount\"].iloc[0]"}
{"question_id": 313, "db_id": "codebase_community", "SQL": "SELECT Text FROM comments WHERE Score = 17", "pandas_query": "result = comments[comments[\"Score\"] == 17][\"Text\"]"}
{"question_id": 314, "db_id": "codebase_community", "SQL": "SELECT T1.DisplayName FROM users AS T1 INNER JOIN comments AS T2 ON T1.Id = T2.UserId WHERE T2.Text = 'thank you user93!'", "pandas_query": "merged_df = pd.merge(users, comments, left_on=\"Id\", right_on=\"UserId\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"Text\"] == \"thank you user93!\"]\nresult = filtered_df[\"DisplayName\"].iloc[0]"}
{"question_id": 315, "db_id": "codebase_community", "SQL": "SELECT T1.DisplayName, T1.Reputation FROM users AS T1 INNER JOIN posts AS T2 ON T1.Id = T2.OwnerUserId WHERE T2.Title = 'Understanding what Dassault iSight is doing?'", "pandas_query": "merged_df = pd.merge(users, posts, left_on=\"Id\", right_on=\"OwnerUserId\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"Title\"] == 'Understanding what Dassault iSight is doing?']\nresult = filtered_df[[\"DisplayName\", \"Reputation\"]]"}
{"question_id": 316, "db_id": "codebase_community", "SQL": "SELECT T2.DisplayName FROM posts AS T1 INNER JOIN users AS T2 ON T1.OwnerUserId = T2.Id WHERE T1.Title = 'Open source tools for visualizing multi-dimensional data?'", "pandas_query": "merged_df = pd.merge(posts, users, left_on=\"OwnerUserId\", right_on=\"Id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"Title\"] == 'Open source tools for visualizing multi-dimensional data?']\nresult = filtered_df[\"DisplayName\"].iloc[0]"}
{"question_id": 317, "db_id": "codebase_community", "SQL": "SELECT T2.Comment FROM posts AS T1 INNER JOIN postHistory AS T2 ON T1.Id = T2.PostId WHERE T1.Title = 'Why square the difference instead of taking the absolute value in standard deviation?'", "pandas_query": "merged_df = pd.merge(posts, postHistory, left_on=\"Id\", right_on=\"PostId\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"Title\"] == 'Why square the difference instead of taking the absolute value in standard deviation?']\nresult = filtered_df[\"Comment\"]"}
{"question_id": 318, "db_id": "codebase_community", "SQL": "SELECT T3.DisplayName FROM posts AS T1 INNER JOIN votes AS T2 ON T1.Id = T2.PostId INNER JOIN users AS T3 ON T3.Id = T2.UserId WHERE T2.BountyAmount = 50 AND T1.Title LIKE '%variance%'", "pandas_query": "merged_df_1 = pd.merge(posts, votes, left_on=\"Id\", right_on=\"PostId\", how=\"inner\")\nmerged_df_2 = pd.merge(merged_df_1, users, left_on=\"UserId\", right_on=\"Id\", how=\"inner\")\nfiltered_df = merged_df_2[(merged_df_2[\"BountyAmount\"] == 50) & (merged_df_2[\"Title\"].str.contains(\"variance\", case=False))]\nresult = filtered_df[\"DisplayName\"]"}
{"question_id": 321, "db_id": "codebase_community", "SQL": "SELECT T2.UserId FROM users AS T1 INNER JOIN postHistory AS T2 ON T1.Id = T2.UserId INNER JOIN posts AS T3 ON T2.PostId = T3.Id WHERE T1.Views >= 100 GROUP BY T2.UserId HAVING COUNT(DISTINCT T2.PostHistoryTypeId) = 1", "pandas_query": "merged_df = pd.merge(users, postHistory, left_on=\"Id\", right_on=\"UserId\", how=\"inner\")\nmerged_df = pd.merge(merged_df, posts, left_on=\"PostId\", right_on=\"Id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"Views\"] >= 100]\ngrouped_df = filtered_df.groupby(\"UserId\").agg({\"PostHistoryTypeId\": pd.Series.nunique})\nresult = grouped_df[grouped_df[\"PostHistoryTypeId\"] == 1].index.tolist()"}
{"question_id": 322, "db_id": "codebase_community", "SQL": "SELECT CAST(SUM(CASE WHEN TO_CHAR(CAST(Date AS TIMESTAMP), 'YYYY') = '2010' THEN 1 ELSE 0 END) AS REAL) * 100 / NULLIF(COUNT(Id), 0) - CAST(SUM(CASE WHEN TO_CHAR(CAST(Date AS TIMESTAMP), 'YYYY') = '2011' THEN 1 ELSE 0 END) AS REAL) * 100 / NULLIF(COUNT(Id), 0) FROM badges WHERE Name = 'Student'", "pandas_query": "badges['Date'] = pd.to_datetime(badges['Date'])\n\nbadges_filtered = badges[badges[\"Name\"] == \"Student\"]\n\ncount_2010 = (badges_filtered[\"Date\"].dt.year == 2010).sum()\n\ncount_2011 = (badges_filtered[\"Date\"].dt.year == 2011).sum()\n\ntotal_count = badges_filtered[\"Id\"].count()\n\npercentage_2010 = (count_2010 / total_count) * 100\n\npercentage_2011 = (count_2011 / total_count) * 100\n\nresult = percentage_2010 - percentage_2011"}
{"question_id": 323, "db_id": "codebase_community", "SQL": "SELECT AVG(T1.UpVotes), AVG(T1.Age) FROM users AS T1 INNER JOIN (SELECT OwnerUserId, COUNT(*) AS post_count FROM posts GROUP BY OwnerUserId HAVING COUNT(*) > 10) AS T2 ON T1.Id = T2.OwnerUserId", "pandas_query": "post_counts = posts.groupby(\"OwnerUserId\").size().reset_index(name=\"post_count\")\nfiltered_users = post_counts[post_counts[\"post_count\"] > 10]\nmerged_df = pd.merge(users, filtered_users, left_on=\"Id\", right_on=\"OwnerUserId\", how=\"inner\")\naverage_upvotes = merged_df[\"UpVotes\"].mean()\naverage_age = merged_df[\"Age\"].mean()\nresult = (average_upvotes, average_age)"}
{"question_id": 324, "db_id": "codebase_community", "SQL": "SELECT CAST(SUM(CASE WHEN TO_CHAR(CAST(CreationDate AS TIMESTAMP), 'YYYY') = '2010' THEN 1 ELSE 0 END) AS REAL) / NULLIF(SUM(CASE WHEN TO_CHAR(CAST(CreationDate AS TIMESTAMP), 'YYYY') = '2011' THEN 1 ELSE 0 END), 0) FROM votes", "pandas_query": "votes['Year'] = pd.to_datetime(votes['CreationDate']).dt.year\nvotes_2010 = votes[votes['Year'] == 2010]['Id'].count()\nvotes_2011 = votes[votes['Year'] == 2011]['Id'].count()\nresult = float(votes_2010) / votes_2011"}
{"question_id": 326, "db_id": "codebase_community", "SQL": "SELECT T1.DisplayName FROM users AS T1 INNER JOIN postHistory AS T2 ON T1.Id = T2.UserId INNER JOIN posts AS T3 ON T2.PostId = T3.Id WHERE T1.DisplayName = 'Harvey Motulsky' OR T1.DisplayName = 'Noah Snyder' GROUP BY T1.DisplayName ORDER BY SUM(T3.ViewCount) DESC NULLS LAST LIMIT 1", "pandas_query": "merged_df = pd.merge(users, postHistory, left_on=\"Id\", right_on=\"UserId\", how=\"inner\")\nmerged_df = pd.merge(merged_df, posts, left_on=\"PostId\", right_on=\"Id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"DisplayName\"] == \"Harvey Motulsky\") | (merged_df[\"DisplayName\"] == \"Noah Snyder\")]\ngrouped_df = filtered_df.groupby(\"DisplayName\")[\"ViewCount\"].sum().reset_index()\nresult = grouped_df.loc[grouped_df[\"ViewCount\"].idxmax(), \"DisplayName\"]"}
{"question_id": 327, "db_id": "codebase_community", "SQL": "SELECT T3.Tags FROM users AS T1 INNER JOIN postHistory AS T2 ON T1.Id = T2.UserId INNER JOIN posts AS T3 ON T3.Id = T2.PostId WHERE T1.DisplayName = 'Mark Meckes' AND T3.CommentCount = 0", "pandas_query": "merged_df1 = pd.merge(users, postHistory, left_on=\"Id\", right_on=\"UserId\", how=\"inner\")\nmerged_df2 = pd.merge(merged_df1, posts, left_on=\"PostId\", right_on=\"Id\", how=\"inner\")\nfiltered_df = merged_df2[(merged_df2[\"DisplayName\"] == \"Mark Meckes\") & (merged_df2[\"CommentCount\"] == 0)]\nresult = filtered_df[\"Tags\"]"}
{"question_id": 328, "db_id": "codebase_community", "SQL": "SELECT CAST(SUM(CASE WHEN T3.TagName = 'r' THEN 1 ELSE 0 END) AS REAL) * 100 / NULLIF(COUNT(T1.Id), 0) FROM users AS T1 INNER JOIN postHistory AS T2 ON T1.Id = T2.UserId INNER JOIN tags AS T3 ON T3.ExcerptPostId = T2.PostId WHERE T1.DisplayName = 'Community'", "pandas_query": "merged_df = pd.merge(users, postHistory, left_on=\"Id\", right_on=\"UserId\", how=\"inner\")\nmerged_df = pd.merge(merged_df, tags, left_on=\"PostId\", right_on=\"ExcerptPostId\", how=\"inner\")\ncommunity_posts = merged_df[merged_df[\"DisplayName\"] == \"Community\"]\nr_tag_count = community_posts[\"TagName\"].eq(\"r\").sum()\ntotal_posts = community_posts[\"Id_x\"].count()\nresult = (r_tag_count / total_posts) * 100"}
{"question_id": 329, "db_id": "codebase_community", "SQL": "SELECT SUM(CASE WHEN T1.DisplayName = 'Mornington' THEN T3.ViewCount ELSE 0 END) - SUM(CASE WHEN T1.DisplayName = 'Amos' THEN T3.ViewCount ELSE 0 END) AS diff FROM users AS T1 INNER JOIN postHistory AS T2 ON T1.Id = T2.UserId INNER JOIN posts AS T3 ON T3.Id = T2.PostId", "pandas_query": "merged_df = pd.merge(users, postHistory, left_on=\"Id\", right_on=\"UserId\", how=\"inner\")\nmerged_df = pd.merge(merged_df, posts, left_on=\"PostId\", right_on=\"Id\", how=\"inner\")\nmornington_views = merged_df.loc[merged_df[\"DisplayName\"] == \"Mornington\", \"ViewCount\"].sum()\namos_views = merged_df.loc[merged_df[\"DisplayName\"] == \"Amos\", \"ViewCount\"].sum()\nresult = mornington_views - amos_views"}
{"question_id": 333, "db_id": "codebase_community", "SQL": "SELECT COUNT(DISTINCT T1.Id) FROM users AS T1 INNER JOIN posts AS T2 ON T1.Id = T2.OwnerUserId WHERE T1.Location = 'United Kingdom' AND T2.FavoriteCount >= 4", "pandas_query": "merged_df = pd.merge(users, posts, left_on=\"Id\", right_on=\"OwnerUserId\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"Location\"] == \"United Kingdom\") & (merged_df[\"FavoriteCount\"] >= 4)]\nresult = filtered_df[\"Id_x\"].nunique()"}
{"question_id": 334, "db_id": "codebase_community", "SQL": "SELECT T2.Id, T2.Title FROM users AS T1 INNER JOIN posts AS T2 ON T1.Id = T2.OwnerUserId WHERE T1.DisplayName = 'Harvey Motulsky' ORDER BY T2.ViewCount DESC NULLS LAST LIMIT 1", "pandas_query": "merged_df = pd.merge(users, posts, left_on=\"Id\", right_on=\"OwnerUserId\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"DisplayName\"] == \"Harvey Motulsky\"]\nsorted_df = filtered_df.sort_values(by=\"ViewCount\", ascending=False)\nresult = sorted_df[[\"Id_y\", \"Title\"]].head(1).rename(columns={\"Id_y\": \"Id\"})"}
{"question_id": 336, "db_id": "codebase_community", "SQL": "SELECT CAST(SUM(CASE WHEN TO_CHAR(CAST(T2.CreaionDate AS TIMESTAMP), 'YYYY') = '2011' AND T1.Reputation > 1000 THEN 1 ELSE 0 END) AS REAL) * 100 / NULLIF(COUNT(T1.Id), 0) FROM users AS T1 INNER JOIN posts AS T2 ON T1.Id = T2.OwnerUserId", "pandas_query": "posts['CreaionDate'] = pd.to_datetime(posts['CreaionDate'], errors='coerce')\n\nmerged_df = pd.merge(users, posts, left_on=\"Id\", right_on=\"OwnerUserId\", how=\"inner\")\n\ncondition = (merged_df[\"CreaionDate\"].dt.year == 2011) & (merged_df[\"Reputation\"] > 1000)\n\npercentage = (condition.sum() / len(merged_df)) * 100\n\nresult = percentage"}
{"question_id": 337, "db_id": "codebase_community", "SQL": "SELECT T2.ViewCount, T3.DisplayName FROM postHistory AS T1 INNER JOIN posts AS T2 ON T1.PostId = T2.Id INNER JOIN users AS T3 ON T2.LastEditorUserId = T3.Id WHERE T1.Text = 'Computer Game Datasets'", "pandas_query": "merged_df1 = pd.merge(postHistory, posts, left_on=\"PostId\", right_on=\"Id\", how=\"inner\")\nmerged_df2 = pd.merge(merged_df1, users, left_on=\"LastEditorUserId\", right_on=\"Id\", how=\"inner\")\nfiltered_df = merged_df2[merged_df2[\"Text\"] == \"Computer Game Datasets\"]\nresult = filtered_df[[\"ViewCount\", \"DisplayName\"]]"}
{"question_id": 338, "db_id": "codebase_community", "SQL": "SELECT COUNT(T2.Id) FROM posts AS T1 INNER JOIN comments AS T2 ON T1.Id = T2.PostId GROUP BY T1.Id ORDER BY T1.Score DESC NULLS LAST LIMIT 1", "pandas_query": "merged_df = pd.merge(posts, comments, left_on=\"Id\", right_on=\"PostId\", how=\"inner\")\n\ngrouped_df = merged_df.groupby(\"Id_x\").size().reset_index(name='comment_count')\n\nmax_score_post_id = posts.loc[posts['Score'].idxmax(), 'Id']\n\nresult = grouped_df.loc[grouped_df['Id_x'] == max_score_post_id, 'comment_count'].iloc[0]"}
{"question_id": 340, "db_id": "codebase_community", "SQL": "SELECT CAST(SUM(CASE WHEN T2.Score > 50 THEN 1 ELSE 0 END) AS REAL) * 100 / NULLIF(COUNT(T1.Id), 0) FROM users AS T1 INNER JOIN posts AS T2 ON T1.Id = T2.OwnerUserId INNER JOIN (SELECT MAX(Reputation) AS max_reputation FROM users) AS T3 ON T1.Reputation = T3.max_reputation", "pandas_query": "max_reputation = users[\"Reputation\"].max()\ninfluential_user_posts = posts[posts[\"OwnerUserId\"].isin(users[users[\"Reputation\"] == max_reputation][\"Id\"])]\ncount_high_score = influential_user_posts[influential_user_posts[\"Score\"] > 50].shape[0]\ntotal_posts = influential_user_posts.shape[0]\nresult = (count_high_score / total_posts) * 100"}
{"question_id": 341, "db_id": "codebase_community", "SQL": "SELECT ExcerptPostId, WikiPostId FROM tags WHERE TagName = 'sample'", "pandas_query": "result = tags.loc[tags[\"TagName\"] == \"sample\", [\"ExcerptPostId\", \"WikiPostId\"]]"}
{"question_id": 344, "db_id": "codebase_community", "SQL": "SELECT COUNT(T1.id) FROM comments AS T1 INNER JOIN posts AS T2 ON T1.PostId = T2.Id WHERE T2.CommentCount = 1 AND T1.Score = 0", "pandas_query": "merged_df = pd.merge(comments, posts, left_on=\"PostId\", right_on=\"Id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"CommentCount\"] == 1) & (merged_df[\"Score_x\"] == 0)]\nresult = len(filtered_df)"}
{"question_id": 346, "db_id": "card_games", "SQL": "SELECT id FROM cards WHERE NOT cardKingdomFoilId IS NULL AND NOT cardKingdomId IS NULL", "pandas_query": "result = cards[(cards[\"cardKingdomFoilId\"].notnull()) & (cards[\"cardKingdomId\"].notnull())][\"id\"]"}
{"question_id": 347, "db_id": "card_games", "SQL": "SELECT id FROM cards WHERE borderColor = 'borderless' AND (cardKingdomFoilId IS NULL OR cardKingdomId IS NULL)", "pandas_query": "result = cards[(cards[\"borderColor\"] == \"borderless\") & ((cards[\"cardKingdomFoilId\"].isnull()) | (cards[\"cardKingdomId\"].isnull()))][\"id\"]"}
{"question_id": 348, "db_id": "card_games", "SQL": "SELECT DISTINCT T1.id FROM cards AS T1 INNER JOIN legalities AS T2 ON T1.uuid = T2.uuid WHERE T2.format = 'gladiator' AND T2.status = 'Banned' AND T1.rarity = 'mythic'", "pandas_query": "merged_df = pd.merge(cards, legalities, left_on=\"uuid\", right_on=\"uuid\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"format\"] == \"gladiator\") & (merged_df[\"status\"] == \"Banned\") & (merged_df[\"rarity\"] == \"mythic\")]\nresult = filtered_df[\"id_x\"].unique()"}
{"question_id": 349, "db_id": "card_games", "SQL": "SELECT DISTINCT T2.status FROM cards AS T1 INNER JOIN legalities AS T2 ON T1.uuid = T2.uuid WHERE T1.type = 'Artifact' AND T2.format = 'vintage' AND T1.side IS NULL", "pandas_query": "merged_df = pd.merge(cards, legalities, left_on=\"uuid\", right_on=\"uuid\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"type\"] == \"Artifact\") & (merged_df[\"format\"] == \"vintage\") & (merged_df[\"side\"].isnull())]\nresult = filtered_df[\"status\"].unique()"}
{"question_id": 355, "db_id": "card_games", "SQL": "SELECT DISTINCT borderColor FROM cards WHERE name = 'Ancestor''s Chosen'", "pandas_query": "result = cards[cards[\"name\"] == \"Ancestor's Chosen\"][\"borderColor\"].unique()"}
{"question_id": 357, "db_id": "card_games", "SQL": "SELECT CAST(SUM(CASE WHEN borderColor = 'borderless' THEN 1 ELSE 0 END) AS REAL) * 100 / NULLIF(COUNT(id), 0) FROM cards", "pandas_query": "total_count = len(cards)\nborderless_count = len(cards[cards[\"borderColor\"] == \"borderless\"])\nresult = (borderless_count / total_count) * 100"}
{"question_id": 359, "db_id": "card_games", "SQL": "SELECT COUNT(id) FROM cards WHERE originalType = 'Summon - Angel' AND subtypes <> 'Angel'", "pandas_query": "filtered_df = cards[(cards[\"originalType\"] == \"Summon - Angel\") & (cards[\"subtypes\"] != \"Angel\")]\nresult = filtered_df[\"id\"].count()"}
{"question_id": 360, "db_id": "card_games", "SQL": "SELECT id FROM cards WHERE duelDeck = 'a'", "pandas_query": "result = cards[cards[\"duelDeck\"] == \"a\"][\"id\"]"}
{"question_id": 361, "db_id": "card_games", "SQL": "SELECT COUNT(DISTINCT T1.id) FROM cards AS T1 INNER JOIN legalities AS T2 ON T1.uuid = T2.uuid WHERE T2.status = 'Banned' AND T1.borderColor = 'white'", "pandas_query": "merged_df = pd.merge(cards, legalities, left_on=\"uuid\", right_on=\"uuid\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"status\"] == \"Banned\") & (merged_df[\"borderColor\"] == \"white\")]\nresult = filtered_df[\"id_x\"].nunique()"}
{"question_id": 362, "db_id": "card_games", "SQL": "SELECT DISTINCT T1.name FROM cards AS T1 INNER JOIN foreign_data AS T2 ON T1.uuid = T2.uuid WHERE T1.originalType = 'Artifact' AND T1.colors = 'B'", "pandas_query": "merged_df = pd.merge(cards, foreign_data, on=\"uuid\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"originalType\"] == \"Artifact\") & (merged_df[\"colors\"] == \"B\")]\nresult = filtered_df[\"name_x\"].unique()"}
{"question_id": 363, "db_id": "card_games", "SQL": "SELECT manaCost FROM cards WHERE availability = 'mtgo,paper' AND borderColor = 'black' AND frameVersion = '2003' AND layout = 'normal'", "pandas_query": "result = cards[(cards[\"availability\"] == \"mtgo,paper\") &\n(cards[\"borderColor\"] == \"black\") &\n(cards[\"frameVersion\"] == \"2003\") &\n(cards[\"layout\"] == \"normal\")][\"manaCost\"]"}
{"question_id": 364, "db_id": "card_games", "SQL": "SELECT CAST(SUM(CASE WHEN isTextless = 0 AND isStorySpotlight = 1 THEN 1 ELSE 0 END) AS REAL) * 100 / NULLIF(COUNT(id), 0) FROM cards", "pandas_query": "total_cards = len(cards)\nstory_spotlight_text_cards = len(cards[(cards[\"isTextless\"] == 0) & (cards[\"isStorySpotlight\"] == 1)])\nresult = (story_spotlight_text_cards / total_cards) * 100"}
{"question_id": 365, "db_id": "card_games", "SQL": "SELECT COUNT(T1.id) FROM sets AS T1 INNER JOIN set_translations AS T2 ON T1.code = T2.setCode WHERE T2.language = 'Portuguese (Brazil)' AND T1.block = 'Commander'", "pandas_query": "merged_df = pd.merge(sets, set_translations, left_on=\"code\", right_on=\"setCode\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"language\"] == \"Portuguese (Brazil)\") & (merged_df[\"block\"] == \"Commander\")]\nresult = filtered_df[\"id_x\"].count()"}
{"question_id": 366, "db_id": "card_games", "SQL": "SELECT T1.subtypes, T1.supertypes FROM cards AS T1 INNER JOIN foreign_data AS T2 ON T1.uuid = T2.uuid WHERE T2.language = 'German' AND NOT T1.subtypes IS NULL AND NOT T1.supertypes IS NULL", "pandas_query": "merged_df = pd.merge(cards, foreign_data, left_on=\"uuid\", right_on=\"uuid\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"language\"] == \"German\") & (merged_df[\"subtypes\"].notnull()) & (merged_df[\"supertypes\"].notnull())]\nresult = filtered_df[[\"subtypes\", \"supertypes\"]]"}
{"question_id": 368, "db_id": "card_games", "SQL": "SELECT COUNT(T1.id) FROM cards AS T1 INNER JOIN legalities AS T2 ON T1.uuid = T2.uuid INNER JOIN rulings AS T3 ON T1.uuid = T3.uuid WHERE T2.format = 'premodern' AND T3.text = 'This is a triggered mana ability.' AND T1.Side IS NULL", "pandas_query": "merged_df = pd.merge(cards, legalities, on=\"uuid\", how=\"inner\")\n\nmerged_df = pd.merge(merged_df, rulings, on=\"uuid\", how=\"inner\")\n\nfiltered_df = merged_df[\n(merged_df[\"format\"] == \"premodern\") &\n(merged_df[\"text_y\"] == \"This is a triggered mana ability.\") &\n(merged_df[\"side\"].isnull())\n]\n\nresult = filtered_df[\"id_x\"].nunique()"}
{"question_id": 369, "db_id": "card_games", "SQL": "SELECT name FROM foreign_data WHERE uuid IN (SELECT uuid FROM cards WHERE types = 'Creature' AND layout = 'normal' AND borderColor = 'black' AND artist = 'Matthew D. Wilson') AND language = 'French'", "pandas_query": "filtered_cards = cards[(cards[\"types\"] == \"Creature\") & (cards[\"layout\"] == \"normal\") & (cards[\"borderColor\"] == \"black\") & (cards[\"artist\"] == \"Matthew D. Wilson\")]\nfiltered_foreign_data = foreign_data[(foreign_data[\"uuid\"].isin(filtered_cards[\"uuid\"])) & (foreign_data[\"language\"] == \"French\")]\nresult = filtered_foreign_data[\"name\"]"}
{"question_id": 372, "db_id": "card_games", "SQL": "SELECT CAST(SUM(CASE WHEN T2.language = 'French' THEN 1 ELSE 0 END) AS REAL) * 100 / NULLIF(COUNT(T1.id), 0) FROM cards AS T1 INNER JOIN foreign_data AS T2 ON T1.uuid = T2.uuid WHERE T1.power IS NULL OR T1.power = '*'", "pandas_query": "merged_df = pd.merge(cards, foreign_data, left_on=\"uuid\", right_on=\"uuid\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"power\"].isnull()) | (merged_df[\"power\"] == '*')]\nfrench_count = filtered_df[filtered_df[\"language\"] == \"French\"].shape[0]\ntotal_count = filtered_df.shape[0]\nresult = (french_count / total_count) * 100"}
{"question_id": 376, "db_id": "card_games", "SQL": "SELECT DISTINCT language FROM foreign_data WHERE name = 'A Pedra Fellwar'", "pandas_query": "result = foreign_data[foreign_data[\"name\"] == \"A Pedra Fellwar\"][\"language\"].unique()"}
{"question_id": 377, "db_id": "card_games", "SQL": "SELECT name FROM cards WHERE name IN ('Serra Angel', 'Shrine Keeper') ORDER BY convertedManaCost DESC NULLS LAST LIMIT 1", "pandas_query": "result = cards[cards[\"name\"].isin([\"Serra Angel\", \"Shrine Keeper\"])].sort_values(by=\"convertedManaCost\", ascending=False).head(1)[\"name\"].iloc[0]"}
{"question_id": 378, "db_id": "card_games", "SQL": "SELECT translation FROM set_translations WHERE setCode IN (SELECT setCode FROM cards WHERE name = 'Ancestor''s Chosen') AND language = 'Italian'", "pandas_query": "set_codes = cards[cards[\"name\"] == \"Ancestor's Chosen\"][\"setCode\"].unique()\nresult = set_translations[(set_translations[\"setCode\"].isin(set_codes)) & (set_translations[\"language\"] == \"Italian\")][\"translation\"]"}
{"question_id": 381, "db_id": "card_games", "SQL": "SELECT T2.translation FROM sets AS T1 INNER JOIN set_translations AS T2 ON T2.setCode = T1.code WHERE T1.name = 'Eighth Edition' AND T2.language = 'Chinese Simplified'", "pandas_query": "merged_df = pd.merge(set_translations, sets, left_on=\"setCode\", right_on=\"code\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"name\"] == \"Eighth Edition\") & (merged_df[\"language\"] == \"Chinese Simplified\")]\nresult = filtered_df[\"translation\"].iloc[0]"}
{"question_id": 385, "db_id": "card_games", "SQL": "SELECT COUNT(T1.id) FROM sets AS T1 INNER JOIN set_translations AS T2 ON T2.setCode = T1.code WHERE NOT T2.translation IS NULL AND T1.baseSetSize < 100 AND T2.language = 'Italian'", "pandas_query": "merged_df = pd.merge(set_translations, sets, left_on=\"setCode\", right_on=\"code\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"translation\"].notnull()) & (merged_df[\"baseSetSize\"] < 100) & (merged_df[\"language\"] == \"Italian\")]\nresult = len(filtered_df)"}
{"question_id": 387, "db_id": "card_games", "SQL": "SELECT SUM(CASE WHEN T1.power = '*' OR T1.power IS NULL THEN 1 ELSE 0 END) FROM cards AS T1 INNER JOIN sets AS T2 ON T2.code = T1.setCode WHERE T2.name = 'Coldsnap' AND T1.convertedManaCost > 5", "pandas_query": "merged_df = pd.merge(cards, sets, left_on=\"setCode\", right_on=\"code\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"name_y\"] == \"Coldsnap\") & (merged_df[\"convertedManaCost\"] > 5)]\nresult = ((filtered_df[\"power\"] == '*') | (filtered_df[\"power\"].isnull())).sum()"}
{"question_id": 389, "db_id": "card_games", "SQL": "SELECT DISTINCT T1.text FROM foreign_data AS T1 INNER JOIN cards AS T2 ON T2.uuid = T1.uuid INNER JOIN sets AS T3 ON T3.code = T2.setCode WHERE T3.name = 'Coldsnap' AND T1.language = 'Italian'", "pandas_query": "merged_df_1 = pd.merge(foreign_data, cards, on=\"uuid\", how=\"inner\")\n\nmerged_df_2 = pd.merge(merged_df_1, sets, left_on=\"setCode\", right_on=\"code\", how=\"inner\")\n\nfiltered_df = merged_df_2[(merged_df_2[\"name\"] == \"Coldsnap\") & (merged_df_2[\"language\"] == \"Italian\")]\n\nresult = filtered_df[\"text_x\"].drop_duplicates()"}
{"question_id": 391, "db_id": "card_games", "SQL": "SELECT CAST(SUM(CASE WHEN T1.convertedManaCost = 7 THEN 1 ELSE 0 END) AS REAL) * 100 / NULLIF(COUNT(T1.id), 0) FROM cards AS T1 INNER JOIN sets AS T2 ON T2.code = T1.setCode WHERE T2.name = 'Coldsnap'", "pandas_query": "merged_df = pd.merge(cards, sets, left_on=\"setCode\", right_on=\"code\", how=\"inner\")\n\nfiltered_df = merged_df[merged_df[\"name_y\"] == \"Coldsnap\"]\n\npercentage = (filtered_df[\"convertedManaCost\"] == 7).sum() * 100 / filtered_df[\"id_x\"].count()\n\nresult = percentage"}
{"question_id": 392, "db_id": "card_games", "SQL": "SELECT CAST(SUM(CASE WHEN NOT T1.cardKingdomFoilId IS NULL AND NOT T1.cardKingdomId IS NULL THEN 1 ELSE 0 END) AS REAL) * 100 / NULLIF(COUNT(T1.id), 0) FROM cards AS T1 INNER JOIN sets AS T2 ON T2.code = T1.setCode WHERE T2.name = 'Coldsnap'", "pandas_query": "merged_df = pd.merge(cards, sets, left_on=\"setCode\", right_on=\"code\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"name_y\"] == \"Coldsnap\"]\nincredibly_powerful_count = ((filtered_df[\"cardKingdomFoilId\"].notnull()) & (filtered_df[\"cardKingdomId\"].notnull())).sum()\ntotal_count = filtered_df[\"id_x\"].count()\nresult = (incredibly_powerful_count / total_count) * 100"}
{"question_id": 394, "db_id": "card_games", "SQL": "SELECT T1.name, T2.format FROM cards AS T1 INNER JOIN legalities AS T2 ON T2.uuid = T1.uuid WHERE T1.edhrecRank = 1 AND T2.status = 'Banned' GROUP BY T1.name, T2.format", "pandas_query": "merged_df = pd.merge(cards, legalities, left_on=\"uuid\", right_on=\"uuid\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"edhrecRank\"] == 1) & (merged_df[\"status\"] == \"Banned\")]\nresult = filtered_df[[\"name\", \"format\"]].drop_duplicates()"}
{"question_id": 395, "db_id": "card_games", "SQL": "SELECT DISTINCT T2.name, CASE WHEN T1.status = 'Legal' THEN T1.format ELSE NULL END FROM legalities AS T1 INNER JOIN cards AS T2 ON T2.uuid = T1.uuid WHERE T2.setCode IN (SELECT code FROM sets WHERE name = 'Hour of Devastation')", "pandas_query": "hour_of_devastation_codes = sets.loc[sets[\"name\"] == \"Hour of Devastation\", \"code\"]\ncards_in_hour_of_devastation = cards[cards[\"setCode\"].isin(hour_of_devastation_codes)]\nmerged_df = pd.merge(legalities, cards_in_hour_of_devastation, left_on=\"uuid\", right_on=\"uuid\", how=\"inner\")\nresult = merged_df.loc[merged_df[\"status\"] == \"Legal\", [\"name\", \"format\"]].drop_duplicates()"}
{"question_id": 397, "db_id": "card_games", "SQL": "SELECT DISTINCT T1.frameVersion, T1.name, CASE WHEN T2.status = 'Banned' THEN T1.name ELSE 'NO' END FROM cards AS T1 INNER JOIN legalities AS T2 ON T1.uuid = T2.uuid WHERE T1.artist = 'Allen Williams'", "pandas_query": "merged_df = pd.merge(cards, legalities, left_on=\"uuid\", right_on=\"uuid\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"artist\"] == \"Allen Williams\"]\nfiltered_df[\"banned_status\"] = filtered_df[\"status\"].apply(lambda x: filtered_df[\"name\"] if x == \"Banned\" else \"NO\")\nresult = filtered_df[[\"frameVersion\", \"name\", \"banned_status\"]].drop_duplicates()"}
{"question_id": 399, "db_id": "toxicology", "SQL": "SELECT AVG(oxygen_count) FROM (SELECT T1.molecule_id, COUNT(T1.element) AS oxygen_count FROM atom AS T1 INNER JOIN bond AS T2 ON T1.molecule_id = T2.molecule_id WHERE T2.bond_type = '-' AND T1.element = 'o' GROUP BY T1.molecule_id) AS oxygen_counts", "pandas_query": "merged_df = pd.merge(atom, bond, on=\"molecule_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"bond_type\"] == \"-\") & (merged_df[\"element\"] == \"o\")]\noxygen_counts = filtered_df.groupby(\"molecule_id\").size().reset_index(name=\"oxygen_count\")\nresult = oxygen_counts[\"oxygen_count\"].mean()"}
{"question_id": 401, "db_id": "toxicology", "SQL": "SELECT DISTINCT T2.molecule_id FROM bond AS T1 INNER JOIN molecule AS T2 ON T1.molecule_id = T2.molecule_id WHERE T1.bond_type = '#' AND T2.label = '+'", "pandas_query": "merged_df = pd.merge(bond, molecule, left_on=\"molecule_id\", right_on=\"molecule_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"bond_type\"] == \"#\") & (merged_df[\"label\"] == \"+\")]\nresult = filtered_df[\"molecule_id\"].unique()\n"}
{"question_id": 402, "db_id": "toxicology", "SQL": "SELECT CAST(COUNT(DISTINCT CASE WHEN T1.element = 'c' THEN T1.atom_id ELSE NULL END) AS REAL) * 100 / NULLIF(COUNT(DISTINCT T1.atom_id), 0) FROM atom AS T1 INNER JOIN bond AS T2 ON T1.molecule_id = T2.molecule_id WHERE T2.bond_type = '='", "pandas_query": "merged_df = pd.merge(atom, bond, left_on=\"molecule_id\", right_on=\"molecule_id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"bond_type\"] == \"=\"]\ncarbon_count = filtered_df[filtered_df[\"element\"] == \"c\"][\"atom_id\"].nunique()\ntotal_count = filtered_df[\"atom_id\"].nunique()\nresult = (carbon_count / total_count) * 100"}
{"question_id": 403, "db_id": "toxicology", "SQL": "SELECT DISTINCT T1.element FROM atom AS T1 INNER JOIN connected AS T2 ON T1.atom_id = T2.atom_id WHERE T2.bond_id = 'TR004_8_9'", "pandas_query": "merged_df = pd.merge(atom, connected, left_on=\"atom_id\", right_on=\"atom_id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"bond_id\"] == \"TR004_8_9\"]\nresult = filtered_df[\"element\"].unique()"}
{"question_id": 406, "db_id": "toxicology", "SQL": "SELECT T.element FROM (SELECT T1.element, COUNT(DISTINCT T1.molecule_id) FROM atom AS T1 INNER JOIN molecule AS T2 ON T1.molecule_id = T2.molecule_id WHERE T2.label = '-' GROUP BY T1.element ORDER BY COUNT(DISTINCT T1.molecule_id) ASC NULLS FIRST LIMIT 1) AS t", "pandas_query": "merged_df = pd.merge(atom, molecule, left_on=\"molecule_id\", right_on=\"molecule_id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"label\"] == \"-\"]\nelement_counts = filtered_df.groupby(\"element\")[\"molecule_id\"].nunique()\nleast_numerous_element = element_counts.idxmin()\nresult = least_numerous_element"}
{"question_id": 407, "db_id": "toxicology", "SQL": "SELECT T1.bond_type FROM bond AS T1 INNER JOIN connected AS T2 ON T1.bond_id = T2.bond_id WHERE T2.atom_id = 'TR004_8' AND T2.atom_id2 = 'TR004_20' OR T2.atom_id2 = 'TR004_8' AND T2.atom_id = 'TR004_20'", "pandas_query": "merged_df = pd.merge(bond, connected, left_on=\"bond_id\", right_on=\"bond_id\", how=\"inner\")\nfiltered_df = merged_df[((merged_df[\"atom_id\"] == \"TR004_8\") & (merged_df[\"atom_id2\"] == \"TR004_20\")) | ((merged_df[\"atom_id\"] == \"TR004_20\") & (merged_df[\"atom_id2\"] == \"TR004_8\"))]\nresult = filtered_df[\"bond_type\"]"}
{"question_id": 409, "db_id": "toxicology", "SQL": "SELECT 100 - CAST(COUNT(DISTINCT CASE WHEN T1.element = 'f' THEN T2.molecule_id ELSE NULL END) AS REAL) * 100 / NULLIF(COUNT(DISTINCT T2.molecule_id), 0) FROM atom AS T1 INNER JOIN molecule AS T2 ON T1.molecule_id = T2.molecule_id WHERE T2.label = '+'", "pandas_query": "merged_df = pd.merge(atom, molecule, left_on=\"molecule_id\", right_on=\"molecule_id\", how=\"inner\")\ncarcinogenic_df = merged_df[merged_df[\"label\"] == \"+\"]\nfluorine_molecules = carcinogenic_df[carcinogenic_df[\"element\"] == \"f\"][\"molecule_id\"].nunique()\ntotal_carcinogenic_molecules = carcinogenic_df[\"molecule_id\"].nunique()\nresult = 100 - (fluorine_molecules * 100 / total_carcinogenic_molecules)"}
{"question_id": 410, "db_id": "toxicology", "SQL": "SELECT CAST(COUNT(DISTINCT CASE WHEN T2.label = '+' THEN T2.molecule_id ELSE NULL END) AS REAL) * 100 / NULLIF(COUNT(DISTINCT T2.molecule_id), 0) FROM atom AS T1 INNER JOIN molecule AS T2 ON T1.molecule_id = T2.molecule_id INNER JOIN bond AS T3 ON T2.molecule_id = T3.molecule_id WHERE T3.bond_type = '#'", "pandas_query": "merged_df = pd.merge(atom, molecule, left_on=\"molecule_id\", right_on=\"molecule_id\", how=\"inner\")\nmerged_df = pd.merge(merged_df, bond, left_on=\"molecule_id\", right_on=\"molecule_id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"bond_type\"] == \"#\"]\ncarcinogenic_count = filtered_df[filtered_df[\"label\"] == \"+\"].molecule_id.nunique()\ntotal_count = filtered_df.molecule_id.nunique()\nresult = (carcinogenic_count * 100) / total_count\n"}
{"question_id": 413, "db_id": "toxicology", "SQL": "SELECT ROUND(CAST((CAST(COUNT(CASE WHEN t.label = '+' THEN t.molecule_id ELSE NULL END) AS REAL) / NULLIF(COUNT(t.molecule_id), 0) * 100) AS NUMERIC), 3) AS percentage FROM molecule t", "pandas_query": "total_molecules = molecule[\"molecule_id\"].count()\ncarcinogenic_molecules = molecule[molecule[\"label\"] == \"+\"].shape[0]\nresult = round((carcinogenic_molecules / total_molecules) * 100, 3)"}
{"question_id": 414, "db_id": "toxicology", "SQL": "SELECT ROUND(CAST((CAST(COUNT(CASE WHEN T.element = 'h' THEN T.atom_id ELSE NULL END) AS REAL) * 100 / NULLIF(COUNT(T.atom_id), 0)) AS NUMERIC), 4) AS percentage FROM atom AS T WHERE T.molecule_id = 'TR206'", "pandas_query": "filtered_df = atom[atom[\"molecule_id\"] == \"TR206\"]\nhydrogen_count = filtered_df[filtered_df[\"element\"] == \"h\"][\"atom_id\"].count()\ntotal_count = filtered_df[\"atom_id\"].count()\nresult = round((hydrogen_count / total_count) * 100, 4)"}
{"question_id": 415, "db_id": "toxicology", "SQL": "SELECT DISTINCT T1.element, T2.label FROM atom AS T1 INNER JOIN molecule AS T2 ON T1.molecule_id = T2.molecule_id WHERE T2.molecule_id = 'TR060'", "pandas_query": "merged_df = pd.merge(atom, molecule, left_on=\"molecule_id\", right_on=\"molecule_id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"molecule_id\"] == \"TR060\"]\nresult = filtered_df[[\"element\", \"label\"]].drop_duplicates()"}
{"question_id": 416, "db_id": "toxicology", "SQL": "SELECT T.bond_type FROM (SELECT T1.bond_type, COUNT(T1.molecule_id) FROM bond AS T1 WHERE T1.molecule_id = 'TR010' GROUP BY T1.bond_type ORDER BY COUNT(T1.molecule_id) DESC NULLS LAST LIMIT 1) AS T", "pandas_query": "filtered_bonds = bond[bond[\"molecule_id\"] == \"TR010\"]\nbond_type_counts = filtered_bonds[\"bond_type\"].value_counts()\nresult = bond_type_counts.idxmax()"}
{"question_id": 417, "db_id": "toxicology", "SQL": "SELECT DISTINCT T2.molecule_id FROM bond AS T1 INNER JOIN molecule AS T2 ON T1.molecule_id = T2.molecule_id WHERE T1.bond_type = '-' AND T2.label = '-' ORDER BY T2.molecule_id NULLS FIRST LIMIT 3", "pandas_query": "merged_df = pd.merge(bond, molecule, left_on=\"molecule_id\", right_on=\"molecule_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"bond_type\"] == \"-\") & (merged_df[\"label\"] == \"-\")]\nresult = filtered_df[\"molecule_id\"].drop_duplicates().sort_values().head(3).tolist()"}
{"question_id": 419, "db_id": "toxicology", "SQL": "SELECT T1.bond_type, T2.atom_id, T2.atom_id2 FROM bond AS T1 INNER JOIN connected AS T2 ON T1.bond_id = T2.bond_id WHERE T2.bond_id = 'TR001_6_9'", "pandas_query": "merged_df = pd.merge(bond, connected, left_on=\"bond_id\", right_on=\"bond_id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"bond_id\"] == \"TR001_6_9\"]\nresult = filtered_df[[\"bond_type\", \"atom_id\", \"atom_id2\"]]"}
{"question_id": 420, "db_id": "toxicology", "SQL": "SELECT COUNT(T.bond_id) FROM connected AS T WHERE RIGHT(T.atom_id, 2) = '19'", "pandas_query": "filtered_df = connected[connected[\"atom_id\"].str.endswith(\"19\")]\nresult = filtered_df[\"bond_id\"].count()"}
{"question_id": 423, "db_id": "toxicology", "SQL": "SELECT T2.bond_id FROM atom AS T1 INNER JOIN connected AS T2 ON T1.atom_id = T2.atom_id WHERE T2.bond_id IN (SELECT T3.bond_id FROM connected AS T3 INNER JOIN atom AS T4 ON T3.atom_id = T4.atom_id WHERE T4.element = 'p') AND T1.element = 'n'", "pandas_query": "connected_with_p = connected[connected[\"atom_id\"].isin(atom[atom[\"element\"] == \"p\"][\"atom_id\"])]\nbonds_with_p = connected_with_p[\"bond_id\"].unique()\nconnected_with_n = connected[connected[\"bond_id\"].isin(bonds_with_p) & connected[\"atom_id\"].isin(atom[atom[\"element\"] == \"n\"][\"atom_id\"])]\nresult = connected_with_n[\"bond_id\"].unique()"}
{"question_id": 424, "db_id": "toxicology", "SQL": "SELECT T1.label FROM molecule AS T1 INNER JOIN (SELECT T.molecule_id, COUNT(T.bond_type) FROM bond AS T WHERE T.bond_type = '=' GROUP BY T.molecule_id ORDER BY COUNT(T.bond_type) DESC NULLS LAST LIMIT 1) AS T2 ON T1.molecule_id = T2.molecule_id", "pandas_query": "double_bonds_count = bond[bond[\"bond_type\"] == \"=\"].groupby(\"molecule_id\").size().reset_index(name=\"count\")\nmax_double_bond_molecule = double_bonds_count.sort_values(by=\"count\", ascending=False).head(1)\nresult = molecule[molecule[\"molecule_id\"].isin(max_double_bond_molecule[\"molecule_id\"])][\"label\"].iloc[0]"}
{"question_id": 426, "db_id": "toxicology", "SQL": "SELECT DISTINCT T.element FROM atom AS T WHERE NOT T.atom_id IN (SELECT DISTINCT atom_id FROM connected)", "pandas_query": "bonded_atoms = connected[\"atom_id\"].unique()\nunbonded_atoms = atom[~atom[\"atom_id\"].isin(bonded_atoms)]\nresult = unbonded_atoms[\"element\"].unique()"}
{"question_id": 427, "db_id": "toxicology", "SQL": "SELECT T2.atom_id, T2.atom_id2 FROM atom AS T1 INNER JOIN connected AS T2 ON T1.atom_id = T2.atom_id INNER JOIN bond AS T3 ON T2.bond_id = T3.bond_id WHERE T3.bond_type = '#' AND T3.molecule_id = 'TR041'", "pandas_query": "merged_df1 = pd.merge(atom, connected, left_on=\"atom_id\", right_on=\"atom_id\", how=\"inner\")\nmerged_df2 = pd.merge(merged_df1, bond, left_on=\"bond_id\", right_on=\"bond_id\", how=\"inner\")\nfiltered_df = merged_df2[(merged_df2[\"bond_type\"] == \"#\")& (merged_df2[\"molecule_id_y\"] == \"TR041\")]\nresult = filtered_df[[\"atom_id\", \"atom_id2\"]]\n"}
{"question_id": 428, "db_id": "toxicology", "SQL": "SELECT T2.element FROM connected AS T1 INNER JOIN atom AS T2 ON T1.atom_id = T2.atom_id WHERE T1.bond_id = 'TR144_8_19'", "pandas_query": "merged_df = pd.merge(connected, atom, left_on=\"atom_id\", right_on=\"atom_id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"bond_id\"] == \"TR144_8_19\"]\nresult = filtered_df[\"element\"]"}
{"question_id": 429, "db_id": "toxicology", "SQL": "SELECT DISTINCT T3.element FROM bond AS T1 INNER JOIN connected AS T2 ON T1.bond_id = T2.bond_id INNER JOIN atom AS T3 ON T2.atom_id = T3.atom_id WHERE T1.bond_type = '#'", "pandas_query": "merged_df1 = pd.merge(bond, connected, left_on=\"bond_id\", right_on=\"bond_id\", how=\"inner\")\nmerged_df2 = pd.merge(merged_df1, atom, left_on=\"atom_id\", right_on=\"atom_id\", how=\"inner\")\nfiltered_df = merged_df2[merged_df2[\"bond_type\"] == \"#\"]\nresult = filtered_df[\"element\"].drop_duplicates()\n"}
{"question_id": 432, "db_id": "toxicology", "SQL": "SELECT CAST(COUNT(CASE WHEN T.element = 'cl' THEN T.atom_id ELSE NULL END) AS REAL) * 100 / NULLIF(COUNT(T.atom_id), 0) FROM atom AS T WHERE molecule_id IN (SELECT DISTINCT molecule.molecule_id FROM molecule JOIN bond ON molecule.molecule_id = bond.molecule_id AND bond.bond_type = '-')", "pandas_query": "single_bond_molecules = bond[bond[\"bond_type\"] == \"-\"][\"molecule_id\"].unique()\nfiltered_atoms = atom[atom[\"molecule_id\"].isin(single_bond_molecules)]\ncl_count = filtered_atoms[filtered_atoms[\"element\"] == \"cl\"][\"atom_id\"].count()\ntotal_count = filtered_atoms[\"atom_id\"].count()\nresult = (cl_count / total_count) * 100"}
{"question_id": 433, "db_id": "toxicology", "SQL": "SELECT T2.element FROM connected AS T1 INNER JOIN atom AS T2 ON T1.atom_id = T2.atom_id WHERE T1.bond_id = 'TR001_10_11'", "pandas_query": "merged_df = pd.merge(connected, atom, left_on=\"atom_id\", right_on=\"atom_id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"bond_id\"] == \"TR001_10_11\"]\nresult = filtered_df[\"element\"]"}
{"question_id": 435, "db_id": "toxicology", "SQL": "SELECT DISTINCT T1.element FROM atom AS T1 INNER JOIN molecule AS T2 ON T1.molecule_id = T2.molecule_id WHERE T2.label = '+' AND RIGHT(T1.atom_id, 1) = '4' AND LENGTH(T1.atom_id) = 7", "pandas_query": "merged_df = pd.merge(atom, molecule, left_on=\"molecule_id\", right_on=\"molecule_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"label\"] == \"+\") & (merged_df[\"atom_id\"].str[-1] == \"4\") & (merged_df[\"atom_id\"].str.len() == 7)]\nresult = filtered_df[\"element\"].unique()"}
{"question_id": 437, "db_id": "toxicology", "SQL": "SELECT T.molecule_id FROM (SELECT T1.molecule_id, COUNT(T2.atom_id) FROM molecule AS T1 INNER JOIN atom AS T2 ON T1.molecule_id = T2.molecule_id WHERE T1.label = '-' GROUP BY T1.molecule_id HAVING COUNT(T2.atom_id) > 5) AS t", "pandas_query": "merged_df = pd.merge(molecule, atom, on=\"molecule_id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"label\"] == \"-\"]\ngrouped_df = filtered_df.groupby(\"molecule_id\").size().reset_index(name='atom_count')\nresult = grouped_df[grouped_df[\"atom_count\"] > 5][\"molecule_id\"]"}
{"question_id": 439, "db_id": "california_schools", "SQL": "SELECT T2.CDSCode FROM schools AS T1 INNER JOIN frpm AS T2 ON T1.CDSCode = T2.CDSCode WHERE T2.\"Enrollment (K-12)\" + T2.\"Enrollment (Ages 5-17)\" > 500", "pandas_query": "merged_df = pd.merge(schools, frpm, left_on=\"CDSCode\", right_on=\"CDSCode\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"Enrollment (K-12)\"] + merged_df[\"Enrollment (Ages 5-17)\"]) > 500]\nresult = filtered_df[\"CDSCode\"]"}
{"question_id": 440, "db_id": "california_schools", "SQL": "SELECT MAX(CAST(T1.\"Free Meal Count (Ages 5-17)\" AS REAL) / NULLIF(T1.\"Enrollment (Ages 5-17)\", 0)) FROM frpm AS T1 INNER JOIN satscores AS T2 ON T1.CDSCode = T2.cds WHERE CAST(T2.NumGE1500 AS REAL) / NULLIF(T2.NumTstTakr, 0) > 0.3", "pandas_query": "merged_df = pd.merge(frpm, satscores, left_on=\"CDSCode\", right_on=\"cds\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"NumGE1500\"] / merged_df[\"NumTstTakr\"]) > 0.3]\nresult = (filtered_df[\"Free Meal Count (Ages 5-17)\"] / filtered_df[\"Enrollment (Ages 5-17)\"]).max()"}
{"question_id": 441, "db_id": "california_schools", "SQL": "SELECT CharterNum, AvgScrWrite, RANK() OVER (ORDER BY AvgScrWrite DESC NULLS LAST) AS WritingScoreRank FROM schools AS T1 INNER JOIN satscores AS T2 ON T1.CDSCode = T2.cds WHERE T2.AvgScrWrite > 499 AND NOT CharterNum IS NULL", "pandas_query": "merged_df = pd.merge(schools, satscores, left_on=\"CDSCode\", right_on=\"cds\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"AvgScrWrite\"] > 499) & (merged_df[\"CharterNum\"].notnull())]\nfiltered_df[\"WritingScoreRank\"] = filtered_df[\"AvgScrWrite\"].rank(method=\"min\", ascending=False)\nresult = filtered_df[[\"CharterNum\", \"AvgScrWrite\", \"WritingScoreRank\"]]"}
{"question_id": 442, "db_id": "california_schools", "SQL": "SELECT T1.School, T1.Street FROM schools AS T1 INNER JOIN frpm AS T2 ON T1.CDSCode = T2.CDSCode WHERE T2.\"Enrollment (K-12)\" - T2.\"Enrollment (Ages 5-17)\" > 30", "pandas_query": "merged_df = pd.merge(schools, frpm, left_on=\"CDSCode\", right_on=\"CDSCode\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"Enrollment (K-12)\"] - merged_df[\"Enrollment (Ages 5-17)\"]) > 30]\nresult = filtered_df[[\"School\", \"Street\"]]"}
{"question_id": 443, "db_id": "california_schools", "SQL": "SELECT T2.\"School Name\" FROM satscores AS T1 INNER JOIN frpm AS T2 ON T1.cds = T2.CDSCode WHERE CAST(T2.\"Free Meal Count (K-12)\" AS REAL) / NULLIF(T2.\"Enrollment (K-12)\", 0) > 0.1 AND T1.NumGE1500 > 0", "pandas_query": "merged_df = pd.merge(satscores, frpm, left_on=\"cds\", right_on=\"CDSCode\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"Free Meal Count (K-12)\"] / merged_df[\"Enrollment (K-12)\"] > 0.1) & (merged_df[\"NumGE1500\"] > 0)]\nresult = filtered_df[\"School Name\"]"}
{"question_id": 445, "db_id": "california_schools", "SQL": "SELECT T1.\"School Name\", T2.Street, T2.City, T2.State, T2.Zip FROM frpm AS T1 INNER JOIN schools AS T2 ON T1.CDSCode = T2.CDSCode WHERE T2.County = 'Monterey' AND T1.\"FRPM Count (Ages 5-17)\" > 800 AND T1.\"School Type\" = 'High Schools (Public)'", "pandas_query": "merged_df = pd.merge(frpm, schools, left_on=\"CDSCode\", right_on=\"CDSCode\", how=\"inner\")\nfiltered_df = merged_df[\n(merged_df[\"County\"] == \"Monterey\") &\n(merged_df[\"FRPM Count (Ages 5-17)\"] > 800) &\n(merged_df[\"School Type\"] == \"High Schools (Public)\")\n]\nresult = filtered_df[[\"School Name\", \"Street\", \"City\", \"State\", \"Zip\"]]"}
{"question_id": 447, "db_id": "california_schools", "SQL": "SELECT T2.School, T2.DOCType FROM frpm AS T1 INNER JOIN schools AS T2 ON T1.CDSCode = T2.CDSCode WHERE T2.FundingType = 'Locally funded' AND (T1.\"Enrollment (K-12)\" - T1.\"Enrollment (Ages 5-17)\") > (SELECT AVG(T3.\"Enrollment (K-12)\" - T3.\"Enrollment (Ages 5-17)\") FROM frpm AS T3 INNER JOIN schools AS T4 ON T3.CDSCode = T4.CDSCode WHERE T4.FundingType = 'Locally funded')", "pandas_query": "merged_df = pd.merge(frpm, schools, left_on=\"CDSCode\", right_on=\"CDSCode\", how=\"inner\")\nlocally_funded_df = merged_df[merged_df[\"FundingType\"] == \"Locally funded\"]\nlocally_funded_df[\"Enrollment_Difference\"] = locally_funded_df[\"Enrollment (K-12)\"] - locally_funded_df[\"Enrollment (Ages 5-17)\"]\naverage_difference = locally_funded_df[\"Enrollment_Difference\"].mean()\nresult = locally_funded_df[locally_funded_df[\"Enrollment_Difference\"] > average_difference][[\"School\", \"DOCType\"]]"}
{"question_id": 449, "db_id": "california_schools", "SQL": "SELECT CAST(T1.\"FRPM Count (K-12)\" AS REAL) / NULLIF(T1.\"Enrollment (K-12)\", 0) FROM frpm AS T1 INNER JOIN schools AS T2 ON T1.CDSCode = T2.CDSCode WHERE T2.SOC::integer = 66 ORDER BY T1.\"FRPM Count (K-12)\" DESC NULLS LAST LIMIT 5", "pandas_query": "merged_df = pd.merge(frpm, schools, left_on=\"CDSCode\", right_on=\"CDSCode\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"SOC\"] == \"66\"]\nfiltered_df[\"Eligible Rate\"] = filtered_df[\"FRPM Count (K-12)\"] / filtered_df[\"Enrollment (K-12)\"]\nsorted_df = filtered_df.sort_values(by=\"FRPM Count (K-12)\", ascending=False)\nresult = sorted_df.head(5)[\"Eligible Rate\"]"}
{"question_id": 452, "db_id": "california_schools", "SQL": "SELECT AVG(T1.NumTstTakr) FROM satscores AS T1 INNER JOIN schools AS T2 ON T1.cds = T2.CDSCode WHERE TO_CHAR(CAST(T2.OpenDate AS TIMESTAMP), 'YYYY') = '1980' AND T2.County = 'Fresno'", "pandas_query": "schools['OpenDate'] = pd.to_datetime(schools['OpenDate'], errors='coerce')\n\nmerged_df = pd.merge(satscores, schools, left_on=\"cds\", right_on=\"CDSCode\", how=\"inner\")\n\nfiltered_df = merged_df[(merged_df[\"OpenDate\"].dt.year == 1980) & (merged_df[\"County\"] == \"Fresno\")]\n\nresult = filtered_df[\"NumTstTakr\"].mean()"}
{"question_id": 453, "db_id": "california_schools", "SQL": "SELECT T2.Phone FROM satscores AS T1 INNER JOIN schools AS T2 ON T1.cds = T2.CDSCode WHERE T2.District = 'Fresno Unified' AND NOT T1.AvgScrRead IS NULL ORDER BY T1.AvgScrRead ASC NULLS FIRST LIMIT 1", "pandas_query": "merged_df = pd.merge(satscores, schools, left_on=\"cds\", right_on=\"CDSCode\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"District\"] == \"Fresno Unified\") & (merged_df[\"AvgScrRead\"].notnull())]\nsorted_df = filtered_df.sort_values(by=\"AvgScrRead\", ascending=True)\nresult = sorted_df.iloc[0][\"Phone\"]"}
{"question_id": 455, "db_id": "california_schools", "SQL": "SELECT T2.School, T1.AvgScrWrite FROM satscores AS T1 INNER JOIN schools AS T2 ON T1.cds = T2.CDSCode WHERE T2.AdmFName1 = 'Ricci' AND T2.AdmLName1 = 'Ulrich'", "pandas_query": "merged_df = pd.merge(satscores, schools, left_on=\"cds\", right_on=\"CDSCode\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"AdmFName1\"] == \"Ricci\") & (merged_df[\"AdmLName1\"] == \"Ulrich\")]\nresult = filtered_df[[\"School\", \"AvgScrWrite\"]]"}
{"question_id": 456, "db_id": "california_schools", "SQL": "SELECT T2.School FROM frpm AS T1 INNER JOIN schools AS T2 ON T1.CDSCode = T2.CDSCode WHERE T2.DOC = '31' ORDER BY T1.\"Enrollment (K-12)\" DESC LIMIT 1", "pandas_query": "merged_df = pd.merge(frpm, schools, left_on=\"CDSCode\", right_on=\"CDSCode\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"DOC\"] == \"31\"]\nsorted_df = filtered_df.sort_values(by=\"Enrollment (K-12)\", ascending=False)\nif not sorted_df.empty:\n    result = sorted_df.iloc[0][\"School\"]\nelse:\n    result = None\n"}
{"question_id": 457, "db_id": "california_schools", "SQL": "SELECT CAST(COUNT(School) AS REAL) / NULLIF(12, 0) FROM schools WHERE DOC = '52' AND County = 'Alameda' AND EXTRACT(YEAR FROM OpenDate) = 1980", "pandas_query": "filtered_df = schools[(schools[\"DOC\"] == \"52\") & (schools[\"County\"] == \"Alameda\") & (schools[\"OpenDate\"].str[:4] == \"1980\")]\nresult = filtered_df[\"School\"].count() / 12"}
{"question_id": 458, "db_id": "california_schools", "SQL": "SELECT CAST(SUM(CASE WHEN DOC::integer = 54 THEN 1 ELSE 0 END) AS REAL) / NULLIF(SUM(CASE WHEN DOC::integer = 52 THEN 1 ELSE 0 END), 0) FROM schools WHERE StatusType = 'Merged' AND County = 'Orange'", "pandas_query": "filtered_df = schools[(schools[\"StatusType\"] == \"Merged\") & (schools[\"County\"] == \"Orange\")]\nunified_count = (filtered_df[\"DOC\"] == \"54\").sum()\nelementary_count = (filtered_df[\"DOC\"] == \"52\").sum()\nresult = unified_count / elementary_count"}
{"question_id": 459, "db_id": "california_schools", "SQL": "SELECT T2.MailStreet, T2.School FROM satscores AS T1 INNER JOIN schools AS T2 ON T1.cds = T2.CDSCode ORDER BY T1.AvgScrMath DESC NULLS LAST LIMIT 1 OFFSET 6", "pandas_query": "merged_df = pd.merge(satscores, schools, left_on=\"cds\", right_on=\"CDSCode\", how=\"inner\")\nsorted_df = merged_df.sort_values(by=\"AvgScrMath\", ascending=False)\nseventh_highest = sorted_df.iloc[6]\nresult = (seventh_highest[\"MailStreet\"], seventh_highest[\"School\"])"}
{"question_id": 463, "db_id": "california_schools", "SQL": "SELECT County, COUNT(Virtual) FROM schools WHERE (County = 'San Diego' OR County = 'Santa Barbara') AND Virtual = 'F' GROUP BY County ORDER BY COUNT(Virtual) DESC NULLS LAST LIMIT 1", "pandas_query": "filtered_df = schools[(schools[\"County\"].isin([\"San Diego\", \"Santa Barbara\"])) & (schools[\"Virtual\"] == \"F\")]\ngrouped_df = filtered_df.groupby(\"County\").size().reset_index(name='count')\nresult = grouped_df.nlargest(1, 'count')"}
{"question_id": 464, "db_id": "california_schools", "SQL": "SELECT GSoffered FROM schools ORDER BY ABS(longitude) DESC NULLS LAST LIMIT 1", "pandas_query": "result = schools.loc[schools['Longitude'].abs().idxmax(), 'GSoffered']"}
{"question_id": 465, "db_id": "california_schools", "SQL": "SELECT T2.City, COUNT(T2.CDSCode) FROM frpm AS T1 INNER JOIN schools AS T2 ON T1.CDSCode = T2.CDSCode WHERE T2.Magnet = 1 AND T2.GSoffered = 'K-8' AND T1.\"NSLP Provision Status\" = 'Multiple Provision Types' GROUP BY T2.City", "pandas_query": "merged_df = pd.merge(frpm, schools, left_on=\"CDSCode\", right_on=\"CDSCode\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"Magnet\"] == 1) & (merged_df[\"GSoffered\"] == \"K-8\") & (merged_df[\"NSLP Provision Status\"] == \"Multiple Provision Types\")]\nresult = filtered_df.groupby(\"City\")[\"CDSCode\"].count().reset_index()"}
{"question_id": 467, "db_id": "california_schools", "SQL": "SELECT T2.AdmEmail1, T2.AdmEmail2 FROM frpm AS T1 INNER JOIN schools AS T2 ON T1.CDSCode = T2.CDSCode WHERE T2.County = 'San Bernardino' AND T2.City = 'San Bernardino' AND T2.DOC::integer = 54 AND EXTRACT(YEAR FROM T2.OpenDate) BETWEEN 2009 AND 2010 AND T2.SOC::integer = 62", "pandas_query": "merged_df = pd.merge(frpm, schools, on=\"CDSCode\", how=\"inner\")\nfiltered_df = merged_df[\n(merged_df[\"County\"] == \"San Bernardino\") &\n(merged_df[\"City\"] == \"San Bernardino\") &\n(merged_df[\"DOC\"].astype(str) == \"54\") &\n(merged_df[\"SOC\"].astype(str) == \"62\") &\n(merged_df[\"OpenDate\"].between(\"2009-01-01\", \"2010-12-31\"))\n]\nresult = filtered_df[[\"AdmEmail1\", \"AdmEmail2\"]]"}
{"question_id": 468, "db_id": "financial", "SQL": "SELECT COUNT(T2.account_id) FROM district AS T1 INNER JOIN account AS T2 ON T1.district_id = T2.district_id WHERE T1.A3 = 'east Bohemia' AND T2.frequency = 'POPLATEK PO OBRATU'", "pandas_query": "merged_df = pd.merge(district, account, left_on=\"district_id\", right_on=\"district_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"A3\"] == \"east Bohemia\") & (merged_df[\"frequency\"] == \"POPLATEK PO OBRATU\")]\nresult = filtered_df[\"account_id\"].count()"}
{"question_id": 469, "db_id": "financial", "SQL": "SELECT COUNT(DISTINCT T2.district_id) FROM client AS T1 INNER JOIN district AS T2 ON T1.district_id = T2.district_id WHERE T1.gender = 'F' AND T2.A11 BETWEEN 6000 AND 10000", "pandas_query": "merged_df = pd.merge(client, district, left_on=\"district_id\", right_on=\"district_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"gender\"] == \"F\") & (merged_df[\"A11\"] > 6000) & (merged_df[\"A11\"] < 10000)]\nresult = filtered_df[\"district_id\"].nunique()"}
{"question_id": 471, "db_id": "financial", "SQL": "SELECT T1.account_id, (SELECT MAX(A11) - MIN(A11) FROM district) FROM account AS T1 INNER JOIN district AS T2 ON T1.district_id = T2.district_id INNER JOIN disp AS T3 ON T1.account_id = T3.account_id INNER JOIN client AS T4 ON T3.client_id = T4.client_id WHERE T2.district_id = (SELECT district_id FROM client WHERE gender = 'F' ORDER BY birth_date ASC NULLS FIRST LIMIT 1) ORDER BY T2.A11 DESC NULLS LAST LIMIT 1", "pandas_query": "oldest_female_district_id = client[client[\"gender\"] == \"F\"].sort_values(\"birth_date\").iloc[0][\"district_id\"]\n\ndistrict_gap = district[\"A11\"].max() - district[\"A11\"].min()\n\nmerged_df = account.merge(district, on=\"district_id\").merge(disp, on=\"account_id\").merge(client, on=\"client_id\")\n\nfiltered_df = merged_df[(merged_df[\"district_id_x\"] == oldest_female_district_id)]\n\nresult = filtered_df.sort_values(\"A11\", ascending=False).iloc[0][[\"account_id\"]].to_frame().assign(gap=district_gap)"}
{"question_id": 474, "db_id": "financial", "SQL": "SELECT T1.account_id FROM loan AS T1 INNER JOIN account AS T2 ON T1.account_id = T2.account_id WHERE TO_CHAR(CAST(T2.date AS TIMESTAMP), 'YYYY') = '1993' AND T1.duration > 12 ORDER BY T1.amount DESC NULLS LAST LIMIT 1", "pandas_query": "account['date'] = pd.to_datetime(account['date'])\nloan['date'] = pd.to_datetime(loan['date'])\n\nmerged_df = pd.merge(loan, account, left_on=\"account_id\", right_on=\"account_id\", how=\"inner\")\n\nfiltered_df = merged_df[(merged_df[\"duration\"] > 12) & (merged_df[\"date_y\"].dt.year == 1993)]\n\nsorted_df = filtered_df.sort_values(by=\"amount\", ascending=False)\n\nresult = sorted_df.iloc[0][\"account_id\"]"}
{"question_id": 475, "db_id": "financial", "SQL": "SELECT COUNT(T2.client_id) FROM district AS T1 INNER JOIN client AS T2 ON T1.district_id = T2.district_id WHERE T2.gender = 'F' AND TO_CHAR(CAST(T2.birth_date AS TIMESTAMP), 'YYYY') < '1950' AND T1.A2 = 'Sokolov'", "pandas_query": "merged_df = pd.merge(district, client, left_on=\"district_id\", right_on=\"district_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"gender\"] == \"F\") & (merged_df[\"birth_date\"] < '1950-01-01') & (merged_df[\"A2\"] == \"Sokolov\")]\nresult = filtered_df[\"client_id\"].count()"}
{"question_id": 477, "db_id": "financial", "SQL": "SELECT CAST(SUM(CASE WHEN T1.gender = 'M' THEN 1 ELSE 0 END) AS REAL) * 100 / NULLIF(COUNT(T1.client_id), 0) FROM client AS T1 INNER JOIN district AS T2 ON T1.district_id = T2.district_id WHERE T2.A3 = 'south Bohemia' GROUP BY T2.A4 ORDER BY CAST(T2.A4 AS INT) DESC LIMIT 1", "pandas_query": "merged_df = pd.merge(client, district, left_on=\"district_id\", right_on=\"district_id\", how=\"inner\")\nsouth_bohemia_df = merged_df[merged_df[\"A3\"] == \"south Bohemia\"]\ngrouped_df = south_bohemia_df.groupby(\"A4\").agg(\nmale_clients=(\"gender\", lambda x: (x == 'M').sum()),\ntotal_clients=(\"client_id\", \"count\")\n).reset_index()\ngrouped_df[\"percentage_male\"] = (grouped_df[\"male_clients\"] * 100) / grouped_df[\"total_clients\"]\nsorted_df = grouped_df.sort_values(by=\"A4\", key=lambda x: x.astype(int), ascending=False)\nresult = sorted_df[\"percentage_male\"].iloc[0]"}
{"question_id": 478, "db_id": "financial", "SQL": "SELECT CAST((SUM(CASE WHEN T3.date = '1998-12-27' THEN T3.balance ELSE 0 END) - SUM(CASE WHEN T3.date = '1993-03-22' THEN T3.balance ELSE 0 END)) AS REAL) * 100 / NULLIF(SUM(CASE WHEN T3.date = '1993-03-22' THEN T3.balance ELSE 0 END), 0) FROM loan AS T1 INNER JOIN account AS T2 ON T1.account_id = T2.account_id INNER JOIN trans AS T3 ON T3.account_id = T2.account_id WHERE T1.date = '1993-07-05'", "pandas_query": "loan_account = loan[loan[\"date\"] == \"1993-07-05\"].iloc[0][\"account_id\"]\ntrans_filtered = trans[trans[\"account_id\"] == loan_account]\nbalance_1998_12_27 = trans_filtered[trans_filtered[\"date\"] == \"1998-12-27\"][\"balance\"].sum()\nbalance_1993_03_22 = trans_filtered[trans_filtered[\"date\"] == \"1993-03-22\"][\"balance\"].sum()\nresult = ((balance_1998_12_27 - balance_1993_03_22) / balance_1993_03_22) * 100"}
{"question_id": 479, "db_id": "financial", "SQL": "SELECT (CAST(SUM(CASE WHEN status = 'A' THEN amount ELSE 0 END) AS REAL) * 100) / NULLIF(SUM(amount), 0) FROM loan", "pandas_query": "total_amount = loan[\"amount\"].sum()\namount_no_issue = loan.loc[loan[\"status\"] == \"A\", \"amount\"].sum()\nresult = (amount_no_issue * 100) / total_amount"}
{"question_id": 480, "db_id": "financial", "SQL": "SELECT CAST(SUM(CASE WHEN status = 'C' THEN 1 ELSE 0 END) AS REAL) * 100 / NULLIF(COUNT(account_id), 0) FROM loan WHERE amount < 100000", "pandas_query": "filtered_loan = loan[loan[\"amount\"] < 100000]\nrunning_accounts = filtered_loan[\"status\"].eq('C').sum()\ntotal_accounts = filtered_loan[\"account_id\"].count()\nresult = (running_accounts * 100.0) / total_accounts"}
{"question_id": 485, "db_id": "financial", "SQL": "SELECT COUNT(T1.client_id) FROM client AS T1 INNER JOIN district AS T2 ON T1.district_id = T2.district_id WHERE T1.gender = 'M' AND T2.A15 = (SELECT T3.A15 FROM district AS T3 ORDER BY T3.A15 DESC NULLS LAST LIMIT 1 OFFSET 1)", "pandas_query": "second_highest_crimes = district[\"A15\"].nlargest(2).iloc[-1]\nmerged_df = pd.merge(client, district, left_on=\"district_id\", right_on=\"district_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"gender\"] == \"M\") & (merged_df[\"A15\"] == second_highest_crimes)]\nresult = filtered_df[\"client_id\"].count()"}
{"question_id": 488, "db_id": "financial", "SQL": "SELECT T2.account_id FROM district AS T1 INNER JOIN account AS T2 ON T1.district_id = T2.district_id INNER JOIN disp AS T3 ON T2.account_id = T3.account_id WHERE T3.type = 'OWNER' AND T1.A2 = 'Tabor'", "pandas_query": "merged_df1 = pd.merge(district, account, left_on=\"district_id\", right_on=\"district_id\", how=\"inner\")\nmerged_df2 = pd.merge(merged_df1, disp, left_on=\"account_id\", right_on=\"account_id\", how=\"inner\")\nfiltered_df = merged_df2[(merged_df2[\"type\"] == \"OWNER\") & (merged_df2[\"A2\"] == \"Tabor\")]\nresult = filtered_df[\"account_id\"]"}
{"question_id": 490, "db_id": "financial", "SQL": "SELECT T3.type FROM district AS T1 INNER JOIN account AS T2 ON T1.district_id = T2.district_id INNER JOIN disp AS T3 ON T2.account_id = T3.account_id WHERE T3.type <> 'OWNER' AND T1.A11 BETWEEN 8000 AND 9000", "pandas_query": "merged_df1 = pd.merge(district, account, left_on=\"district_id\", right_on=\"district_id\", how=\"inner\")\nmerged_df2 = pd.merge(merged_df1, disp, left_on=\"account_id\", right_on=\"account_id\", how=\"inner\")\nfiltered_df = merged_df2[(merged_df2[\"type\"] != \"OWNER\") & (merged_df2[\"A11\"].between(8000, 9000))]\nresult = filtered_df[\"type\"]"}
{"question_id": 493, "db_id": "financial", "SQL": "SELECT CAST(SUM(CASE WHEN T2.gender = 'F' THEN 1 ELSE 0 END) AS REAL) * 100 / NULLIF(COUNT(T2.client_id), 0) FROM district AS T1 INNER JOIN client AS T2 ON T1.district_id = T2.district_id WHERE T1.A11 > 10000", "pandas_query": "merged_df = pd.merge(district, client, left_on=\"district_id\", right_on=\"district_id\", how=\"inner\")\nfiltered_df = merged_df[merged_df[\"A11\"] > 10000]\npercentage_women = (filtered_df[\"gender\"] == 'F').sum() * 100 / filtered_df[\"client_id\"].count()\nresult = percentage_women"}
{"question_id": 497, "db_id": "financial", "SQL": "SELECT T3.account_id FROM client AS T1 INNER JOIN district AS T2 ON T1.district_id = T2.district_id INNER JOIN account AS T3 ON T2.district_id = T3.district_id INNER JOIN disp AS T4 ON T1.client_id = T4.client_id AND T4.account_id = T3.account_id WHERE T1.gender = 'F' ORDER BY T1.birth_date ASC NULLS FIRST, T2.A11 ASC NULLS FIRST LIMIT 1", "pandas_query": "merged_df = pd.merge(client, district, left_on=\"district_id\", right_on=\"district_id\", how=\"inner\")\nmerged_df = pd.merge(merged_df, account, left_on=\"district_id\", right_on=\"district_id\", how=\"inner\")\nmerged_df = pd.merge(merged_df, disp, left_on=[\"client_id\", \"account_id\"], right_on=[\"client_id\", \"account_id\"], how=\"inner\")\nfiltered_df = merged_df[merged_df[\"gender\"] == \"F\"]\nsorted_df = filtered_df.sort_values(by=[\"birth_date\", \"A11\"], ascending=[True, True])\nresult = sorted_df.iloc[0][\"account_id\"]"}
{"question_id": 498, "db_id": "financial", "SQL": "SELECT AVG(T2.amount) FROM account AS T1 INNER JOIN loan AS T2 ON T1.account_id = T2.account_id WHERE T2.status IN ('C', 'D') AND T1.frequency = 'POPLATEK PO OBRATU'", "pandas_query": "merged_df = pd.merge(account, loan, left_on=\"account_id\", right_on=\"account_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"status\"].isin(['C', 'D'])) & (merged_df[\"frequency\"] == 'POPLATEK PO OBRATU')]\nresult = filtered_df[\"amount\"].mean()"}
{"question_id": 499, "db_id": "financial", "SQL": "SELECT T1.client_id, EXTRACT(YEAR FROM CURRENT_TIMESTAMP) - EXTRACT(YEAR FROM T3.birth_date) AS age FROM disp AS T1 INNER JOIN card AS T2 ON T2.disp_id = T1.disp_id INNER JOIN client AS T3 ON T1.client_id = T3.client_id WHERE T2.type = 'gold' AND T1.type = 'OWNER'", "pandas_query": "from datetime import datetime\n\ncurrent_year = datetime.now().year\nmerged_df = pd.merge(disp, card, on=\"disp_id\", how=\"inner\")\nmerged_df = pd.merge(merged_df, client, on=\"client_id\", how=\"inner\")\nfiltered_df = merged_df[(merged_df[\"type_x\"] == \"OWNER\") & (merged_df[\"type_y\"] == \"gold\")]\nfiltered_df[\"age\"] = current_year - pd.to_datetime(filtered_df[\"birth_date\"]).dt.year\nresult = filtered_df[[\"client_id\", \"age\"]]"}