cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`Role of narrator, and a Year larger than 2009, and a Release/Air Date of 7 october 2010 belongs to what author?`

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

CREATE TABLE "radio_and_cd_audio_drama" (
  "year" real,
  "role" text,
  "author" text,
  "radio_station_production_company" text,
  "release_air_date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Role of narrator, and a Year larger than 2009, and a Release/Air Date of 7 october 2010 belongs to what author?`:
```sql
                SELECT "author" FROM "radio_and_cd_audio_drama" WHERE "role"='narrator' AND "year">2009 AND "release_air_date"='7 october 2010';
```
## Task
Generate a SQL query to answer the following question:
`Role of narrator, and a Radio Station/Production Company of bbc audiobooks, and a Release/Air Date of 13 november 2008 is what sum of the year?`

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

CREATE TABLE "radio_and_cd_audio_drama" (
  "year" real,
  "role" text,
  "author" text,
  "radio_station_production_company" text,
  "release_air_date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Role of narrator, and a Radio Station/Production Company of bbc audiobooks, and a Release/Air Date of 13 november 2008 is what sum of the year?`:
```sql
                SELECT SUM("year") FROM "radio_and_cd_audio_drama" WHERE "role"='narrator' AND "radio_station_production_company"='bbc audiobooks' AND "release_air_date"='13 november 2008';
```
## Task
Generate a SQL query to answer the following question:
`Radio Station/Production Company that has a Role of interviewee & monologues is what radio station?`

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

CREATE TABLE "radio_and_cd_audio_drama" (
  "year" real,
  "role" text,
  "author" text,
  "radio_station_production_company" text,
  "release_air_date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Radio Station/Production Company that has a Role of interviewee & monologues is what radio station?`:
```sql
                SELECT "radio_station_production_company" FROM "radio_and_cd_audio_drama" WHERE "role"='interviewee & monologues';
```
## Task
Generate a SQL query to answer the following question:
`What was the position of the Racing Organisation Course team?`

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

CREATE TABLE "24_hours_of_le_mans_results" (
  "year" real,
  "team" text,
  "co_drivers" text,
  "class" text,
  "laps" real,
  "pos" text,
  "class_pos" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the position of the Racing Organisation Course team?`:
```sql
                SELECT "pos" FROM "24_hours_of_le_mans_results" WHERE "team"='racing organisation course';
```
## Task
Generate a SQL query to answer the following question:
`Who were the co-drivers for the Racing Organisation Course team in years before 2011, who had a position of DNF?`

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

CREATE TABLE "24_hours_of_le_mans_results" (
  "year" real,
  "team" text,
  "co_drivers" text,
  "class" text,
  "laps" real,
  "pos" text,
  "class_pos" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who were the co-drivers for the Racing Organisation Course team in years before 2011, who had a position of DNF?`:
```sql
                SELECT "co_drivers" FROM "24_hours_of_le_mans_results" WHERE "pos"='dnf' AND "year"<2011 AND "team"='racing organisation course';
```
## Task
Generate a SQL query to answer the following question:
`Who were the co-drivers in years after 2010?`

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

CREATE TABLE "24_hours_of_le_mans_results" (
  "year" real,
  "team" text,
  "co_drivers" text,
  "class" text,
  "laps" real,
  "pos" text,
  "class_pos" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who were the co-drivers in years after 2010?`:
```sql
                SELECT "co_drivers" FROM "24_hours_of_le_mans_results" WHERE "year">2010;
```
## Task
Generate a SQL query to answer the following question:
`What is the date made that has an associated fleet number of 4?`

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

CREATE TABLE "londonderry_and_lough_swilly_railway" (
  "type" text,
  "fleet_numbers" text,
  "quantity_made" real,
  "manufacturer" text,
  "date_made" text,
  "date_withdrawn" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the date made that has an associated fleet number of 4?`:
```sql
                SELECT "date_made" FROM "londonderry_and_lough_swilly_railway" WHERE "fleet_numbers"='4';
```
## Task
Generate a SQL query to answer the following question:
`What is the withdrawal date associated with a date made of 1904?`

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

CREATE TABLE "londonderry_and_lough_swilly_railway" (
  "type" text,
  "fleet_numbers" text,
  "quantity_made" real,
  "manufacturer" text,
  "date_made" text,
  "date_withdrawn" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the withdrawal date associated with a date made of 1904?`:
```sql
                SELECT "date_withdrawn" FROM "londonderry_and_lough_swilly_railway" WHERE "date_made"='1904';
```
## Task
Generate a SQL query to answer the following question:
`Name the game site with result of l 7-38`

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

CREATE TABLE "schedule" (
  "week" real,
  "date" text,
  "opponent" text,
  "result" text,
  "game_site" text,
  "record" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the game site with result of l 7-38`:
```sql
                SELECT "game_site" FROM "schedule" WHERE "result"='l 7-38';
```
## Task
Generate a SQL query to answer the following question:
`Name the result for arrowhead stadium`

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

CREATE TABLE "schedule" (
  "week" real,
  "date" text,
  "opponent" text,
  "result" text,
  "game_site" text,
  "record" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the result for arrowhead stadium`:
```sql
                SELECT "result" FROM "schedule" WHERE "game_site"='arrowhead stadium';
```
## Task
Generate a SQL query to answer the following question:
`Name the least attendance for opponent of new orleans saints and week more than 2`

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

CREATE TABLE "schedule" (
  "week" real,
  "date" text,
  "opponent" text,
  "result" text,
  "game_site" text,
  "record" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the least attendance for opponent of new orleans saints and week more than 2`:
```sql
                SELECT MIN("attendance") FROM "schedule" WHERE "week">2 AND "opponent"='new orleans saints';
```
## Task
Generate a SQL query to answer the following question:
`What amount of earnings corresponds with a Top 10s rank of 23?`

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

CREATE TABLE "pga_tour_career_summary" (
  "year" text,
  "tournaments_played" real,
  "cuts_made" real,
  "wins" real,
  "top_10s" real,
  "best_finish" text,
  "earnings" text,
  "money_list_rank" text
);
### SQL
Given the database schema, here is the SQL query that answers `What amount of earnings corresponds with a Top 10s rank of 23?`:
```sql
                SELECT "earnings" FROM "pga_tour_career_summary" WHERE "top_10s"=23;
```
## Task
Generate a SQL query to answer the following question:
`What 2012 amount of earnings corresponds with less than 28 tournaments played?`

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

CREATE TABLE "pga_tour_career_summary" (
  "year" text,
  "tournaments_played" real,
  "cuts_made" real,
  "wins" real,
  "top_10s" real,
  "best_finish" text,
  "earnings" text,
  "money_list_rank" text
);
### SQL
Given the database schema, here is the SQL query that answers `What 2012 amount of earnings corresponds with less than 28 tournaments played?`:
```sql
                SELECT "earnings" FROM "pga_tour_career_summary" WHERE "tournaments_played"<28 AND "year"='2012';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the year with Laps less than 197 and start of 2`

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

CREATE TABLE "indy_500_results" (
  "year" text,
  "start" text,
  "qual" text,
  "rank" text,
  "finish" text,
  "laps" real
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the year with Laps less than 197 and start of 2`:
```sql
                SELECT "year" FROM "indy_500_results" WHERE "laps"<197 AND "start"='2';
```
## Task
Generate a SQL query to answer the following question:
`Name the qual with start of totals`

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

CREATE TABLE "indy_500_results" (
  "year" text,
  "start" text,
  "qual" text,
  "rank" text,
  "finish" text,
  "laps" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the qual with start of totals`:
```sql
                SELECT "qual" FROM "indy_500_results" WHERE "start"='totals';
```
## Task
Generate a SQL query to answer the following question:
`Name the total number of laps with rank of 8`

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

CREATE TABLE "indy_500_results" (
  "year" text,
  "start" text,
  "qual" text,
  "rank" text,
  "finish" text,
  "laps" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the total number of laps with rank of 8`:
```sql
                SELECT COUNT("laps") FROM "indy_500_results" WHERE "rank"='8';
```
## Task
Generate a SQL query to answer the following question:
`Name the start with Laps of 199 with qual of 224.838`

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

CREATE TABLE "indy_500_results" (
  "year" text,
  "start" text,
  "qual" text,
  "rank" text,
  "finish" text,
  "laps" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the start with Laps of 199 with qual of 224.838`:
```sql
                SELECT "start" FROM "indy_500_results" WHERE "laps"=199 AND "qual"='224.838';
```
## Task
Generate a SQL query to answer the following question:
`On what date was the score 1-2 at Athens Olympic Stadium?`

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

CREATE TABLE "national_team" (
  "date" text,
  "venue" text,
  "score" text,
  "competition" text,
  "match_report" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date was the score 1-2 at Athens Olympic Stadium?`:
```sql
                SELECT "date" FROM "national_team" WHERE "score"='1-2' AND "venue"='athens olympic stadium';
```
## Task
Generate a SQL query to answer the following question:
`What was the Match Report for the Euro2008q at the Athens Olympic Stadium on November 17, 2007?`

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

CREATE TABLE "national_team" (
  "date" text,
  "venue" text,
  "score" text,
  "competition" text,
  "match_report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the Match Report for the Euro2008q at the Athens Olympic Stadium on November 17, 2007?`:
```sql
                SELECT "match_report" FROM "national_team" WHERE "competition"='euro2008q' AND "venue"='athens olympic stadium' AND "date"='november 17, 2007';
```
## Task
Generate a SQL query to answer the following question:
`What was the Match Report for the Euro2008q at the Athens Olympic Stadium and a score of 1-2?`

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

CREATE TABLE "national_team" (
  "date" text,
  "venue" text,
  "score" text,
  "competition" text,
  "match_report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the Match Report for the Euro2008q at the Athens Olympic Stadium and a score of 1-2?`:
```sql
                SELECT "match_report" FROM "national_team" WHERE "competition"='euro2008q' AND "venue"='athens olympic stadium' AND "score"='1-2';
```
## Task
Generate a SQL query to answer the following question:
`On what date was the score 2-1?`

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

CREATE TABLE "national_team" (
  "date" text,
  "venue" text,
  "score" text,
  "competition" text,
  "match_report" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date was the score 2-1?`:
```sql
                SELECT "date" FROM "national_team" WHERE "score"='2-1';
```
## Task
Generate a SQL query to answer the following question:
`On what date was the Competition of Friendly held?`

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

CREATE TABLE "national_team" (
  "date" text,
  "venue" text,
  "score" text,
  "competition" text,
  "match_report" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date was the Competition of Friendly held?`:
```sql
                SELECT "date" FROM "national_team" WHERE "competition"='friendly';
```
## Task
Generate a SQL query to answer the following question:
`What was the score at Pankritio Stadium on June 6, 2007?`

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

CREATE TABLE "national_team" (
  "date" text,
  "venue" text,
  "score" text,
  "competition" text,
  "match_report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score at Pankritio Stadium on June 6, 2007?`:
```sql
                SELECT "score" FROM "national_team" WHERE "venue"='pankritio stadium' AND "date"='june 6, 2007';
```
## Task
Generate a SQL query to answer the following question:
`On what date was there a draw at Sydney Cricket Ground?`

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

CREATE TABLE "west_indies_in_australia" (
  "date" text,
  "home_captain" text,
  "away_captain" text,
  "venue" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date was there a draw at Sydney Cricket Ground?`:
```sql
                SELECT "date" FROM "west_indies_in_australia" WHERE "result"='draw' AND "venue"='sydney cricket ground';
```
## Task
Generate a SQL query to answer the following question:
`In what venue was the result a draw?`

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

CREATE TABLE "west_indies_in_australia" (
  "date" text,
  "home_captain" text,
  "away_captain" text,
  "venue" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `In what venue was the result a draw?`:
```sql
                SELECT "venue" FROM "west_indies_in_australia" WHERE "result"='draw';
```
## Task
Generate a SQL query to answer the following question:
`On what date was the result Wi by 1 run?`

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

CREATE TABLE "west_indies_in_australia" (
  "date" text,
  "home_captain" text,
  "away_captain" text,
  "venue" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date was the result Wi by 1 run?`:
```sql
                SELECT "date" FROM "west_indies_in_australia" WHERE "result"='wi by 1 run';
```
## Task
Generate a SQL query to answer the following question:
`What venue had a draw?`

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

CREATE TABLE "west_indies_in_australia" (
  "date" text,
  "home_captain" text,
  "away_captain" text,
  "venue" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What venue had a draw?`:
```sql
                SELECT "venue" FROM "west_indies_in_australia" WHERE "result"='draw';
```
## Task
Generate a SQL query to answer the following question:
`What is the total number of points for entrants with a Jordan 192 chassis?`

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

CREATE TABLE "complete_formula_one_results" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "pts" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of points for entrants with a Jordan 192 chassis?`:
```sql
                SELECT SUM("pts") FROM "complete_formula_one_results" WHERE "chassis"='jordan 192';
```
## Task
Generate a SQL query to answer the following question:
`Which entrant had a chassis of March CG891?`

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

CREATE TABLE "complete_formula_one_results" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "pts" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which entrant had a chassis of March CG891?`:
```sql
                SELECT "entrant" FROM "complete_formula_one_results" WHERE "chassis"='march cg891';
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest number of points for an entrant with a Jordan 192 chassis?`

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

CREATE TABLE "complete_formula_one_results" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "pts" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest number of points for an entrant with a Jordan 192 chassis?`:
```sql
                SELECT MIN("pts") FROM "complete_formula_one_results" WHERE "chassis"='jordan 192';
```
## Task
Generate a SQL query to answer the following question:
`What Opponent has the Attendance of 14,029?`

### 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,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Opponent has the Attendance of 14,029?`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "attendance"='14,029';
```
## Task
Generate a SQL query to answer the following question:
`Can you tell me the Attendance that has the Date of april 12?`

### 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,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Can you tell me the Attendance that has the Date of april 12?`:
```sql
                SELECT "attendance" FROM "game_log" WHERE "date"='april 12';
```
## Task
Generate a SQL query to answer the following question:
`Can you tell me the Score that has the Opponent of brewers, and the Attendance of 11,235?`

### 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,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Can you tell me the Score that has the Opponent of brewers, and the Attendance of 11,235?`:
```sql
                SELECT "score" FROM "game_log" WHERE "opponent"='brewers' AND "attendance"='11,235';
```
## Task
Generate a SQL query to answer the following question:
`Can you tell me the Score that has the Attendance of 4,567?`

### 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,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Can you tell me the Score that has the Attendance of 4,567?`:
```sql
                SELECT "score" FROM "game_log" WHERE "attendance"='4,567';
```
## Task
Generate a SQL query to answer the following question:
`What is the date with the distance of km (mi) at the course of roccaraso to san giorgio del sannio?`

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

CREATE TABLE "stage_results" (
  "date" text,
  "course" text,
  "distance" text,
  "type" text,
  "winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the date with the distance of km (mi) at the course of roccaraso to san giorgio del sannio?`:
```sql
                SELECT "date" FROM "stage_results" WHERE "distance"='km (mi)' AND "course"='roccaraso to san giorgio del sannio';
```
## Task
Generate a SQL query to answer the following question:
`Name the engine with entrant of larrousse f1`

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

CREATE TABLE "complete_formula_one_results" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the engine with entrant of larrousse f1`:
```sql
                SELECT "engine" FROM "complete_formula_one_results" WHERE "entrant"='larrousse f1';
```
## Task
Generate a SQL query to answer the following question:
`Name the average yeara for engine of renault v10 with points more than 4`

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

CREATE TABLE "complete_formula_one_results" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the average yeara for engine of renault v10 with points more than 4`:
```sql
                SELECT AVG("year") FROM "complete_formula_one_results" WHERE "engine"='renault v10' AND "points">4;
```
## Task
Generate a SQL query to answer the following question:
`Name the sumof points for year less than 1994 and chassis of lola lc89b`

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

CREATE TABLE "complete_formula_one_results" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the sumof points for year less than 1994 and chassis of lola lc89b`:
```sql
                SELECT SUM("points") FROM "complete_formula_one_results" WHERE "year"<1994 AND "chassis"='lola lc89b';
```
## Task
Generate a SQL query to answer the following question:
`Name the entrant for year more than 1991 and chassis of lotus 109`

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

CREATE TABLE "complete_formula_one_results" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the entrant for year more than 1991 and chassis of lotus 109`:
```sql
                SELECT "entrant" FROM "complete_formula_one_results" WHERE "year">1991 AND "chassis"='lotus 109';
```
## Task
Generate a SQL query to answer the following question:
`Name the sum of points for 1991`

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

CREATE TABLE "complete_formula_one_results" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the sum of points for 1991`:
```sql
                SELECT SUM("points") FROM "complete_formula_one_results" WHERE "year"=1991;
```
## Task
Generate a SQL query to answer the following question:
`Which type has turin to monza as a course?`

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

CREATE TABLE "stage_results" (
  "date" text,
  "course" text,
  "distance" text,
  "type" text,
  "winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which type has turin to monza as a course?`:
```sql
                SELECT "type" FROM "stage_results" WHERE "course"='turin to monza';
```
## Task
Generate a SQL query to answer the following question:
`Which course has km (mi) as a type?`

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

CREATE TABLE "stage_results" (
  "date" text,
  "course" text,
  "distance" text,
  "type" text,
  "winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which course has km (mi) as a type?`:
```sql
                SELECT "course" FROM "stage_results" WHERE "type"='km (mi)';
```
## Task
Generate a SQL query to answer the following question:
`What winner has the sanremo to cuneo as the course?`

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

CREATE TABLE "stage_results" (
  "date" text,
  "course" text,
  "distance" text,
  "type" text,
  "winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `What winner has the sanremo to cuneo as the course?`:
```sql
                SELECT "winner" FROM "stage_results" WHERE "course"='sanremo to cuneo';
```
## Task
Generate a SQL query to answer the following question:
`Name the distance for stage of 2`

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

CREATE TABLE "schedule" (
  "stage" text,
  "route" text,
  "distance" text,
  "date" text,
  "winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the distance for stage of 2`:
```sql
                SELECT "distance" FROM "schedule" WHERE "stage"='2';
```
## Task
Generate a SQL query to answer the following question:
`Name the route with winner of sébastien rosseler`

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

CREATE TABLE "schedule" (
  "stage" text,
  "route" text,
  "distance" text,
  "date" text,
  "winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the route with winner of sébastien rosseler`:
```sql
                SELECT "route" FROM "schedule" WHERE "winner"='sébastien rosseler';
```
## Task
Generate a SQL query to answer the following question:
`Name the route for 170.8km distance`

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

CREATE TABLE "schedule" (
  "stage" text,
  "route" text,
  "distance" text,
  "date" text,
  "winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the route for 170.8km distance`:
```sql
                SELECT "route" FROM "schedule" WHERE "distance"='170.8km';
```
## Task
Generate a SQL query to answer the following question:
`Name the date for luciano pagliarini`

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

CREATE TABLE "schedule" (
  "stage" text,
  "route" text,
  "distance" text,
  "date" text,
  "winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the date for luciano pagliarini`:
```sql
                SELECT "date" FROM "schedule" WHERE "winner"='luciano pagliarini';
```
## Task
Generate a SQL query to answer the following question:
`Name the date for mark cavendish`

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

CREATE TABLE "schedule" (
  "stage" text,
  "route" text,
  "distance" text,
  "date" text,
  "winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the date for mark cavendish`:
```sql
                SELECT "date" FROM "schedule" WHERE "winner"='mark cavendish';
```
## Task
Generate a SQL query to answer the following question:
`Name the laps for qual of 144.665`

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

CREATE TABLE "indy_500_results" (
  "year" text,
  "start" text,
  "qual" text,
  "rank" text,
  "finish" text,
  "laps" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the laps for qual of 144.665`:
```sql
                SELECT SUM("laps") FROM "indy_500_results" WHERE "qual"='144.665';
```
## Task
Generate a SQL query to answer the following question:
`Name the total number of Laps for year of 1961`

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

CREATE TABLE "indy_500_results" (
  "year" text,
  "start" text,
  "qual" text,
  "rank" text,
  "finish" text,
  "laps" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the total number of Laps for year of 1961`:
```sql
                SELECT COUNT("laps") FROM "indy_500_results" WHERE "year"='1961';
```
## Task
Generate a SQL query to answer the following question:
`Name the finish for start of 28`

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

CREATE TABLE "indy_500_results" (
  "year" text,
  "start" text,
  "qual" text,
  "rank" text,
  "finish" text,
  "laps" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the finish for start of 28`:
```sql
                SELECT "finish" FROM "indy_500_results" WHERE "start"='28';
```
## Task
Generate a SQL query to answer the following question:
`Name the laps for rank of 14 and start of 16`

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

CREATE TABLE "indy_500_results" (
  "year" text,
  "start" text,
  "qual" text,
  "rank" text,
  "finish" text,
  "laps" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the laps for rank of 14 and start of 16`:
```sql
                SELECT "laps" FROM "indy_500_results" WHERE "rank"='14' AND "start"='16';
```
## Task
Generate a SQL query to answer the following question:
`Name the qual for year of 1960`

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

CREATE TABLE "indy_500_results" (
  "year" text,
  "start" text,
  "qual" text,
  "rank" text,
  "finish" text,
  "laps" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the qual for year of 1960`:
```sql
                SELECT "qual" FROM "indy_500_results" WHERE "year"='1960';
```
## Task
Generate a SQL query to answer the following question:
`What is the name of the player in position lb and an overall of 128?`

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

CREATE TABLE "1980_raiders_draft_selections" (
  "round" real,
  "overall" real,
  "player" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the name of the player in position lb and an overall of 128?`:
```sql
                SELECT "player" FROM "1980_raiders_draft_selections" WHERE "position"='lb' AND "overall"=128;
```
## Task
Generate a SQL query to answer the following question:
`What is the total overall when Kenny Lewis is the player in a round after 5?`

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

CREATE TABLE "1980_raiders_draft_selections" (
  "round" real,
  "overall" real,
  "player" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total overall when Kenny Lewis is the player in a round after 5?`:
```sql
                SELECT COUNT("overall") FROM "1980_raiders_draft_selections" WHERE "player"='kenny lewis' AND "round">5;
```
## Task
Generate a SQL query to answer the following question:
`What is the college when the over is larger than 15 in round 7?`

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

CREATE TABLE "1980_raiders_draft_selections" (
  "round" real,
  "overall" real,
  "player" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the college when the over is larger than 15 in round 7?`:
```sql
                SELECT "college" FROM "1980_raiders_draft_selections" WHERE "overall">15 AND "round"=7;
```
## Task
Generate a SQL query to answer the following question:
`What is the position with an overall less than 128 for Brigham Young college?`

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

CREATE TABLE "1980_raiders_draft_selections" (
  "round" real,
  "overall" real,
  "player" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the position with an overall less than 128 for Brigham Young college?`:
```sql
                SELECT "position" FROM "1980_raiders_draft_selections" WHERE "overall"<128 AND "college"='brigham young';
```
## Task
Generate a SQL query to answer the following question:
`How many attended the game on 4 February 2003?`

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

CREATE TABLE "premier_league" (
  "date" text,
  "opponents" text,
  "result_f_a" text,
  "attendance" real,
  "league_position" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many attended the game on 4 February 2003?`:
```sql
                SELECT AVG("attendance") FROM "premier_league" WHERE "date"='4 february 2003';
```
## Task
Generate a SQL query to answer the following question:
`yes or no for the auckland with a yes for sydney, no for perth, yes for melbourne and yes for the gold coast?`

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

CREATE TABLE "1997" (
  "sydney" text,
  "melbourne" text,
  "perth" text,
  "adelaide" text,
  "gold_coast" text,
  "auckland" text
);
### SQL
Given the database schema, here is the SQL query that answers `yes or no for the auckland with a yes for sydney, no for perth, yes for melbourne and yes for the gold coast?`:
```sql
                SELECT "auckland" FROM "1997" WHERE "sydney"='yes' AND "perth"='no' AND "melbourne"='yes' AND "gold_coast"='yes';
```
## Task
Generate a SQL query to answer the following question:
`yes or no for the adelaide with no for auckland, yes for melbourne, yes for the gold coast?`

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

CREATE TABLE "1997" (
  "sydney" text,
  "melbourne" text,
  "perth" text,
  "adelaide" text,
  "gold_coast" text,
  "auckland" text
);
### SQL
Given the database schema, here is the SQL query that answers `yes or no for the adelaide with no for auckland, yes for melbourne, yes for the gold coast?`:
```sql
                SELECT "adelaide" FROM "1997" WHERE "auckland"='no' AND "melbourne"='yes' AND "gold_coast"='yes';
```
## Task
Generate a SQL query to answer the following question:
`yes or no for the gold coast with yes for melbourne, yes for adelaide, yes for auckland?`

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

CREATE TABLE "1997" (
  "sydney" text,
  "melbourne" text,
  "perth" text,
  "adelaide" text,
  "gold_coast" text,
  "auckland" text
);
### SQL
Given the database schema, here is the SQL query that answers `yes or no for the gold coast with yes for melbourne, yes for adelaide, yes for auckland?`:
```sql
                SELECT "gold_coast" FROM "1997" WHERE "melbourne"='yes' AND "adelaide"='yes' AND "auckland"='yes';
```
## Task
Generate a SQL query to answer the following question:
`yes or no for the melbourne with yes for gold coast, yes for adelaide, no for auckland?`

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

CREATE TABLE "1997" (
  "sydney" text,
  "melbourne" text,
  "perth" text,
  "adelaide" text,
  "gold_coast" text,
  "auckland" text
);
### SQL
Given the database schema, here is the SQL query that answers `yes or no for the melbourne with yes for gold coast, yes for adelaide, no for auckland?`:
```sql
                SELECT "melbourne" FROM "1997" WHERE "gold_coast"='yes' AND "adelaide"='no' AND "auckland"='no';
```
## Task
Generate a SQL query to answer the following question:
`yes or no for the sydney with yes for melbourne, no for perth, no for auckland and no for gold coast?`

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

CREATE TABLE "1997" (
  "sydney" text,
  "melbourne" text,
  "perth" text,
  "adelaide" text,
  "gold_coast" text,
  "auckland" text
);
### SQL
Given the database schema, here is the SQL query that answers `yes or no for the sydney with yes for melbourne, no for perth, no for auckland and no for gold coast?`:
```sql
                SELECT "sydney" FROM "1997" WHERE "melbourne"='yes' AND "perth"='no' AND "auckland"='no' AND "gold_coast"='no';
```
## Task
Generate a SQL query to answer the following question:
`yes or no for the melbourne that has no for adelaide, no for gold coast?`

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

CREATE TABLE "1997" (
  "sydney" text,
  "melbourne" text,
  "perth" text,
  "adelaide" text,
  "gold_coast" text,
  "auckland" text
);
### SQL
Given the database schema, here is the SQL query that answers `yes or no for the melbourne that has no for adelaide, no for gold coast?`:
```sql
                SELECT "melbourne" FROM "1997" WHERE "adelaide"='yes' AND "gold_coast"='no';
```
## Task
Generate a SQL query to answer the following question:
`How many losses did the team with 0 wins and more than 72 runs allowed have?`

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

CREATE TABLE "pool_a" (
  "rank" real,
  "team" text,
  "wins" real,
  "losses" real,
  "runs_allowed" real,
  "run_ratio" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many losses did the team with 0 wins and more than 72 runs allowed have?`:
```sql
                SELECT SUM("losses") FROM "pool_a" WHERE "wins"=0 AND "runs_allowed">72;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest amount of losses the United States, ranked higher than 3 with more than 6 wins, have?`

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

CREATE TABLE "pool_a" (
  "rank" real,
  "team" text,
  "wins" real,
  "losses" real,
  "runs_allowed" real,
  "run_ratio" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest amount of losses the United States, ranked higher than 3 with more than 6 wins, have?`:
```sql
                SELECT MIN("losses") FROM "pool_a" WHERE "rank"<3 AND "team"='united states' AND "wins">6;
```
## Task
Generate a SQL query to answer the following question:
`How many runs allowed did the team ranked 2 with more than 2 losses have?`

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

CREATE TABLE "pool_a" (
  "rank" real,
  "team" text,
  "wins" real,
  "losses" real,
  "runs_allowed" real,
  "run_ratio" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many runs allowed did the team ranked 2 with more than 2 losses have?`:
```sql
                SELECT AVG("runs_allowed") FROM "pool_a" WHERE "rank"=2 AND "losses">2;
```
## Task
Generate a SQL query to answer the following question:
`How many total wins did the team ranked lower than 1 with a run ratio less than 5.85 and more than 4 losses have?`

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

CREATE TABLE "pool_a" (
  "rank" real,
  "team" text,
  "wins" real,
  "losses" real,
  "runs_allowed" real,
  "run_ratio" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many total wins did the team ranked lower than 1 with a run ratio less than 5.85 and more than 4 losses have?`:
```sql
                SELECT COUNT("wins") FROM "pool_a" WHERE "rank">1 AND "run_ratio"<5.85 AND "losses">4;
```
## Task
Generate a SQL query to answer the following question:
`What is the highest run ratio Japan, which has less than 58 runs and 5 wins, have?`

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

CREATE TABLE "pool_a" (
  "rank" real,
  "team" text,
  "wins" real,
  "losses" real,
  "runs_allowed" real,
  "run_ratio" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest run ratio Japan, which has less than 58 runs and 5 wins, have?`:
```sql
                SELECT MAX("run_ratio") FROM "pool_a" WHERE "runs_allowed"<58 AND "wins"=5 AND "team"='japan';
```
## Task
Generate a SQL query to answer the following question:
`What is the average number of losses the team with less than 25 runs allowed and 5 wins have?`

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

CREATE TABLE "pool_a" (
  "rank" real,
  "team" text,
  "wins" real,
  "losses" real,
  "runs_allowed" real,
  "run_ratio" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average number of losses the team with less than 25 runs allowed and 5 wins have?`:
```sql
                SELECT AVG("losses") FROM "pool_a" WHERE "runs_allowed"<25 AND "wins"=5;
```
## Task
Generate a SQL query to answer the following question:
`Which date has tigers as the opponent?`

### 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,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which date has tigers as the opponent?`:
```sql
                SELECT "date" FROM "game_log" WHERE "opponent"='tigers';
```
## Task
Generate a SQL query to answer the following question:
`What loss has october 1 as the date?`

### 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,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What loss has october 1 as the date?`:
```sql
                SELECT "loss" FROM "game_log" WHERE "date"='october 1';
```
## Task
Generate a SQL query to answer the following question:
`What year is listed that has points greater than 0 with a chassis labeled AGS JH22?`

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

CREATE TABLE "complete_formula_one_results" (
  "year" real,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What year is listed that has points greater than 0 with a chassis labeled AGS JH22?`:
```sql
                SELECT "year" FROM "complete_formula_one_results" WHERE "points">0 AND "chassis"='ags jh22';
```
## Task
Generate a SQL query to answer the following question:
`What is the total points listed that includes P listed Tyres after 1986?`

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

CREATE TABLE "complete_formula_one_results" (
  "year" real,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total points listed that includes P listed Tyres after 1986?`:
```sql
                SELECT SUM("points") FROM "complete_formula_one_results" WHERE "tyres"='p' AND "year">1986;
```
## Task
Generate a SQL query to answer the following question:
`What point is the lowest for listings of chassis labeled AGS JH23 before 1988?`

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

CREATE TABLE "complete_formula_one_results" (
  "year" real,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What point is the lowest for listings of chassis labeled AGS JH23 before 1988?`:
```sql
                SELECT MIN("points") FROM "complete_formula_one_results" WHERE "chassis"='ags jh23' AND "year"<1988;
```
## Task
Generate a SQL query to answer the following question:
`What is the total point for the year listed in 1988?`

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

CREATE TABLE "complete_formula_one_results" (
  "year" real,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total point for the year listed in 1988?`:
```sql
                SELECT SUM("points") FROM "complete_formula_one_results" WHERE "year"=1988;
```
## Task
Generate a SQL query to answer the following question:
`What was the attendance on August 2?`

### 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,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the attendance on August 2?`:
```sql
                SELECT MAX("attendance") FROM "game_log" WHERE "date"='august 2';
```
## Task
Generate a SQL query to answer the following question:
`Which opponent lost with pitcher Kinney (0-1)?`

### 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,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which opponent lost with pitcher Kinney (0-1)?`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "loss"='kinney (0-1)';
```
## Task
Generate a SQL query to answer the following question:
`What was the attendance on August 23?`

### 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,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the attendance on August 23?`:
```sql
                SELECT COUNT("attendance") FROM "game_log" WHERE "date"='august 23';
```
## Task
Generate a SQL query to answer the following question:
`What is the highest wins a tournament with 3 cuts and more than 4 events has?`

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

CREATE TABLE "summary" (
  "tournament" text,
  "wins" real,
  "top_10" real,
  "events" real,
  "cuts_made" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest wins a tournament with 3 cuts and more than 4 events has?`:
```sql
                SELECT MAX("wins") FROM "summary" WHERE "cuts_made"=3 AND "events">4;
```