cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`How many Silver medals did the Nation with 10 or more Bronze receive?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "medal_table" (
  "rank" real,
  "nation" text,
  "gold" real,
  "silver" real,
  "bronze" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many Silver medals did the Nation with 10 or more Bronze receive?`:
```sql
                SELECT MIN("silver") FROM "medal_table" WHERE "bronze">10;
```
## Task
Generate a SQL query to answer the following question:
`what is the average wins when draws is less than 0?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "1937_ladder" (
  "club" text,
  "wins" real,
  "losses" real,
  "draws" real,
  "against" real
);
### SQL
Given the database schema, here is the SQL query that answers `what is the average wins when draws is less than 0?`:
```sql
                SELECT AVG("wins") FROM "1937_ladder" WHERE "draws"<0;
```
## Task
Generate a SQL query to answer the following question:
`what is the average losses when the club is warrnambool and wins is less than 12?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "1937_ladder" (
  "club" text,
  "wins" real,
  "losses" real,
  "draws" real,
  "against" real
);
### SQL
Given the database schema, here is the SQL query that answers `what is the average losses when the club is warrnambool and wins is less than 12?`:
```sql
                SELECT AVG("losses") FROM "1937_ladder" WHERE "club"='warrnambool' AND "wins"<12;
```
## Task
Generate a SQL query to answer the following question:
`what is the most losses when the club is terang and draws is less than 0?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "1937_ladder" (
  "club" text,
  "wins" real,
  "losses" real,
  "draws" real,
  "against" real
);
### SQL
Given the database schema, here is the SQL query that answers `what is the most losses when the club is terang and draws is less than 0?`:
```sql
                SELECT MAX("losses") FROM "1937_ladder" WHERE "club"='terang' AND "draws"<0;
