output stringlengths 27 479 | instruction stringlengths 407 1.39k |
|---|---|
SELECT "kit_maker" FROM "personnel_and_kits" WHERE "team"='aston villa'; |
## Task
Generate a SQL query to answer the following question:
`Which kit maker does Aston Villa use?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "personnel_and_kits" (
"team" text,
"manager" text,
"captain" text,
"kit_maker" text,
"shirt_sponsor" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which kit maker does Aston Villa use?`:
```sql
|
SELECT "captain" FROM "personnel_and_kits" WHERE "team"='portsmouth'; |
## Task
Generate a SQL query to answer the following question:
`Who captains Portsmouth?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "personnel_and_kits" (
"team" text,
"manager" text,
"captain" text,
"kit_maker" text,
"shirt_sponsor" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who captains Portsmouth?`:
```sql
|
SELECT "event" FROM "list_of_some_notable_incidents_involving" WHERE "location"='brighton, uk'; |
## Task
Generate a SQL query to answer the following question:
`What bombing happened in Brighton, UK?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_some_notable_incidents_involving" (
"year" real,
"event" text,
"location" text,
"perpetrator_s" text,
"deaths" text
);
### SQL
Given the database schema, here is the SQL query that answers `What bombing happened in Brighton, UK?`:
```sql
|
SELECT "result" FROM "papa_bouba_diop_international_goals" WHERE "score"='3–0'; |
## Task
Generate a SQL query to answer the following question:
`What result had a score of 3–0?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "papa_bouba_diop_international_goals" (
"goal" real,
"date" text,
"venue" text,
"score" text,
"result" text,
"competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `What result had a score of 3–0?`:
```sql
|
SELECT "result" FROM "papa_bouba_diop_international_goals" WHERE "venue"='suwon world cup stadium , suwon , south korea' AND "score"='3–0'; |
## Task
Generate a SQL query to answer the following question:
`For the venue of suwon world cup stadium , suwon , south korea and a Score of 3–0 what is the result?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "papa_bouba_diop_international_goals" (
"goal" real,
"date" text,
"venue" text,
"score" text,
"result" text,
"competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `For the venue of suwon world cup stadium , suwon , south korea and a Score of 3–0 what is the result?`:
```sql
|
SELECT MAX("goal") FROM "papa_bouba_diop_international_goals" WHERE "result"='2–3'; |
## Task
Generate a SQL query to answer the following question:
`What is the top goal for the result of 2–3?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "papa_bouba_diop_international_goals" (
"goal" real,
"date" text,
"venue" text,
"score" text,
"result" text,
"competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the top goal for the result of 2–3?`:
```sql
|
SELECT MIN("year") FROM "event_records" WHERE "time"='12:49:08'; |
## Task
Generate a SQL query to answer the following question:
`When was the time of 12:49:08 first set?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "event_records" (
"grade" text,
"team" text,
"town" text,
"time" text,
"year" real
);
### SQL
Given the database schema, here is the SQL query that answers `When was the time of 12:49:08 first set?`:
```sql
|
SELECT "date" FROM "regular_season" WHERE "attendance"='77,918'; |
## Task
Generate a SQL query to answer the following question:
`What was the date when the attendance was 77,918?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "regular_season" (
"week" real,
"date" text,
"opponent" text,
"result" text,
"game_site" text,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the date when the attendance was 77,918?`:
```sql
|
SELECT "attendance" FROM "regular_season" WHERE "game_site"='georgia dome'; |
## Task
Generate a SQL query to answer the following question:
`What was the attendance of the game played in the Georgia Dome?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "regular_season" (
"week" real,
"date" text,
"opponent" text,
"result" text,
"game_site" text,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the attendance of the game played in the Georgia Dome?`:
```sql
|
SELECT "date" FROM "regular_season" WHERE "attendance"='73,529'; |
## Task
Generate a SQL query to answer the following question:
`What was the date when the attendance was 73,529?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "regular_season" (
"week" real,
"date" text,
"opponent" text,
"result" text,
"game_site" text,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the date when the attendance was 73,529?`:
```sql
|
SELECT "away_team" FROM "round_14" WHERE "venue"='western oval'; |
## Task
Generate a SQL query to answer the following question:
`What away team played at Western Oval?`
### 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 away team played at Western Oval?`:
```sql
|
SELECT "away_team" FROM "round_14" WHERE "away_team_score"='18.14 (122)'; |
## Task
Generate a SQL query to answer the following question:
`What away team scored 18.14 (122)?`
### 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 away team scored 18.14 (122)?`:
```sql
|
SELECT "away_team" FROM "round_14" WHERE "away_team_score"='9.15 (69)'; |
## Task
Generate a SQL query to answer the following question:
`What away team scored 9.15 (69)?`
### 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 away team scored 9.15 (69)?`:
```sql
|
SELECT MIN("crowd") FROM "round_14" WHERE "home_team"='footscray'; |
## Task
Generate a SQL query to answer the following question:
`What was the smallest crowd when Footscray played at home?`
### 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 smallest crowd when Footscray played at home?`:
```sql
|
SELECT "away_team" FROM "round_14" WHERE "home_team_score"='9.8 (62)'; |
## Task
Generate a SQL query to answer the following question:
`What was the away team when the home team scored 9.8 (62)?`
### 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 team when the home team scored 9.8 (62)?`:
```sql
|
SELECT "venue" FROM "round_11" WHERE "away_team_score"='10.12 (72)'; |
## Task
Generate a SQL query to answer the following question:
`Where was the game held when the away team scored 10.12 (72)?`
### 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 `Where was the game held when the away team scored 10.12 (72)?`:
```sql
|
SELECT "home_team_score" FROM "round_11" WHERE "away_team_score"='13.6 (84)'; |
## Task
Generate a SQL query to answer the following question:
`What was the home team's score at the game where the away team scored 13.6 (84)?`
### 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 was the home team's score at the game where the away team scored 13.6 (84)?`:
```sql
|
SELECT "outcome" FROM "doubles_11_1_10" WHERE "partner"='mashona washington'; |
## Task
Generate a SQL query to answer the following question:
`What was the outcome when she partnered with mashona washington?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_11_1_10" (
"outcome" text,
"date" text,
"surface" text,
"partner" text,
"opponents" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the outcome when she partnered with mashona washington?`:
```sql
|
SELECT "crowd" FROM "round_9" WHERE "venue"='junction oval'; |
## Task
Generate a SQL query to answer the following question:
`What is the listed crowd at junction oval?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_9" (
"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 listed crowd at junction oval?`:
```sql
|
SELECT SUM("crowd") FROM "round_9" WHERE "away_team"='north melbourne'; |
## Task
Generate a SQL query to answer the following question:
`What is the sum of crowd(s) when north melbourne is away?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_9" (
"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 sum of crowd(s) when north melbourne is away?`:
```sql
|
SELECT "date" FROM "round_9" WHERE "away_team"='south melbourne'; |
## Task
Generate a SQL query to answer the following question:
`What day is south melbourne away?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_9" (
"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 day is south melbourne away?`:
```sql
|
SELECT "away_team_score" FROM "round_8" WHERE "home_team_score"='16.14 (110)'; |
## Task
Generate a SQL query to answer the following question:
`What was the away team's score when the home team scored 16.14 (110)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_8" (
"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's score when the home team scored 16.14 (110)?`:
```sql
|
SELECT "home_team_score" FROM "round_8" WHERE "away_team_score"='13.14 (92)'; |
## Task
Generate a SQL query to answer the following question:
`What was the home team's score when the away team scored 13.14 (92)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_8" (
"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 when the away team scored 13.14 (92)?`:
```sql
|
SELECT "home_team" FROM "round_8" WHERE "crowd">'24,119' AND "away_team_score"='10.13 (73)'; |
## Task
Generate a SQL query to answer the following question:
`Who was the home team at the game where the away team scored 10.13 (73) and there was a crowd over 24,119?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_8" (
"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 was the home team at the game where the away team scored 10.13 (73) and there was a crowd over 24,119?`:
```sql
|
SELECT "score" FROM "goals_for_senior_national_team" WHERE "date"='23 november 2003'; |
## Task
Generate a SQL query to answer the following question:
`What was the score of the competition on 23 November 2003?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "goals_for_senior_national_team" (
"date" text,
"venue" text,
"score" text,
"result" text,
"competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score of the competition on 23 November 2003?`:
```sql
|
SELECT "venue" FROM "round_14" WHERE "away_team"='richmond'; |
## Task
Generate a SQL query to answer the following question:
`Where did Richmond play as an away team?`
### 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 `Where did Richmond play as an away team?`:
```sql
|
SELECT "date" FROM "round_14" WHERE "home_team"='south melbourne'; |
## Task
Generate a SQL query to answer the following question:
`When did South Melbourne play at home?`
### 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 `When did South Melbourne play at home?`:
```sql
|
SELECT AVG("election") FROM "provinces" WHERE "party"='liga veneta' AND "province"='vicenza'; |
## Task
Generate a SQL query to answer the following question:
`What is the average election for vicenza province with the liga veneta party?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "provinces" (
"province" text,
"inhabitants" real,
"president" text,
"party" text,
"election" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average election for vicenza province with the liga veneta party?`:
```sql
|
SELECT SUM("election") FROM "provinces" WHERE "province"='vicenza'; |
## Task
Generate a SQL query to answer the following question:
`What is the sum of elections in vicenza?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "provinces" (
"province" text,
"inhabitants" real,
"president" text,
"party" text,
"election" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the sum of elections in vicenza?`:
```sql
|
SELECT "province" FROM "provinces" WHERE "election">2009; |
## Task
Generate a SQL query to answer the following question:
`What province has an election after 2009?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "provinces" (
"province" text,
"inhabitants" real,
"president" text,
"party" text,
"election" real
);
### SQL
Given the database schema, here is the SQL query that answers `What province has an election after 2009?`:
```sql
|
SELECT "format" FROM "release_details" WHERE "country"='japan'; |
## Task
Generate a SQL query to answer the following question:
`What format does Japan use?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "release_details" (
"country" text,
"date" text,
"label" text,
"format" text,
"catalogue" text
);
### SQL
Given the database schema, here is the SQL query that answers `What format does Japan use?`:
```sql
|
SELECT "date" FROM "release_details" WHERE "catalogue"='540 3622'; |
## Task
Generate a SQL query to answer the following question:
`What date has a catalogue of 540 3622?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "release_details" (
"country" text,
"date" text,
"label" text,
"format" text,
"catalogue" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date has a catalogue of 540 3622?`:
```sql
|
SELECT "format" FROM "release_details" WHERE "catalogue"='asw 40362'; |
## Task
Generate a SQL query to answer the following question:
`What format has a catalogue of asw 40362?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "release_details" (
"country" text,
"date" text,
"label" text,
"format" text,
"catalogue" text
);
### SQL
Given the database schema, here is the SQL query that answers `What format has a catalogue of asw 40362?`:
```sql
|
SELECT "date" FROM "release_details" WHERE "catalogue"='asw 40362'; |
## Task
Generate a SQL query to answer the following question:
`What date has a catalogue of asw 40362?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "release_details" (
"country" text,
"date" text,
"label" text,
"format" text,
"catalogue" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date has a catalogue of asw 40362?`:
```sql
|
SELECT "date" FROM "round_12" WHERE "crowd">'17,000'; |
## Task
Generate a SQL query to answer the following question:
`On what Date is the Crowd larger than 17,000?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_12" (
"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 is the Crowd larger than 17,000?`:
```sql
|
SELECT "home_team" FROM "round_12" WHERE "away_team_score"='8.9 (57)'; |
## Task
Generate a SQL query to answer the following question:
`What Home team has an Away team score of 8.9 (57)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_12" (
"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 Home team has an Away team score of 8.9 (57)?`:
```sql
|
SELECT "home_team_score" FROM "round_12" WHERE "away_team_score"='17.16 (118)'; |
## Task
Generate a SQL query to answer the following question:
`What is the Home team score when the Away team score is 17.16 (118)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_12" (
"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 Home team score when the Away team score is 17.16 (118)?`:
```sql
|
SELECT "away_team" FROM "round_12" WHERE "home_team"='carlton'; |
## Task
Generate a SQL query to answer the following question:
`Which Away team has the Home team of Carlton?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_12" (
"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 the Home team of Carlton?`:
```sql
|
SELECT "score" FROM "doubles_5" WHERE "partner"='jeff tarango'; |
## Task
Generate a SQL query to answer the following question:
`What was the score of the Jeff Tarango game?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_5" (
"date" text,
"tournament" text,
"surface" text,
"partner" text,
"opponents_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score of the Jeff Tarango game?`:
```sql
|
SELECT "venue" FROM "round_7" WHERE "away_team"='collingwood'; |
## Task
Generate a SQL query to answer the following question:
`Where did Collingwood play ae 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 `Where did Collingwood play ae the away team?`:
```sql
|
SELECT "home_team_score" FROM "round_7" WHERE "crowd">'27,000'; |
## Task
Generate a SQL query to answer the following question:
`What was the score when there was more than 27,000 in attendance?`
### 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 was the score when there was more than 27,000 in attendance?`:
```sql
|
SELECT "venue" FROM "round_7" WHERE "home_team"='hawthorn'; |
## Task
Generate a SQL query to answer the following question:
`Where did Hawthorn play as the home 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 `Where did Hawthorn play as the home team?`:
```sql
|
SELECT MIN("start") FROM "leading_point_scorers" WHERE "span"='1990-2005' AND "conv"<2; |
## Task
Generate a SQL query to answer the following question:
`In 1990-2005 what is the lowest Start with Convs smaller than 2?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "leading_point_scorers" (
"player" text,
"span" text,
"start" real,
"tries" real,
"conv" real,
"pens" real,
"drop" real
);
### SQL
Given the database schema, here is the SQL query that answers `In 1990-2005 what is the lowest Start with Convs smaller than 2?`:
```sql
|
SELECT "away_team" FROM "round_14" WHERE "away_team_score"='6.9 (45)'; |
## Task
Generate a SQL query to answer the following question:
`What is the away team when the score is 6.9 (45)?`
### 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 is the away team when the score is 6.9 (45)?`:
```sql
|
SELECT COUNT("crowd") FROM "round_14" WHERE "home_team"='footscray'; |
## Task
Generate a SQL query to answer the following question:
`What is the total of the crowd when the home team is footscray?`
### 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 is the total of the crowd when the home team is footscray?`:
```sql
|
SELECT "away_team_score" FROM "round_14" WHERE "away_team"='essendon'; |
## Task
Generate a SQL query to answer the following question:
`What is the away team score when the away team is Essendon?`
### 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 is the away team score when the away team is Essendon?`:
```sql
|
SELECT "crowd" FROM "round_14" WHERE "home_team_score"='5.9 (39)'; |
## Task
Generate a SQL query to answer the following question:
`What is the crowd total when the home score is 5.9 (39)?`
### 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 is the crowd total when the home score is 5.9 (39)?`:
```sql
|
SELECT COUNT("week") FROM "schedule" WHERE "result"='l 20-10'; |
## Task
Generate a SQL query to answer the following question:
`How many weeks ended in a result of L 20-10?`
### 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 `How many weeks ended in a result of L 20-10?`:
```sql
|
SELECT "attendance" FROM "schedule" WHERE "week"=6; |
## Task
Generate a SQL query to answer the following question:
`What was the attendance in week 6?`
### 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 the attendance in week 6?`:
```sql
|
SELECT "opponent" FROM "schedule" WHERE "attendance"='60,066'; |
## Task
Generate a SQL query to answer the following question:
`Who was the opponent in the game that had an attendance of 60,066?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "schedule" (
"week" real,
"date" text,
"opponent" text,
"result" text,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the opponent in the game that had an attendance of 60,066?`:
```sql
|
SELECT "material_or_non_material" FROM "classification" WHERE "positional_or_automatic"='either' AND "count_rectified"='no' AND "opponents"='either'; |
## Task
Generate a SQL query to answer the following question:
`What is the designation of material or non-material for either positional or automatic with no rectified count and either opponent?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "classification" (
"positional_or_automatic" text,
"opponents" text,
"suits" text,
"material_or_non_material" text,
"count_rectified" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the designation of material or non-material for either positional or automatic with no rectified count and either opponent?`:
```sql
|
SELECT "opponents" FROM "classification" WHERE "positional_or_automatic"='positional' AND "material_or_non_material"='no' AND "suits"='3'; |
## Task
Generate a SQL query to answer the following question:
`What is the value for positional opponents with no material or non-material, and 3 suits?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "classification" (
"positional_or_automatic" text,
"opponents" text,
"suits" text,
"material_or_non_material" text,
"count_rectified" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the value for positional opponents with no material or non-material, and 3 suits?`:
```sql
|
SELECT "material_or_non_material" FROM "classification" WHERE "suits"='2' AND "opponents"='either'; |
## Task
Generate a SQL query to answer the following question:
`Is it material or non-material when there are 2 suits for either opponent?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "classification" (
"positional_or_automatic" text,
"opponents" text,
"suits" text,
"material_or_non_material" text,
"count_rectified" text
);
### SQL
Given the database schema, here is the SQL query that answers `Is it material or non-material when there are 2 suits for either opponent?`:
```sql
|
SELECT "suits" FROM "classification" WHERE "material_or_non_material"='no' AND "opponents"='either' AND "positional_or_automatic"='positional'; |
## Task
Generate a SQL query to answer the following question:
`Which suits have no material or non-material, either opponent, and are positional?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "classification" (
"positional_or_automatic" text,
"opponents" text,
"suits" text,
"material_or_non_material" text,
"count_rectified" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which suits have no material or non-material, either opponent, and are positional?`:
```sql
|
SELECT "count_rectified" FROM "classification" WHERE "opponents"='single' AND "positional_or_automatic"='either' AND "material_or_non_material"='no'; |
## Task
Generate a SQL query to answer the following question:
`Is the count rectified for single opponents, either positional or automatic, and no material or non-material?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "classification" (
"positional_or_automatic" text,
"opponents" text,
"suits" text,
"material_or_non_material" text,
"count_rectified" text
);
### SQL
Given the database schema, here is the SQL query that answers `Is the count rectified for single opponents, either positional or automatic, and no material or non-material?`:
```sql
|
SELECT COUNT("point") FROM "finalised_league_table" WHERE "team"='happy valley' AND "game"<14; |
## Task
Generate a SQL query to answer the following question:
`How many points did Happy Valley score before game 14?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "finalised_league_table" (
"team" text,
"game" real,
"draw" real,
"loss" real,
"goal_gain" real,
"goal_loss" real,
"goal_diff" real,
"point" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many points did Happy Valley score before game 14?`:
```sql
|
SELECT COUNT("point") FROM "finalised_league_table" WHERE "goal_loss"=16 AND "goal_diff"<26 AND "game">14; |
## Task
Generate a SQL query to answer the following question:
`How many points were there in the game with a goal loss of 16 and a goal diff less than 26 after game 14?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "finalised_league_table" (
"team" text,
"game" real,
"draw" real,
"loss" real,
"goal_gain" real,
"goal_loss" real,
"goal_diff" real,
"point" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many points were there in the game with a goal loss of 16 and a goal diff less than 26 after game 14?`:
```sql
|
SELECT MAX("draw") FROM "finalised_league_table" WHERE "goal_gain"=17 AND "game">14; |
## Task
Generate a SQL query to answer the following question:
`How many draws did the game after game 14 with goal gain 17 have?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "finalised_league_table" (
"team" text,
"game" real,
"draw" real,
"loss" real,
"goal_gain" real,
"goal_loss" real,
"goal_diff" real,
"point" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many draws did the game after game 14 with goal gain 17 have?`:
```sql
|
SELECT COUNT("draw") FROM "finalised_league_table" WHERE "loss"<8 AND "point">30 AND "goal_diff">26; |
## Task
Generate a SQL query to answer the following question:
`How many total draws were there with a less than 8 loss, more than 30 points, and a goal diff larger than 26?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "finalised_league_table" (
"team" text,
"game" real,
"draw" real,
"loss" real,
"goal_gain" real,
"goal_loss" real,
"goal_diff" real,
"point" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many total draws were there with a less than 8 loss, more than 30 points, and a goal diff larger than 26?`:
```sql
|
SELECT MAX("loss") FROM "finalised_league_table" WHERE "game"<14; |
## Task
Generate a SQL query to answer the following question:
`What is the highest loss before game 14?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "finalised_league_table" (
"team" text,
"game" real,
"draw" real,
"loss" real,
"goal_gain" real,
"goal_loss" real,
"goal_diff" real,
"point" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest loss before game 14?`:
```sql
|
SELECT AVG("points") FROM "race" WHERE "time_retired"='+16.789' AND "laps">68; |
## Task
Generate a SQL query to answer the following question:
`How many average points did the player with a time/retired of +16.789 and have more laps than 68 have?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race" (
"driver" text,
"team" text,
"laps" real,
"time_retired" text,
"grid" real,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many average points did the player with a time/retired of +16.789 and have more laps than 68 have?`:
```sql
|
SELECT AVG("points") FROM "race" WHERE "team"='minardi team usa' AND "grid"=3 AND "laps">68; |
## Task
Generate a SQL query to answer the following question:
`How many average points did the team Minardi Team USA have when there was a grid 3 and more laps than 68?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race" (
"driver" text,
"team" text,
"laps" real,
"time_retired" text,
"grid" real,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many average points did the team Minardi Team USA have when there was a grid 3 and more laps than 68?`:
```sql
|
SELECT MAX("crowd") FROM "round_9" WHERE "away_team"='richmond'; |
## Task
Generate a SQL query to answer the following question:
`Which was the highest crowd drawn by an Away team in Richmond?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_9" (
"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 was the highest crowd drawn by an Away team in Richmond?`:
```sql
|
SELECT "home_team" FROM "round_9" WHERE "venue"='arden street oval'; |
## Task
Generate a SQL query to answer the following question:
`Which home team has a venue of Arden Street Oval?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_9" (
"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 a venue of Arden Street Oval?`:
```sql
|
SELECT "away_team" FROM "round_9" WHERE "venue"='arden street oval'; |
## Task
Generate a SQL query to answer the following question:
`Which away team has a venue of Arden Street Oval?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_9" (
"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 venue of Arden Street Oval?`:
```sql
|
SELECT "2011" FROM "doubles_performance_timeline" WHERE "2007"='1r'; |
## Task
Generate a SQL query to answer the following question:
`What is the value for 2011 corresponding to a 2007 value of 1r?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_performance_timeline" (
"tournament" text,
"2007" text,
"2011" text,
"2012" text,
"2013" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the value for 2011 corresponding to a 2007 value of 1r?`:
```sql
|
SELECT "2013" FROM "doubles_performance_timeline" WHERE "2012"='grand slam tournaments'; |
## Task
Generate a SQL query to answer the following question:
`What value in 2013 corresponds to Grand Slam Tournaments in 2012?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_performance_timeline" (
"tournament" text,
"2007" text,
"2011" text,
"2012" text,
"2013" text
);
### SQL
Given the database schema, here is the SQL query that answers `What value in 2013 corresponds to Grand Slam Tournaments in 2012?`:
```sql
|
SELECT "2012" FROM "doubles_performance_timeline" WHERE "2011"='1r' AND "2007"='1r'; |
## Task
Generate a SQL query to answer the following question:
`What is the 2012 value when the 2011 and 2007 values are 1R?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_performance_timeline" (
"tournament" text,
"2007" text,
"2011" text,
"2012" text,
"2013" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the 2012 value when the 2011 and 2007 values are 1R?`:
```sql
|
SELECT "2013" FROM "doubles_performance_timeline" WHERE "tournament"='us open'; |
## Task
Generate a SQL query to answer the following question:
`What value for 2013 corresponds to the US Open Tournament?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_performance_timeline" (
"tournament" text,
"2007" text,
"2011" text,
"2012" text,
"2013" text
);
### SQL
Given the database schema, here is the SQL query that answers `What value for 2013 corresponds to the US Open Tournament?`:
```sql
|
SELECT SUM("enrollment") FROM "current_members" WHERE "team_nickname"='wildcats'; |
## Task
Generate a SQL query to answer the following question:
`The school nicknamed the wildcats has what sum of enrollment?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "current_members" (
"institution" text,
"location" text,
"founded" real,
"affiliation" text,
"enrollment" real,
"team_nickname" text
);
### SQL
Given the database schema, here is the SQL query that answers `The school nicknamed the wildcats has what sum of enrollment?`:
```sql
|
SELECT "founded" FROM "current_members" WHERE "location"='paul smiths, new york'; |
## Task
Generate a SQL query to answer the following question:
`What is the Founded year of the school located in Paul Smiths, New York?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "current_members" (
"institution" text,
"location" text,
"founded" real,
"affiliation" text,
"enrollment" real,
"team_nickname" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Founded year of the school located in Paul Smiths, New York?`:
```sql
|
SELECT "home_team" FROM "round_11" WHERE "home_team_score"='9.4 (58)'; |
## Task
Generate a SQL query to answer the following question:
`What home side scored 9.4 (58)?`
### 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 home side scored 9.4 (58)?`:
```sql
|
SELECT "away_team_score" FROM "round_11" WHERE "away_team"='fitzroy'; |
## Task
Generate a SQL query to answer the following question:
`What was fitzroy's away side score?`
### 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 was fitzroy's away side score?`:
```sql
|
SELECT "away_team_score" FROM "round_11" WHERE "home_team_score"='9.4 (58)'; |
## Task
Generate a SQL query to answer the following question:
`What is the away team's score when the home side scores 9.4 (58)?`
### 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 is the away team's score when the home side scores 9.4 (58)?`:
```sql
|
SELECT "player" FROM "2002_new_york_jets_season" WHERE "college"='uab'; |
## Task
Generate a SQL query to answer the following question:
`What player attended UAB college?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2002_new_york_jets_season" (
"round" real,
"pick" real,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What player attended UAB college?`:
```sql
|
SELECT "result" FROM "schedule" WHERE "stadium"='rich stadium'; |
## Task
Generate a SQL query to answer the following question:
`What was the score of the game at RIch Stadium?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "schedule" (
"week" real,
"date" text,
"opponent" text,
"result" text,
"stadium" text,
"record" text,
"attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score of the game at RIch Stadium?`:
```sql
|
SELECT "name" FROM "qualifying_results" WHERE "best"='1:32.269'; |
## Task
Generate a SQL query to answer the following question:
`Who had the best time of 1:32.269?`
### 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 the best time of 1:32.269?`:
```sql
|
SELECT "best" FROM "qualifying_results" WHERE "team"='conquest racing' AND "qual_1"='1:34.748'; |
## Task
Generate a SQL query to answer the following question:
`Who from Conquest Racing had the best time of 1:34.748 in Qual 1?`
### 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 from Conquest Racing had the best time of 1:34.748 in Qual 1?`:
```sql
|
SELECT "qual_2" FROM "qualifying_results" WHERE "best"='1:31.327'; |
## Task
Generate a SQL query to answer the following question:
`Who in Qual 2 had the best time of 1:31.327?`
### 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 in Qual 2 had the best time of 1:31.327?`:
```sql
|
SELECT "best" FROM "qualifying_results" WHERE "name"='dan selznick'; |
## Task
Generate a SQL query to answer the following question:
`What was Dan Selznick best time?`
### 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 was Dan Selznick best time?`:
```sql
|
SELECT "team" FROM "qualifying_results" WHERE "qual_2"='1:34.578'; |
## Task
Generate a SQL query to answer the following question:
`What team had 1:34.578 in Qual 2?`
### 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 1:34.578 in Qual 2?`:
```sql
|
SELECT "team" FROM "qualifying_results" WHERE "name"='jiang tengyi'; |
## Task
Generate a SQL query to answer the following question:
`Jiang Tengyi is on which team?`
### 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 `Jiang Tengyi is on which team?`:
```sql
|
SELECT "away_team_score" FROM "round_9" WHERE "away_team"='footscray'; |
## Task
Generate a SQL query to answer the following question:
`What is the away team's score when footscray is the away team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_9" (
"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 away team's score when footscray is the away team?`:
```sql
|
SELECT "venue" FROM "round_9" WHERE "away_team_score"='8.8 (56)'; |
## Task
Generate a SQL query to answer the following question:
`What venue has an Away team score of 8.8 (56)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_9" (
"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 an Away team score of 8.8 (56)?`:
```sql
|
SELECT "away_team" FROM "round_9" WHERE "away_team_score"='23.14 (152)'; |
## Task
Generate a SQL query to answer the following question:
`Whom is the away team when the Away team score is 23.14 (152)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_9" (
"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 `Whom is the away team when the Away team score is 23.14 (152)?`:
```sql
|
SELECT "home_team" FROM "round_9" WHERE "home_team_score"='12.13 (85)'; |
## Task
Generate a SQL query to answer the following question:
`Whom is the home team when the home team score is 12.13 (85)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_9" (
"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 `Whom is the home team when the home team score is 12.13 (85)?`:
```sql
|
SELECT "rank" FROM "medal_table" WHERE "bronze"=1 AND "nation"='czechoslovakia'; |
## Task
Generate a SQL query to answer the following question:
`What was the rank for czechoslovakia with 1 bronze?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table" (
"rank" text,
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the rank for czechoslovakia with 1 bronze?`:
```sql
|
SELECT COUNT("bronze") FROM "medal_table" WHERE "gold">9; |
## Task
Generate a SQL query to answer the following question:
`How many bronze medals for the nation with over 9 golds?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table" (
"rank" text,
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many bronze medals for the nation with over 9 golds?`:
```sql
|
SELECT AVG("goals") FROM "international_career" WHERE "venue"='hong kong stadium, hong kong'; |
## Task
Generate a SQL query to answer the following question:
`What is the average number of goals that occurred in Hong Kong Stadium, Hong Kong?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "international_career" (
"date" text,
"venue" text,
"result" text,
"goals" real,
"competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average number of goals that occurred in Hong Kong Stadium, Hong Kong?`:
```sql
|
SELECT "country" FROM "currency_and_central_banks" WHERE "value_in_usd">1.33 AND "currency"='pound sterling'; |
## Task
Generate a SQL query to answer the following question:
`Which country uses pound sterling with a value higher than 1.33 USD?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "currency_and_central_banks" (
"country" text,
"currency" text,
"value_in_euro" text,
"value_in_usd" real,
"central_bank" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which country uses pound sterling with a value higher than 1.33 USD?`:
```sql
|
SELECT "away_team" FROM "round_7" WHERE "home_team_score"='13.22 (100)'; |
## Task
Generate a SQL query to answer the following question:
`Who is the away side, when the home side scores 13.22 (100)?`
### 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 `Who is the away side, when the home side scores 13.22 (100)?`:
```sql
|
SELECT "venue" FROM "round_7" WHERE "home_team"='carlton'; |
## Task
Generate a SQL query to answer the following question:
`What venue features carlton at home?`
### 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 carlton at home?`:
```sql
|
SELECT "venue" FROM "round_7" WHERE "away_team"='fitzroy'; |
## Task
Generate a SQL query to answer the following question:
`What venue features fitzroy as the away side?`
### 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 fitzroy as the away side?`:
```sql
|
SELECT "crowd" FROM "round_2" WHERE "home_team_score"='17.14 (116)'; |
## Task
Generate a SQL query to answer the following question:
`What was the crowd size when the home team scored 17.14 (116)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_2" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the crowd size when the home team scored 17.14 (116)?`:
```sql
|
SELECT MIN("crowd") FROM "round_2" WHERE "home_team"='melbourne'; |
## Task
Generate a SQL query to answer the following question:
`What was the smallest crowd that Melbourne played for at home?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_2" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the smallest crowd that Melbourne played for at home?`:
```sql
|
SELECT "home_team_score" FROM "round_2" WHERE "away_team_score"='7.5 (47)'; |
## Task
Generate a SQL query to answer the following question:
`What was the home teams score when the away team scored 7.5 (47)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_2" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the home teams score when the away team scored 7.5 (47)?`:
```sql
|
SELECT "home_team_score" FROM "round_2" WHERE "venue"='victoria park'; |
## Task
Generate a SQL query to answer the following question:
`What was the home teams score at Victoria Park?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_2" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the home teams score at Victoria Park?`:
```sql
|
SELECT "away_team" FROM "round_2" WHERE "home_team_score"='10.14 (74)'; |
## Task
Generate a SQL query to answer the following question:
`What was the away team against which the home team scored 10.14 (74)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_2" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the away team against which the home team scored 10.14 (74)?`:
```sql
|
SELECT "home_team" FROM "round_2" WHERE "away_team"='richmond'; |
## Task
Generate a SQL query to answer the following question:
`What home team played the away team of Richmond?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_2" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What home team played the away team of Richmond?`:
```sql
|
SELECT SUM("high_score") FROM "batting_averages" WHERE "stump"=0 AND "catches"=4 AND "average"<56.1 AND "inns">14; |
## Task
Generate a SQL query to answer the following question:
`What is the high score for the player with 0 stumps, 4 catches, more than 14 inns and an average smaller than 56.1?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "batting_averages" (
"player" text,
"matches" real,
"inns" real,
"runs" real,
"high_score" real,
"average" real,
"catches" real,
"stump" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the high score for the player with 0 stumps, 4 catches, more than 14 inns and an average smaller than 56.1?`:
```sql
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.