cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`What is the average episode # with a name of the origin of Donnie (part 1)?`

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

CREATE TABLE "season_4_2001_2002" (
  "episode_num" real,
  "num_in_season" real,
  "episode_name" text,
  "airdate" text,
  "location" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average episode # with a name of the origin of Donnie (part 1)?`:
```sql
                SELECT AVG("episode_num") FROM "season_4_2001_2002" WHERE "episode_name"='the origin of donnie (part 1)';
```
## Task
Generate a SQL query to answer the following question:
`Which air date has 5 for # in season?`

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

CREATE TABLE "season_4_2001_2002" (
  "episode_num" real,
  "num_in_season" real,
  "episode_name" text,
  "airdate" text,
  "location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which air date has 5 for # in season?`:
```sql
                SELECT "airdate" FROM "season_4_2001_2002" WHERE "num_in_season"=5;
```
## Task
Generate a SQL query to answer the following question:
`What venue is home for the Melbourne team?`

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

CREATE TABLE "round_13" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What venue is home for the Melbourne team?`:
```sql
                SELECT "venue" FROM "round_13" WHERE "home_team"='melbourne';
```
## Task
Generate a SQL query to answer the following question:
`What is the venue for the home team in Melbourne?`

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

CREATE TABLE "round_13" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the venue for the home team in Melbourne?`:
```sql
                SELECT "venue" FROM "round_13" WHERE "home_team"='melbourne';
```
## Task
Generate a SQL query to answer the following question:
`Which venue has a home team that has a score of 18.16 (124)?`

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

CREATE TABLE "round_13" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which venue has a home team that has a score of 18.16 (124)?`:
```sql
                SELECT "venue" FROM "round_13" WHERE "home_team_score"='18.16 (124)';
```
## Task
Generate a SQL query to answer the following question:
`Which home team played an away team that had a score of 16.15 (111)?`

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

CREATE TABLE "round_13" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which home team played an away team that had a score of 16.15 (111)?`:
```sql
                SELECT "home_team" FROM "round_13" WHERE "away_team_score"='16.15 (111)';
```
## Task
Generate a SQL query to answer the following question:
`Which License has a System of amiga, and a Name of pocketuae?`

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

CREATE TABLE "list_of_computer_system_emulators" (
  "name" text,
  "actual_version" text,
  "system" text,
  "platform" text,
  "license" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which License has a System of amiga, and a Name of pocketuae?`:
```sql
                SELECT "license" FROM "list_of_computer_system_emulators" WHERE "system"='amiga' AND "name"='pocketuae';
```
## Task
Generate a SQL query to answer the following question:
`What name has a License of gpl, and an Actual version of 0.8.29wip4?`

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

CREATE TABLE "list_of_computer_system_emulators" (
  "name" text,
  "actual_version" text,
  "system" text,
  "platform" text,
  "license" text
);
### SQL
Given the database schema, here is the SQL query that answers `What name has a License of gpl, and an Actual version of 0.8.29wip4?`:
```sql
                SELECT "name" FROM "list_of_computer_system_emulators" WHERE "license"='gpl' AND "actual_version"='0.8.29wip4';
```
## Task
Generate a SQL query to answer the following question:
`Which platform has an Actual version of 0.147?`

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

CREATE TABLE "list_of_computer_system_emulators" (
  "name" text,
  "actual_version" text,
  "system" text,
  "platform" text,
  "license" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which platform has an Actual version of 0.147?`:
```sql
                SELECT "platform" FROM "list_of_computer_system_emulators" WHERE "actual_version"='0.147';
```
## Task
Generate a SQL query to answer the following question:
`Which name has a License of gpl, and a Platform of windows?`

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

CREATE TABLE "list_of_computer_system_emulators" (
  "name" text,
  "actual_version" text,
  "system" text,
  "platform" text,
  "license" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which name has a License of gpl, and a Platform of windows?`:
```sql
                SELECT "name" FROM "list_of_computer_system_emulators" WHERE "license"='gpl' AND "platform"='windows';
```
## Task
Generate a SQL query to answer the following question:
`Which system is named mess?`

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

CREATE TABLE "list_of_computer_system_emulators" (
  "name" text,
  "actual_version" text,
  "system" text,
  "platform" text,
  "license" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which system is named mess?`:
```sql
                SELECT "system" FROM "list_of_computer_system_emulators" WHERE "name"='mess';
```
## Task
Generate a SQL query to answer the following question:
`Which Platform has an Actual version of 0.8.29?`

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

CREATE TABLE "list_of_computer_system_emulators" (
  "name" text,
  "actual_version" text,
  "system" text,
  "platform" text,
  "license" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Platform has an Actual version of 0.8.29?`:
```sql
                SELECT "platform" FROM "list_of_computer_system_emulators" WHERE "actual_version"='0.8.29';
```
## Task
Generate a SQL query to answer the following question:
`What's the earliest year that had a category of best supporting actress at the asian film awards?`

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

CREATE TABLE "awards_and_nominations" (
  "year" real,
  "award" text,
  "category" text,
  "nominated_work" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the earliest year that had a category of best supporting actress at the asian film awards?`:
```sql
                SELECT MIN("year") FROM "awards_and_nominations" WHERE "category"='best supporting actress' AND "award"='asian film awards';
```
## Task
Generate a SQL query to answer the following question:
`Which award show had the category of best supporting actress?`

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

CREATE TABLE "awards_and_nominations" (
  "year" real,
  "award" text,
  "category" text,
  "nominated_work" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which award show had the category of best supporting actress?`:
```sql
                SELECT "award" FROM "awards_and_nominations" WHERE "category"='best supporting actress';
```
## Task
Generate a SQL query to answer the following question:
`Did the nominated work of white valentine win an award?`

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

CREATE TABLE "awards_and_nominations" (
  "year" real,
  "award" text,
  "category" text,
  "nominated_work" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Did the nominated work of white valentine win an award?`:
```sql
                SELECT "result" FROM "awards_and_nominations" WHERE "nominated_work"='white valentine';
```
## Task
Generate a SQL query to answer the following question:
`Which category was the berlin file up to win in 2013?`

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

CREATE TABLE "awards_and_nominations" (
  "year" real,
  "award" text,
  "category" text,
  "nominated_work" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which category was the berlin file up to win in 2013?`:
```sql
                SELECT "category" FROM "awards_and_nominations" WHERE "year"=2013 AND "nominated_work"='the berlin file';
```
## Task
Generate a SQL query to answer the following question:
`What is the final position/round of the UEFA cup?`

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

CREATE TABLE "overall" (
  "competition" text,
  "current_position_round" text,
  "final_position_round" text,
  "first_match" text,
  "last_match" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the final position/round of the UEFA cup?`:
```sql
                SELECT "final_position_round" FROM "overall" WHERE "competition"='uefa cup';
```
## Task
Generate a SQL query to answer the following question:
`When the final position/round is group stage, when is the last match?`

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

CREATE TABLE "overall" (
  "competition" text,
  "current_position_round" text,
  "final_position_round" text,
  "first_match" text,
  "last_match" text
);
### SQL
Given the database schema, here is the SQL query that answers `When the final position/round is group stage, when is the last match?`:
```sql
                SELECT "last_match" FROM "overall" WHERE "final_position_round"='group stage';
```
## Task
Generate a SQL query to answer the following question:
`When did the DC Comics title that debuted in 1937 end?`

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

CREATE TABLE "u_s" (
  "title" text,
  "publisher" text,
  "first_year" text,
  "last_year" text,
  "genre" text
);
### SQL
Given the database schema, here is the SQL query that answers `When did the DC Comics title that debuted in 1937 end?`:
```sql
                SELECT "last_year" FROM "u_s" WHERE "first_year"='1937' AND "publisher"='dc comics';
```
## Task
Generate a SQL query to answer the following question:
`Who published Weird War Tales?`

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

CREATE TABLE "u_s" (
  "title" text,
  "publisher" text,
  "first_year" text,
  "last_year" text,
  "genre" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who published Weird War Tales?`:
```sql
                SELECT "publisher" FROM "u_s" WHERE "title"='weird war tales';
```
## Task
Generate a SQL query to answer the following question:
`When did the comic which came out in 1982 end?`

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

CREATE TABLE "u_s" (
  "title" text,
  "publisher" text,
  "first_year" text,
  "last_year" text,
  "genre" text
);
### SQL
Given the database schema, here is the SQL query that answers `When did the comic which came out in 1982 end?`:
```sql
                SELECT "last_year" FROM "u_s" WHERE "first_year"='1982';
```
## Task
Generate a SQL query to answer the following question:
`Which EC Comics title ran from 1950 to 1953?`

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

CREATE TABLE "u_s" (
  "title" text,
  "publisher" text,
  "first_year" text,
  "last_year" text,
  "genre" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which EC Comics title ran from 1950 to 1953?`:
```sql
                SELECT "title" FROM "u_s" WHERE "first_year"='1950' AND "publisher"='ec comics' AND "last_year"='1953';
```
## Task
Generate a SQL query to answer the following question:
`What is the first year for Popgun?`

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

CREATE TABLE "u_s" (
  "title" text,
  "publisher" text,
  "first_year" text,
  "last_year" text,
  "genre" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the first year for Popgun?`:
```sql
                SELECT "first_year" FROM "u_s" WHERE "title"='popgun';
```
## Task
Generate a SQL query to answer the following question:
`What's the region for an item on November 10, 2007 that's a cd?`

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

CREATE TABLE "release_history" (
  "region" text,
  "date" text,
  "label" text,
  "format" text,
  "catalog" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the region for an item on November 10, 2007 that's a cd?`:
```sql
                SELECT "region" FROM "release_history" WHERE "date"='november 10, 2007' AND "format"='cd';
```
## Task
Generate a SQL query to answer the following question:
`What's the catalog number for a record from columbia formatted in a cd/dvd that's from the United States region?`

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

CREATE TABLE "release_history" (
  "region" text,
  "date" text,
  "label" text,
  "format" text,
  "catalog" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the catalog number for a record from columbia formatted in a cd/dvd that's from the United States region?`:
```sql
                SELECT "catalog" FROM "release_history" WHERE "label"='columbia' AND "region"='united states' AND "format"='cd/dvd';
```
## Task
Generate a SQL query to answer the following question:
`What's the catalog number for a December 11, 2007 record from columbia formatted in a that's from Canada?`

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

CREATE TABLE "release_history" (
  "region" text,
  "date" text,
  "label" text,
  "format" text,
  "catalog" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the catalog number for a December 11, 2007 record from columbia formatted in a that's from Canada?`:
```sql
                SELECT "catalog" FROM "release_history" WHERE "label"='columbia' AND "date"='december 11, 2007' AND "region"='canada';
```
## Task
Generate a SQL query to answer the following question:
`Which team has an away score of 18.14 (122)?`

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

CREATE TABLE "round_22" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which team has an away score of 18.14 (122)?`:
```sql
                SELECT "home_team" FROM "round_22" WHERE "away_team_score"='18.14 (122)';
```
## Task
Generate a SQL query to answer the following question:
`What is the average crowd size for an away team with a score of 14.19 (103)?`

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

CREATE TABLE "round_22" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average crowd size for an away team with a score of 14.19 (103)?`:
```sql
                SELECT AVG("crowd") FROM "round_22" WHERE "away_team_score"='14.19 (103)';
```
## Task
Generate a SQL query to answer the following question:
`What is the average crowd size at Princes Park?`

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

CREATE TABLE "round_22" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average crowd size at Princes Park?`:
```sql
                SELECT SUM("crowd") FROM "round_22" WHERE "venue"='princes park';
```
## Task
Generate a SQL query to answer the following question:
`who is the constructor when the free practice driver(s) is n/a, the chassis is 005 and the driver is takuma sato?`

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

CREATE TABLE "drivers_and_constructors" (
  "entrant" text,
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyre" text,
  "driver" text,
  "rounds" text,
  "free_practice_driver_s" text
);
### SQL
Given the database schema, here is the SQL query that answers `who is the constructor when the free practice driver(s) is n/a, the chassis is 005 and the driver is takuma sato?`:
```sql
                SELECT "constructor" FROM "drivers_and_constructors" WHERE "free_practice_driver_s"='n/a' AND "chassis"='005' AND "driver"='takuma sato';
```
## Task
Generate a SQL query to answer the following question:
`what is the rounds when the entrant is scuderia ferrari marlboro?`

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

CREATE TABLE "drivers_and_constructors" (
  "entrant" text,
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyre" text,
  "driver" text,
  "rounds" text,
  "free_practice_driver_s" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the rounds when the entrant is scuderia ferrari marlboro?`:
```sql
                SELECT "rounds" FROM "drivers_and_constructors" WHERE "entrant"='scuderia ferrari marlboro';
```
## Task
Generate a SQL query to answer the following question:
`what is the chassis when the entrant is mild seven renault f1 team and the driver is jarno trulli?`

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

CREATE TABLE "drivers_and_constructors" (
  "entrant" text,
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyre" text,
  "driver" text,
  "rounds" text,
  "free_practice_driver_s" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the chassis when the entrant is mild seven renault f1 team and the driver is jarno trulli?`:
```sql
                SELECT "chassis" FROM "drivers_and_constructors" WHERE "entrant"='mild seven renault f1 team' AND "driver"='jarno trulli';
```
## Task
Generate a SQL query to answer the following question:
`what is the engine when the tyre is m and the driver is fernando alonso?`

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

CREATE TABLE "drivers_and_constructors" (
  "entrant" text,
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyre" text,
  "driver" text,
  "rounds" text,
  "free_practice_driver_s" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the engine when the tyre is m and the driver is fernando alonso?`:
```sql
                SELECT "engine" FROM "drivers_and_constructors" WHERE "tyre"='m' AND "driver"='fernando alonso';
```
## Task
Generate a SQL query to answer the following question:
`who is the constructor when the driver is juan pablo montoya?`

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

CREATE TABLE "drivers_and_constructors" (
  "entrant" text,
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyre" text,
  "driver" text,
  "rounds" text,
  "free_practice_driver_s" text
);
### SQL
Given the database schema, here is the SQL query that answers `who is the constructor when the driver is juan pablo montoya?`:
```sql
                SELECT "constructor" FROM "drivers_and_constructors" WHERE "driver"='juan pablo montoya';
```
## Task
Generate a SQL query to answer the following question:
`What is the low TD for 49 longs and 1436 less yards?`

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

CREATE TABLE "receiving" (
  "player" text,
  "rec" real,
  "yards" real,
  "avg" real,
  "td_s" real,
  "long" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the low TD for 49 longs and 1436 less yards?`:
```sql
                SELECT MIN("td_s") FROM "receiving" WHERE "long"=49 AND "yards"<1436;
```
## Task
Generate a SQL query to answer the following question:
`What is the total count of TD longs more than 29?`

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

CREATE TABLE "receiving" (
  "player" text,
  "rec" real,
  "yards" real,
  "avg" real,
  "td_s" real,
  "long" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total count of TD longs more than 29?`:
```sql
                SELECT COUNT("long") FROM "receiving" WHERE "td_s">29;
```
## Task
Generate a SQL query to answer the following question:
`What is the toal rec with more than 27 and averages less than 10.8 and TDs more than 6?`

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

CREATE TABLE "receiving" (
  "player" text,
  "rec" real,
  "yards" real,
  "avg" real,
  "td_s" real,
  "long" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the toal rec with more than 27 and averages less than 10.8 and TDs more than 6?`:
```sql
                SELECT COUNT("long") FROM "receiving" WHERE "rec">27 AND "avg"<10.8 AND "td_s">6;
```
## Task
Generate a SQL query to answer the following question:
`How many people attended the game with a record of 86-56`

### 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 `How many people attended the game with a record of 86-56`:
```sql
                SELECT COUNT("attendance") FROM "game_log" WHERE "record"='86-56';
```
## Task
Generate a SQL query to answer the following question:
`Name the date that had a record of 90-60`

### 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 `Name the date that had a record of 90-60`:
```sql
                SELECT "date" FROM "game_log" WHERE "record"='90-60';
```
## Task
Generate a SQL query to answer the following question:
`On the game where the home team scored 9.9 (63) and the crowd exceeded 14,589, what was the date?`

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

CREATE TABLE "round_2" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `On the game where the home team scored 9.9 (63) and the crowd exceeded 14,589, what was the date?`:
```sql
                SELECT "date" FROM "round_2" WHERE "crowd">'14,589' AND "home_team_score"='9.9 (63)';
```
## Task
Generate a SQL query to answer the following question:
`On the game where the home team scored 9.9 (63), where was the venue.`

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

CREATE TABLE "round_2" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `On the game where the home team scored 9.9 (63), where was the venue.`:
```sql
                SELECT "venue" FROM "round_2" WHERE "home_team_score"='9.9 (63)';
```
## Task
Generate a SQL query to answer the following question:
`On which date did the away team score 10.11 (71)?`

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

CREATE TABLE "round_2" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `On which date did the away team score 10.11 (71)?`:
```sql
                SELECT "date" FROM "round_2" WHERE "away_team_score"='10.11 (71)';
```
## Task
Generate a SQL query to answer the following question:
`What was the highest Sinclair Total that had a rank of 3, but a World Record smaller than 217?`

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

CREATE TABLE "notable_sinclair_totals_throughout_the_h" (
  "weight_class_kg" real,
  "world_record_kg" real,
  "sinclair_coefficient" real,
  "sinclair_total" real,
  "rank" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the highest Sinclair Total that had a rank of 3, but a World Record smaller than 217?`:
```sql
                SELECT MAX("sinclair_total") FROM "notable_sinclair_totals_throughout_the_h" WHERE "rank"=3 AND "world_record_kg"<217;
```
## Task
Generate a SQL query to answer the following question:
`What is the name of the venue that they away team Collingwood played at?`

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

CREATE TABLE "round_1" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the name of the venue that they away team Collingwood played at?`:
```sql
                SELECT "venue" FROM "round_1" WHERE "away_team"='collingwood';
```
## Task
Generate a SQL query to answer the following question:
`What is the score of the away team where the home team scored 14.8 (92)?`

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

CREATE TABLE "round_1" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the score of the away team where the home team scored 14.8 (92)?`:
```sql
                SELECT "away_team_score" FROM "round_1" WHERE "home_team_score"='14.8 (92)';
```
## Task
Generate a SQL query to answer the following question:
`What is the name of the home team that scored 11.16 (82)?`

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

CREATE TABLE "round_1" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the name of the home team that scored 11.16 (82)?`:
```sql
                SELECT "home_team" FROM "round_1" WHERE "home_team_score"='11.16 (82)';
```
## Task
Generate a SQL query to answer the following question:
`What is the score of the away team whose opponent scored 14.8 (92)?`

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

CREATE TABLE "round_1" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the score of the away team whose opponent scored 14.8 (92)?`:
```sql
                SELECT "away_team_score" FROM "round_1" WHERE "home_team_score"='14.8 (92)';
```
## Task
Generate a SQL query to answer the following question:
`On what date did the home team score 9.14 (68)?`

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

CREATE TABLE "round_1" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date did the home team score 9.14 (68)?`:
```sql
                SELECT "date" FROM "round_1" WHERE "home_team_score"='9.14 (68)';
```
## Task
Generate a SQL query to answer the following question:
`What date did Carlton play as the away team?`

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

CREATE TABLE "round_17" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date did Carlton play as the away team?`:
```sql
                SELECT "date" FROM "round_17" WHERE "away_team"='carlton';
```
## Task
Generate a SQL query to answer the following question:
`What was the home team's score at Windy Hill?`

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

CREATE TABLE "round_17" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the home team's score at Windy Hill?`:
```sql
                SELECT "home_team_score" FROM "round_17" WHERE "venue"='windy hill';
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest grid value with fewer than 17 laps and constructor Sauber - Petronas?`

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

CREATE TABLE "classification" (
  "driver" text,
  "constructor" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest grid value with fewer than 17 laps and constructor Sauber - Petronas?`:
```sql
                SELECT MIN("grid") FROM "classification" WHERE "laps"<17 AND "constructor"='sauber - petronas';
```
## Task
Generate a SQL query to answer the following question:
`Which Time/Retired entry has greater than 51 laps and driver Cristiano da Matta?`

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

CREATE TABLE "classification" (
  "driver" text,
  "constructor" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Time/Retired entry has greater than 51 laps and driver Cristiano da Matta?`:
```sql
                SELECT "time_retired" FROM "classification" WHERE "laps">51 AND "driver"='cristiano da matta';
```
## Task
Generate a SQL query to answer the following question:
`How many ties did the Montreal Victorias have with a GA of less than 24?`

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

CREATE TABLE "final_standing" (
  "team" text,
  "games_played" real,
  "wins" real,
  "losses" real,
  "ties" real,
  "goals_for" real,
  "goals_against" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many ties did the Montreal Victorias have with a GA of less than 24?`:
```sql
                SELECT MAX("ties") FROM "final_standing" WHERE "team"='montreal victorias' AND "goals_against"<24;
```
## Task
Generate a SQL query to answer the following question:
`How many years was the record 3:40.8?`

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

CREATE TABLE "period_of_differently_named_meetings" (
  "year" real,
  "event" text,
  "record" text,
  "athlete" text,
  "nationality" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many years was the record 3:40.8?`:
```sql
                SELECT COUNT("year") FROM "period_of_differently_named_meetings" WHERE "record"='3:40.8';
```
## Task
Generate a SQL query to answer the following question:
`What event is before 1964 and has an athlete of lászló tábori gunnar nielsen?`

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

CREATE TABLE "period_of_differently_named_meetings" (
  "year" real,
  "event" text,
  "record" text,
  "athlete" text,
  "nationality" text
);
### SQL
Given the database schema, here is the SQL query that answers `What event is before 1964 and has an athlete of lászló tábori gunnar nielsen?`:
```sql
                SELECT "event" FROM "period_of_differently_named_meetings" WHERE "year"<1964 AND "athlete"='lászló tábori gunnar nielsen';
```
## Task
Generate a SQL query to answer the following question:
`Who is the leading scorer of the game where the Kings is the home team?`

### 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,
  "leading_scorer" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the leading scorer of the game where the Kings is the home team?`:
```sql
                SELECT "leading_scorer" FROM "march" WHERE "home"='kings';
```
## Task
Generate a SQL query to answer the following question:
`Who is the visitor team of the game on March 2, 2008?`

### 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,
  "leading_scorer" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the visitor team of the game on March 2, 2008?`:
```sql
                SELECT "visitor" FROM "march" WHERE "date"='march 2, 2008';
```
## Task
Generate a SQL query to answer the following question:
`What is the attendance total of the game with the Lakers as the home team?`

### 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,
  "leading_scorer" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the attendance total of the game with the Lakers as the home team?`:
```sql
                SELECT COUNT("attendance") FROM "march" WHERE "home"='lakers';
```
## Task
Generate a SQL query to answer the following question:
`Which week had 39,056 people in attendance?`

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

CREATE TABLE "schedule" (
  "week" text,
  "date" text,
  "opponent" text,
  "result" text,
  "kickoff_a" text,
  "game_site" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which week had 39,056 people in attendance?`:
```sql
                SELECT "week" FROM "schedule" WHERE "attendance"='39,056';
```
## Task
Generate a SQL query to answer the following question:
`What is the kickoff time for week 3?`

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

CREATE TABLE "schedule" (
  "week" text,
  "date" text,
  "opponent" text,
  "result" text,
  "kickoff_a" text,
  "game_site" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the kickoff time for week 3?`:
```sql
                SELECT "kickoff_a" FROM "schedule" WHERE "week"='3';
```
## Task
Generate a SQL query to answer the following question:
`What is the kickoff time for the Hubert H. Humphrey Metrodome?`

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

CREATE TABLE "schedule" (
  "week" text,
  "date" text,
  "opponent" text,
  "result" text,
  "kickoff_a" text,
  "game_site" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the kickoff time for the Hubert H. Humphrey Metrodome?`:
```sql
                SELECT "kickoff_a" FROM "schedule" WHERE "game_site"='hubert h. humphrey metrodome';
```
## Task
Generate a SQL query to answer the following question:
`What is the result when the Indianapolis Colts are the opponents?`

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

CREATE TABLE "schedule" (
  "week" text,
  "date" text,
  "opponent" text,
  "result" text,
  "kickoff_a" text,
  "game_site" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the result when the Indianapolis Colts are the opponents?`:
```sql
                SELECT "result" FROM "schedule" WHERE "opponent"='indianapolis colts';
```
## Task
Generate a SQL query to answer the following question:
`Who was the opponent on September 13, 1992?`

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

CREATE TABLE "schedule" (
  "week" text,
  "date" text,
  "opponent" text,
  "result" text,
  "kickoff_a" text,
  "game_site" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the opponent on September 13, 1992?`:
```sql
                SELECT "opponent" FROM "schedule" WHERE "date"='september 13, 1992';
```
## Task
Generate a SQL query to answer the following question:
`What is the result on November 1, 1992?`

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

CREATE TABLE "schedule" (
  "week" text,
  "date" text,
  "opponent" text,
  "result" text,
  "kickoff_a" text,
  "game_site" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the result on November 1, 1992?`:
```sql
                SELECT "result" FROM "schedule" WHERE "date"='november 1, 1992';
```
## Task
Generate a SQL query to answer the following question:
`What was the away score when the home team was Melbourne?`

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

CREATE TABLE "round_14" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the away score when the home team was Melbourne?`:
```sql
                SELECT "away_team_score" FROM "round_14" WHERE "home_team"='melbourne';
```
## Task
Generate a SQL query to answer the following question:
`Who played Collingwood?`

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

CREATE TABLE "round_14" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who played Collingwood?`:
```sql
                SELECT "away_team" FROM "round_14" WHERE "home_team"='collingwood';
```
## Task
Generate a SQL query to answer the following question:
`Who was the visiting team on April 8 where more than 19,141 were in attendance?`

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

CREATE TABLE "april" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "leading_scorer" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the visiting team on April 8 where more than 19,141 were in attendance?`:
```sql
                SELECT "visitor" FROM "april" WHERE "attendance">'19,141' AND "date"='april 8';
```
## Task
Generate a SQL query to answer the following question:
`How big was the crowd for Essendon?`

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

CREATE TABLE "round_2" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `How big was the crowd for Essendon?`:
```sql
                SELECT SUM("crowd") FROM "round_2" WHERE "home_team"='essendon';
```
## Task
Generate a SQL query to answer the following question:
`Which team played against North Melbourne as the home team?`

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

CREATE TABLE "round_2" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which team played against North Melbourne as the home team?`:
```sql
                SELECT "home_team" FROM "round_2" WHERE "away_team"='north melbourne';
```
## Task
Generate a SQL query to answer the following question:
`Which home team plays at Punt Road Oval?`

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

CREATE TABLE "round_2" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which home team plays at Punt Road Oval?`:
```sql
                SELECT "home_team" FROM "round_2" WHERE "venue"='punt road oval';
```
## Task
Generate a SQL query to answer the following question:
`Which team plays at Punt Road Oval?`

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

CREATE TABLE "round_2" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which team plays at Punt Road Oval?`:
```sql
                SELECT "home_team" FROM "round_2" WHERE "venue"='punt road oval';
```
## Task
Generate a SQL query to answer the following question:
`When did a home team score 9.6 (60)?`

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

CREATE TABLE "round_2" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `When did a home team score 9.6 (60)?`:
```sql
                SELECT "date" FROM "round_2" WHERE "home_team_score"='9.6 (60)';
```
## Task
Generate a SQL query to answer the following question:
`What did the away team score at corio oval?`

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

CREATE TABLE "round_2" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What did the away team score at corio oval?`:
```sql
                SELECT "away_team_score" FROM "round_2" WHERE "venue"='corio oval';
```
## Task
Generate a SQL query to answer the following question:
`Who did the cowboys play when 65,537 attended?`

### 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,
  "attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who did the cowboys play when 65,537 attended?`:
```sql
                SELECT "opponent" FROM "schedule" WHERE "attendance"='65,537';
```
## Task
Generate a SQL query to answer the following question:
`What is the name of the tournament when antonia xenia tout nataša zorić was the opponenet?`

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

CREATE TABLE "doubles_finals_2_4" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponents" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the name of the tournament when antonia xenia tout nataša zorić was the opponenet?`:
```sql
                SELECT "tournament" FROM "doubles_finals_2_4" WHERE "opponents"='antonia xenia tout nataša zorić';
```
## Task
Generate a SQL query to answer the following question:
`What date was georgie stoop emily webley-smith the opponent?`

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

CREATE TABLE "doubles_finals_2_4" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponents" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date was georgie stoop emily webley-smith the opponent?`:
```sql
                SELECT "date" FROM "doubles_finals_2_4" WHERE "opponents"='georgie stoop emily webley-smith';
```
## Task
Generate a SQL query to answer the following question:
`What is the surface of the match when the opponent was iryna bremond valeria savinykh?`

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

CREATE TABLE "doubles_finals_2_4" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponents" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the surface of the match when the opponent was iryna bremond valeria savinykh?`:
```sql
                SELECT "surface" FROM "doubles_finals_2_4" WHERE "opponents"='iryna bremond valeria savinykh';
```
## Task
Generate a SQL query to answer the following question:
`What is the name of the opponent for the Sutton tournament?`

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

CREATE TABLE "doubles_finals_2_4" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponents" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the name of the opponent for the Sutton tournament?`:
```sql
                SELECT "opponents" FROM "doubles_finals_2_4" WHERE "tournament"='sutton';
```