cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`What is listed for the Bronze, with the Location of Bangkok, and the Year of 1978?`

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

CREATE TABLE "individual" (
  "year" real,
  "location" text,
  "gold" text,
  "silver" text,
  "bronze" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is listed for the Bronze, with the Location of Bangkok, and the Year of 1978?`:
```sql
                SELECT "bronze" FROM "individual" WHERE "location"='bangkok' AND "year"=1978;
```
## Task
Generate a SQL query to answer the following question:
`What's listed for the lowest Year that a Silver of Kim Kyung-Ho?`

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

CREATE TABLE "individual" (
  "year" real,
  "location" text,
  "gold" text,
  "silver" text,
  "bronze" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's listed for the lowest Year that a Silver of Kim Kyung-Ho?`:
```sql
                SELECT MIN("year") FROM "individual" WHERE "silver"='kim kyung-ho';
```
## Task
Generate a SQL query to answer the following question:
`What's the Gold that also has Bronze of Kim Sun-Bin?`

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

CREATE TABLE "individual" (
  "year" real,
  "location" text,
  "gold" text,
  "silver" text,
  "bronze" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the Gold that also has Bronze of Kim Sun-Bin?`:
```sql
                SELECT "gold" FROM "individual" WHERE "bronze"='kim sun-bin';
```
## Task
Generate a SQL query to answer the following question:
`What's the Bronze that's also got a Godl of Kim Woo-Jin?`

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

CREATE TABLE "individual" (
  "year" real,
  "location" text,
  "gold" text,
  "silver" text,
  "bronze" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the Bronze that's also got a Godl of Kim Woo-Jin?`:
```sql
                SELECT "bronze" FROM "individual" WHERE "gold"='kim woo-jin';
```
## Task
Generate a SQL query to answer the following question:
`What is listed as the highest Year that's also got a Bronze of Wataru Haraguchi?`

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

CREATE TABLE "individual" (
  "year" real,
  "location" text,
  "gold" text,
  "silver" text,
  "bronze" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is listed as the highest Year that's also got a Bronze of Wataru Haraguchi?`:
```sql
                SELECT MAX("year") FROM "individual" WHERE "bronze"='wataru haraguchi';
```
## Task
Generate a SQL query to answer the following question:
`What was the score when their record was 35–23–15?`

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

CREATE TABLE "march" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score when their record was 35–23–15?`:
```sql
                SELECT "score" FROM "march" WHERE "record"='35–23–15';
```
## Task
Generate a SQL query to answer the following question:
`Which home team has a score of 5 – 6?`

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

CREATE TABLE "march" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which home team has a score of 5 – 6?`:
```sql
                SELECT "home" FROM "march" WHERE "score"='5 – 6';
```
## Task
Generate a SQL query to answer the following question:
`In what county is the school of Merrillville?`

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

CREATE TABLE "current_members" (
  "school" text,
  "location" text,
  "mascot" text,
  "county" text,
  "enrollment_08_09" real,
  "ihsaa_class" text,
  "ihsaa_class_football" text,
  "year_joined" real,
  "previous_conference" text
);
### SQL
Given the database schema, here is the SQL query that answers `In what county is the school of Merrillville?`:
```sql
                SELECT "county" FROM "current_members" WHERE "school"='merrillville';
```
## Task
Generate a SQL query to answer the following question:
`The school of Portage was in what conference previous?`

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

CREATE TABLE "current_members" (
  "school" text,
  "location" text,
  "mascot" text,
  "county" text,
  "enrollment_08_09" real,
  "ihsaa_class" text,
  "ihsaa_class_football" text,
  "year_joined" real,
  "previous_conference" text
);
### SQL
Given the database schema, here is the SQL query that answers `The school of Portage was in what conference previous?`:
```sql
                SELECT "previous_conference" FROM "current_members" WHERE "school"='portage';
```
## Task
Generate a SQL query to answer the following question:
`What is the name of the school that is in Valparaiso?`

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

CREATE TABLE "current_members" (
  "school" text,
  "location" text,
  "mascot" text,
  "county" text,
  "enrollment_08_09" real,
  "ihsaa_class" text,
  "ihsaa_class_football" text,
  "year_joined" real,
  "previous_conference" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the name of the school that is in Valparaiso?`:
```sql
                SELECT "school" FROM "current_members" WHERE "location"='valparaiso';
```
## Task
Generate a SQL query to answer the following question:
`Which FA Cup is the highest one that has a Malaysia Cup of 0, and a Player of ahmad fouzee masuri, and a Total larger than 0?`

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

CREATE TABLE "scorers" (
  "player" text,
  "league" real,
  "malaysia_cup" real,
  "fa_cup" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which FA Cup is the highest one that has a Malaysia Cup of 0, and a Player of ahmad fouzee masuri, and a Total larger than 0?`:
```sql
                SELECT MAX("fa_cup") FROM "scorers" WHERE "malaysia_cup"=0 AND "player"='ahmad fouzee masuri' AND "total">0;
```
## Task
Generate a SQL query to answer the following question:
`How many totals have a Player of ahmad fouzee masuri, and an FA Cup larger than 0?`

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

CREATE TABLE "scorers" (
  "player" text,
  "league" real,
  "malaysia_cup" real,
  "fa_cup" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many totals have a Player of ahmad fouzee masuri, and an FA Cup larger than 0?`:
```sql
                SELECT COUNT("total") FROM "scorers" WHERE "player"='ahmad fouzee masuri' AND "fa_cup">0;
```
## Task
Generate a SQL query to answer the following question:
`Which FA Cup has a Player of khairan ezuan razali, and a Total smaller than 0?`

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

CREATE TABLE "scorers" (
  "player" text,
  "league" real,
  "malaysia_cup" real,
  "fa_cup" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which FA Cup has a Player of khairan ezuan razali, and a Total smaller than 0?`:
```sql
                SELECT AVG("fa_cup") FROM "scorers" WHERE "player"='khairan ezuan razali' AND "total"<0;
```
## Task
Generate a SQL query to answer the following question:
`How many Malaysia Cups have a Total larger than 3, and a Player of ivan yusoff, and a League smaller than 2?`

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

CREATE TABLE "scorers" (
  "player" text,
  "league" real,
  "malaysia_cup" real,
  "fa_cup" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many Malaysia Cups have a Total larger than 3, and a Player of ivan yusoff, and a League smaller than 2?`:
```sql
                SELECT COUNT("malaysia_cup") FROM "scorers" WHERE "total">3 AND "player"='ivan yusoff' AND "league"<2;
```
## Task
Generate a SQL query to answer the following question:
`Which FA Cup has a Malaysia Cup larger than 0, and a Total of 8?`

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

CREATE TABLE "scorers" (
  "player" text,
  "league" real,
  "malaysia_cup" real,
  "fa_cup" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which FA Cup has a Malaysia Cup larger than 0, and a Total of 8?`:
```sql
                SELECT SUM("fa_cup") FROM "scorers" WHERE "malaysia_cup">0 AND "total"=8;
```
## Task
Generate a SQL query to answer the following question:
`Which Year is the highest one that has a Venue of edmonton, canada?`

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

CREATE TABLE "achievements" (
  "year" real,
  "competition" text,
  "venue" text,
  "position" text,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Year is the highest one that has a Venue of edmonton, canada?`:
```sql
                SELECT MAX("year") FROM "achievements" WHERE "venue"='edmonton, canada';
```
## Task
Generate a SQL query to answer the following question:
`Which Position has a Competition of world championships, and a Year larger than 1997?`

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

CREATE TABLE "achievements" (
  "year" real,
  "competition" text,
  "venue" text,
  "position" text,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Position has a Competition of world championships, and a Year larger than 1997?`:
```sql
                SELECT "position" FROM "achievements" WHERE "competition"='world championships' AND "year">1997;
```
## Task
Generate a SQL query to answer the following question:
`Which Venue has a Notes of heptathlon, and a Year of 1991?`

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

CREATE TABLE "achievements" (
  "year" real,
  "competition" text,
  "venue" text,
  "position" text,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Venue has a Notes of heptathlon, and a Year of 1991?`:
```sql
                SELECT "venue" FROM "achievements" WHERE "notes"='heptathlon' AND "year"=1991;
```
## Task
Generate a SQL query to answer the following question:
`What days held has noiz as the wrestler?`

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

CREATE TABLE "pro_wrestling_zero1_version_disputed_bra" (
  "wrestler" text,
  "reign" text,
  "days_held" text,
  "location" text,
  "event" text
);
### SQL
Given the database schema, here is the SQL query that answers `What days held has noiz as the wrestler?`:
```sql
                SELECT "days_held" FROM "pro_wrestling_zero1_version_disputed_bra" WHERE "wrestler"='noiz';
```
## Task
Generate a SQL query to answer the following question:
`What location has tatsuhito takaiwa as the wrestler?`

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

CREATE TABLE "pro_wrestling_zero1_version_disputed_bra" (
  "wrestler" text,
  "reign" text,
  "days_held" text,
  "location" text,
  "event" text
);
### SQL
Given the database schema, here is the SQL query that answers `What location has tatsuhito takaiwa as the wrestler?`:
```sql
                SELECT "location" FROM "pro_wrestling_zero1_version_disputed_bra" WHERE "wrestler"='tatsuhito takaiwa';
```
## Task
Generate a SQL query to answer the following question:
`What event has 8 as the days held?`

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

CREATE TABLE "pro_wrestling_zero1_version_disputed_bra" (
  "wrestler" text,
  "reign" text,
  "days_held" text,
  "location" text,
  "event" text
);
### SQL
Given the database schema, here is the SQL query that answers `What event has 8 as the days held?`:
```sql
                SELECT "event" FROM "pro_wrestling_zero1_version_disputed_bra" WHERE "days_held"='8';
```
## Task
Generate a SQL query to answer the following question:
`What event has unknown as the days held.?`

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

CREATE TABLE "pro_wrestling_zero1_version_disputed_bra" (
  "wrestler" text,
  "reign" text,
  "days_held" text,
  "location" text,
  "event" text
);
### SQL
Given the database schema, here is the SQL query that answers `What event has unknown as the days held.?`:
```sql
                SELECT "event" FROM "pro_wrestling_zero1_version_disputed_bra" WHERE "days_held"='unknown';
```
## Task
Generate a SQL query to answer the following question:
`What is the Displacement of the Iveco F1CE3481E Engine?`

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

CREATE TABLE "2011" (
  "model" text,
  "engine" text,
  "displacement" text,
  "valvetrain" text,
  "fuel_system" text,
  "max_power_at_rpm" text,
  "max_torque_at_rpm" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Displacement of the Iveco F1CE3481E Engine?`:
```sql
                SELECT "displacement" FROM "2011" WHERE "engine"='iveco f1ce3481e';
```
## Task
Generate a SQL query to answer the following question:
`What is the Displacement of the 180 Multijet Power/3.0 HDI Model?`

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

CREATE TABLE "2011" (
  "model" text,
  "engine" text,
  "displacement" text,
  "valvetrain" text,
  "fuel_system" text,
  "max_power_at_rpm" text,
  "max_torque_at_rpm" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Displacement of the 180 Multijet Power/3.0 HDI Model?`:
```sql
                SELECT "displacement" FROM "2011" WHERE "model"='180 multijet power/3.0 hdi';
```
## Task
Generate a SQL query to answer the following question:
`What is the Valvetrain of the Diesel Engines Model?`

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

CREATE TABLE "2011" (
  "model" text,
  "engine" text,
  "displacement" text,
  "valvetrain" text,
  "fuel_system" text,
  "max_power_at_rpm" text,
  "max_torque_at_rpm" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Valvetrain of the Diesel Engines Model?`:
```sql
                SELECT "valvetrain" FROM "2011" WHERE "model"='diesel engines';
```
## Task
Generate a SQL query to answer the following question:
`Year(s) won of 1994 , 1997 has what average total?`

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

CREATE TABLE "made_the_cut" (
  "player" text,
  "country" text,
  "year_s_won" text,
  "total" real,
  "to_par" real,
  "finish" text
);
### SQL
Given the database schema, here is the SQL query that answers `Year(s) won of 1994 , 1997 has what average total?`:
```sql
                SELECT AVG("total") FROM "made_the_cut" WHERE "year_s_won"='1994 , 1997';
```
## Task
Generate a SQL query to answer the following question:
`Player of corey pavin, and a To par larger than 5 has what average total?`

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

CREATE TABLE "made_the_cut" (
  "player" text,
  "country" text,
  "year_s_won" text,
  "total" real,
  "to_par" real,
  "finish" text
);
### SQL
Given the database schema, here is the SQL query that answers `Player of corey pavin, and a To par larger than 5 has what average total?`:
```sql
                SELECT AVG("total") FROM "made_the_cut" WHERE "player"='corey pavin' AND "to_par">5;
```
## Task
Generate a SQL query to answer the following question:
`Total smaller than 285, and a To par larger than 1 belongs to what player?`

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

CREATE TABLE "made_the_cut" (
  "player" text,
  "country" text,
  "year_s_won" text,
  "total" real,
  "to_par" real,
  "finish" text
);
### SQL
Given the database schema, here is the SQL query that answers `Total smaller than 285, and a To par larger than 1 belongs to what player?`:
```sql
                SELECT "player" FROM "made_the_cut" WHERE "total"<285 AND "to_par">1;
```
## Task
Generate a SQL query to answer the following question:
`Total larger than 285, and a Finish of t30 belongs to what player?`

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

CREATE TABLE "made_the_cut" (
  "player" text,
  "country" text,
  "year_s_won" text,
  "total" real,
  "to_par" real,
  "finish" text
);
### SQL
Given the database schema, here is the SQL query that answers `Total larger than 285, and a Finish of t30 belongs to what player?`:
```sql
                SELECT "player" FROM "made_the_cut" WHERE "total">285 AND "finish"='t30';
```
## Task
Generate a SQL query to answer the following question:
`Which player for a team with an 18-20 record had the most rebounds in a game?`

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

CREATE TABLE "game_log" (
  "game" real,
  "date" text,
  "team" text,
  "score" text,
  "high_points" text,
  "high_rebounds" text,
  "high_assists" text,
  "location_attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which player for a team with an 18-20 record had the most rebounds in a game?`:
```sql
                SELECT "high_rebounds" FROM "game_log" WHERE "record"='18-20';
```
## Task
Generate a SQL query to answer the following question:
`What is the total area of Kruzof island?`

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

CREATE TABLE "islands_km" (
  "rank" real,
  "island_s_name" text,
  "area_sqmi" real,
  "area_km_2" real,
  "location" text,
  "population_2000" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total area of Kruzof island?`:
```sql
                SELECT COUNT("area_km_2") FROM "islands_km" WHERE "island_s_name"='kruzof island';
```
## Task
Generate a SQL query to answer the following question:
`Name the total number of frequency Mhz with class of d and call sign of k201bm and ERP W less than 74`

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

CREATE TABLE "external_links" (
  "call_sign" text,
  "frequency_m_hz" real,
  "city_of_license" text,
  "erp_w" real,
  "class" text,
  "fcc_info" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the total number of frequency Mhz with class of d and call sign of k201bm and ERP W less than 74`:
```sql
                SELECT COUNT("frequency_m_hz") FROM "external_links" WHERE "class"='d' AND "call_sign"='k201bm' AND "erp_w"<74;
```
## Task
Generate a SQL query to answer the following question:
`Name the least frequency Mhz with call sign of k202ag`

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

CREATE TABLE "external_links" (
  "call_sign" text,
  "frequency_m_hz" real,
  "city_of_license" text,
  "erp_w" real,
  "class" text,
  "fcc_info" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the least frequency Mhz with call sign of k202ag`:
```sql
                SELECT MIN("frequency_m_hz") FROM "external_links" WHERE "call_sign"='k202ag';
```
## Task
Generate a SQL query to answer the following question:
`Name the class with call sign of k220cp`

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

CREATE TABLE "external_links" (
  "call_sign" text,
  "frequency_m_hz" real,
  "city_of_license" text,
  "erp_w" real,
  "class" text,
  "fcc_info" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the class with call sign of k220cp`:
```sql
                SELECT "class" FROM "external_links" WHERE "call_sign"='k220cp';
```
## Task
Generate a SQL query to answer the following question:
`What is the Winnipeg Jets record?`

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

CREATE TABLE "schedule_and_results" (
  "game" real,
  "december" real,
  "opponent" text,
  "score" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Winnipeg Jets record?`:
```sql
                SELECT "record" FROM "schedule_and_results" WHERE "opponent"='winnipeg jets';
```
## Task
Generate a SQL query to answer the following question:
`What's the stadium on November 8?`

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

CREATE TABLE "regular_season" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the stadium on November 8?`:
```sql
                SELECT "home" FROM "regular_season" WHERE "date"='november 8';
```
## Task
Generate a SQL query to answer the following question:
`Who was the visitor on March 17?`

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

CREATE TABLE "regular_season" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the visitor on March 17?`:
```sql
                SELECT "visitor" FROM "regular_season" WHERE "date"='march 17';
```
## Task
Generate a SQL query to answer the following question:
`What's the score for Toronto Maple Leafs on November 10?`

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

CREATE TABLE "regular_season" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the score for Toronto Maple Leafs on November 10?`:
```sql
                SELECT "score" FROM "regular_season" WHERE "home"='toronto maple leafs' AND "date"='november 10';
```
## Task
Generate a SQL query to answer the following question:
`Who was the visitor on October 31?`

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

CREATE TABLE "regular_season" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the visitor on October 31?`:
```sql
                SELECT "visitor" FROM "regular_season" WHERE "date"='october 31';
```
## Task
Generate a SQL query to answer the following question:
`What is the rank associated with 0 wins and a 350cc class?`

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

CREATE TABLE "motorcycle_grand_prix_results" (
  "year" real,
  "class" text,
  "team" text,
  "points" real,
  "rank" text,
  "wins" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the rank associated with 0 wins and a 350cc class?`:
```sql
                SELECT "rank" FROM "motorcycle_grand_prix_results" WHERE "wins"=0 AND "class"='350cc';
```
## Task
Generate a SQL query to answer the following question:
`What is the run 2 of the athlete from Australia with a run 1 less than 53.75?`

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

CREATE TABLE "women" (
  "athlete" text,
  "country" text,
  "run_1" real,
  "run_2" real,
  "run_3" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the run 2 of the athlete from Australia with a run 1 less than 53.75?`:
```sql
                SELECT "run_2" FROM "women" WHERE "country"='australia' AND "run_1"<53.75;
```
## Task
Generate a SQL query to answer the following question:
`What is the run 2 of athlete Maria Orlova from Russia?`

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

CREATE TABLE "women" (
  "athlete" text,
  "country" text,
  "run_1" real,
  "run_2" real,
  "run_3" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the run 2 of athlete Maria Orlova from Russia?`:
```sql
                SELECT SUM("run_2") FROM "women" WHERE "country"='russia' AND "athlete"='maria orlova';
```
## Task
Generate a SQL query to answer the following question:
`What is the run 3 of the athlete with a run 1 more than 53.75 and a run 2 less than 52.91?`

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

CREATE TABLE "women" (
  "athlete" text,
  "country" text,
  "run_1" real,
  "run_2" real,
  "run_3" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the run 3 of the athlete with a run 1 more than 53.75 and a run 2 less than 52.91?`:
```sql
                SELECT SUM("run_3") FROM "women" WHERE "run_1">53.75 AND "run_2"<52.91;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest run 3 an athlete with a run 2 less than 53.72 and a run 1 of 53.1 has?`

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

CREATE TABLE "women" (
  "athlete" text,
  "country" text,
  "run_1" real,
  "run_2" real,
  "run_3" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest run 3 an athlete with a run 2 less than 53.72 and a run 1 of 53.1 has?`:
```sql
                SELECT MIN("run_3") FROM "women" WHERE "run_2"<53.72 AND "run_1"=53.1;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest run 2 of the athlete with a run 1 of 52.44 and a run 3 less than 52.35?`

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

CREATE TABLE "women" (
  "athlete" text,
  "country" text,
  "run_1" real,
  "run_2" real,
  "run_3" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest run 2 of the athlete with a run 1 of 52.44 and a run 3 less than 52.35?`:
```sql
                SELECT MIN("run_2") FROM "women" WHERE "run_1"=52.44 AND "run_3"<52.35;
```
## Task
Generate a SQL query to answer the following question:
`How many points are associated with over 1 top 5, 1 win, over 0 poles, and andrew ranger as the driver?`

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

CREATE TABLE "standings" (
  "position" real,
  "driver" text,
  "wins" real,
  "poles" real,
  "top_5_s" real,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many points are associated with over 1 top 5, 1 win, over 0 poles, and andrew ranger as the driver?`:
```sql
                SELECT MAX("points") FROM "standings" WHERE "top_5_s">1 AND "wins"=1 AND "poles">0 AND "driver"='andrew ranger';
```
## Task
Generate a SQL query to answer the following question:
`How many points are associated with 0 poles?`

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

CREATE TABLE "standings" (
  "position" real,
  "driver" text,
  "wins" real,
  "poles" real,
  "top_5_s" real,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many points are associated with 0 poles?`:
```sql
                SELECT COUNT("points") FROM "standings" WHERE "poles"<0;
```
## Task
Generate a SQL query to answer the following question:
`How many wins are associated with a position of under 6, over 8 top 5s, and 1793 points?`

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

CREATE TABLE "standings" (
  "position" real,
  "driver" text,
  "wins" real,
  "poles" real,
  "top_5_s" real,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many wins are associated with a position of under 6, over 8 top 5s, and 1793 points?`:
```sql
                SELECT SUM("wins") FROM "standings" WHERE "position"<6 AND "top_5_s"=8 AND "points"=1793;
```
## Task
Generate a SQL query to answer the following question:
`What is the first game that has a home team of Detroit?`

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

CREATE TABLE "march" (
  "game_num" real,
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "record" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the first game that has a home team of Detroit?`:
```sql
                SELECT MIN("game_num") FROM "march" WHERE "home"='detroit';
```
## Task
Generate a SQL query to answer the following question:
`Which home team has higher than 92 points?`

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

CREATE TABLE "march" (
  "game_num" real,
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "record" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which home team has higher than 92 points?`:
```sql
                SELECT "home" FROM "march" WHERE "points">92;
```
## Task
Generate a SQL query to answer the following question:
`what team's score is 101?`

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

CREATE TABLE "test_centuries_by_nightwatchmen" (
  "player" text,
  "team" text,
  "score" text,
  "versus" text,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `what team's score is 101?`:
```sql
                SELECT "team" FROM "test_centuries_by_nightwatchmen" WHERE "score"='101';
```
## Task
Generate a SQL query to answer the following question:
`what team played against zimbabwe in 1999?`

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

CREATE TABLE "test_centuries_by_nightwatchmen" (
  "player" text,
  "team" text,
  "score" text,
  "versus" text,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `what team played against zimbabwe in 1999?`:
```sql
                SELECT "team" FROM "test_centuries_by_nightwatchmen" WHERE "year"=1999 AND "versus"='zimbabwe';
```
## Task
Generate a SQL query to answer the following question:
`what is the team that played in 2006?`

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

CREATE TABLE "test_centuries_by_nightwatchmen" (
  "player" text,
  "team" text,
  "score" text,
  "versus" text,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `what is the team that played in 2006?`:
```sql
                SELECT "team" FROM "test_centuries_by_nightwatchmen" WHERE "year"=2006;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest amount of points driver Romain Grosjean, who has an average pre-2010 less than 0, has?`

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

CREATE TABLE "highest_average_points_per_race_entered" (
  "driver" text,
  "entries" real,
  "points" real,
  "average_points_per_race_entered" real,
  "average_pre_2010" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest amount of points driver Romain Grosjean, who has an average pre-2010 less than 0, has?`:
```sql
                SELECT MIN("points") FROM "highest_average_points_per_race_entered" WHERE "driver"='romain grosjean' AND "average_pre_2010"<0;
```
## Task
Generate a SQL query to answer the following question:
`What is the average number of entries driver Mark Webber, who has more than 1014.5 points, has?`

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

CREATE TABLE "highest_average_points_per_race_entered" (
  "driver" text,
  "entries" real,
  "points" real,
  "average_points_per_race_entered" real,
  "average_pre_2010" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average number of entries driver Mark Webber, who has more than 1014.5 points, has?`:
```sql
                SELECT AVG("entries") FROM "highest_average_points_per_race_entered" WHERE "driver"='mark webber' AND "points">1014.5;
```
## Task
Generate a SQL query to answer the following question:
`What is the highest average points per race of the driver with less than 969 points and an average pre-2010 less than 0?`

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

CREATE TABLE "highest_average_points_per_race_entered" (
  "driver" text,
  "entries" real,
  "points" real,
  "average_points_per_race_entered" real,
  "average_pre_2010" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest average points per race of the driver with less than 969 points and an average pre-2010 less than 0?`:
```sql
                SELECT MAX("average_points_per_race_entered") FROM "highest_average_points_per_race_entered" WHERE "points"<969 AND "average_pre_2010"<0;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest average points per race entered of driver kimi räikkönen, who has more than 194 entries?`

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

CREATE TABLE "highest_average_points_per_race_entered" (
  "driver" text,
  "entries" real,
  "points" real,
  "average_points_per_race_entered" real,
  "average_pre_2010" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest average points per race entered of driver kimi räikkönen, who has more than 194 entries?`:
```sql
                SELECT MIN("average_points_per_race_entered") FROM "highest_average_points_per_race_entered" WHERE "driver"='kimi räikkönen' AND "entries">194;
```
## Task
Generate a SQL query to answer the following question:
`What is the first game played against the Chicago Black Hawks?`

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

CREATE TABLE "schedule_and_results" (
  "game" real,
  "january" real,
  "opponent" text,
  "score" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the first game played against the Chicago Black Hawks?`:
```sql
                SELECT MIN("game") FROM "schedule_and_results" WHERE "opponent"='chicago black hawks';
```
## Task
Generate a SQL query to answer the following question:
`Name the opponent for 9 november 1991`

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

CREATE TABLE "premier_division" (
  "date" text,
  "opponent" text,
  "venue" text,
  "result" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the opponent for 9 november 1991`:
```sql
                SELECT "opponent" FROM "premier_division" WHERE "date"='9 november 1991';
```
## Task
Generate a SQL query to answer the following question:
`Which Losses is the lowest one that has Wins smaller than 0?`

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

CREATE TABLE "cfl_teams_with_one_or_no_wins_in_a_seaso" (
  "season" real,
  "team" text,
  "games" real,
  "wins" real,
  "losses" real,
  "ties" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Losses is the lowest one that has Wins smaller than 0?`:
```sql
                SELECT MIN("losses") FROM "cfl_teams_with_one_or_no_wins_in_a_seaso" WHERE "wins"<0;
```
## Task
Generate a SQL query to answer the following question:
`Which Losses have a Season larger than 1941, and a Team of hamilton wildcats, and Ties of 0?`

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

CREATE TABLE "cfl_teams_with_one_or_no_wins_in_a_seaso" (
  "season" real,
  "team" text,
  "games" real,
  "wins" real,
  "losses" real,
  "ties" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Losses have a Season larger than 1941, and a Team of hamilton wildcats, and Ties of 0?`:
```sql
                SELECT "losses" FROM "cfl_teams_with_one_or_no_wins_in_a_seaso" WHERE "season">1941 AND "team"='hamilton wildcats' AND "ties"=0;
```
## Task
Generate a SQL query to answer the following question:
`Which Season has Ties smaller than 1, and a Team of vancouver grizzlies, and Wins smaller than 1?`

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

CREATE TABLE "cfl_teams_with_one_or_no_wins_in_a_seaso" (
  "season" real,
  "team" text,
  "games" real,
  "wins" real,
  "losses" real,
  "ties" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Season has Ties smaller than 1, and a Team of vancouver grizzlies, and Wins smaller than 1?`:
```sql
                SELECT SUM("season") FROM "cfl_teams_with_one_or_no_wins_in_a_seaso" WHERE "ties"<1 AND "team"='vancouver grizzlies' AND "wins"<1;
```
## Task
Generate a SQL query to answer the following question:
`How many Ties have Wins smaller than 1, and Games of 6, and Losses of 6, and a Season larger than 1941?`

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

CREATE TABLE "cfl_teams_with_one_or_no_wins_in_a_seaso" (
  "season" real,
  "team" text,
  "games" real,
  "wins" real,
  "losses" real,
  "ties" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many Ties have Wins smaller than 1, and Games of 6, and Losses of 6, and a Season larger than 1941?`:
```sql
                SELECT COUNT("ties") FROM "cfl_teams_with_one_or_no_wins_in_a_seaso" WHERE "wins"<1 AND "games"=6 AND "losses"=6 AND "season">1941;
```
## Task
Generate a SQL query to answer the following question:
`Which Wins have a Team of winnipeg blue bombers, and a Season larger than 1964?`

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

CREATE TABLE "cfl_teams_with_one_or_no_wins_in_a_seaso" (
  "season" real,
  "team" text,
  "games" real,
  "wins" real,
  "losses" real,
  "ties" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Wins have a Team of winnipeg blue bombers, and a Season larger than 1964?`:
```sql
                SELECT AVG("wins") FROM "cfl_teams_with_one_or_no_wins_in_a_seaso" WHERE "team"='winnipeg blue bombers' AND "season">1964;
```
## Task
Generate a SQL query to answer the following question:
`What engine class is associated with a year after 1985 and over 0 wins?`

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

CREATE TABLE "motorcycle_grand_prix_results" (
  "year" real,
  "class" text,
  "team" text,
  "points" real,
  "wins" real
);
### SQL
Given the database schema, here is the SQL query that answers `What engine class is associated with a year after 1985 and over 0 wins?`:
```sql
                SELECT "class" FROM "motorcycle_grand_prix_results" WHERE "year">1985 AND "wins">0;
```
## Task
Generate a SQL query to answer the following question:
`Which opponent has a loss of trout (7-4)?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "save" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which opponent has a loss of trout (7-4)?`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "loss"='trout (7-4)';
```
## Task
Generate a SQL query to answer the following question:
`Which opponent has a save of smith (22)?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "save" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which opponent has a save of smith (22)?`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "save"='smith (22)';
```
## Task
Generate a SQL query to answer the following question:
`How much Gold has a Bronze larger than 1, and a Silver larger than 2?`

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

CREATE TABLE "medal_table" (
  "rank" text,
  "nation" text,
  "gold" real,
  "silver" real,
  "bronze" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How much Gold has a Bronze larger than 1, and a Silver larger than 2?`:
```sql
                SELECT COUNT("gold") FROM "medal_table" WHERE "bronze">1 AND "silver">2;
```
## Task
Generate a SQL query to answer the following question:
`Which Total has a Nation of japan (jpn), and a Silver smaller than 1?`

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

CREATE TABLE "medal_table" (
  "rank" text,
  "nation" text,
  "gold" real,
  "silver" real,
  "bronze" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Total has a Nation of japan (jpn), and a Silver smaller than 1?`:
```sql
                SELECT AVG("total") FROM "medal_table" WHERE "nation"='japan (jpn)' AND "silver"<1;
```
## Task
Generate a SQL query to answer the following question:
`What is the margin of victory in WGC-Accenture Match Play Championship?`

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

CREATE TABLE "pga_tour_wins_13" (
  "date" text,
  "tournament" text,
  "winning_score" text,
  "margin_of_victory" text,
  "runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the margin of victory in WGC-Accenture Match Play Championship?`:
```sql
                SELECT "margin_of_victory" FROM "pga_tour_wins_13" WHERE "tournament"='wgc-accenture match play championship';
```
## Task
Generate a SQL query to answer the following question:
`On what date was Nick Price the runner-up?`

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

CREATE TABLE "pga_tour_wins_13" (
  "date" text,
  "tournament" text,
  "winning_score" text,
  "margin_of_victory" text,
  "runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date was Nick Price the runner-up?`:
```sql
                SELECT "date" FROM "pga_tour_wins_13" WHERE "runner_s_up"='nick price';
```
## Task
Generate a SQL query to answer the following question:
`What is the margin of victory for Nick Price as a runner-up?`

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

CREATE TABLE "pga_tour_wins_13" (
  "date" text,
  "tournament" text,
  "winning_score" text,
  "margin_of_victory" text,
  "runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the margin of victory for Nick Price as a runner-up?`:
```sql
                SELECT "margin_of_victory" FROM "pga_tour_wins_13" WHERE "runner_s_up"='nick price';
```
## Task
Generate a SQL query to answer the following question:
`What is the margin of victory for PGA Championship?`

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

CREATE TABLE "pga_tour_wins_13" (
  "date" text,
  "tournament" text,
  "winning_score" text,
  "margin_of_victory" text,
  "runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the margin of victory for PGA Championship?`:
```sql
                SELECT "margin_of_victory" FROM "pga_tour_wins_13" WHERE "tournament"='pga championship';
```
## Task
Generate a SQL query to answer the following question:
`On what date was the winning score –20 (68-67-65-64=264)?`

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

CREATE TABLE "pga_tour_wins_13" (
  "date" text,
  "tournament" text,
  "winning_score" text,
  "margin_of_victory" text,
  "runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date was the winning score –20 (68-67-65-64=264)?`:
```sql
                SELECT "date" FROM "pga_tour_wins_13" WHERE "winning_score"='–20 (68-67-65-64=264)';
```
## Task
Generate a SQL query to answer the following question:
`Which player was D past Round 3?`

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

CREATE TABLE "draft_picks" (
  "round" real,
  "player" text,
  "position" text,
  "nationality" text,
  "college_junior_club_team_league" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which player was D past Round 3?`:
```sql
                SELECT "player" FROM "draft_picks" WHERE "position"='d' AND "round">3;
```
## Task
Generate a SQL query to answer the following question:
`Which Round was F picked?`

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

CREATE TABLE "draft_picks" (
  "round" real,
  "player" text,
  "position" text,
  "nationality" text,
  "college_junior_club_team_league" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Round was F picked?`:
```sql
                SELECT "round" FROM "draft_picks" WHERE "position"='f';
```
## Task
Generate a SQL query to answer the following question:
`What Position is Ryan Russell?`

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

CREATE TABLE "draft_picks" (
  "round" real,
  "player" text,
  "position" text,
  "nationality" text,
  "college_junior_club_team_league" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Position is Ryan Russell?`:
```sql
                SELECT "position" FROM "draft_picks" WHERE "player"='ryan russell';
```
## Task
Generate a SQL query to answer the following question:
`What country does Round 4 come from?`

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

CREATE TABLE "draft_picks" (
  "round" real,
  "player" text,
  "position" text,
  "nationality" text,
  "college_junior_club_team_league" text
);
### SQL
Given the database schema, here is the SQL query that answers `What country does Round 4 come from?`:
```sql
                SELECT "nationality" FROM "draft_picks" WHERE "round"=4;
```
## Task
Generate a SQL query to answer the following question:
`Which opponent was present on April 14?`

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

CREATE TABLE "playoffs" (
  "game" real,
  "date" text,
  "opponent" text,
  "score" text,
  "series" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which opponent was present on April 14?`:
```sql
                SELECT "opponent" FROM "playoffs" WHERE "date"='april 14';
```
## Task
Generate a SQL query to answer the following question:
`what team lost on april 15`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "save" text
);
### SQL
Given the database schema, here is the SQL query that answers `what team lost on april 15`:
```sql
                SELECT "loss" FROM "game_log" WHERE "date"='april 15';
```