output stringlengths 27 479 | instruction stringlengths 407 1.39k |
|---|---|
SELECT "circuit" FROM "races" WHERE "date"='july 24'; |
## Task
Generate a SQL query to answer the following question:
`Which Circuit is on July 24?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "races" (
"race_name" text,
"circuit" text,
"city_location" text,
"date" text,
"pole_position" text,
"winning_driver" text,
"winning_team" text,
"report" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Circuit is on July 24?`:
```sql
|
SELECT "date" FROM "other_grands_prix" WHERE "winning_constructor"='delage'; |
## Task
Generate a SQL query to answer the following question:
`What date did Delage win?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "other_grands_prix" (
"name" text,
"circuit" text,
"date" text,
"winning_driver" text,
"winning_constructor" text,
"report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date did Delage win?`:
```sql
|
SELECT "circuit" FROM "other_grands_prix" WHERE "winning_driver"='luigi villoresi' AND "name"='lausanne grand prix'; |
## Task
Generate a SQL query to answer the following question:
`What circuit did Luigi Villoresi win the Lausanne Grand Prix?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "other_grands_prix" (
"name" text,
"circuit" text,
"date" text,
"winning_driver" text,
"winning_constructor" text,
"report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What circuit did Luigi Villoresi win the Lausanne Grand Prix?`:
```sql
|
SELECT "name" FROM "other_grands_prix" WHERE "winning_driver"='nello pagani'; |
## Task
Generate a SQL query to answer the following question:
`Which Grand Prix did Nello Pagani win?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "other_grands_prix" (
"name" text,
"circuit" text,
"date" text,
"winning_driver" text,
"winning_constructor" text,
"report" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Grand Prix did Nello Pagani win?`:
```sql
|
SELECT "home_team_score" FROM "round_17" WHERE "away_team"='fitzroy'; |
## Task
Generate a SQL query to answer the following question:
`What did the home team score when playing Fitzroy 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 did the home team score when playing Fitzroy as the away team?`:
```sql
|
SELECT "home_team_score" FROM "round_17" WHERE "venue"='western oval'; |
## Task
Generate a SQL query to answer the following question:
`What did the home team score when playing at Western Oval?`
### 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 did the home team score when playing at Western Oval?`:
```sql
|
SELECT "away_team" FROM "round_17" WHERE "home_team"='collingwood'; |
## Task
Generate a SQL query to answer the following question:
`What away team played Collingwood?`
### 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 away team played Collingwood?`:
```sql
|
SELECT "date" FROM "round_17" WHERE "home_team"='collingwood'; |
## Task
Generate a SQL query to answer the following question:
`On what date did Collingwood play at home?`
### 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 `On what date did Collingwood play at home?`:
```sql
|
SELECT AVG("round") FROM "2000_new_england_patriots_draft_selectio" WHERE "overall"<187 AND "player"='dave stachelski'; |
## Task
Generate a SQL query to answer the following question:
`Name the average round where Dave Stachelski was picked smaller than 187.`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2000_new_england_patriots_draft_selectio" (
"round" real,
"overall" real,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the average round where Dave Stachelski was picked smaller than 187.`:
```sql
|
SELECT "position" FROM "2000_new_england_patriots_draft_selectio" WHERE "overall">187 AND "player"='david nugent'; |
## Task
Generate a SQL query to answer the following question:
`Which position did David Nugent play with an overall small than 187?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2000_new_england_patriots_draft_selectio" (
"round" real,
"overall" real,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which position did David Nugent play with an overall small than 187?`:
```sql
|
SELECT "college" FROM "2000_new_england_patriots_draft_selectio" WHERE "overall">187 AND "round"<7 AND "position"='defensive end'; |
## Task
Generate a SQL query to answer the following question:
`Name the college that has an overall larger than 187 and a round smaller than 7 for the defensive end position.`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2000_new_england_patriots_draft_selectio" (
"round" real,
"overall" real,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the college that has an overall larger than 187 and a round smaller than 7 for the defensive end position.`:
```sql
|
SELECT "player" FROM "shutouts" WHERE "games"<201 AND "rank"=2 AND "years"='2007-2012'; |
## Task
Generate a SQL query to answer the following question:
`Which player has less than 201 games, is ranked 2, and played between 2007-2012?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "shutouts" (
"rank" real,
"player" text,
"nation" text,
"shutouts" real,
"games" real,
"years" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which player has less than 201 games, is ranked 2, and played between 2007-2012?`:
```sql
|
SELECT AVG("games") FROM "shutouts" WHERE "player"='nick rimando'; |
## Task
Generate a SQL query to answer the following question:
`How many average games did Nick Rimando have?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "shutouts" (
"rank" real,
"player" text,
"nation" text,
"shutouts" real,
"games" real,
"years" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many average games did Nick Rimando have?`:
```sql
|
SELECT "party" FROM "list_of_lieutenant_governors" WHERE "left_office"='january 12, 1857'; |
## Task
Generate a SQL query to answer the following question:
`What is the party of the politician who left office on January 12, 1857`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_lieutenant_governors" (
"name" text,
"took_office" text,
"left_office" text,
"party" text,
"governor" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the party of the politician who left office on January 12, 1857`:
```sql
|
SELECT "governor" FROM "list_of_lieutenant_governors" WHERE "name"='hugh thomas miller'; |
## Task
Generate a SQL query to answer the following question:
`What is the party of the governor under Hugh Thomas Miller.`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_lieutenant_governors" (
"name" text,
"took_office" text,
"left_office" text,
"party" text,
"governor" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the party of the governor under Hugh Thomas Miller.`:
```sql
|
SELECT "name" FROM "list_of_lieutenant_governors" WHERE "left_office"='january 9, 1893'; |
## Task
Generate a SQL query to answer the following question:
`Who left office on January 9, 1893`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_lieutenant_governors" (
"name" text,
"took_office" text,
"left_office" text,
"party" text,
"governor" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who left office on January 9, 1893`:
```sql
|
SELECT "took_office" FROM "list_of_lieutenant_governors" WHERE "governor"='matthew e. welsh'; |
## Task
Generate a SQL query to answer the following question:
`Who took office under the government of Matthew E. Welsh?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_lieutenant_governors" (
"name" text,
"took_office" text,
"left_office" text,
"party" text,
"governor" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who took office under the government of Matthew E. Welsh?`:
```sql
|
SELECT "governor" FROM "list_of_lieutenant_governors" WHERE "took_office"='january 13, 1877'; |
## Task
Generate a SQL query to answer the following question:
`Which governor took office on January 13, 1877`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_lieutenant_governors" (
"name" text,
"took_office" text,
"left_office" text,
"party" text,
"governor" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which governor took office on January 13, 1877`:
```sql
|
SELECT "away_team_score" FROM "round_3" WHERE "away_team"='geelong'; |
## Task
Generate a SQL query to answer the following question:
`What is the score of the Geelong away team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_3" (
"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 Geelong away team?`:
```sql
|
SELECT COUNT("crowd") FROM "round_3" WHERE "home_team_score"='10.9 (69)'; |
## Task
Generate a SQL query to answer the following question:
`What is the crowd for the team with a score of 10.9 (69)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_3" (
"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 crowd for the team with a score of 10.9 (69)?`:
```sql
|
SELECT "away_team_score" FROM "round_3" WHERE "venue"='lake oval'; |
## Task
Generate a SQL query to answer the following question:
`What is the score of the team that plays in lake oval?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_3" (
"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 team that plays in lake oval?`:
```sql
|
SELECT "date" FROM "round_3" WHERE "venue"='princes park'; |
## Task
Generate a SQL query to answer the following question:
`What the date of the game of the team that plays in princes park?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_3" (
"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 the date of the game of the team that plays in princes park?`:
```sql
|
SELECT "home_team_score" FROM "round_3" WHERE "home_team"='carlton'; |
## Task
Generate a SQL query to answer the following question:
`What was the score of the home team of carlton?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_3" (
"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 score of the home team of carlton?`:
```sql
|
SELECT "crowd" FROM "round_7" WHERE "away_team"='geelong'; |
## Task
Generate a SQL query to answer the following question:
`How many people watched the away team of Geelong?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_7" (
"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 many people watched the away team of Geelong?`:
```sql
|
SELECT "home_team_score" FROM "round_1" WHERE "venue"='brunswick street oval'; |
## Task
Generate a SQL query to answer the following question:
`Which home team has the Brunswick Street Oval venue?`
### 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 `Which home team has the Brunswick Street Oval venue?`:
```sql
|
SELECT "home_team" FROM "round_1" WHERE "venue"='brunswick street oval'; |
## Task
Generate a SQL query to answer the following question:
`Which home team has the Brunswick Street Oval venue?`
### 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 `Which home team has the Brunswick Street Oval venue?`:
```sql
|
SELECT "away_team" FROM "round_1" WHERE "away_team_score"='11.18 (84)'; |
## Task
Generate a SQL query to answer the following question:
`Which Away team has an Away team score of 11.18 (84)?`
### 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 `Which Away team has an Away team score of 11.18 (84)?`:
```sql
|
SELECT "away_team" FROM "round_1" WHERE "home_team"='collingwood'; |
## Task
Generate a SQL query to answer the following question:
`Which Away team has a Home team of Collingwood?`
### 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 `Which Away team has a Home team of Collingwood?`:
```sql
|
SELECT "away_team" FROM "round_1" WHERE "home_team_score"='9.15 (69)'; |
## Task
Generate a SQL query to answer the following question:
`Which Away team has a Home score of 9.15 (69)?`
### 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 `Which Away team has a Home score of 9.15 (69)?`:
```sql
|
SELECT MIN("total") FROM "crops" WHERE "new_south_wales"=42 AND "victoria"<68; |
## Task
Generate a SQL query to answer the following question:
`Which is the lowest crop total with New South Wales at 42 kilotonnes and Victorian at less than 68 kilotonnes?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "crops" (
"crop_kilotonnes" text,
"new_south_wales" real,
"victoria" real,
"queensland" real,
"western_australia" real,
"south_australia" real,
"tasmania" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which is the lowest crop total with New South Wales at 42 kilotonnes and Victorian at less than 68 kilotonnes?`:
```sql
|
SELECT "qual_1" FROM "qualifying_results" WHERE "best"='1:01.704'; |
## Task
Generate a SQL query to answer the following question:
`Who had a qual 1 best of 1:01.704?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "qualifying_results" (
"name" text,
"team" text,
"qual_1" text,
"qual_2" text,
"best" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who had a qual 1 best of 1:01.704?`:
```sql
|
SELECT "team" FROM "qualifying_results" WHERE "qual_1"='1:02.755'; |
## Task
Generate a SQL query to answer the following question:
`What team had a qual 1 of 1:02.755?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "qualifying_results" (
"name" text,
"team" text,
"qual_1" text,
"qual_2" text,
"best" text
);
### SQL
Given the database schema, here is the SQL query that answers `What team had a qual 1 of 1:02.755?`:
```sql
|
SELECT "qual_1" FROM "qualifying_results" WHERE "team"='rusport' AND "best"='58.665'; |
## Task
Generate a SQL query to answer the following question:
`What is the qual 1 for rusport and had a best of 58.665?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "qualifying_results" (
"name" text,
"team" text,
"qual_1" text,
"qual_2" text,
"best" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the qual 1 for rusport and had a best of 58.665?`:
```sql
|
SELECT "team" FROM "qualifying_results" WHERE "qual_1"='59.895'; |
## Task
Generate a SQL query to answer the following question:
`What team had a qual 1 of 59.895?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "qualifying_results" (
"name" text,
"team" text,
"qual_1" text,
"qual_2" text,
"best" text
);
### SQL
Given the database schema, here is the SQL query that answers `What team had a qual 1 of 59.895?`:
```sql
|
SELECT "name" FROM "qualifying_results" WHERE "qual_1"='1:01.461'; |
## Task
Generate a SQL query to answer the following question:
`Who had a qual 1 of 1:01.461?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "qualifying_results" (
"name" text,
"team" text,
"qual_1" text,
"qual_2" text,
"best" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who had a qual 1 of 1:01.461?`:
```sql
|
SELECT "lfn_support" FROM "windows_nt" WHERE "architecture"='32-bit' AND "name"='windows home server'; |
## Task
Generate a SQL query to answer the following question:
`What is the LFN support with 32-bit architecture on Windows Home Server?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "windows_nt" (
"name" text,
"architecture" text,
"usb_support" text,
"lfn_support" text,
"ap_is" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the LFN support with 32-bit architecture on Windows Home Server?`:
```sql
|
SELECT "lfn_support" FROM "windows_nt" WHERE "name"='windows nt 3.1'; |
## Task
Generate a SQL query to answer the following question:
`What is the LFN support on Windows NT 3.1?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "windows_nt" (
"name" text,
"architecture" text,
"usb_support" text,
"lfn_support" text,
"ap_is" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the LFN support on Windows NT 3.1?`:
```sql
|
SELECT "venue" FROM "round_7" WHERE "away_team_score"='15.23 (113)'; |
## Task
Generate a SQL query to answer the following question:
`What venue has the away side scoring 15.23 (113)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_7" (
"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 has the away side scoring 15.23 (113)?`:
```sql
|
SELECT "venue" FROM "round_7" WHERE "away_team"='hawthorn'; |
## Task
Generate a SQL query to answer the following question:
`What venue features hawthorn as the away team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_7" (
"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 features hawthorn as the away team?`:
```sql
|
SELECT COUNT("crowd") FROM "round_7" WHERE "home_team_score"='11.13 (79)'; |
## Task
Generate a SQL query to answer the following question:
`How many people attended the game with the home side scoring 11.13 (79)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_7" (
"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 many people attended the game with the home side scoring 11.13 (79)?`:
```sql
|
SELECT SUM("cup_apps") FROM "swindon_town_career_details" WHERE "league_apps"<12; |
## Task
Generate a SQL query to answer the following question:
`How many cop apps in the season with fewer than 12 league apps?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "swindon_town_career_details" (
"season" text,
"team" text,
"league_apps" real,
"league_goals" real,
"cup_apps" real,
"cup_goals" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many cop apps in the season with fewer than 12 league apps?`:
```sql
|
SELECT "season" FROM "swindon_town_career_details" WHERE "cup_apps"=6 AND "cup_goals"=5; |
## Task
Generate a SQL query to answer the following question:
`What season saw 6 cup apps and 5 cup goals?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "swindon_town_career_details" (
"season" text,
"team" text,
"league_apps" real,
"league_goals" real,
"cup_apps" real,
"cup_goals" real
);
### SQL
Given the database schema, here is the SQL query that answers `What season saw 6 cup apps and 5 cup goals?`:
```sql
|
SELECT SUM("league_apps") FROM "swindon_town_career_details" WHERE "cup_goals">2 AND "cup_apps">6; |
## Task
Generate a SQL query to answer the following question:
`How many league apps in the season with more than 2 cup goals and more than 6 cup apps?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "swindon_town_career_details" (
"season" text,
"team" text,
"league_apps" real,
"league_goals" real,
"cup_apps" real,
"cup_goals" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many league apps in the season with more than 2 cup goals and more than 6 cup apps?`:
```sql
|
SELECT AVG("cup_goals") FROM "swindon_town_career_details" WHERE "league_apps">34; |
## Task
Generate a SQL query to answer the following question:
`How many cup goals for the season with more than 34 league apps?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "swindon_town_career_details" (
"season" text,
"team" text,
"league_apps" real,
"league_goals" real,
"cup_apps" real,
"cup_goals" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many cup goals for the season with more than 34 league apps?`:
```sql
|
SELECT SUM("cup_goals") FROM "swindon_town_career_details" WHERE "league_apps">5 AND "cup_apps"=1 AND "league_goals"<4; |
## Task
Generate a SQL query to answer the following question:
`How many cup goals in the season with more than 5 league apps, 1 cup apps and fewer than 4 league goals?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "swindon_town_career_details" (
"season" text,
"team" text,
"league_apps" real,
"league_goals" real,
"cup_apps" real,
"cup_goals" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many cup goals in the season with more than 5 league apps, 1 cup apps and fewer than 4 league goals?`:
```sql
|
SELECT "cup_apps" FROM "swindon_town_career_details" WHERE "league_goals">10 AND "league_apps"=23; |
## Task
Generate a SQL query to answer the following question:
`How many cup apps for the season where there are more than 10 league goals and 23 league apps?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "swindon_town_career_details" (
"season" text,
"team" text,
"league_apps" real,
"league_goals" real,
"cup_apps" real,
"cup_goals" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many cup apps for the season where there are more than 10 league goals and 23 league apps?`:
```sql
|
SELECT "route" FROM "stage_results" WHERE "date"='2 july'; |
## Task
Generate a SQL query to answer the following question:
`Which route has a Date of 2 july?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "stage_results" (
"stage" text,
"date" text,
"route" text,
"terrain" text,
"length" text,
"winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which route has a Date of 2 july?`:
```sql
|
SELECT "length" FROM "stage_results" WHERE "stage"='9'; |
## Task
Generate a SQL query to answer the following question:
`Which length has a Stage of 9?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "stage_results" (
"stage" text,
"date" text,
"route" text,
"terrain" text,
"length" text,
"winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which length has a Stage of 9?`:
```sql
|
SELECT "date" FROM "stage_results" WHERE "terrain"='plain stage' AND "stage"='4'; |
## Task
Generate a SQL query to answer the following question:
`Which date has a Terrain of plain stage, and a Stage of 4?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "stage_results" (
"stage" text,
"date" text,
"route" text,
"terrain" text,
"length" text,
"winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which date has a Terrain of plain stage, and a Stage of 4?`:
```sql
|
SELECT "away_team" FROM "round_5" WHERE "crowd">'15,500' AND "venue"='mcg'; |
## Task
Generate a SQL query to answer the following question:
`Who is the away team at the game at MCG with the crowd is larger than 15,500?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_5" (
"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 is the away team at the game at MCG with the crowd is larger than 15,500?`:
```sql
|
SELECT "home_team_score" FROM "round_5" WHERE "home_team"='fitzroy'; |
## Task
Generate a SQL query to answer the following question:
`What is the score for Fitzroy when they are the home team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_5" (
"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 for Fitzroy when they are the home team?`:
```sql
|
SELECT "date" FROM "round_5" WHERE "venue"='arden street oval'; |
## Task
Generate a SQL query to answer the following question:
`What is the date of the game at Arden Street Oval?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_5" (
"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 date of the game at Arden Street Oval?`:
```sql
|
SELECT MIN("crowd") FROM "round_5" WHERE "home_team"='melbourne'; |
## Task
Generate a SQL query to answer the following question:
`What is the smallest crowd for a game when Melbourne is the home team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_5" (
"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 smallest crowd for a game when Melbourne is the home team?`:
```sql
|
SELECT "drafting_team" FROM "2009" WHERE "graduated">2010 AND "college_prior"='michigan'; |
## Task
Generate a SQL query to answer the following question:
`Who drafted the player from Michigan after 2010?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2009" (
"player" text,
"home_town" text,
"college_prior" text,
"drafting_team" text,
"graduated" real
);
### SQL
Given the database schema, here is the SQL query that answers `Who drafted the player from Michigan after 2010?`:
```sql
|
SELECT "home_town" FROM "2009" WHERE "graduated">2010 AND "college_prior"='michigan'; |
## Task
Generate a SQL query to answer the following question:
`Where was the player from who graduated from Michigan after 2010?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2009" (
"player" text,
"home_town" text,
"college_prior" text,
"drafting_team" text,
"graduated" real
);
### SQL
Given the database schema, here is the SQL query that answers `Where was the player from who graduated from Michigan after 2010?`:
```sql
|
SELECT "home_town" FROM "2009" WHERE "player"='steve zakuani'; |
## Task
Generate a SQL query to answer the following question:
`From what town was Steve Zakuani?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2009" (
"player" text,
"home_town" text,
"college_prior" text,
"drafting_team" text,
"graduated" real
);
### SQL
Given the database schema, here is the SQL query that answers `From what town was Steve Zakuani?`:
```sql
|
SELECT SUM("graduated") FROM "2009" WHERE "player"='omar gonzalez'; |
## Task
Generate a SQL query to answer the following question:
`What year did Omar Gonzalez graduate?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2009" (
"player" text,
"home_town" text,
"college_prior" text,
"drafting_team" text,
"graduated" real
);
### SQL
Given the database schema, here is the SQL query that answers `What year did Omar Gonzalez graduate?`:
```sql
|
SELECT "host" FROM "first_and_second_rounds" WHERE "city"='long beach'; |
## Task
Generate a SQL query to answer the following question:
`Which university hosted in Long Beach?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "first_and_second_rounds" (
"region" text,
"host" text,
"venue" text,
"city" text,
"state" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which university hosted in Long Beach?`:
```sql
|
SELECT "venue" FROM "first_and_second_rounds" WHERE "host"='saint joseph''s university'; |
## Task
Generate a SQL query to answer the following question:
`What is the venue that Saint Joseph's University hosted at?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "first_and_second_rounds" (
"region" text,
"host" text,
"venue" text,
"city" text,
"state" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the venue that Saint Joseph's University hosted at?`:
```sql
|
SELECT "city" FROM "first_and_second_rounds" WHERE "venue"='hayman hall (tom gola arena)'; |
## Task
Generate a SQL query to answer the following question:
`In which city is Hayman Hall (Tom Gola Arena) located?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "first_and_second_rounds" (
"region" text,
"host" text,
"venue" text,
"city" text,
"state" text
);
### SQL
Given the database schema, here is the SQL query that answers `In which city is Hayman Hall (Tom Gola Arena) located?`:
```sql
|
SELECT "venue" FROM "first_and_second_rounds" WHERE "city"='villanova'; |
## Task
Generate a SQL query to answer the following question:
`Which venue is in the city of Villanova?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "first_and_second_rounds" (
"region" text,
"host" text,
"venue" text,
"city" text,
"state" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which venue is in the city of Villanova?`:
```sql
|
SELECT "date" FROM "debutantes" WHERE "team"='clare' AND "player"='ger loughnane'; |
## Task
Generate a SQL query to answer the following question:
`On which date did Ger Loughnane from Team Clare have a match?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "debutantes" (
"player" text,
"team" text,
"date" text,
"opposition" text,
"game" text
);
### SQL
Given the database schema, here is the SQL query that answers `On which date did Ger Loughnane from Team Clare have a match?`:
```sql
|
SELECT "team" FROM "debutantes" WHERE "opposition"='tipperary' AND "game"='munster final'; |
## Task
Generate a SQL query to answer the following question:
`What team opposed Tipperary in the Munster Final game?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "debutantes" (
"player" text,
"team" text,
"date" text,
"opposition" text,
"game" text
);
### SQL
Given the database schema, here is the SQL query that answers `What team opposed Tipperary in the Munster Final game?`:
```sql
|
SELECT "date" FROM "debutantes" WHERE "opposition"='limerick' AND "game"='all-ireland final'; |
## Task
Generate a SQL query to answer the following question:
`On what date did Limerick play in the All-Ireland Final game?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "debutantes" (
"player" text,
"team" text,
"date" text,
"opposition" text,
"game" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date did Limerick play in the All-Ireland Final game?`:
```sql
|
SELECT "opposition" FROM "debutantes" WHERE "date"='july 29'; |
## Task
Generate a SQL query to answer the following question:
`Who was the opposition in the game on July 29?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "debutantes" (
"player" text,
"team" text,
"date" text,
"opposition" text,
"game" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the opposition in the game on July 29?`:
```sql
|
SELECT "date" FROM "schedule" WHERE "week"=13; |
## Task
Generate a SQL query to answer the following question:
`What day did the team play week 13?`
### 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 `What day did the team play week 13?`:
```sql
|
SELECT "attendance" FROM "schedule" WHERE "opponent"='bye'; |
## Task
Generate a SQL query to answer the following question:
`What was Bye's opponent's attendance?`
### 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 `What was Bye's opponent's attendance?`:
```sql
|
SELECT "opponent" FROM "schedule" WHERE "week"<10 AND "attendance"='63,672'; |
## Task
Generate a SQL query to answer the following question:
`Which opponent, before Week 10, had an attendance of 63,672?`
### 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 `Which opponent, before Week 10, had an attendance of 63,672?`:
```sql
|
SELECT MIN("week") FROM "schedule" WHERE "attendance"='70,225'; |
## Task
Generate a SQL query to answer the following question:
`Which week had an attendance of 70,225`
### 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 `Which week had an attendance of 70,225`:
```sql
|
SELECT MAX("injured") FROM "2007" WHERE "place"='rohtas, bihar' AND "killed"<13; |
## Task
Generate a SQL query to answer the following question:
`What was the highest number of people injured at incidents located at Rohtas, Bihar where fewer than 13 were killed?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2007" (
"incident_no" text,
"date" text,
"place" text,
"killed" real,
"injured" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the highest number of people injured at incidents located at Rohtas, Bihar where fewer than 13 were killed?`:
```sql
|
SELECT MAX("injured") FROM "2007" WHERE "place"='vaishali, bihar'; |
## Task
Generate a SQL query to answer the following question:
`What was the highest number of people injured in incidents in Vaishali, Bihar?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2007" (
"incident_no" text,
"date" text,
"place" text,
"killed" real,
"injured" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the highest number of people injured in incidents in Vaishali, Bihar?`:
```sql
|
SELECT "away_team_score" FROM "round_7" WHERE "away_team"='geelong'; |
## Task
Generate a SQL query to answer the following question:
`How many points did the Away team from Geelong score?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_7" (
"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 many points did the Away team from Geelong score?`:
```sql
|
SELECT COUNT("crowd") FROM "round_7" WHERE "venue"='victoria park'; |
## Task
Generate a SQL query to answer the following question:
`How many people were in the crowd at Victoria Park?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_7" (
"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 many people were in the crowd at Victoria Park?`:
```sql
|
SELECT "away_team_score" FROM "round_7" WHERE "away_team"='melbourne'; |
## Task
Generate a SQL query to answer the following question:
`How many points did the away team from Melbourne score?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_7" (
"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 many points did the away team from Melbourne score?`:
```sql
|
SELECT "date" FROM "round_7" WHERE "home_team"='carlton'; |
## Task
Generate a SQL query to answer the following question:
`What date did the home team from Carlton play on?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_7" (
"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 the home team from Carlton play on?`:
```sql
|
SELECT "manager" FROM "list_of_managers" WHERE "club"='st. johnstone'; |
## Task
Generate a SQL query to answer the following question:
`Who is the manager of the St. Johnstone club?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_managers" (
"manager" text,
"nationality" text,
"date_of_birth_and_age" text,
"club" text,
"division" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the manager of the St. Johnstone club?`:
```sql
|
SELECT "manager" FROM "list_of_managers" WHERE "club"='stenhousemuir'; |
## Task
Generate a SQL query to answer the following question:
`Who is the manager of the Stenhousemuir club?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_managers" (
"manager" text,
"nationality" text,
"date_of_birth_and_age" text,
"club" text,
"division" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the manager of the Stenhousemuir club?`:
```sql
|
SELECT "away_team" FROM "round_16" WHERE "away_team_score"='13.12 (90)'; |
## Task
Generate a SQL query to answer the following question:
`What team was the away ream when they scored 13.12 (90)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_16" (
"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 team was the away ream when they scored 13.12 (90)?`:
```sql
|
SELECT "home_team" FROM "round_16" WHERE "away_team"='south melbourne'; |
## Task
Generate a SQL query to answer the following question:
`What team was home team when south Melbourne was the away team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_16" (
"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 team was home team when south Melbourne was the away team?`:
```sql
|
SELECT "away_team_score" FROM "round_16" WHERE "home_team"='carlton'; |
## Task
Generate a SQL query to answer the following question:
`What was the away team score when the home team was Carlton?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_16" (
"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 team score when the home team was Carlton?`:
```sql
|
SELECT "basin_area_mi_2" FROM "basins" WHERE "basin_area_km_2">'2,261,763' AND "basin"='pearl river'; |
## Task
Generate a SQL query to answer the following question:
`What is the Basin Area mi 2 when the Basin Area km 2 is larger than 2,261,763 and the Basin is Pearl River?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "basins" (
"basin" text,
"continent" text,
"drains_to" text,
"basin_area_km_2" real,
"basin_area_mi_2" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Basin Area mi 2 when the Basin Area km 2 is larger than 2,261,763 and the Basin is Pearl River?`:
```sql
|
SELECT "basin" FROM "basins" WHERE "continent"='south america' AND "basin_area_km_2">'6,144,727' AND "basin_area_mi_2"='238,539'; |
## Task
Generate a SQL query to answer the following question:
`Which Basin's Continent is South America, has a Basin Area km 2 larger than 6,144,727, and a Basin Area mi 2 of 238,539?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "basins" (
"basin" text,
"continent" text,
"drains_to" text,
"basin_area_km_2" real,
"basin_area_mi_2" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Basin's Continent is South America, has a Basin Area km 2 larger than 6,144,727, and a Basin Area mi 2 of 238,539?`:
```sql
|
SELECT "date" FROM "schedule" WHERE "attendance"='bye' AND "week"=11; |
## Task
Generate a SQL query to answer the following question:
`What was date of the bye week 11?`
### 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 `What was date of the bye week 11?`:
```sql
|
SELECT "venue" FROM "round_10" WHERE "away_team"='essendon'; |
## Task
Generate a SQL query to answer the following question:
`Where did Essendon play as the away team?`
### 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 `Where did Essendon play as the away team?`:
```sql
|
SELECT "location" FROM "major_awards" WHERE "female_artist_of_the_year"='carolyn dawn johnson' AND "male_artist_of_the_year"='paul brandt'; |
## Task
Generate a SQL query to answer the following question:
`Where did Carolyn Dawn Johnson win Female Artist of the Year, and Paul Brandt win Male Artist of the Year?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "major_awards" (
"year" real,
"location" text,
"fans_choice_award" text,
"male_artist_of_the_year" text,
"female_artist_of_the_year" text,
"group_or_duo_of_the_year" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where did Carolyn Dawn Johnson win Female Artist of the Year, and Paul Brandt win Male Artist of the Year?`:
```sql
|
SELECT "location" FROM "major_awards" WHERE "group_or_duo_of_the_year"='doc walker' AND "female_artist_of_the_year"='crystal shawanda'; |
## Task
Generate a SQL query to answer the following question:
`Where did Doc Walker win Group or Duo of the Year, and where did Crystal Shawanda win Female Artist of the year?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "major_awards" (
"year" real,
"location" text,
"fans_choice_award" text,
"male_artist_of_the_year" text,
"female_artist_of_the_year" text,
"group_or_duo_of_the_year" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where did Doc Walker win Group or Duo of the Year, and where did Crystal Shawanda win Female Artist of the year?`:
```sql
|
SELECT "female_artist_of_the_year" FROM "major_awards" WHERE "group_or_duo_of_the_year"='family brown' AND "year"=1983; |
## Task
Generate a SQL query to answer the following question:
`Who won Female Artist of the year in 1983, in the same city that Family Brown won Group of Duo of the year?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "major_awards" (
"year" real,
"location" text,
"fans_choice_award" text,
"male_artist_of_the_year" text,
"female_artist_of_the_year" text,
"group_or_duo_of_the_year" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who won Female Artist of the year in 1983, in the same city that Family Brown won Group of Duo of the year?`:
```sql
|
SELECT MAX("season") FROM "by_season" WHERE "engine"='ferrari' AND "driver"='fernando alonso' AND "podiums">13; |
## Task
Generate a SQL query to answer the following question:
`What is the most recent season when Fernando Alonso had more than 13 podiums in a car with a Ferrari engine?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "by_season" (
"season" real,
"driver" text,
"team" text,
"engine" text,
"poles" real,
"wins" real,
"podiums" real,
"points" real,
"margin_of_defeat" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the most recent season when Fernando Alonso had more than 13 podiums in a car with a Ferrari engine?`:
```sql
|
SELECT "engine" FROM "drivers_and_constructors" WHERE "team"='bettenhausen motorsports'; |
## Task
Generate a SQL query to answer the following question:
`What is the engine for the Bettenhausen Motorsports team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "drivers_and_constructors" (
"team" text,
"chassis" text,
"engine" text,
"tires" text,
"drivers" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the engine for the Bettenhausen Motorsports team?`:
```sql
|
SELECT "engine" FROM "drivers_and_constructors" WHERE "chassis"='march' AND "drivers"='steve chassey'; |
## Task
Generate a SQL query to answer the following question:
`What engine does Steve Chassey drive with a march chassis?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "drivers_and_constructors" (
"team" text,
"chassis" text,
"engine" text,
"tires" text,
"drivers" text
);
### SQL
Given the database schema, here is the SQL query that answers `What engine does Steve Chassey drive with a march chassis?`:
```sql
|
SELECT "engine" FROM "drivers_and_constructors" WHERE "team"='arciero racing'; |
## Task
Generate a SQL query to answer the following question:
`What is the engine for the Arciero Racing team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "drivers_and_constructors" (
"team" text,
"chassis" text,
"engine" text,
"tires" text,
"drivers" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the engine for the Arciero Racing team?`:
```sql
|
SELECT "chassis" FROM "drivers_and_constructors" WHERE "engine"='cosworth' AND "drivers"='scott pruett' AND "team"='dick simon racing'; |
## Task
Generate a SQL query to answer the following question:
`What chassis belongs with the Cosworth Engine driven by Scott Pruett on the Dick Simon Racing team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "drivers_and_constructors" (
"team" text,
"chassis" text,
"engine" text,
"tires" text,
"drivers" text
);
### SQL
Given the database schema, here is the SQL query that answers `What chassis belongs with the Cosworth Engine driven by Scott Pruett on the Dick Simon Racing team?`:
```sql
|
SELECT "engine" FROM "drivers_and_constructors" WHERE "team"='alex morales motorsports'; |
## Task
Generate a SQL query to answer the following question:
`What is the engine for the team of Alex Morales Motorsports?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "drivers_and_constructors" (
"team" text,
"chassis" text,
"engine" text,
"tires" text,
"drivers" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the engine for the team of Alex Morales Motorsports?`:
```sql
|
SELECT "engine" FROM "drivers_and_constructors" WHERE "team"='machinists union racing'; |
## Task
Generate a SQL query to answer the following question:
`What is the engine for the Machinists Union Racing team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "drivers_and_constructors" (
"team" text,
"chassis" text,
"engine" text,
"tires" text,
"drivers" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the engine for the Machinists Union Racing team?`:
```sql
|
SELECT "home_team" FROM "round_16" WHERE "away_team_score"='11.14 (80)'; |
## Task
Generate a SQL query to answer the following question:
`Who is the home side when the away side score is 11.14 (80)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_16" (
"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 is the home side when the away side score is 11.14 (80)?`:
```sql
|
SELECT "attendance" FROM "regular_season" WHERE "week"=1; |
## Task
Generate a SQL query to answer the following question:
`What was the attendance for Week 1?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "regular_season" (
"week" real,
"kickoff" text,
"date" text,
"opponent" text,
"result" text,
"record" text,
"game_site" text,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the attendance for Week 1?`:
```sql
|
SELECT "opponent" FROM "regular_season" WHERE "attendance"='73,369'; |
## Task
Generate a SQL query to answer the following question:
`Which team did the Patriots play when there was a game attendance of 73,369?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "regular_season" (
"week" real,
"kickoff" text,
"date" text,
"opponent" text,
"result" text,
"record" text,
"game_site" text,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which team did the Patriots play when there was a game attendance of 73,369?`:
```sql
|
SELECT "date" FROM "regular_season" WHERE "week"=3; |
## Task
Generate a SQL query to answer the following question:
`What date was the Week 3 game played?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "regular_season" (
"week" real,
"kickoff" text,
"date" text,
"opponent" text,
"result" text,
"record" text,
"game_site" text,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date was the Week 3 game played?`:
```sql
|
SELECT MAX("crowd") FROM "round_15" WHERE "venue"='windy hill'; |
## Task
Generate a SQL query to answer the following question:
`What was the highest attendance of the matches that took place at Windy Hill?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_15" (
"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 highest attendance of the matches that took place at Windy Hill?`:
```sql
|
SELECT "home_team" FROM "round_15" WHERE "venue"='glenferrie oval'; |
## Task
Generate a SQL query to answer the following question:
`Which team has a home field at Glenferrie Oval?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_15" (
"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 a home field at Glenferrie Oval?`:
```sql
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.