output stringlengths 27 479 | instruction stringlengths 407 1.39k |
|---|---|
SELECT "away_team" FROM "round_17" WHERE "home_team"='south melbourne'; |
## Task
Generate a SQL query to answer the following question:
`Who was South Melbourne's away team opponents?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_17" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was South Melbourne's away team opponents?`:
```sql
|
SELECT "leading_scorer" FROM "november" WHERE "date"='november 2, 2007'; |
## Task
Generate a SQL query to answer the following question:
`Who was the leading scorer on November 2, 2007?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "november" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"leading_scorer" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the leading scorer on November 2, 2007?`:
```sql
|
SELECT COUNT("attendance") FROM "november" WHERE "home"='hawks'; |
## Task
Generate a SQL query to answer the following question:
`What was the attendance when the Hawks played?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "november" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"leading_scorer" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the attendance when the Hawks played?`:
```sql
|
SELECT AVG("bronze") FROM "medal_table" WHERE "total">72 AND "nation"='total' AND "silver"<112; |
## Task
Generate a SQL query to answer the following question:
`How many bronzes are there for the total nation with 112 silver and a total of 72?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table" (
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many bronzes are there for the total nation with 112 silver and a total of 72?`:
```sql
|
SELECT MAX("bronze") FROM "medal_table" WHERE "total"<82 AND "nation"='san marino' AND "gold"<3; |
## Task
Generate a SQL query to answer the following question:
`What is the highest bronze for San Marino with less than 82 total and less than 3 golds?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table" (
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest bronze for San Marino with less than 82 total and less than 3 golds?`:
```sql
|
SELECT COUNT("gold") FROM "medal_table" WHERE "bronze">11 AND "total"=29; |
## Task
Generate a SQL query to answer the following question:
`How many golds were there when there was more than 11 bronze and 29 in total?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table" (
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many golds were there when there was more than 11 bronze and 29 in total?`:
```sql
|
SELECT AVG("bronze") FROM "medal_table" WHERE "silver"<7 AND "nation"='montenegro' AND "gold">4; |
## Task
Generate a SQL query to answer the following question:
`What was Montenegro's average bronze with less than 7 silver and more than 4 golds?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table" (
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was Montenegro's average bronze with less than 7 silver and more than 4 golds?`:
```sql
|
SELECT COUNT("gold") FROM "medal_table" WHERE "silver">15 AND "nation"='iceland'; |
## Task
Generate a SQL query to answer the following question:
`How many golds were there for Iceland with more than 15 silver?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table" (
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many golds were there for Iceland with more than 15 silver?`:
```sql
|
SELECT SUM("total") FROM "medal_table" WHERE "silver"<10 AND "nation"='andorra' AND "bronze">5; |
## Task
Generate a SQL query to answer the following question:
`What was Andorra's total with less than 10 silver and more than 5 bronze?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table" (
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was Andorra's total with less than 10 silver and more than 5 bronze?`:
```sql
|
SELECT "roll" FROM "whangarei" WHERE "decile"='6' AND "name"='poroti school'; |
## Task
Generate a SQL query to answer the following question:
`What is the roll number of Poroti school, which has a 6 decile?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "whangarei" (
"name" text,
"years" text,
"area" text,
"authority" text,
"decile" text,
"roll" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the roll number of Poroti school, which has a 6 decile?`:
```sql
|
SELECT "roll" FROM "whangarei" WHERE "authority"='state' AND "area"='waiotira'; |
## Task
Generate a SQL query to answer the following question:
`What is the roll number of the school with a state authority in Waiotira?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "whangarei" (
"name" text,
"years" text,
"area" text,
"authority" text,
"decile" text,
"roll" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the roll number of the school with a state authority in Waiotira?`:
```sql
|
SELECT "area" FROM "whangarei" WHERE "decile"='2' AND "roll"='222'; |
## Task
Generate a SQL query to answer the following question:
`What is the area of the school with a decile of 2 and a roll number 222?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "whangarei" (
"name" text,
"years" text,
"area" text,
"authority" text,
"decile" text,
"roll" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the area of the school with a decile of 2 and a roll number 222?`:
```sql
|
SELECT "decile" FROM "whangarei" WHERE "area"='purua'; |
## Task
Generate a SQL query to answer the following question:
`WHat is the decile of the school in Purua?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "whangarei" (
"name" text,
"years" text,
"area" text,
"authority" text,
"decile" text,
"roll" text
);
### SQL
Given the database schema, here is the SQL query that answers `WHat is the decile of the school in Purua?`:
```sql
|
SELECT "away_team_score" FROM "round_5" WHERE "home_team"='essendon'; |
## Task
Generate a SQL query to answer the following question:
`what is the away team score when the home team is essendon?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_5" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the away team score when the home team is essendon?`:
```sql
|
SELECT "venue" FROM "round_5" WHERE "crowd">'11,131' AND "home_team"='essendon'; |
## Task
Generate a SQL query to answer the following question:
`what is the venue when the crowd is more than 11,131 and the home team is essendon?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_5" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the venue when the crowd is more than 11,131 and the home team is essendon?`:
```sql
|
SELECT COUNT("tied") FROM "ncaa_division_i_fbs_football_win_loss_re" WHERE "total_games"<1183 AND "years"=121 AND "lost">541; |
## Task
Generate a SQL query to answer the following question:
`How many total ties had less than 1183 total games, 121 years, and more than 541 losses?`
### 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" (
"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 total ties had less than 1183 total games, 121 years, and more than 541 losses?`:
```sql
|
SELECT SUM("lost") FROM "ncaa_division_i_fbs_football_win_loss_re" WHERE "years">122 AND "total_games">1244; |
## Task
Generate a SQL query to answer the following question:
`How many losses had more than 122 years and more than 1244 total games?`
### 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" (
"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 losses had more than 122 years and more than 1244 total games?`:
```sql
|
SELECT MIN("earnings") FROM "leaders" WHERE "wins">24; |
## Task
Generate a SQL query to answer the following question:
`What is the lowest earnings for a player with over 24 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 is the lowest earnings for a player with over 24 wins?`:
```sql
|
SELECT MAX("wins") FROM "leaders" WHERE "country"='new zealand' AND "earnings">'1,910,413'; |
## Task
Generate a SQL query to answer the following question:
`Who has the most wins from new zealand with over $1,910,413?`
### 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 `Who has the most wins from new zealand with over $1,910,413?`:
```sql
|
SELECT "constructor" FROM "classification" WHERE "laps"=45 AND "qual"<142.29 AND "driver"='chuck weyant'; |
## Task
Generate a SQL query to answer the following question:
`Which constructor has Chuck Weyant as a driver, 45 laps, and a qual of less than 142.29?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "classification" (
"grid" real,
"driver" text,
"constructor" text,
"qual" real,
"rank" real,
"laps" real,
"time_retired" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which constructor has Chuck Weyant as a driver, 45 laps, and a qual of less than 142.29?`:
```sql
|
SELECT "time_retired" FROM "classification" WHERE "qual"=144.02; |
## Task
Generate a SQL query to answer the following question:
`Which time/retired has a qual of 144.02?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "classification" (
"grid" real,
"driver" text,
"constructor" text,
"qual" real,
"rank" real,
"laps" real,
"time_retired" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which time/retired has a qual of 144.02?`:
```sql
|
SELECT "rounds" FROM "teams_and_drivers" WHERE "driver"='vic elford' AND "engine"='ford cosworth dfv 3.0 v8'; |
## Task
Generate a SQL query to answer the following question:
`Which rounds did Vic Elford with a Ford cosworth dfv 3.0 v8 engine have?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "teams_and_drivers" (
"constructor" text,
"chassis" text,
"engine" text,
"tyre" text,
"driver" text,
"rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which rounds did Vic Elford with a Ford cosworth dfv 3.0 v8 engine have?`:
```sql
|
SELECT "chassis" FROM "teams_and_drivers" WHERE "rounds"='all' AND "tyre"='g' AND "driver"='bruce mclaren'; |
## Task
Generate a SQL query to answer the following question:
`What is the chassis for Bruce Mclaren with all rounds and a g tyre?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "teams_and_drivers" (
"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 Bruce Mclaren with all rounds and a g tyre?`:
```sql
|
SELECT "nhl_team" FROM "draft_picks" WHERE "college_junior_club_team_league"='mississauga icedogs (ohl)'; |
## Task
Generate a SQL query to answer the following question:
`What is the NHL team that has a team (League) of Mississauga Icedogs (ohl)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "draft_picks" (
"round" real,
"player" text,
"nationality" text,
"nhl_team" text,
"college_junior_club_team_league" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the NHL team that has a team (League) of Mississauga Icedogs (ohl)?`:
```sql
|
SELECT COUNT("crowd") FROM "fixtures" WHERE "home_team"='melbourne victory'; |
## Task
Generate a SQL query to answer the following question:
`Im the match where the home team is Melbourne Victory, what was the crowd attendance?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "fixtures" (
"round" text,
"date" text,
"home_team" text,
"score" text,
"away_team" text,
"crowd" real,
"stadium" text,
"match_details" text
);
### SQL
Given the database schema, here is the SQL query that answers `Im the match where the home team is Melbourne Victory, what was the crowd attendance?`:
```sql
|
SELECT "score" FROM "fixtures" WHERE "round"='playoff'; |
## Task
Generate a SQL query to answer the following question:
`What was the score of the match that took place in the playoff round?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "fixtures" (
"round" text,
"date" text,
"home_team" text,
"score" text,
"away_team" text,
"crowd" real,
"stadium" text,
"match_details" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score of the match that took place in the playoff round?`:
```sql
|
SELECT "crowd" FROM "fixtures" WHERE "away_team"='newcastle jets'; |
## Task
Generate a SQL query to answer the following question:
`In the match where newcastle jets was the away team, what was the crown attendance?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "fixtures" (
"round" text,
"date" text,
"home_team" text,
"score" text,
"away_team" text,
"crowd" real,
"stadium" text,
"match_details" text
);
### SQL
Given the database schema, here is the SQL query that answers `In the match where newcastle jets was the away team, what was the crown attendance?`:
```sql
|
SELECT "opponent" FROM "schedule" WHERE "date"='1990-10-21'; |
## Task
Generate a SQL query to answer the following question:
`What team was the opponent on 1990-10-21?`
### 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,
"venue" text,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What team was the opponent on 1990-10-21?`:
```sql
|
SELECT "competition" FROM "achievements" WHERE "year"<1987; |
## Task
Generate a SQL query to answer the following question:
`What was the competition earlier than 1987?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "achievements" (
"year" real,
"competition" text,
"venue" text,
"placed" text,
"event" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the competition earlier than 1987?`:
```sql
|
SELECT "event" FROM "achievements" WHERE "placed"='bronze' AND "year"<1987; |
## Task
Generate a SQL query to answer the following question:
`What event placed bronze earlier than 1987?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "achievements" (
"year" real,
"competition" text,
"venue" text,
"placed" text,
"event" text
);
### SQL
Given the database schema, here is the SQL query that answers `What event placed bronze earlier than 1987?`:
```sql
|
SELECT "score" FROM "singles_12_9_titles_3_runners_up" WHERE "date"='november 13, 2005'; |
## Task
Generate a SQL query to answer the following question:
`What was the score for the match on November 13, 2005?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_12_9_titles_3_runners_up" (
"outcome" text,
"date" text,
"tournament" text,
"surface" text,
"opponent" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score for the match on November 13, 2005?`:
```sql
|
SELECT "tournament" FROM "singles_12_9_titles_3_runners_up" WHERE "surface"='clay' AND "date"='july 17, 2005'; |
## Task
Generate a SQL query to answer the following question:
`What tournament took place on July 17, 2005, with a clay surface?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_12_9_titles_3_runners_up" (
"outcome" text,
"date" text,
"tournament" text,
"surface" text,
"opponent" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What tournament took place on July 17, 2005, with a clay surface?`:
```sql
|
SELECT MAX("grid") FROM "race" WHERE "laps">72; |
## Task
Generate a SQL query to answer the following question:
`What is the highest Grid with over 72 laps?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race" (
"driver" text,
"constructor" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest Grid with over 72 laps?`:
```sql
|
SELECT AVG("laps") FROM "race" WHERE "time_retired"='+1:14.801'; |
## Task
Generate a SQL query to answer the following question:
`What is the average number of laps associated with a Time/Retired of +1:14.801?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race" (
"driver" text,
"constructor" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average number of laps associated with a Time/Retired of +1:14.801?`:
```sql
|
SELECT "date" FROM "race_calendar" WHERE "circuit"='wanneroo park'; |
## Task
Generate a SQL query to answer the following question:
`What date is the circuit at wanneroo park?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race_calendar" (
"race_title" text,
"circuit" text,
"city_state" text,
"date" text,
"winner" text,
"team" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date is the circuit at wanneroo park?`:
```sql
|
SELECT "team" FROM "race_calendar" WHERE "race_title"='calder'; |
## Task
Generate a SQL query to answer the following question:
`What team has a title of calder?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race_calendar" (
"race_title" text,
"circuit" text,
"city_state" text,
"date" text,
"winner" text,
"team" text
);
### SQL
Given the database schema, here is the SQL query that answers `What team has a title of calder?`:
```sql
|
SELECT "laps" FROM "race" WHERE "time_retired"='+1:08.491'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the Laps for time/retired of +1:08.491`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race" (
"driver" text,
"constructor" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the Laps for time/retired of +1:08.491`:
```sql
|
SELECT MAX("laps") FROM "race" WHERE "constructor"='toyota' AND "grid"=13; |
## Task
Generate a SQL query to answer the following question:
`Tell me the highest laps for toyota and grid of 13`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race" (
"driver" text,
"constructor" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the highest laps for toyota and grid of 13`:
```sql
|
SELECT "driver" FROM "race" WHERE "laps"=20; |
## Task
Generate a SQL query to answer the following question:
`I want the Driver with Laps of 20`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race" (
"driver" text,
"constructor" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `I want the Driver with Laps of 20`:
```sql
|
SELECT SUM("grid") FROM "race" WHERE "driver"='giancarlo fisichella'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the sum of Grid for giancarlo fisichella`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race" (
"driver" text,
"constructor" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the sum of Grid for giancarlo fisichella`:
```sql
|
SELECT "date" FROM "round_16" WHERE "venue"='vfl park'; |
## Task
Generate a SQL query to answer the following question:
`What date was the venue 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 date was the venue at VFL park?`:
```sql
|
SELECT COUNT("crowd") FROM "round_16" WHERE "home_team"='melbourne'; |
## Task
Generate a SQL query to answer the following question:
`What was the crowd attendance when the home team was Melbourne?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_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 crowd attendance when the home team was Melbourne?`:
```sql
|
SELECT SUM("crowd") FROM "round_16" WHERE "home_team_score"='13.17 (95)'; |
## Task
Generate a SQL query to answer the following question:
`What was the crowd attendance when the home team scored 13.17 (95)?`
### 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 crowd attendance when the home team scored 13.17 (95)?`:
```sql
|
SELECT "away_team_score" FROM "round_16" WHERE "home_team_score"='15.16 (106)'; |
## Task
Generate a SQL query to answer the following question:
`What was the away team's score when the home team scored 15.16 (106)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_16" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the away team's score when the home team scored 15.16 (106)?`:
```sql
|
SELECT "away_team" FROM "round_16" WHERE "venue"='lake oval'; |
## Task
Generate a SQL query to answer the following question:
`What was the away team when the venue was Lake Oval?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_16" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the away team when the venue was Lake Oval?`:
```sql
|
SELECT "away_team" FROM "round_16" WHERE "home_team"='carlton'; |
## Task
Generate a SQL query to answer the following question:
`What was the away team when the home team was Carlton?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_16" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the away team when the home team was Carlton?`:
```sql
|
SELECT "player" FROM "nfl_draft" WHERE "round"=11 AND "pick"=302; |
## Task
Generate a SQL query to answer the following question:
`What player is picked 302 in round 11?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "nfl_draft" (
"pick" real,
"round" real,
"player" text,
"position" text,
"school" text
);
### SQL
Given the database schema, here is the SQL query that answers `What player is picked 302 in round 11?`:
```sql
|
SELECT MAX("purse") FROM "tournament_results" WHERE "1st_prize"='26,000'; |
## Task
Generate a SQL query to answer the following question:
`What is the biggest purse with a 1st prize of $26,000?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "tournament_results" (
"date" text,
"tournament" text,
"location" text,
"purse" real,
"winner" text,
"score" text,
"1st_prize" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the biggest purse with a 1st prize of $26,000?`:
```sql
|
SELECT "laps" FROM "classification" WHERE "driver"='jackie oliver'; |
## Task
Generate a SQL query to answer the following question:
`How many laps did Jackie Oliver do?`
### 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 `How many laps did Jackie Oliver do?`:
```sql
|
SELECT SUM("laps") FROM "classification" WHERE "grid">7 AND "constructor"='lotus - ford' AND "time_retired"='+ 2 laps'; |
## Task
Generate a SQL query to answer the following question:
`How many laps with a grid larger than 7 did a Lotus - Ford do with a Time/Retired of + 2 laps?`
### 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 `How many laps with a grid larger than 7 did a Lotus - Ford do with a Time/Retired of + 2 laps?`:
```sql
|
SELECT "constellation" FROM "5401_5500" WHERE "ngc_number"<5457; |
## Task
Generate a SQL query to answer the following question:
`What is the name of the constellation that has a NGC number smaller tha 5457?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "5401_5500" (
"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 name of the constellation that has a NGC number smaller tha 5457?`:
```sql
|
SELECT MIN("apparent_magnitude") FROM "5401_5500" WHERE "declination_j2000"='°39′45″'; |
## Task
Generate a SQL query to answer the following question:
`What is the Apparent magnitude of a Declination (J2000) of °39′45″?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "5401_5500" (
"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 a Declination (J2000) of °39′45″?`:
```sql
|
SELECT "supercharger_gear_ratio" FROM "specifications_for_different_r_985_wasp_" WHERE "octane_rating"='68'; |
## Task
Generate a SQL query to answer the following question:
`Which supercharger gear ratio has a Octane rating of 68?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "specifications_for_different_r_985_wasp_" (
"engine" text,
"power_continuous" text,
"power_takeoff" text,
"compression_ratio" text,
"supercharger_gear_ratio" text,
"octane_rating" text,
"dry_weight" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which supercharger gear ratio has a Octane rating of 68?`:
```sql
|
SELECT "elite_eight" FROM "record_by_conference" WHERE "conference"='big west'; |
## Task
Generate a SQL query to answer the following question:
`What is the elite eight result for the big west?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "record_by_conference" (
"conference" text,
"num_of_bids" real,
"record" text,
"win_pct" text,
"round_of_32" text,
"sweet_sixteen" text,
"elite_eight" text,
"final_four" text,
"championship_game" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the elite eight result for the big west?`:
```sql
|
SELECT "votes_pct" FROM "results" WHERE "votes_num">'241,306' AND "appointed"='july 10, 2007'; |
## Task
Generate a SQL query to answer the following question:
`What is the vote percentage when the number is more than 241,306 appointed on July 10, 2007?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "results" (
"candidate" text,
"party" text,
"votes_num" real,
"votes_pct" text,
"ballots_pct" text,
"elected" text,
"appointed" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the vote percentage when the number is more than 241,306 appointed on July 10, 2007?`:
```sql
|
SELECT "votes_pct" FROM "results" WHERE "candidate"='cliff breitkreuz'; |
## Task
Generate a SQL query to answer the following question:
`What is the vote % for Cliff Breitkreuz?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "results" (
"candidate" text,
"party" text,
"votes_num" real,
"votes_pct" text,
"ballots_pct" text,
"elected" text,
"appointed" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the vote % for Cliff Breitkreuz?`:
```sql
|
SELECT "time_retired" FROM "race" WHERE "driver"='damon hill'; |
## Task
Generate a SQL query to answer the following question:
`What is the time/retired for damon hill?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race" (
"driver" text,
"constructor" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the time/retired for damon hill?`:
```sql
|
SELECT "constructor" FROM "race" WHERE "time_retired"='+1 lap' AND "driver"='olivier panis'; |
## Task
Generate a SQL query to answer the following question:
`Who constructed olivier panis' car that retired after +1 lap?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race" (
"driver" text,
"constructor" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `Who constructed olivier panis' car that retired after +1 lap?`:
```sql
|
SELECT "high_assists" FROM "playoffs" WHERE "high_points"='hamilton (24)'; |
## Task
Generate a SQL query to answer the following question:
`What is the high assists of Hamilton (24)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "playoffs" (
"game" real,
"date" text,
"team" text,
"score" text,
"high_points" text,
"high_rebounds" text,
"high_assists" text,
"location_attendance" text,
"series" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the high assists of Hamilton (24)?`:
```sql
|
SELECT "series" FROM "playoffs" WHERE "high_points"='prince (23)'; |
## Task
Generate a SQL query to answer the following question:
`What series had a high points of Prince (23)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "playoffs" (
"game" real,
"date" text,
"team" text,
"score" text,
"high_points" text,
"high_rebounds" text,
"high_assists" text,
"location_attendance" text,
"series" text
);
### SQL
Given the database schema, here is the SQL query that answers `What series had a high points of Prince (23)?`:
```sql
|
SELECT "category" FROM "television" WHERE "awards"='british soap awards' AND "result"='nominated'; |
## Task
Generate a SQL query to answer the following question:
`What category of the British Soap Awards resulted in nominated?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "television" (
"awards" text,
"year" real,
"category" text,
"result" text,
"production" text,
"roll" text
);
### SQL
Given the database schema, here is the SQL query that answers `What category of the British Soap Awards resulted in nominated?`:
```sql
|
SELECT "category" FROM "television" WHERE "year"=2010 AND "result"='nominated' AND "awards"='british soap awards'; |
## Task
Generate a SQL query to answer the following question:
`What category was nominated in 2010 fo the British Soap Awards?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "television" (
"awards" text,
"year" real,
"category" text,
"result" text,
"production" text,
"roll" text
);
### SQL
Given the database schema, here is the SQL query that answers `What category was nominated in 2010 fo the British Soap Awards?`:
```sql
|
SELECT "country" FROM "in" WHERE "name"='dyer'; |
## Task
Generate a SQL query to answer the following question:
`Which country is Dyer from?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "in" (
"name" text,
"country" text,
"type" text,
"moving_from" text,
"transfer_window" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which country is Dyer from?`:
```sql
|
SELECT "country" FROM "in" WHERE "moving_from"='everton'; |
## Task
Generate a SQL query to answer the following question:
`What country is the athlete moving from Everton from?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "in" (
"name" text,
"country" text,
"type" text,
"moving_from" text,
"transfer_window" text
);
### SQL
Given the database schema, here is the SQL query that answers `What country is the athlete moving from Everton from?`:
```sql
|
SELECT "tournament" FROM "grand_slam_doubles_performance_timeline" WHERE "2009"='2r'; |
## Task
Generate a SQL query to answer the following question:
`Name the tournament for 2009 2r`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "grand_slam_doubles_performance_timeline" (
"tournament" text,
"2009" text,
"2011" text,
"2012" text,
"2013" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the tournament for 2009 2r`:
```sql
|
SELECT "2011" FROM "grand_slam_doubles_performance_timeline" WHERE "2009"='2r' AND "tournament"='wimbledon'; |
## Task
Generate a SQL query to answer the following question:
`Name the 2011 for 2009 being 2r at wimbledon`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "grand_slam_doubles_performance_timeline" (
"tournament" text,
"2009" text,
"2011" text,
"2012" text,
"2013" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the 2011 for 2009 being 2r at wimbledon`:
```sql
|
SELECT "2012" FROM "grand_slam_doubles_performance_timeline" WHERE "2009"='1r'; |
## Task
Generate a SQL query to answer the following question:
`Name the 2012 for 2009 of 1r`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "grand_slam_doubles_performance_timeline" (
"tournament" text,
"2009" text,
"2011" text,
"2012" text,
"2013" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the 2012 for 2009 of 1r`:
```sql
|
SELECT "away_team" FROM "round_1" WHERE "home_team"='south melbourne'; |
## Task
Generate a SQL query to answer the following question:
`Who 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_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 was South Melbourne?`:
```sql
|
SELECT MAX("asts") FROM "p" WHERE "from"='2010' AND "rebs"<76; |
## Task
Generate a SQL query to answer the following question:
`What is the high assist total for players from 2010 and under 76 rebounds?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "p" (
"player" text,
"pos" text,
"from" text,
"school_country" text,
"rebs" real,
"asts" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the high assist total for players from 2010 and under 76 rebounds?`:
```sql
|
SELECT COUNT("swimsuit") FROM "scores" WHERE "evening_gown">9.48 AND "country"='florida' AND "interview">8.94; |
## Task
Generate a SQL query to answer the following question:
`What is the total swimsuit number with gowns larger than 9.48 with interviews larger than 8.94 in florida?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "scores" (
"country" text,
"interview" real,
"swimsuit" real,
"evening_gown" real,
"average" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total swimsuit number with gowns larger than 9.48 with interviews larger than 8.94 in florida?`:
```sql
|
SELECT SUM("average") FROM "scores" WHERE "swimsuit"<9.62 AND "country"='colorado'; |
## Task
Generate a SQL query to answer the following question:
`What is the total average for swimsuits smaller than 9.62 in Colorado?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "scores" (
"country" text,
"interview" real,
"swimsuit" real,
"evening_gown" real,
"average" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total average for swimsuits smaller than 9.62 in Colorado?`:
```sql
|
SELECT AVG("bronze") FROM "medal_count" WHERE "total"=47; |
## Task
Generate a SQL query to answer the following question:
`What was the bronze medal count of the team that finished with 47 total medals?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_count" (
"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 bronze medal count of the team that finished with 47 total medals?`:
```sql
|
SELECT SUM("silver") FROM "medal_count" WHERE "bronze"=8; |
## Task
Generate a SQL query to answer the following question:
`What is the silver medal count of the team that finished with 8 bronze medals?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_count" (
"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 is the silver medal count of the team that finished with 8 bronze medals?`:
```sql
|
SELECT "status" FROM "individual" WHERE "athlete"='rené hoppe'; |
## Task
Generate a SQL query to answer the following question:
`What is the status of rené hoppe?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "individual" (
"athlete" text,
"country" text,
"from" real,
"gold" real,
"silver" real,
"total" real,
"status" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the status of rené hoppe?`:
```sql
|
SELECT COUNT("total") FROM "individual" WHERE "country"='switzerland' AND "gold"<7 AND "silver"<3; |
## Task
Generate a SQL query to answer the following question:
`How many times does Switzerland have under 7 golds and less than 3 silvers?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "individual" (
"athlete" text,
"country" text,
"from" real,
"gold" real,
"silver" real,
"total" real,
"status" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many times does Switzerland have under 7 golds and less than 3 silvers?`:
```sql
|
SELECT "athlete" FROM "individual" WHERE "gold"<7 AND "total"=14; |
## Task
Generate a SQL query to answer the following question:
`What athlete has less than 7 gold and 14 total medals?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "individual" (
"athlete" text,
"country" text,
"from" real,
"gold" real,
"silver" real,
"total" real,
"status" text
);
### SQL
Given the database schema, here is the SQL query that answers `What athlete has less than 7 gold and 14 total medals?`:
```sql
|
SELECT AVG("crowd") FROM "round_19" WHERE "home_team"='hawthorn'; |
## Task
Generate a SQL query to answer the following question:
`What is the average crowd size for the home team hawthorn?`
### 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 average crowd size for the home team hawthorn?`:
```sql
|
SELECT "venue" FROM "round_19" WHERE "away_team_score"='8.13 (61)'; |
## Task
Generate a SQL query to answer the following question:
`Where did the away team score 8.13 (61)?`
### 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 `Where did the away team score 8.13 (61)?`:
```sql
|
SELECT "date" FROM "round_19" WHERE "home_team_score"='9.13 (67)'; |
## Task
Generate a SQL query to answer the following question:
`When did the home team score 9.13 (67)?`
### 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 `When did the home team score 9.13 (67)?`:
```sql
|
SELECT "venue" FROM "round_7" WHERE "home_team"='st kilda'; |
## Task
Generate a SQL query to answer the following question:
`Where does St Kilda 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 `Where does St Kilda play?`:
```sql
|
SELECT "home_team" FROM "round_16" WHERE "away_team"='fitzroy'; |
## Task
Generate a SQL query to answer the following question:
`Who was the home team when Fitzroy was the away team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_16" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the home team when Fitzroy was the away team?`:
```sql
|
SELECT "home_team_score" FROM "round_4" WHERE "venue"='kardinia park'; |
## Task
Generate a SQL query to answer the following question:
`What was the home team score at Kardinia Park?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_4" (
"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 score at Kardinia Park?`:
```sql
|
SELECT MIN("crowd") FROM "round_4" WHERE "home_team"='carlton'; |
## Task
Generate a SQL query to answer the following question:
`What was the lowest crowd size for the Carlton at home?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_4" (
"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 lowest crowd size for the Carlton at home?`:
```sql
|
SELECT "engine" FROM "teams_and_drivers" WHERE "rounds"='7' AND "driver"='geki'; |
## Task
Generate a SQL query to answer the following question:
`Name the engine with rounds of 7 with geki driver`
### 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,
"tyre" text,
"driver" text,
"rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the engine with rounds of 7 with geki driver`:
```sql
|
SELECT "driver" FROM "teams_and_drivers" WHERE "rounds"='3'; |
## Task
Generate a SQL query to answer the following question:
`Name the driver for 3 rounds`
### 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,
"tyre" text,
"driver" text,
"rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the driver for 3 rounds`:
```sql
|
SELECT COUNT("crowd") FROM "round_20" WHERE "home_team"='north melbourne'; |
## Task
Generate a SQL query to answer the following question:
`What was the attendance of the North Melbourne's home game?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_20" (
"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 attendance of the North Melbourne's home game?`:
```sql
|
SELECT SUM("crowd") FROM "round_20" WHERE "home_team"='fitzroy'; |
## Task
Generate a SQL query to answer the following question:
`What was the attendance at the Fitzroy home game?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_20" (
"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 attendance at the Fitzroy home game?`:
```sql
|
SELECT MAX("crowd") FROM "round_20" WHERE "home_team"='richmond'; |
## Task
Generate a SQL query to answer the following question:
`What was Richmond's highest attendance?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_20" (
"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 Richmond's highest attendance?`:
```sql
|
SELECT "ground" FROM "friendly" WHERE "match"=4; |
## Task
Generate a SQL query to answer the following question:
`Which ground is match 4 held on?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "friendly" (
"match" real,
"date" text,
"competition_or_tour" text,
"ground" text,
"opponent" text,
"score1" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which ground is match 4 held on?`:
```sql
|
SELECT "game" FROM "game_log" WHERE "team"='chicago'; |
## Task
Generate a SQL query to answer the following question:
`Which game number did they play the Chicago team?`
### 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 `Which game number did they play the Chicago team?`:
```sql
|
SELECT "record" FROM "game_log" WHERE "location_attendance"='air canada centre 19,800'; |
## Task
Generate a SQL query to answer the following question:
`What was the season record when the location attendance was Air Canada Centre 19,800?`
### 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 was the season record when the location attendance was Air Canada Centre 19,800?`:
```sql
|
SELECT "visitor" FROM "january" WHERE "home"='ny rangers'; |
## Task
Generate a SQL query to answer the following question:
`Name the visitor for home of ny rangers`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "january" (
"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 `Name the visitor for home of ny rangers`:
```sql
|
SELECT "label" FROM "versions" WHERE "media"='cd' AND "release_date"=2004; |
## Task
Generate a SQL query to answer the following question:
`What is the label for a CD released in 2004?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "versions" (
"country" text,
"label" text,
"cat_no" text,
"media" text,
"release_date" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the label for a CD released in 2004?`:
```sql
|
SELECT "label" FROM "versions" WHERE "release_date"=1982 AND "country"='us'; |
## Task
Generate a SQL query to answer the following question:
`Who made a release in the US in 1982?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "versions" (
"country" text,
"label" text,
"cat_no" text,
"media" text,
"release_date" real
);
### SQL
Given the database schema, here is the SQL query that answers `Who made a release in the US in 1982?`:
```sql
|
SELECT "date" FROM "round_9" WHERE "home_team_score"='6.17 (53)'; |
## Task
Generate a SQL query to answer the following question:
`On which date did a home team score 6.17 (53)?`
### 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 `On which date did a home team score 6.17 (53)?`:
```sql
|
SELECT SUM("crowd") FROM "round_9" WHERE "venue"='arden street oval'; |
## Task
Generate a SQL query to answer the following question:
`In the match where the venue was arden street oval, what was the crowd attendance?`
### 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 `In the match where the venue was arden street oval, what was the crowd attendance?`:
```sql
|
SELECT SUM("crowd") FROM "round_9" WHERE "venue"='punt road oval'; |
## Task
Generate a SQL query to answer the following question:
`What was the crowd attendance in the match at punt road 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 was the crowd attendance in the match at punt road oval?`:
```sql
|
SELECT "away_team" FROM "round_12" WHERE "crowd">'12,528' AND "home_team"='st kilda'; |
## Task
Generate a SQL query to answer the following question:
`What team played st kilda at their home with a crowd larger than 12,528?`
### 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 team played st kilda at their home with a crowd larger than 12,528?`:
```sql
|
SELECT "home_team_score" FROM "round_12" WHERE "crowd">'21,188'; |
## Task
Generate a SQL query to answer the following question:
`What was the score when the home team had a crowd larger than 21,188?`
### 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 was the score when the home team had a crowd larger than 21,188?`:
```sql
|
SELECT "venue" FROM "round_12" WHERE "away_team"='north melbourne'; |
## Task
Generate a SQL query to answer the following question:
`Where did north melbourne play while away?`
### 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 `Where did north melbourne play while away?`:
```sql
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.