```
## Task
Generate a SQL query to answer the following question:
`What is the sum of losses when wins is more than 6, club is camperdown and against is more than 1238?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "1937_ladder" (
  "club" text,
  "wins" real,
  "losses" real,
  "draws" real,
  "against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the sum of losses when wins is more than 6, club is camperdown and against is more than 1238?`:
```sql
                SELECT SUM("losses") FROM "1937_ladder" WHERE "wins">6 AND "club"='camperdown' AND "against">1238;
```
## Task
Generate a SQL query to answer the following question:
`What is the drew for the 1999-2000 season when they were in third place?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "year_by_year_performance" (
  "season" text,
  "competition" text,
  "round" text,
  "played" text,
  "drew" text,
  "lost" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the drew for the 1999-2000 season when they were in third place?`:
```sql
                SELECT "drew" FROM "year_by_year_performance" WHERE "round"='third place' AND "season"='1999-2000';
```
## Task
Generate a SQL query to answer the following question:
`What competition did they have 1 lost, 3 draws, and played 9 games?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "year_by_year_performance" (
  "season" text,
  "competition" text,
  "round" text,
  "played" text,
  "drew" text,
  "lost" text
);
### SQL
Given the database schema, here is the SQL query that answers `What competition did they have 1 lost, 3 draws, and played 9 games?`:
```sql
                SELECT "competition" FROM "year_by_year_performance" WHERE "lost"='1' AND "drew"='3' AND "played"='9';
```
## Task
Generate a SQL query to answer the following question:
`What is the number of draws when the played 9 and lost 3?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "year_by_year_performance" (
  "season" text,
  "competition" text,
  "round" text,
  "played" text,
  "drew" text,
  "lost" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the number of draws when the played 9 and lost 3?`:
```sql
                SELECT "drew" FROM "year_by_year_performance" WHERE "played"='9' AND "lost"='3';
```
## Task
Generate a SQL query to answer the following question:
`How many cable channels have callsign CBFT-DT?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "television_stations" (
  "call_sign" text,
  "broadcast_channel" real,
  "digital_psip" real,
  "cable_channel" real,
  "network" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many cable channels have callsign CBFT-DT?`:
```sql
                SELECT COUNT("cable_channel") FROM "television_stations" WHERE "call_sign"='cbft-dt';
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest Digital PSIP for channels over 29 with callsign CFTU-DT?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "television_stations" (
  "call_sign" text,
  "broadcast_channel" real,
  "digital_psip" real,
  "cable_channel" real,
  "network" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest Digital PSIP for channels over 29 with callsign CFTU-DT?`:
```sql
                SELECT MIN("digital_psip") FROM "television_stations" WHERE "call_sign"='cftu-dt' AND "broadcast_channel">29;
```
## Task
Generate a SQL query to answer the following question:
`What is the Digital PSIP for channels over 15 with callsign CFTU-DT?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "television_stations" (
  "call_sign" text,
  "broadcast_channel" real,
  "digital_psip" real,
  "cable_channel" real,
  "network" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Digital PSIP for channels over 15 with callsign CFTU-DT?`:
```sql
                SELECT "digital_psip" FROM "television_stations" WHERE "broadcast_channel">15 AND "call_sign"='cftu-dt';
```
## Task
Generate a SQL query to answer the following question:
`Where was the location of the Mong Kok Stadium?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "s" (
  "club" text,
  "league_division" text,
  "home_ground" text,
  "location" text,
  "position_in_2012_13" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where was the location of the Mong Kok Stadium?`:
```sql
                SELECT "location" FROM "s" WHERE "home_ground"='mong kok stadium';
```
## Task
Generate a SQL query to answer the following question:
`Which club, had a home ground of n/a?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "s" (
  "club" text,
  "league_division" text,
  "home_ground" text,
  "location" text,
  "position_in_2012_13" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which club, had a home ground of n/a?`:
```sql
                SELECT "club" FROM "s" WHERE "home_ground"='n/a';
```
## Task
Generate a SQL query to answer the following question:
`What is the location for the first division, Sun Pegasus Club?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "s" (
  "club" text,
  "league_division" text,
  "home_ground" text,
  "location" text,
  "position_in_2012_13" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the location for the first division, Sun Pegasus Club?`:
```sql
                SELECT "location" FROM "s" WHERE "league_division"='first division' AND "club"='sun pegasus';
```
## Task
Generate a SQL query to answer the following question:
`What division is Sai Kung in?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "s" (
  "club" text,
  "league_division" text,
  "home_ground" text,
  "location" text,
  "position_in_2012_13" text
);
### SQL
Given the database schema, here is the SQL query that answers `What division is Sai Kung in?`:
```sql
                SELECT "league_division" FROM "s" WHERE "club"='sai kung';
```
## Task
Generate a SQL query to answer the following question:
`What league is Sun Source in?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "s" (
  "club" text,
  "league_division" text,
  "home_ground" text,
  "location" text,
  "position_in_2012_13" text
);
### SQL
Given the database schema, here is the SQL query that answers `What league is Sun Source in?`:
```sql
                SELECT "league_division" FROM "s" WHERE "club"='sun source';
```
## Task
Generate a SQL query to answer the following question:
`What was the model that had years 2004-?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "engines" (
  "model" text,
  "years" text,
  "type_code" text,
  "power_rpm" text,
  "torque_rpm" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the model that had years 2004-?`:
```sql
                SELECT "model" FROM "engines" WHERE "years"='2004-';
```
## Task
Generate a SQL query to answer the following question:
`What was the torque@rpm of the sl 65 amg?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "engines" (
  "model" text,
  "years" text,
  "type_code" text,
  "power_rpm" text,
  "torque_rpm" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the torque@rpm of the sl 65 amg?`:
```sql
                SELECT "torque_rpm" FROM "engines" WHERE "model"='sl 65 amg';
```
## Task
Generate a SQL query to answer the following question:
`What is the IHSAA Class for football for the team joining in 1968?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "membership" (
  "school" text,
  "city" text,
  "team_name" text,
  "enrollment_08_09" real,
  "ihsaa_class" text,
  "ihsaa_class_football" text,
  "county" text,
  "year_joined" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the IHSAA Class for football for the team joining in 1968?`:
```sql
                SELECT "ihsaa_class_football" FROM "membership" WHERE "year_joined"=1968;
```
## Task
Generate a SQL query to answer the following question:
`What is the IHSAA class for Tipton?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "membership" (
  "school" text,
  "city" text,
  "team_name" text,
  "enrollment_08_09" real,
  "ihsaa_class" text,
  "ihsaa_class_football" text,
  "county" text,
  "year_joined" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the IHSAA class for Tipton?`:
```sql
                SELECT "ihsaa_class" FROM "membership" WHERE "school"='tipton';
```
## Task
Generate a SQL query to answer the following question:
`What is the rank for the person with time 11.14?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "heat_8" (
  "rank" real,
  "lane" real,
  "athlete" text,
  "time_sec" real,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the rank for the person with time 11.14?`:
```sql
                SELECT AVG("rank") FROM "heat_8" WHERE "time_sec"=11.14;
```
## Task
Generate a SQL query to answer the following question:
`What is the rank when time is 11.15 and lane is bigger than 7 with notes Q, PB?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "heat_8" (
  "rank" real,
  "lane" real,
  "athlete" text,
  "time_sec" real,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the rank when time is 11.15 and lane is bigger than 7 with notes Q, PB?`:
```sql
                SELECT SUM("rank") FROM "heat_8" WHERE "notes"='q, pb' AND "time_sec"=11.15 AND "lane">7;
```
## Task
Generate a SQL query to answer the following question:
`What is the lane for notes Q, SB and time less than 11.22?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "heat_8" (
  "rank" real,
  "lane" real,
  "athlete" text,
  "time_sec" real,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lane for notes Q, SB and time less than 11.22?`:
```sql
                SELECT SUM("lane") FROM "heat_8" WHERE "notes"='q, sb' AND "time_sec"<11.22;
```
## Task
Generate a SQL query to answer the following question:
`Which athlete is ranked less than 5 with time over 11.22?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "heat_8" (
  "rank" real,
  "lane" real,
  "athlete" text,
  "time_sec" real,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which athlete is ranked less than 5 with time over 11.22?`:
```sql
                SELECT "athlete" FROM "heat_8" WHERE "time_sec">11.22 AND "rank"<5;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest played when draws P.K. Wins / P.K. Losses is 3/0, and points is larger than 18?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "torneo_apertura" (
  "position" real,
  "team" text,
  "played" real,
  "wins" real,
  "draws_p_k_wins_p_k_losses" text,
  "losses" real,
  "scored" real,
  "conceded" real,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest played when draws P.K. Wins / P.K. Losses is 3/0, and points is larger than 18?`:
```sql
                SELECT MIN("played") FROM "torneo_apertura" WHERE "draws_p_k_wins_p_k_losses"='3/0' AND "points">18;
```
## Task
Generate a SQL query to answer the following question:
`How many lanes does Australia have with a reaction smaller than 0.138?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "final" (
  "lane" real,
  "name" text,
  "nationality" text,
  "reaction" real,
  "time" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many lanes does Australia have with a reaction smaller than 0.138?`:
```sql
                SELECT COUNT("lane") FROM "final" WHERE "nationality"='australia' AND "reaction"<0.138;
```
## Task
Generate a SQL query to answer the following question:
`Who had a reaction larger than 0.17400000000000002 and a lane larger than 6?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "final" (
  "lane" real,
  "name" text,
  "nationality" text,
  "reaction" real,
  "time" real
);
### SQL
Given the database schema, here is the SQL query that answers `Who had a reaction larger than 0.17400000000000002 and a lane larger than 6?`:
```sql
                SELECT "name" FROM "final" WHERE "reaction">0.17400000000000002 AND "lane">6;
```
## Task
Generate a SQL query to answer the following question:
`The ship MS Vistafjord has what in service for NAL?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "passenger_ships" (
  "ship" text,
  "built" real,
  "in_service_for_nal" text,
  "type" text,
  "tonnage" text
);
### SQL
Given the database schema, here is the SQL query that answers `The ship MS Vistafjord has what in service for NAL?`:
```sql
                SELECT "in_service_for_nal" FROM "passenger_ships" WHERE "ship"='ms vistafjord';
```
## Task
Generate a SQL query to answer the following question:
`The ship SSBergensfjord built before 1973 has what tonnage?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "passenger_ships" (
  "ship" text,
  "built" real,
  "in_service_for_nal" text,
  "type" text,
  "tonnage" text
);
### SQL
Given the database schema, here is the SQL query that answers `The ship SSBergensfjord built before 1973 has what tonnage?`:
```sql
                SELECT "tonnage" FROM "passenger_ships" WHERE "built"<1973 AND "ship"='ssbergensfjord';
```
## Task
Generate a SQL query to answer the following question:
`Which nationality has a time of 50.92?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "semifinal_2" (
  "rank" real,
  "lane" real,
  "name" text,
  "nationality" text,
  "time" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which nationality has a time of 50.92?`:
```sql
                SELECT "nationality" FROM "semifinal_2" WHERE "time"=50.92;
```
## Task
Generate a SQL query to answer the following question:
`What is the time with fewer than 5 lanes for the United States?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "semifinal_2" (
  "rank" real,
  "lane" real,
  "name" text,
  "nationality" text,
  "time" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the time with fewer than 5 lanes for the United States?`:
```sql
                SELECT SUM("time") FROM "semifinal_2" WHERE "lane"<5 AND "nationality"='united states';
```
## Task
Generate a SQL query to answer the following question:
`Which Att-Cmp has a GP-GS of 7-1?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "passing" (
  "name" text,
  "gp_gs" text,
  "effic" real,
  "att_cmp" text,
  "td_int" text,
  "avg_g" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Att-Cmp has a GP-GS of 7-1?`:
```sql
                SELECT "att_cmp" FROM "passing" WHERE "gp_gs"='7-1';
```
## Task
Generate a SQL query to answer the following question:
`Which Att-Cmp has a TD-INT of 7-8?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "passing" (
  "name" text,
  "gp_gs" text,
  "effic" real,
  "att_cmp" text,
  "td_int" text,
  "avg_g" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Att-Cmp has a TD-INT of 7-8?`:
```sql
                SELECT "att_cmp" FROM "passing" WHERE "td_int"='7-8';
```
## Task
Generate a SQL query to answer the following question:
`Which TD-INT has an Effic larger than 111.4?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "passing" (
  "name" text,
  "gp_gs" text,
  "effic" real,
  "att_cmp" text,
  "td_int" text,
  "avg_g" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which TD-INT has an Effic larger than 111.4?`:
```sql
                SELECT "td_int" FROM "passing" WHERE "effic">111.4;
```
## Task
Generate a SQL query to answer the following question:
`What is the total number of losses with less than 6 wins and less than 0 draws?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "2011_ladder" (
  "wimmera_fl" text,
  "wins" real,
  "byes" real,
  "losses" real,
  "draws" real,
  "against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of losses with less than 6 wins and less than 0 draws?`:
```sql
                SELECT COUNT("losses") FROM "2011_ladder" WHERE "wins"<6 AND "draws"<0;
```
## Task
Generate a SQL query to answer the following question:
`What is the average number of against with less than 10 losses, more than 0 draws, and more than 7 wins?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "2011_ladder" (
  "wimmera_fl" text,
  "wins" real,
  "byes" real,
  "losses" real,
  "draws" real,
  "against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average number of against with less than 10 losses, more than 0 draws, and more than 7 wins?`:
```sql
                SELECT AVG("against") FROM "2011_ladder" WHERE "losses"<10 AND "draws">0 AND "wins">7;
```
## Task
Generate a SQL query to answer the following question:
`What is the total number of byes with more than 0 losses and 1526 against?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "2011_ladder" (
  "wimmera_fl" text,
  "wins" real,
  "byes" real,
  "losses" real,
  "draws" real,
  "against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of byes with more than 0 losses and 1526 against?`:
```sql
                SELECT COUNT("byes") FROM "2011_ladder" WHERE "losses">0 AND "against"=1526;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest number of draws with more than 2 byes?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "2011_ladder" (
  "wimmera_fl" text,
  "wins" real,
  "byes" real,
  "losses" real,
  "draws" real,
  "against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest number of draws with more than 2 byes?`:
```sql
                SELECT MIN("draws") FROM "2011_ladder" WHERE "byes">2;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest against of the wimmera fl warrack eagles, which have less than 16 wins?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "2011_ladder" (
  "wimmera_fl" text,
  "wins" real,
  "byes" real,
  "losses" real,
  "draws" real,
  "against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest against of the wimmera fl warrack eagles, which have less than 16 wins?`:
```sql
                SELECT MIN("against") FROM "2011_ladder" WHERE "wins"<16 AND "wimmera_fl"='warrack eagles';
```
## Task
Generate a SQL query to answer the following question:
`How many races did the German racer that won less than 10 races ride?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "highest_number_of_six_day_victories" (
  "name" text,
  "nationality" text,
  "races_won" real,
  "races_ridden" real,
  "win_average" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many races did the German racer that won less than 10 races ride?`:
```sql
                SELECT COUNT("races_ridden") FROM "highest_number_of_six_day_victories" WHERE "nationality"='german' AND "races_won"<10;
```
## Task
Generate a SQL query to answer the following question:
`What is the average win as a percentage of German racer Rudi Altig, who has ridden in over 79 races?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "highest_number_of_six_day_victories" (
  "name" text,
  "nationality" text,
  "races_won" real,
  "races_ridden" real,
  "win_average" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average win as a percentage of German racer Rudi Altig, who has ridden in over 79 races?`:
```sql
                SELECT AVG("win_average") FROM "highest_number_of_six_day_victories" WHERE "nationality"='german' AND "name"='rudi altig' AND "races_ridden">79;
```
## Task
Generate a SQL query to answer the following question:
`what is the highest top-5 when cuts made is more than 39?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "summary" (
  "tournament" text,
  "wins" real,
  "top_5" real,
  "top_10" real,
  "top_25" real,
  "events" real,
  "cuts_made" real
);
### SQL
Given the database schema, here is the SQL query that answers `what is the highest top-5 when cuts made is more than 39?`:
```sql
                SELECT MAX("top_5") FROM "summary" WHERE "cuts_made">39;
```
## Task
Generate a SQL query to answer the following question:
`what is the highest events when wins is more than 0 and cuts made is more than 14?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "summary" (
  "tournament" text,
  "wins" real,
  "top_5" real,
  "top_10" real,
  "top_25" real,
  "events" real,
  "cuts_made" real
);
### SQL
Given the database schema, here is the SQL query that answers `what is the highest events when wins is more than 0 and cuts made is more than 14?`:
```sql
                SELECT MAX("events") FROM "summary" WHERE "wins">0 AND "cuts_made">14;
```
## Task
Generate a SQL query to answer the following question:
`what is the highest top-5 when wins is more than 1?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "summary" (
  "tournament" text,
  "wins" real,
  "top_5" real,
  "top_10" real,
  "top_25" real,
  "events" real,
  "cuts_made" real
);
### SQL
Given the database schema, here is the SQL query that answers `what is the highest top-5 when wins is more than 1?`:
```sql
                SELECT MAX("top_5") FROM "summary" WHERE "wins">1;
```
## Task
Generate a SQL query to answer the following question:
`How many times is the tournament the masters tournament and the top-10 is less than 2?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "summary" (
  "tournament" text,
  "wins" real,
  "top_5" real,
  "top_10" real,
  "top_25" real,
  "events" real,
  "cuts_made" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many times is the tournament the masters tournament and the top-10 is less than 2?`:
```sql
                SELECT COUNT("top_5") FROM "summary" WHERE "tournament"='masters tournament' AND "top_10"<2;
```
## Task
Generate a SQL query to answer the following question:
`What ran has noel patterson as the rider?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "race_5_senior_manx_grand_prix" (
  "rank" real,
  "rider" text,
  "team" text,
  "speed" text,
  "time" text
);
### SQL
Given the database schema, here is the SQL query that answers `What ran has noel patterson as the rider?`:
```sql
                SELECT "rank" FROM "race_5_senior_manx_grand_prix" WHERE "rider"='noel patterson';
```
## Task
Generate a SQL query to answer the following question:
`What time has jules croft as the rider?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "race_5_senior_manx_grand_prix" (
  "rank" real,
  "rider" text,
  "team" text,
  "speed" text,
  "time" text
);
### SQL
Given the database schema, here is the SQL query that answers `What time has jules croft as the rider?`:
```sql
                SELECT "time" FROM "race_5_senior_manx_grand_prix" WHERE "rider"='jules croft';
```
## Task
Generate a SQL query to answer the following question:
`What team has adam barclay as the rider?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "race_5_senior_manx_grand_prix" (
  "rank" real,
  "rider" text,
  "team" text,
  "speed" text,
  "time" text
);
### SQL
Given the database schema, here is the SQL query that answers `What team has adam barclay as the rider?`:
```sql
                SELECT "team" FROM "race_5_senior_manx_grand_prix" WHERE "rider"='adam barclay';
```
## Task
Generate a SQL query to answer the following question:
`What Round has h/a hurst`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "manchester_and_district_senior_cup" (
  "date" text,
  "round" text,
  "opponents" text,
  "h_a" text,
  "result_f_a" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Round has h/a hurst`:
```sql
                SELECT "round" FROM "manchester_and_district_senior_cup" WHERE "h_a"='hurst';
```
## Task
Generate a SQL query to answer the following question:
`what game ended f-a with a round of round 1 replay`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "manchester_and_district_senior_cup" (
  "date" text,
  "round" text,
  "opponents" text,
  "h_a" text,
  "result_f_a" text
);
### SQL
Given the database schema, here is the SQL query that answers `what game ended f-a with a round of round 1 replay`:
```sql
                SELECT "result_f_a" FROM "manchester_and_district_senior_cup" WHERE "round"='round 1 replay';
```
## Task
Generate a SQL query to answer the following question:
`what is the h/a round of round 2`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "manchester_and_district_senior_cup" (
  "date" text,
  "round" text,
  "opponents" text,
  "h_a" text,
  "result_f_a" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the h/a round of round 2`:
```sql
                SELECT "h_a" FROM "manchester_and_district_senior_cup" WHERE "round"='round 2';
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest laps that has an on lap less than 4, with 35 as a class pos.?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "miller_grand_am_cup_200_gs_class_only_re" (
  "class" text,
  "class_pos" real,
  "driver" text,
  "team_car" text,
  "laps" real,
  "best_lap" text,
  "on_lap" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest laps that has an on lap less than 4, with 35 as a class pos.?`:
```sql
                SELECT MIN("laps") FROM "miller_grand_am_cup_200_gs_class_only_re" WHERE "on_lap"<4 AND "class_pos"=35;
```
## Task
Generate a SQL query to answer the following question:
`What was the Role/Episode after 2006 with Ellen Burstyn as a recipient and nominee?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "emmy_awards" (
  "year" real,
  "category" text,
  "recipients_and_nominees" text,
  "role_episode" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the Role/Episode after 2006 with Ellen Burstyn as a recipient and nominee?`:
```sql
                SELECT "role_episode" FROM "emmy_awards" WHERE "year">2006 AND "recipients_and_nominees"='ellen burstyn';
```
## Task
Generate a SQL query to answer the following question:
`For which Category was Outstanding Main Title Design a Recipient and nominee?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "emmy_awards" (
  "year" real,
  "category" text,
  "recipients_and_nominees" text,
  "role_episode" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `For which Category was Outstanding Main Title Design a Recipient and nominee?`:
```sql
                SELECT "category" FROM "emmy_awards" WHERE "recipients_and_nominees"='outstanding main title design';
```
## Task
Generate a SQL query to answer the following question:
`Which Category was from before 2009 with a Role/Episode of Libby Goldstein and Junie Lowry-Johnson?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "emmy_awards" (
  "year" real,
  "category" text,
  "recipients_and_nominees" text,
  "role_episode" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Category was from before 2009 with a Role/Episode of Libby Goldstein and Junie Lowry-Johnson?`:
```sql
                SELECT "category" FROM "emmy_awards" WHERE "year"<2009 AND "role_episode"='libby goldstein and junie lowry-johnson';
```
## Task
Generate a SQL query to answer the following question:
`Which Category were Libby Goldstein and Junie Lowry-Johnson recipients and nominees for?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "emmy_awards" (
  "year" real,
  "category" text,
  "recipients_and_nominees" text,
  "role_episode" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Category were Libby Goldstein and Junie Lowry-Johnson recipients and nominees for?`:
```sql
                SELECT "category" FROM "emmy_awards" WHERE "recipients_and_nominees"='libby goldstein and junie lowry-johnson';
```
## Task
Generate a SQL query to answer the following question:
`what is the highest runners when the jockey is frankie dettori and the placing is higher than 1?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "race_record" (
  "race" text,
  "dist_f" real,
  "course" text,
  "runners" real,
  "placing" real,
  "margin" real,
  "jockey" text,
  "trainer" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the highest runners when the jockey is frankie dettori and the placing is higher than 1?`:
```sql
                SELECT MAX("runners") FROM "race_record" WHERE "jockey"='frankie dettori' AND "placing">1;
```
## Task
Generate a SQL query to answer the following question:
`what is the race when the jockey is frankie dettori, the margin is more than 3 and the course is yarmouth?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "race_record" (
  "race" text,
  "dist_f" real,
  "course" text,
  "runners" real,
  "placing" real,
  "margin" real,
  "jockey" text,
  "trainer" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the race when the jockey is frankie dettori, the margin is more than 3 and the course is yarmouth?`:
```sql
                SELECT "race" FROM "race_record" WHERE "jockey"='frankie dettori' AND "margin">3 AND "course"='yarmouth';
```
## Task
Generate a SQL query to answer the following question:
`Who is the Partner in the match with a Score of 6-4, 2-6, 7-6?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "doubles_9_4_titles_5_runner_ups" (
  "outcome" text,
  "year" text,
  "tournament" text,
  "surface" text,
  "partnering" text,
  "opponents_in_the_final" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the Partner in the match with a Score of 6-4, 2-6, 7-6?`:
```sql
                SELECT "partnering" FROM "doubles_9_4_titles_5_runner_ups" WHERE "score"='6-4, 2-6, 7-6';
```
## Task
Generate a SQL query to answer the following question:
`what is the competition when the result is won and the date is september 13, 1996?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "international_goals" (
  "date" text,
  "venue" text,
  "score" text,
  "result" text,
  "competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the competition when the result is won and the date is september 13, 1996?`:
```sql
                SELECT "competition" FROM "international_goals" WHERE "result"='won' AND "date"='september 13, 1996';
```
## Task
Generate a SQL query to answer the following question:
`what is the date when the competition is 1996 tiger cup and the result is drew?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "international_goals" (
  "date" text,
  "venue" text,
  "score" text,
  "result" text,
  "competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the date when the competition is 1996 tiger cup and the result is drew?`:
```sql
                SELECT "date" FROM "international_goals" WHERE "competition"='1996 tiger cup' AND "result"='drew';
```
## Task
Generate a SQL query to answer the following question:
`what is the score when the competition is 1995 southeast asian games?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "international_goals" (
  "date" text,
  "venue" text,
  "score" text,
  "result" text,
  "competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the score when the competition is 1995 southeast asian games?`:
```sql
                SELECT "score" FROM "international_goals" WHERE "competition"='1995 southeast asian games';
```
## Task
Generate a SQL query to answer the following question:
`what is the result when the venue is singapore on september 8, 1996?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "international_goals" (
  "date" text,
  "venue" text,
  "score" text,
  "result" text,
  "competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the result when the venue is singapore on september 8, 1996?`:
```sql
                SELECT "result" FROM "international_goals" WHERE "venue"='singapore' AND "date"='september 8, 1996';
```
## Task
Generate a SQL query to answer the following question:
`what is the competition when the result is won and the score is 8-0?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "international_goals" (
  "date" text,
  "venue" text,
  "score" text,
  "result" text,
  "competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the competition when the result is won and the score is 8-0?`:
```sql
                SELECT "competition" FROM "international_goals" WHERE "result"='won' AND "score"='8-0';
```
## Task
Generate a SQL query to answer the following question:
`Waht laps have points smaller than 1, and a team of dale coyne racing, and the grid larger than 13?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "race" (
  "driver" text,
  "team" text,
  "laps" real,
  "time_retired" text,
  "grid" real,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Waht laps have points smaller than 1, and a team of dale coyne racing, and the grid larger than 13?`:
```sql
                SELECT "laps" FROM "race" WHERE "points"<1 AND "team"='dale coyne racing' AND "grid">13;
```
## Task
Generate a SQL query to answer the following question:
`What is the total number of laps for a team of team player's, and has a grid of 9, and points larger than 10?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "race" (
  "driver" text,
  "team" text,
  "laps" real,
  "time_retired" text,
  "grid" real,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of laps for a team of team player's, and has a grid of 9, and points larger than 10?`:
```sql
                SELECT COUNT("laps") FROM "race" WHERE "team"='team player''s' AND "grid"=9 AND "points">10;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest points for a time/retired of +30.7 secs, and laps smaller than 165?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "race" (
  "driver" text,
  "team" text,
  "laps" real,
  "time_retired" text,
  "grid" real,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest points for a time/retired of +30.7 secs, and laps smaller than 165?`:
```sql
                SELECT MIN("points") FROM "race" WHERE "time_retired"='+30.7 secs' AND "laps"<165;
```
## Task
Generate a SQL query to answer the following question:
`What was the first leg score of the matchup with a 2nd leg of 80-70?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "second_qualifying_round" (
  "team_num1" text,
  "agg" text,
  "team_num2" text,
  "1st_leg" text,
  "2nd_leg" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the first leg score of the matchup with a 2nd leg of 80-70?`:
```sql
                SELECT "1st_leg" FROM "second_qualifying_round" WHERE "2nd_leg"='80-70';
```
## Task
Generate a SQL query to answer the following question:
`Who was the team 2 in the game with a team 1 of Liege Basket?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "second_qualifying_round" (
  "team_num1" text,
  "agg" text,
  "team_num2" text,
  "1st_leg" text,
  "2nd_leg" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the team 2 in the game with a team 1 of Liege Basket?`:
```sql
                SELECT "team_num2" FROM "second_qualifying_round" WHERE "team_num1"='liege basket';
```
## Task
Generate a SQL query to answer the following question:
`What was the 1st leg score in the matchup with a 2nd leg of 72-89?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "second_qualifying_round" (
  "team_num1" text,
  "agg" text,
  "team_num2" text,
  "1st_leg" text,
  "2nd_leg" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the 1st leg score in the matchup with a 2nd leg of 72-89?`:
```sql
                SELECT "1st_leg" FROM "second_qualifying_round" WHERE "2nd_leg"='72-89';
```
## Task
Generate a SQL query to answer the following question:
`What was the aggregate score of the matchup with a leg 2 of 72-64?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "second_qualifying_round" (
  "team_num1" text,
  "agg" text,
  "team_num2" text,
  "1st_leg" text,
  "2nd_leg" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the aggregate score of the matchup with a leg 2 of 72-64?`:
```sql
                SELECT "agg" FROM "second_qualifying_round" WHERE "2nd_leg"='72-64';
```
## Task
Generate a SQL query to answer the following question:
`What was the 2nd leg score in the matchup with a team 2 of KK Borac?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "second_qualifying_round" (
  "team_num1" text,
  "agg" text,
  "team_num2" text,
  "1st_leg" text,
  "2nd_leg" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the 2nd leg score in the matchup with a team 2 of KK Borac?`:
```sql
                SELECT "2nd_leg" FROM "second_qualifying_round" WHERE "team_num2"='kk borac';
```
## Task
Generate a SQL query to answer the following question:
`What are the serial numbers for the locomotives of Class 4-8-4 — oooooooo — northern?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "4_8_4" (
  "class" text,
  "wheel_arrangement" text,
  "fleet_number_s" text,
  "manufacturer" text,
  "serial_numbers" text,
  "year_made" text,
  "quantity_made" text,
  "quantity_preserved" text,
  "year_s_retired" text
);
### SQL
Given the database schema, here is the SQL query that answers `What are the serial numbers for the locomotives of Class 4-8-4 — oooooooo — northern?`:
```sql
                SELECT "serial_numbers" FROM "4_8_4" WHERE "class"='4-8-4 — oooooooo — northern';
```
## Task
Generate a SQL query to answer the following question:
`What is the fleet number for the model with Serial number 68056?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "4_8_4" (
  "class" text,
  "wheel_arrangement" text,
  "fleet_number_s" text,
  "manufacturer" text,
  "serial_numbers" text,
  "year_made" text,
  "quantity_made" text,
  "quantity_preserved" text,
  "year_s_retired" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the fleet number for the model with Serial number 68056?`:
```sql
                SELECT "fleet_number_s" FROM "4_8_4" WHERE "serial_numbers"='68056';
```
## Task
Generate a SQL query to answer the following question:
`What is the serial number of the model made in 1930?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "4_8_4" (
  "class" text,
  "wheel_arrangement" text,
  "fleet_number_s" text,
  "manufacturer" text,
  "serial_numbers" text,
  "year_made" text,
  "quantity_made" text,
  "quantity_preserved" text,
  "year_s_retired" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the serial number of the model made in 1930?`:
```sql
                SELECT "serial_numbers" FROM "4_8_4" WHERE "year_made"='1930';
```
## Task
Generate a SQL query to answer the following question:
`What is the wheel arrangement for the model that was retired in 1955?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "4_8_4" (
  "class" text,
  "wheel_arrangement" text,
  "fleet_number_s" text,
  "manufacturer" text,
  "serial_numbers" text,
  "year_made" text,
  "quantity_made" text,
  "quantity_preserved" text,
  "year_s_retired" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the wheel arrangement for the model that was retired in 1955?`:
```sql
                SELECT "wheel_arrangement" FROM "4_8_4" WHERE "year_s_retired"='1955';
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest number of matches that has a Clubs of 46 → 32?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "calendar" (
  "round" text,
  "date" text,
  "matches" real,
  "clubs" text,
  "new_entries_this_round" text,
  "prize_money" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest number of matches that has a Clubs of 46 → 32?`:
```sql
                SELECT MIN("matches") FROM "calendar" WHERE "clubs"='46 → 32';
```
## Task
Generate a SQL query to answer the following question:
`What is the highest number of matches that has a round of Third Round?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "calendar" (
  "round" text,
  "date" text,
  "matches" real,
  "clubs" text,
  "new_entries_this_round" text,
  "prize_money" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest number of matches that has a round of Third Round?`:
```sql
                SELECT MAX("matches") FROM "calendar" WHERE "round"='third round';
```
## Task
Generate a SQL query to answer the following question:
`What is the prize money for the final round?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "calendar" (
  "round" text,
  "date" text,
  "matches" real,
  "clubs" text,
  "new_entries_this_round" text,
  "prize_money" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the prize money for the final round?`:
```sql
                SELECT "prize_money" FROM "calendar" WHERE "round"='final';
```