output stringlengths 27 479 | instruction stringlengths 407 1.39k |
|---|---|
SELECT MAX("crowd") FROM "round_16" WHERE "home_team"='collingwood'; |
## Task
Generate a SQL query to answer the following question:
`How big was the crowd of the Home team of Collingwood?`
### 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 `How big was the crowd of the Home team of Collingwood?`:
```sql
|
SELECT "away_team" FROM "round_16" WHERE "away_team_score"='7.9 (51)'; |
## Task
Generate a SQL query to answer the following question:
`What away team had a score of 7.9 (51)?`
### 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,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What away team had a score of 7.9 (51)?`:
```sql
|
SELECT "home_team_score" FROM "round_16" WHERE "away_team_score"='6.13 (49)'; |
## Task
Generate a SQL query to answer the following question:
`What was the home team score when the away team scored 6.13 (49)?`
### 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,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the home team score when the away team scored 6.13 (49)?`:
```sql
|
SELECT "date" FROM "round_16" WHERE "home_team_score"='5.9 (39)'; |
## Task
Generate a SQL query to answer the following question:
`What date was the home team score 5.9 (39)?`
### 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,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date was the home team score 5.9 (39)?`:
```sql
|
SELECT "away_team" FROM "round_16" WHERE "home_team"='south melbourne'; |
## Task
Generate a SQL query to answer the following question:
`What was the away team when the home team was south melbourne?`
### 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,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the away team when the home team was south melbourne?`:
```sql
|
SELECT "away_team" FROM "round_16" WHERE "home_team_score"='5.9 (39)'; |
## Task
Generate a SQL query to answer the following question:
`What was the away team when the home team score was 5.9 (39)?`
### 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,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the away team when the home team score was 5.9 (39)?`:
```sql
|
SELECT "home_team_score" FROM "round_16" WHERE "away_team_score"='6.13 (49)'; |
## Task
Generate a SQL query to answer the following question:
`What is the home team score when the away team score was 6.13 (49)?`
### 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,
"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 was 6.13 (49)?`:
```sql
|
SELECT "player" FROM "round_one" WHERE "college"='calgary'; |
## Task
Generate a SQL query to answer the following question:
`Who was recruited from Calgary?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_one" (
"pick_num" real,
"cfl_team" text,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was recruited from Calgary?`:
```sql
|
SELECT SUM("wins") FROM "leaders" WHERE "rank">5; |
## Task
Generate a SQL query to answer the following question:
`What number of wins was ranked higher than 5?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "leaders" (
"rank" real,
"player" text,
"country" text,
"earnings" real,
"wins" real
);
### SQL
Given the database schema, here is the SQL query that answers `What number of wins was ranked higher than 5?`:
```sql
|
SELECT "rank" FROM "leaders" WHERE "wins">11 AND "player"='miller barber'; |
## Task
Generate a SQL query to answer the following question:
`What rank is Miller Barber with more than 11 wins?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "leaders" (
"rank" real,
"player" text,
"country" text,
"earnings" real,
"wins" real
);
### SQL
Given the database schema, here is the SQL query that answers `What rank is Miller Barber with more than 11 wins?`:
```sql
|
SELECT "venue" FROM "round_16" WHERE "away_team_score"='11.11 (77)'; |
## Task
Generate a SQL query to answer the following question:
`What was the venue when the away team scored 11.11 (77)?`
### 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 venue when the away team scored 11.11 (77)?`:
```sql
|
SELECT "venue" FROM "round_16" WHERE "home_team"='collingwood'; |
## Task
Generate a SQL query to answer the following question:
`What was the venue when Collingwood was the home 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 was the venue when Collingwood was the home team?`:
```sql
|
SELECT "venue" FROM "round_16" WHERE "away_team_score"='11.11 (77)'; |
## Task
Generate a SQL query to answer the following question:
`What was the venue when the away team scored 11.11 (77)?`
### 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 venue when the away team scored 11.11 (77)?`:
```sql
|
SELECT SUM("crowd") FROM "round_16" WHERE "away_team_score"='17.17 (119)'; |
## Task
Generate a SQL query to answer the following question:
`How many people were in the crowd when the away team scored 17.17 (119)?`
### 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 `How many people were in the crowd when the away team scored 17.17 (119)?`:
```sql
|
SELECT MAX("crowd") FROM "round_16" WHERE "venue"='vfl park'; |
## Task
Generate a SQL query to answer the following question:
`What was the largest crowd at vfl park?`
### 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 largest crowd at vfl park?`:
```sql
|
SELECT "crowd" FROM "round_3" WHERE "home_team"='south melbourne'; |
## Task
Generate a SQL query to answer the following question:
`How many people were at the game where the home team was South Melbourne?`
### 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 `How many people were at the game where the home team was South Melbourne?`:
```sql
|
SELECT "away_team_score" FROM "round_3" WHERE "away_team"='footscray'; |
## Task
Generate a SQL query to answer the following question:
`What was the score when the away team was Footscray?`
### 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 when the away team was Footscray?`:
```sql
|
SELECT "away_team_score" FROM "round_3" WHERE "away_team"='collingwood'; |
## Task
Generate a SQL query to answer the following question:
`What was the score when the away team was Collingwood?`
### 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 when the away team was Collingwood?`:
```sql
|
SELECT "home_team" FROM "round_3" WHERE "venue"='corio oval'; |
## Task
Generate a SQL query to answer the following question:
`What was the home team that played at Corio 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 was the home team that played at Corio Oval?`:
```sql
|
SELECT SUM("goal") FROM "international_goals" WHERE "date"='november 22, 1994'; |
## Task
Generate a SQL query to answer the following question:
`How many goals were scored on November 22, 1994?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "international_goals" (
"goal" real,
"date" text,
"score" text,
"result" text,
"competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many goals were scored on November 22, 1994?`:
```sql
|
SELECT "result" FROM "international_goals" WHERE "goal"=9; |
## Task
Generate a SQL query to answer the following question:
`What was the result of the game with 9 goals?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "international_goals" (
"goal" real,
"date" text,
"score" text,
"result" text,
"competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the result of the game with 9 goals?`:
```sql
|
SELECT MAX("for_prohibition") FROM "results_of_the_national_referendum_on_pr" WHERE "percent_against">10.8 AND "percent_for"<72.2 AND "jurisdiction"='british columbia' AND "against_prohibition"<'4,756'; |
## Task
Generate a SQL query to answer the following question:
`What is the highest number supporting prohibition in British Columbia when the percent opposing is more than 10.8, the percent supporting is less than 72.2, number against is less than 4,756?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "results_of_the_national_referendum_on_pr" (
"jurisdiction" text,
"for_prohibition" real,
"percent_for" real,
"against_prohibition" real,
"percent_against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest number supporting prohibition in British Columbia when the percent opposing is more than 10.8, the percent supporting is less than 72.2, number against is less than 4,756?`:
```sql
|
SELECT MIN("percent_against") FROM "results_of_the_national_referendum_on_pr" WHERE "against_prohibition"='9,575' AND "percent_for"<72.2; |
## Task
Generate a SQL query to answer the following question:
`What is the lowest percentage opposing prohibition when the number opposing is 9,575 and the percent supporting is less than 72.2?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "results_of_the_national_referendum_on_pr" (
"jurisdiction" text,
"for_prohibition" real,
"percent_for" real,
"against_prohibition" real,
"percent_against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest percentage opposing prohibition when the number opposing is 9,575 and the percent supporting is less than 72.2?`:
```sql
|
SELECT MAX("percent_for") FROM "results_of_the_national_referendum_on_pr" WHERE "against_prohibition"<'2,978' AND "percent_against"<31.2 AND "for_prohibition"<'9,461'; |
## Task
Generate a SQL query to answer the following question:
`What is the highest percent supporting prohibition when the number opposing is less than 2,978 and the percent opposing is less than 31.2 while the number supporting is less than 9,461?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "results_of_the_national_referendum_on_pr" (
"jurisdiction" text,
"for_prohibition" real,
"percent_for" real,
"against_prohibition" real,
"percent_against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest percent supporting prohibition when the number opposing is less than 2,978 and the percent opposing is less than 31.2 while the number supporting is less than 9,461?`:
```sql
|
SELECT COUNT("apparent_magnitude") FROM "7701_7800" WHERE "constellation"='sculptor'; |
## Task
Generate a SQL query to answer the following question:
`what is the apparent magnitude of the constellation sculptor`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "7701_7800" (
"ngc_number" real,
"object_type" text,
"constellation" text,
"right_ascension_j2000" text,
"declination_j2000" text,
"apparent_magnitude" real
);
### SQL
Given the database schema, here is the SQL query that answers `what is the apparent magnitude of the constellation sculptor`:
```sql
|
SELECT "right_ascension_j2000" FROM "7701_7800" WHERE "object_type"='spiral galaxy' AND "apparent_magnitude">12.2; |
## Task
Generate a SQL query to answer the following question:
`What is the Right ascension of the Object type spiral galaxy that has an Apparent magnitude larger that 12.2`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "7701_7800" (
"ngc_number" real,
"object_type" text,
"constellation" text,
"right_ascension_j2000" text,
"declination_j2000" text,
"apparent_magnitude" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Right ascension of the Object type spiral galaxy that has an Apparent magnitude larger that 12.2`:
```sql
|
SELECT "constellation" FROM "7701_7800" WHERE "apparent_magnitude">7.7 AND "ngc_number"=7777; |
## Task
Generate a SQL query to answer the following question:
`Which Constellation has an Apparent magnitude larger that 7.7, and an NGC number of 7777`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "7701_7800" (
"ngc_number" real,
"object_type" text,
"constellation" text,
"right_ascension_j2000" text,
"declination_j2000" text,
"apparent_magnitude" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Constellation has an Apparent magnitude larger that 7.7, and an NGC number of 7777`:
```sql
|
SELECT "chassis" FROM "teams_and_drivers" WHERE "rounds"='1' AND "driver"='maria teresa de filippis'; |
## Task
Generate a SQL query to answer the following question:
`What is the name of the Chassis of Diver Maria Teresa de Filippis in round 1?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "teams_and_drivers" (
"entrant" text,
"constructor" text,
"chassis" text,
"engine" text,
"driver" text,
"rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the name of the Chassis of Diver Maria Teresa de Filippis in round 1?`:
```sql
|
SELECT COUNT("yards") FROM "running_backs" WHERE "player"='james macpherson' AND "long"<1; |
## Task
Generate a SQL query to answer the following question:
`How many yards have a Player of james macpherson, and a Long smaller than 1?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "running_backs" (
"player" text,
"car" real,
"yards" real,
"avg" real,
"td_s" real,
"long" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many yards have a Player of james macpherson, and a Long smaller than 1?`:
```sql
|
SELECT COUNT("avg") FROM "running_backs" WHERE "td_s"=6 AND "yards">25; |
## Task
Generate a SQL query to answer the following question:
`How many averages have a TD's of 6, and more than 25 yards?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "running_backs" (
"player" text,
"car" real,
"yards" real,
"avg" real,
"td_s" real,
"long" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many averages have a TD's of 6, and more than 25 yards?`:
```sql
|
SELECT MIN("car") FROM "running_backs" WHERE "yards">122; |
## Task
Generate a SQL query to answer the following question:
`What is the lowest car with more than 122 yards?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "running_backs" (
"player" text,
"car" real,
"yards" real,
"avg" real,
"td_s" real,
"long" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest car with more than 122 yards?`:
```sql
|
SELECT "away_team" FROM "round_9" WHERE "home_team_score"='10.13 (73)'; |
## Task
Generate a SQL query to answer the following question:
`What away team has a home team score of 10.13 (73)?`
### 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 away team has a home team score of 10.13 (73)?`:
```sql
|
SELECT "home_team" FROM "round_9" WHERE "home_team_score"='12.12 (84)'; |
## Task
Generate a SQL query to answer the following question:
`Which home team has home team score of 12.12 (84)?`
### 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 home team score of 12.12 (84)?`:
```sql
|
SELECT MIN("round") FROM "draft_picks" WHERE "player"='ryan thang'; |
## Task
Generate a SQL query to answer the following question:
`What round was Ryan Thang drafted in?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "draft_picks" (
"round" real,
"player" text,
"position" text,
"nationality" text,
"college_junior_club_team_league" text
);
### SQL
Given the database schema, here is the SQL query that answers `What round was Ryan Thang drafted in?`:
```sql
|
SELECT COUNT("laps") FROM "race_results" WHERE "car_num">9 AND "driver"='jeff burton' AND "points">118; |
## Task
Generate a SQL query to answer the following question:
`How many laps did Jeff Burton have when he drove car with a # over 9 and more than 118 points?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race_results" (
"driver" text,
"car_num" real,
"make" text,
"points" real,
"laps" real,
"winnings" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many laps did Jeff Burton have when he drove car with a # over 9 and more than 118 points?`:
```sql
|
SELECT SUM("points") FROM "race_results" WHERE "driver"='scott riggs' AND "laps">400; |
## Task
Generate a SQL query to answer the following question:
`What was Scott Riggs points when he had more than 400 laps?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race_results" (
"driver" text,
"car_num" real,
"make" text,
"points" real,
"laps" real,
"winnings" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was Scott Riggs points when he had more than 400 laps?`:
```sql
|
SELECT "driver" FROM "race_results" WHERE "car_num"<5 AND "make"='dodge'; |
## Task
Generate a SQL query to answer the following question:
`Who drove the dodge with a car # less than 5?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race_results" (
"driver" text,
"car_num" real,
"make" text,
"points" real,
"laps" real,
"winnings" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who drove the dodge with a car # less than 5?`:
```sql
|
SELECT "team" FROM "game_log" WHERE "game"<78 AND "high_rebounds"='perkins (9)'; |
## Task
Generate a SQL query to answer the following question:
`What team had a high rebound of perkins (9) and a game smaller than 78?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"game" real,
"date" text,
"team" text,
"score" text,
"high_points" text,
"high_rebounds" text,
"high_assists" text,
"location_attendance" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What team had a high rebound of perkins (9) and a game smaller than 78?`:
```sql
|
SELECT "date" FROM "game_log" WHERE "high_assists"='rondo (5)' AND "high_rebounds"='rondo (10)'; |
## Task
Generate a SQL query to answer the following question:
`What date were the high assists rondo (5) and the high rebounds rondo (10)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"game" real,
"date" text,
"team" text,
"score" text,
"high_points" text,
"high_rebounds" text,
"high_assists" text,
"location_attendance" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date were the high assists rondo (5) and the high rebounds rondo (10)?`:
```sql
|
SELECT "high_points" FROM "game_log" WHERE "date"='april 11'; |
## Task
Generate a SQL query to answer the following question:
`On the date April 11, what were the high points?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"game" real,
"date" text,
"team" text,
"score" text,
"high_points" text,
"high_rebounds" text,
"high_assists" text,
"location_attendance" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `On the date April 11, what were the high points?`:
```sql
|
SELECT COUNT("game") FROM "game_log" WHERE "date"='april 11'; |
## Task
Generate a SQL query to answer the following question:
`On the date April 11, what is the total game number?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"game" real,
"date" text,
"team" text,
"score" text,
"high_points" text,
"high_rebounds" text,
"high_assists" text,
"location_attendance" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `On the date April 11, what is the total game number?`:
```sql
|
SELECT "name" FROM "best_supporting_actress" WHERE "year"='1957'; |
## Task
Generate a SQL query to answer the following question:
`What actor made a film in 1957?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "best_supporting_actress" (
"year" text,
"name" text,
"film" text,
"role" text,
"status" text
);
### SQL
Given the database schema, here is the SQL query that answers `What actor made a film in 1957?`:
```sql
|
SELECT "year" FROM "best_supporting_actress" WHERE "name"='miyoshi umeki'; |
## Task
Generate a SQL query to answer the following question:
`What year did Miyoshi Umeki make a film?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "best_supporting_actress" (
"year" text,
"name" text,
"film" text,
"role" text,
"status" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year did Miyoshi Umeki make a film?`:
```sql
|
SELECT "status" FROM "best_supporting_actress" WHERE "role"='role'; |
## Task
Generate a SQL query to answer the following question:
`What status has a role?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "best_supporting_actress" (
"year" text,
"name" text,
"film" text,
"role" text,
"status" text
);
### SQL
Given the database schema, here is the SQL query that answers `What status has a role?`:
```sql
|
SELECT MIN("round") FROM "winners_by_round" WHERE "nominees"='david mundy'; |
## Task
Generate a SQL query to answer the following question:
`what is the earliest round for nominee david mundy?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "winners_by_round" (
"round" real,
"nominees" text,
"team" text,
"match" text,
"ground" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the earliest round for nominee david mundy?`:
```sql
|
SELECT MAX("round") FROM "winners_by_round" WHERE "ground"='telstra dome' AND "nominees"='shaun burgoyne'; |
## Task
Generate a SQL query to answer the following question:
`what round saw the ground of telstra dome and shaun burgoyne as nominees?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "winners_by_round" (
"round" real,
"nominees" text,
"team" text,
"match" text,
"ground" text
);
### SQL
Given the database schema, here is the SQL query that answers `what round saw the ground of telstra dome and shaun burgoyne as nominees?`:
```sql
|
SELECT AVG("half_marathon_men_s") FROM "winners_by_country" WHERE "marathon_women_s"=2 AND "total"<2; |
## Task
Generate a SQL query to answer the following question:
`When the total winners was smaller than 2 and 2 woman won, what's the average of the men's half marathon winners?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "winners_by_country" (
"country" text,
"total" real,
"marathon_men_s" real,
"marathon_women_s" real,
"half_marathon_men_s" real,
"half_marathon_women_s" real
);
### SQL
Given the database schema, here is the SQL query that answers `When the total winners was smaller than 2 and 2 woman won, what's the average of the men's half marathon winners?`:
```sql
|
SELECT MIN("wins") FROM "final_standing" WHERE "goals_against"<39 AND "losses">2 AND "ties">0; |
## Task
Generate a SQL query to answer the following question:
`What has the lowest number of wins with GA smaller than 39, more than 2 losses, and ties greater than 0?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "final_standing" (
"team" text,
"games_played" real,
"wins" real,
"losses" real,
"ties" real,
"goals_for" real,
"goals_against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What has the lowest number of wins with GA smaller than 39, more than 2 losses, and ties greater than 0?`:
```sql
|
SELECT MAX("ties") FROM "final_standing" WHERE "losses"<4 AND "goals_against"<20; |
## Task
Generate a SQL query to answer the following question:
`Which team has the most ties with fewer than 4 losses and GA smaller than 20?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "final_standing" (
"team" text,
"games_played" real,
"wins" real,
"losses" real,
"ties" real,
"goals_for" real,
"goals_against" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which team has the most ties with fewer than 4 losses and GA smaller than 20?`:
```sql
|
SELECT COUNT("losses") FROM "final_standing" WHERE "games_played"=7 AND "goals_against"<27; |
## Task
Generate a SQL query to answer the following question:
`How many games did the team lose that played 7 games and has a GA of less than 27?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "final_standing" (
"team" text,
"games_played" real,
"wins" real,
"losses" real,
"ties" real,
"goals_for" real,
"goals_against" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many games did the team lose that played 7 games and has a GA of less than 27?`:
```sql
|
SELECT "date" FROM "1930s_bears_12_11_1" WHERE "loser"='chicago bears' AND "location"='green bay' AND "year"<1931; |
## Task
Generate a SQL query to answer the following question:
`what date saw the chicago bears lose in green bay earlier than 1931?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1930s_bears_12_11_1" (
"year" real,
"date" text,
"winner" text,
"result" text,
"loser" text,
"attendance" real,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `what date saw the chicago bears lose in green bay earlier than 1931?`:
```sql
|
SELECT "away_team_score" FROM "round_19" WHERE "away_team"='melbourne'; |
## Task
Generate a SQL query to answer the following question:
`What is the Away team score for Away team Melbourne?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_19" (
"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 for Away team Melbourne?`:
```sql
|
SELECT "home_team" FROM "round_19" WHERE "crowd">'21,876' AND "away_team"='hawthorn'; |
## Task
Generate a SQL query to answer the following question:
`Which Home team with the Hawthorn Away team has a Crowd larger than 21,876?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_19" (
"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 with the Hawthorn Away team has a Crowd larger than 21,876?`:
```sql
|
SELECT "years" FROM "engines" WHERE "displacement"='4.0l (242cid)'; |
## Task
Generate a SQL query to answer the following question:
`what is the years for the displacement 4.0l (242cid)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "engines" (
"years" text,
"displacement" text,
"engine" text,
"power" text,
"torque" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the years for the displacement 4.0l (242cid)?`:
```sql
|
SELECT "engine" FROM "engines" WHERE "torque"='lb·ft (n·m)'; |
## Task
Generate a SQL query to answer the following question:
`Which engine has a torgue of lb·ft (n·m)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "engines" (
"years" text,
"displacement" text,
"engine" text,
"power" text,
"torque" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which engine has a torgue of lb·ft (n·m)?`:
```sql
|
SELECT "years" FROM "ncaa_division_i_fbs_football_win_loss_re" WHERE "tied"<31 AND "pct"=0.5451; |
## Task
Generate a SQL query to answer the following question:
`How many years for the team with under 31 ties and a percentage of 0.5451?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "ncaa_division_i_fbs_football_win_loss_re" (
"mountain_west" text,
"lost" real,
"tied" real,
"pct" real,
"years" real,
"total_games" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many years for the team with under 31 ties and a percentage of 0.5451?`:
```sql
|
SELECT COUNT("tied") FROM "ncaa_division_i_fbs_football_win_loss_re" WHERE "mountain_west"='air force' AND "years">57; |
## Task
Generate a SQL query to answer the following question:
`How many games tied for the air force with over 57 years participating?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "ncaa_division_i_fbs_football_win_loss_re" (
"mountain_west" text,
"lost" real,
"tied" real,
"pct" real,
"years" real,
"total_games" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many games tied for the air force with over 57 years participating?`:
```sql
|
SELECT "description" FROM "coaches" WHERE "date"=1911; |
## Task
Generate a SQL query to answer the following question:
`What is the description where the date is 1911?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "coaches" (
"number_name" text,
"description" text,
"livery" text,
"owner_s" text,
"date" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the description where the date is 1911?`:
```sql
|
SELECT "number_name" FROM "coaches" WHERE "date"<1905; |
## Task
Generate a SQL query to answer the following question:
`What is the number and name where the date is earlier than 1905?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "coaches" (
"number_name" text,
"description" text,
"livery" text,
"owner_s" text,
"date" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the number and name where the date is earlier than 1905?`:
```sql
|
SELECT "years" FROM "secondary_schools" WHERE "name"='mount roskill grammar school'; |
## Task
Generate a SQL query to answer the following question:
`What year was the name mount roskill grammar school?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "secondary_schools" (
"name" text,
"years" text,
"gender" text,
"local_board" text,
"suburb" text,
"authority" text,
"decile" text,
"roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `What year was the name mount roskill grammar school?`:
```sql
|
SELECT "away_team" FROM "round_7" WHERE "home_team"='melbourne'; |
## Task
Generate a SQL query to answer the following question:
`When melbourne played as the home team, who did they play?`
### 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 `When melbourne played as the home team, who did they play?`:
```sql
|
SELECT "away_team" FROM "round_7" WHERE "home_team"='geelong'; |
## Task
Generate a SQL query to answer the following question:
`When the home team was geelong, who played 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 `When the home team was geelong, who played as the away team?`:
```sql
|
SELECT "away_team" FROM "round_7" WHERE "home_team"='north melbourne'; |
## Task
Generate a SQL query to answer the following question:
`If north melbourne played as the home team, who was the away team they played?`
### 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 `If north melbourne played as the home team, who was the away team they played?`:
```sql
|
SELECT "away_team" FROM "round_7" WHERE "home_team_score"='10.5 (65)'; |
## Task
Generate a SQL query to answer the following question:
`Who was the away team when the home team scored 10.5 (65)?`
### 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 was the away team when the home team scored 10.5 (65)?`:
```sql
|
SELECT "away_team_score" FROM "round_7" WHERE "home_team"='st kilda'; |
## Task
Generate a SQL query to answer the following question:
`When st kilda was playing at home what was the away teams 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 `When st kilda was playing at home what was the away teams score?`:
```sql
|
SELECT "production_code" FROM "season_2_1995_1996" WHERE "season_num"<8 AND "series_num"<31 AND "original_air_date"='september 21, 1995'; |
## Task
Generate a SQL query to answer the following question:
`What is the production code of the episode before season 8, with a series number less than 31, and aired on September 21, 1995?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "season_2_1995_1996" (
"series_num" real,
"season_num" real,
"title" text,
"directed_by" text,
"original_air_date" text,
"production_code" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the production code of the episode before season 8, with a series number less than 31, and aired on September 21, 1995?`:
```sql
|
SELECT "venue" FROM "round_1" WHERE "home_team_score"='14.12 (96)'; |
## Task
Generate a SQL query to answer the following question:
`Where was the game played where the home team scored 14.12 (96)?`
### 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 `Where was the game played where the home team scored 14.12 (96)?`:
```sql
|
SELECT "away_team" FROM "round_1" WHERE "home_team_score"='18.9 (117)'; |
## Task
Generate a SQL query to answer the following question:
`Who was the away team when the home team scored 18.9 (117)?`
### 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 `Who was the away team when the home team scored 18.9 (117)?`:
```sql
|
SELECT "home_team" FROM "round_1" WHERE "home_team_score"='18.9 (117)'; |
## Task
Generate a SQL query to answer the following question:
`Which home team scored 18.9 (117)?`
### 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 scored 18.9 (117)?`:
```sql
|
SELECT MIN("crowd") FROM "round_1" WHERE "away_team"='hawthorn'; |
## Task
Generate a SQL query to answer the following question:
`What is the smallest amount of spectators when the away team was Hawthorn?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_1" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the smallest amount of spectators when the away team was Hawthorn?`:
```sql
|
SELECT SUM("crowd") FROM "round_1" WHERE "away_team"='richmond'; |
## Task
Generate a SQL query to answer the following question:
`How many people attended when the away team was Richmond?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_1" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many people attended when the away team was Richmond?`:
```sql
|
SELECT "score" FROM "december" WHERE "decision"='toivonen' AND "record"='18–14–4'; |
## Task
Generate a SQL query to answer the following question:
`What was the score when the record was 18–14–4 with a toivonen decision?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "december" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"decision" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score when the record was 18–14–4 with a toivonen decision?`:
```sql
|
SELECT SUM("attendance") FROM "december" WHERE "home"='calgary'; |
## Task
Generate a SQL query to answer the following question:
`What's the sum of the attendance for the calgary home team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "december" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"decision" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the sum of the attendance for the calgary home team?`:
```sql
|
SELECT "record" FROM "december" WHERE "visitor"='chicago'; |
## Task
Generate a SQL query to answer the following question:
`What was the record when chicago was the visiting team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "december" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"decision" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the record when chicago was the visiting team?`:
```sql
|
SELECT "series" FROM "postseason" WHERE "attendance">'17,181' AND "loss"='giguere (0–1)'; |
## Task
Generate a SQL query to answer the following question:
`What was the record of the series at the game attended by 17,181 and a loss of Giguere (0–1)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "postseason" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" real,
"series" text,
"arena" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the record of the series at the game attended by 17,181 and a loss of Giguere (0–1)?`:
```sql
|
SELECT "date" FROM "postseason" WHERE "series"='0–1'; |
## Task
Generate a SQL query to answer the following question:
`What was the date of the game when the record of the series was 0–1?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "postseason" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" real,
"series" text,
"arena" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the date of the game when the record of the series was 0–1?`:
```sql
|
SELECT "away_team" FROM "round_10" WHERE "home_team_score"='10.16 (76)'; |
## Task
Generate a SQL query to answer the following question:
`what team was the away team when the home team scored 10.16 (76)?`
### 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 `what team was the away team when the home team scored 10.16 (76)?`:
```sql
|
SELECT SUM("crowd") FROM "round_10" WHERE "away_team_score"='8.12 (60)'; |
## Task
Generate a SQL query to answer the following question:
`What is the sum of Crowd when the away team scored 8.12 (60)?`
### 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 `What is the sum of Crowd when the away team scored 8.12 (60)?`:
```sql
|
SELECT COUNT("crowd") FROM "round_10" WHERE "home_team_score"='15.20 (110)'; |
## Task
Generate a SQL query to answer the following question:
`What is the number of people in the crowd when the home team scored 15.20 (110)?`
### 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 `What is the number of people in the crowd when the home team scored 15.20 (110)?`:
```sql
|
SELECT "away_team_score" FROM "round_10" WHERE "home_team"='south melbourne'; |
## Task
Generate a SQL query to answer the following question:
`What is the score for the away team when South Melbourne was the home 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 `What is the score for the away team when South Melbourne was the home team?`:
```sql
|
SELECT "result" FROM "2000s_chiefs_12_8" WHERE "year"=2001 AND "location"='network associates coliseum'; |
## Task
Generate a SQL query to answer the following question:
`What was the score of the 2001 game held at Network Associates Coliseum?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2000s_chiefs_12_8" (
"year" real,
"date" text,
"winner" text,
"result" text,
"loser" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score of the 2001 game held at Network Associates Coliseum?`:
```sql
|
SELECT "region" FROM "serie_d" WHERE "home_venue"='giuseppe sivori'; |
## Task
Generate a SQL query to answer the following question:
`What region has giuseppe sivori as a home venue?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "serie_d" (
"name" text,
"short_name" text,
"city" text,
"region" text,
"girone" text,
"home_venue" text
);
### SQL
Given the database schema, here is the SQL query that answers `What region has giuseppe sivori as a home venue?`:
```sql
|
SELECT "city" FROM "serie_d" WHERE "short_name"='pontisola'; |
## Task
Generate a SQL query to answer the following question:
`What city has the nickname of pontisola?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "serie_d" (
"name" text,
"short_name" text,
"city" text,
"region" text,
"girone" text,
"home_venue" text
);
### SQL
Given the database schema, here is the SQL query that answers `What city has the nickname of pontisola?`:
```sql
|
SELECT "name" FROM "serie_d" WHERE "home_venue"='comunale' AND "city"='darfo boario terme'; |
## Task
Generate a SQL query to answer the following question:
`What squad plays at comunale in darfo boario terme?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "serie_d" (
"name" text,
"short_name" text,
"city" text,
"region" text,
"girone" text,
"home_venue" text
);
### SQL
Given the database schema, here is the SQL query that answers `What squad plays at comunale in darfo boario terme?`:
```sql
|
SELECT "pick_num" FROM "round_one" WHERE "league_from"='western hockey league' AND "player"='scott glennie'; |
## Task
Generate a SQL query to answer the following question:
`What pick was Scott Glennie from the Western hockey league`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_one" (
"pick_num" real,
"player" text,
"nationality" text,
"position" text,
"league_from" text
);
### SQL
Given the database schema, here is the SQL query that answers `What pick was Scott Glennie from the Western hockey league`:
```sql
|
SELECT "player" FROM "round_one" WHERE "nationality"='united states' AND "league_from"='western collegiate hockey association'; |
## Task
Generate a SQL query to answer the following question:
`What player from the United States played in the western collegiate hockey association?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_one" (
"pick_num" real,
"player" text,
"nationality" text,
"position" text,
"league_from" text
);
### SQL
Given the database schema, here is the SQL query that answers `What player from the United States played in the western collegiate hockey association?`:
```sql
|
SELECT MAX("laps") FROM "classification" WHERE "time_retired"='+1 lap' AND "constructor"='brm' AND "grid">1; |
## Task
Generate a SQL query to answer the following question:
`Where the time/retired is +1 lap, the constructor is BRM, and the grid is above 1, what's the highest laps recorded?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "classification" (
"driver" text,
"constructor" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `Where the time/retired is +1 lap, the constructor is BRM, and the grid is above 1, what's the highest laps recorded?`:
```sql
|
SELECT COUNT("grid") FROM "classification" WHERE "laps"<9 AND "time_retired"='engine'; |
## Task
Generate a SQL query to answer the following question:
`When the laps driven were under 9 and the time/retired recorded was engine, what's the total number of grid values?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "classification" (
"driver" text,
"constructor" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `When the laps driven were under 9 and the time/retired recorded was engine, what's the total number of grid values?`:
```sql
|
SELECT "driver" FROM "classification" WHERE "grid"=3; |
## Task
Generate a SQL query to answer the following question:
`Which driver has a grid of 3?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "classification" (
"driver" text,
"constructor" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which driver has a grid of 3?`:
```sql
|
SELECT SUM("grid") FROM "classification" WHERE "constructor"='honda' AND "laps"=31; |
## Task
Generate a SQL query to answer the following question:
`When the laps are 31 and the constructor was honda, what's the sum of all grid values?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "classification" (
"driver" text,
"constructor" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `When the laps are 31 and the constructor was honda, what's the sum of all grid values?`:
```sql
|
SELECT "chassis" FROM "drivers_and_constructors" WHERE "rounds"='all' AND "entrant"='benson and hedges jordan' AND "driver"='damon hill'; |
## Task
Generate a SQL query to answer the following question:
`What is the chassis for all rounds on the entrant Benson and Hedges Jordan driven by Damon Hill?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "drivers_and_constructors" (
"entrant" text,
"constructor" text,
"chassis" text,
"engine" text,
"tyre" text,
"driver" text,
"rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the chassis for all rounds on the entrant Benson and Hedges Jordan driven by Damon Hill?`:
```sql
|
SELECT "constructor" FROM "drivers_and_constructors" WHERE "driver"='alexander wurz'; |
## Task
Generate a SQL query to answer the following question:
`What is the constructor of driver Alexander Wurz?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "drivers_and_constructors" (
"entrant" text,
"constructor" text,
"chassis" text,
"engine" text,
"tyre" text,
"driver" text,
"rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the constructor of driver Alexander Wurz?`:
```sql
|
SELECT "driver" FROM "drivers_and_constructors" WHERE "rounds"='all' AND "chassis"='f399'; |
## Task
Generate a SQL query to answer the following question:
`Who was the driver that had all rounds and a f399 chassis?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "drivers_and_constructors" (
"entrant" text,
"constructor" text,
"chassis" text,
"engine" text,
"tyre" text,
"driver" text,
"rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the driver that had all rounds and a f399 chassis?`:
```sql
|
SELECT "rounds" FROM "drivers_and_constructors" WHERE "engine"='ferrari 048'; |
## Task
Generate a SQL query to answer the following question:
`What were the rounds on the Engine † of the Ferrari 048?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "drivers_and_constructors" (
"entrant" text,
"constructor" text,
"chassis" text,
"engine" text,
"tyre" text,
"driver" text,
"rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What were the rounds on the Engine † of the Ferrari 048?`:
```sql
|
SELECT "semifinal" FROM "badminton" WHERE "event"='team'; |
## Task
Generate a SQL query to answer the following question:
`Which Semifinal has an Event of team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "badminton" (
"event" text,
"2nd_round" text,
"quarterfinal" text,
"semifinal" text,
"final" text,
"rank" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Semifinal has an Event of team?`:
```sql
|
SELECT "quarterfinal" FROM "badminton" WHERE "rank">9; |
## Task
Generate a SQL query to answer the following question:
`Which Quarterfinal has a Rank larger than 9?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "badminton" (
"event" text,
"2nd_round" text,
"quarterfinal" text,
"semifinal" text,
"final" text,
"rank" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Quarterfinal has a Rank larger than 9?`:
```sql
|
SELECT COUNT("pick_num") FROM "round_two" WHERE "position"='db'; |
## Task
Generate a SQL query to answer the following question:
`What is the pick number of the DB?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_two" (
"pick_num" real,
"cfl_team" text,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the pick number of the DB?`:
```sql
|
SELECT "college" FROM "round_two" WHERE "pick_num">13 AND "position"='t'; |
## Task
Generate a SQL query to answer the following question:
`What college did the T who was pick after 13 go to?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_two" (
"pick_num" real,
"cfl_team" text,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What college did the T who was pick after 13 go to?`:
```sql
|
SELECT "cfl_team" FROM "round_two" WHERE "college"='boston college'; |
## Task
Generate a SQL query to answer the following question:
`Which CFL team drafted a pick from Boston College?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_two" (
"pick_num" real,
"cfl_team" text,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which CFL team drafted a pick from Boston College?`:
```sql
|
SELECT "position" FROM "round_two" WHERE "college"='saskatchewan'; |
## Task
Generate a SQL query to answer the following question:
`What position did the Saskatchewan player get drafted as?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_two" (
"pick_num" real,
"cfl_team" text,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What position did the Saskatchewan player get drafted as?`:
```sql
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.