output stringlengths 27 479 | instruction stringlengths 407 1.39k |
|---|---|
SELECT "music" FROM "jacopetti_and_prosperi" WHERE "year"=1962; |
## Task
Generate a SQL query to answer the following question:
`What music is in the film before 1962?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "jacopetti_and_prosperi" (
"title" text,
"year" real,
"country" text,
"music" text,
"uncut_run_time" text
);
### SQL
Given the database schema, here is the SQL query that answers `What music is in the film before 1962?`:
```sql
|
SELECT "home_team" FROM "round_10" WHERE "home_team_score"='15.16 (106)'; |
## Task
Generate a SQL query to answer the following question:
`Which home team scored 15.16 (106)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_10" (
"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 scored 15.16 (106)?`:
```sql
|
SELECT "home_team" FROM "round_10" WHERE "away_team"='north melbourne'; |
## Task
Generate a SQL query to answer the following question:
`Which team played as the home team when north melbourne played as away?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_10" (
"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 as the home team when north melbourne played as away?`:
```sql
|
SELECT "home_team_score" FROM "round_10" WHERE "away_team_score"='7.13 (55)'; |
## Task
Generate a SQL query to answer the following question:
`When the away team scored 7.13 (55), who were they playing?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_10" (
"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 the away team scored 7.13 (55), who were they playing?`:
```sql
|
SELECT COUNT("crowd") FROM "round_10" WHERE "home_team_score"='19.10 (124)'; |
## Task
Generate a SQL query to answer the following question:
`When the home team scored 19.10 (124), what was the total crowd number?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_10" (
"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 the home team scored 19.10 (124), what was the total crowd number?`:
```sql
|
SELECT "position" FROM "round_six" WHERE "pick_num"=53; |
## Task
Generate a SQL query to answer the following question:
`what is the position of pick #53?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_six" (
"pick_num" real,
"cfl_team" text,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the position of pick #53?`:
```sql
|
SELECT "position" FROM "round_six" WHERE "player"='andrew paopao'; |
## Task
Generate a SQL query to answer the following question:
`what is the position for andrew paopao?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_six" (
"pick_num" real,
"cfl_team" text,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the position for andrew paopao?`:
```sql
|
SELECT "venue" FROM "round_11" WHERE "home_team"='south melbourne'; |
## Task
Generate a SQL query to answer the following question:
`In which venue is South Melbourne the home team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_11" (
"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 `In which venue is South Melbourne the home team?`:
```sql
|
SELECT COUNT("crowd") FROM "round_11" WHERE "home_team_score"='12.14 (86)'; |
## Task
Generate a SQL query to answer the following question:
`In the game where the home team scored 12.14 (86), what was the total crowd number?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_11" (
"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 `In the game where the home team scored 12.14 (86), what was the total crowd number?`:
```sql
|
SELECT "away_team" FROM "round_11" WHERE "home_team"='south melbourne'; |
## Task
Generate a SQL query to answer the following question:
`When South Melbourne was the home team, who was the away team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_11" (
"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 South Melbourne was the home team, who was the away team?`:
```sql
|
SELECT "venue" FROM "round_11" WHERE "home_team"='hawthorn'; |
## Task
Generate a SQL query to answer the following question:
`What venue is Hawthorn the home team at?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_11" (
"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 Hawthorn the home team at?`:
```sql
|
SELECT "capacity" FROM "teams" WHERE "city_area"='chester'; |
## Task
Generate a SQL query to answer the following question:
`What is the capacity for the arena in Chester?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "teams" (
"team" text,
"city_area" text,
"arena" text,
"capacity" text,
"last_season" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the capacity for the arena in Chester?`:
```sql
|
SELECT "arena" FROM "teams" WHERE "capacity"='1,100'; |
## Task
Generate a SQL query to answer the following question:
`Which arena has a capactiy of 1,100?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "teams" (
"team" text,
"city_area" text,
"arena" text,
"capacity" text,
"last_season" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which arena has a capactiy of 1,100?`:
```sql
|
SELECT "last_season" FROM "teams" WHERE "team"='scottish rocks'; |
## Task
Generate a SQL query to answer the following question:
`What is the last season that the Scottish Rocks played?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "teams" (
"team" text,
"city_area" text,
"arena" text,
"capacity" text,
"last_season" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the last season that the Scottish Rocks played?`:
```sql
|
SELECT "arena" FROM "teams" WHERE "capacity"='800' AND "team"='milton keynes lions'; |
## Task
Generate a SQL query to answer the following question:
`Which arena has the Milton Keynes Lions and a capacity of 800?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "teams" (
"team" text,
"city_area" text,
"arena" text,
"capacity" text,
"last_season" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which arena has the Milton Keynes Lions and a capacity of 800?`:
```sql
|
SELECT "last_season" FROM "teams" WHERE "team"='worcester wolves'; |
## Task
Generate a SQL query to answer the following question:
`What is the last season the Worcester Wolves played?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "teams" (
"team" text,
"city_area" text,
"arena" text,
"capacity" text,
"last_season" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the last season the Worcester Wolves played?`:
```sql
|
SELECT "team" FROM "teams" WHERE "city_area"='birmingham & telford'; |
## Task
Generate a SQL query to answer the following question:
`Which team is from Birmingham & Telford?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "teams" (
"team" text,
"city_area" text,
"arena" text,
"capacity" text,
"last_season" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which team is from Birmingham & Telford?`:
```sql
|
SELECT MIN("wins") FROM "leaders" WHERE "rank"<3 AND "events">10; |
## Task
Generate a SQL query to answer the following question:
`Who has the least wins when ranked above 3 with over 10 events?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "leaders" (
"rank" real,
"player" text,
"country" text,
"earnings" real,
"events" real,
"wins" real
);
### SQL
Given the database schema, here is the SQL query that answers `Who has the least wins when ranked above 3 with over 10 events?`:
```sql
|
SELECT MIN("wins") FROM "leaders" WHERE "events"=8 AND "player"='billy casper' AND "earnings"<'71,979'; |
## Task
Generate a SQL query to answer the following question:
`How many wins for billy casper over 8 events and uner $71,979 in earnings?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "leaders" (
"rank" real,
"player" text,
"country" text,
"earnings" real,
"events" real,
"wins" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many wins for billy casper over 8 events and uner $71,979 in earnings?`:
```sql
|
SELECT MIN("rank") FROM "leaders" WHERE "earnings"<'71,979'; |
## Task
Generate a SQL query to answer the following question:
`What is the lowest rank for a player earning $71,979?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "leaders" (
"rank" real,
"player" text,
"country" text,
"earnings" real,
"events" real,
"wins" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest rank for a player earning $71,979?`:
```sql
|
SELECT "gdp_bn" FROM "administrative_divisions" WHERE "capital"='ioannina'; |
## Task
Generate a SQL query to answer the following question:
`What was the Gdp (bn) for the region that has ioannina as its Capital?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "administrative_divisions" (
"region" text,
"capital" text,
"area_km" text,
"area_sq_mi" text,
"population" text,
"gdp_bn" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the Gdp (bn) for the region that has ioannina as its Capital?`:
```sql
|
SELECT "region" FROM "administrative_divisions" WHERE "area_km"='9,451'; |
## Task
Generate a SQL query to answer the following question:
`Which Region has an Area of 9,451km²?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "administrative_divisions" (
"region" text,
"capital" text,
"area_km" text,
"area_sq_mi" text,
"population" text,
"gdp_bn" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Region has an Area of 9,451km²?`:
```sql
|
SELECT "capital" FROM "administrative_divisions" WHERE "population"='308,610'; |
## Task
Generate a SQL query to answer the following question:
`Which capital has a population of 308,610?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "administrative_divisions" (
"region" text,
"capital" text,
"area_km" text,
"area_sq_mi" text,
"population" text,
"gdp_bn" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which capital has a population of 308,610?`:
```sql
|
SELECT "region" FROM "administrative_divisions" WHERE "area_km"='14,037'; |
## Task
Generate a SQL query to answer the following question:
`Which Region has an area of 14,037km²?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "administrative_divisions" (
"region" text,
"capital" text,
"area_km" text,
"area_sq_mi" text,
"population" text,
"gdp_bn" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Region has an area of 14,037km²?`:
```sql
|
SELECT "gdp_bn" FROM "administrative_divisions" WHERE "area_sq_mi"='7,263'; |
## Task
Generate a SQL query to answer the following question:
`What is the GDP for the region with an area of 7,263 sq. mi.?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "administrative_divisions" (
"region" text,
"capital" text,
"area_km" text,
"area_sq_mi" text,
"population" text,
"gdp_bn" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the GDP for the region with an area of 7,263 sq. mi.?`:
```sql
|
SELECT "population" FROM "administrative_divisions" WHERE "area_sq_mi"='6,004'; |
## Task
Generate a SQL query to answer the following question:
`What is the population for the region with an area of 6,004 sq. Mi.?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "administrative_divisions" (
"region" text,
"capital" text,
"area_km" text,
"area_sq_mi" text,
"population" text,
"gdp_bn" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the population for the region with an area of 6,004 sq. Mi.?`:
```sql
|
SELECT MIN("episode_num") FROM "season_4_2001_2002" WHERE "airdate"='october 31, 2001'; |
## Task
Generate a SQL query to answer the following question:
`What is the lowest episode # with an air date of October 31, 2001?`
### 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 lowest episode # with an air date of October 31, 2001?`:
```sql
|
SELECT AVG("episode_num") FROM "season_4_2001_2002" WHERE "location"='tanzania' AND "num_in_season">5; |
## Task
Generate a SQL query to answer the following question:
`What is the average episode # located in Tanzania and whose # in season is larger than 5?`
### 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 # located in Tanzania and whose # in season is larger than 5?`:
```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:
`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 "airdate" FROM "season_4_2001_2002" WHERE "num_in_season"=5; |
## 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 "venue" FROM "round_13" WHERE "home_team"='melbourne'; |
## 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_score"='18.16 (124)'; |
## 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 "home_team" FROM "round_13" WHERE "away_team_score"='16.15 (111)'; |
## 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 "license" FROM "list_of_computer_system_emulators" WHERE "system"='amiga' AND "name"='pocketuae'; |
## 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 "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:
`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 "platform" FROM "list_of_computer_system_emulators" WHERE "actual_version"='0.147'; |
## 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 "name" FROM "list_of_computer_system_emulators" WHERE "license"='gpl' AND "platform"='windows'; |
## 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 "system" FROM "list_of_computer_system_emulators" WHERE "name"='mess'; |
## 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 "platform" FROM "list_of_computer_system_emulators" WHERE "actual_version"='0.8.29'; |
## 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 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:
`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 "award" FROM "awards_and_nominations" WHERE "category"='best supporting actress'; |
## 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 "result" FROM "awards_and_nominations" WHERE "nominated_work"='white valentine'; |
## 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 "category" FROM "awards_and_nominations" WHERE "year"=2013 AND "nominated_work"='the berlin file'; |
## 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 "final_position_round" FROM "overall" WHERE "competition"='uefa cup'; |
## 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 "last_match" FROM "overall" WHERE "final_position_round"='group stage'; |
## 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_year" FROM "u_s" WHERE "first_year"='1937' AND "publisher"='dc comics'; |
## 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 "publisher" FROM "u_s" WHERE "title"='weird war tales'; |
## 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 "last_year" FROM "u_s" WHERE "first_year"='1982'; |
## 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 "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:
`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 "first_year" FROM "u_s" WHERE "title"='popgun'; |
## 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 "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 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 "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 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 "date"='december 11, 2007' AND "region"='canada'; |
## 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 "home_team" FROM "round_22" WHERE "away_team_score"='18.14 (122)'; |
## 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 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 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 SUM("crowd") FROM "round_22" WHERE "venue"='princes park'; |
## 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 "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:
`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 "rounds" FROM "drivers_and_constructors" WHERE "entrant"='scuderia ferrari marlboro'; |
## 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 "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 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 "engine" FROM "drivers_and_constructors" WHERE "tyre"='m' AND "driver"='fernando alonso'; |
## 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 "constructor" FROM "drivers_and_constructors" WHERE "driver"='juan pablo montoya'; |
## 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 MIN("td_s") FROM "receiving" WHERE "long"=49 AND "yards"<1436; |
## 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 COUNT("long") FROM "receiving" WHERE "td_s">29; |
## 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 "rec">27 AND "avg"<10.8 AND "td_s">6; |
## 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("attendance") FROM "game_log" WHERE "record"='86-56'; |
## 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 "date" FROM "game_log" WHERE "record"='90-60'; |
## 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 "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) 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 "venue" FROM "round_2" WHERE "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 "date" FROM "round_2" WHERE "away_team_score"='10.11 (71)'; |
## 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 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 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 "venue" FROM "round_1" WHERE "away_team"='collingwood'; |
## 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 "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 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 "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 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 "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 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 "date" FROM "round_1" WHERE "home_team_score"='9.14 (68)'; |
## 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 "away_team_score" FROM "round_1" WHERE "away_team"='st kilda'; |
## Task
Generate a SQL query to answer the following question:
`How much did the away team St Kilda score?`
### 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 `How much did the away team St Kilda score?`:
```sql
|
SELECT "date" FROM "round_17" WHERE "away_team"='carlton'; |
## 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 "home_team_score" FROM "round_17" WHERE "venue"='windy hill'; |
## 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 MIN("grid") FROM "classification" WHERE "laps"<17 AND "constructor"='sauber - petronas'; |
## 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 "time_retired" FROM "classification" WHERE "laps">51 AND "driver"='cristiano da matta'; |
## 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 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 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 COUNT("year") FROM "period_of_differently_named_meetings" WHERE "record"='3:40.8'; |
## 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 "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:
`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 "leading_scorer" FROM "march" WHERE "home"='kings'; |
## 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 "visitor" FROM "march" WHERE "date"='march 2, 2008'; |
## 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 COUNT("attendance") FROM "march" WHERE "home"='lakers'; |
## 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 "week" FROM "schedule" WHERE "attendance"='39,056'; |
## 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 "kickoff_a" FROM "schedule" WHERE "week"='3'; |
## 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 "game_site"='hubert h. humphrey metrodome'; |
## 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 "result" FROM "schedule" WHERE "opponent"='indianapolis colts'; |
## 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 "opponent" FROM "schedule" WHERE "date"='september 13, 1992'; |
## 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 "result" FROM "schedule" WHERE "date"='november 1, 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 "away_team_score" FROM "round_14" WHERE "home_team"='melbourne'; |
## 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" FROM "round_14" WHERE "home_team"='collingwood'; |
## 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 "visitor" FROM "april" WHERE "attendance">'19,141' AND "date"='april 8'; |
## 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 SUM("crowd") FROM "round_2" WHERE "home_team"='essendon'; |
## 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 "home_team" FROM "round_2" WHERE "away_team"='north melbourne'; |
## 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 "venue"='punt road oval'; |
## 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
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.