output stringlengths 27 479 | instruction stringlengths 407 1.39k |
|---|---|
SELECT "home_team" FROM "round_11" WHERE "venue"='victoria park'; |
## Task
Generate a SQL query to answer the following question:
`Who played home team at Victoria Park?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_11" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who played home team at Victoria Park?`:
```sql
|
SELECT "season" FROM "club_statistics" WHERE "goals">0 AND "apps"<33; |
## Task
Generate a SQL query to answer the following question:
`What Season has Goals greater than 0 and less than 33 Apps?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "club_statistics" (
"season" text,
"team" text,
"country" text,
"league" text,
"level" real,
"apps" real,
"goals" real
);
### SQL
Given the database schema, here is the SQL query that answers `What Season has Goals greater than 0 and less than 33 Apps?`:
```sql
|
SELECT SUM("car") FROM "running_backs" WHERE "avg"=4.7 AND "long">30; |
## Task
Generate a SQL query to answer the following question:
`How many carries for the RB averaging 4.7, and a long of over 30 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 carries for the RB averaging 4.7, and a long of over 30 yards?`:
```sql
|
SELECT MIN("avg") FROM "running_backs" WHERE "player"='kevin swayne' AND "long">7; |
## Task
Generate a SQL query to answer the following question:
`How many yards did kevin swayne average, with a long carry over 7?`
### 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 did kevin swayne average, with a long carry over 7?`:
```sql
|
SELECT MIN("yards") FROM "running_backs" WHERE "td_s">0 AND "avg"=2.9; |
## Task
Generate a SQL query to answer the following question:
`How many yards for the player with over 0 TDs and an average of 2.9?`
### 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 for the player with over 0 TDs and an average of 2.9?`:
```sql
|
SELECT MIN("td_s") FROM "running_backs" WHERE "avg">7 AND "yards">39; |
## Task
Generate a SQL query to answer the following question:
`How many TDs for the player averaging over 7, and over 39 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 TDs for the player averaging over 7, and over 39 yards?`:
```sql
|
SELECT "catalogue" FROM "disc_one" WHERE "song_title"='harbor lights'; |
## Task
Generate a SQL query to answer the following question:
`What is the catalogue for Harbor Lights as a title?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "disc_one" (
"track" real,
"recorded" text,
"catalogue" text,
"release_date" text,
"song_title" text,
"time" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the catalogue for Harbor Lights as a title?`:
```sql
|
SELECT "catalogue" FROM "disc_one" WHERE "track"=27; |
## Task
Generate a SQL query to answer the following question:
`What cataglogue has 27 tracks?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "disc_one" (
"track" real,
"recorded" text,
"catalogue" text,
"release_date" text,
"song_title" text,
"time" text
);
### SQL
Given the database schema, here is the SQL query that answers `What cataglogue has 27 tracks?`:
```sql
|
SELECT "first_year_played" FROM "current_and_former_player_information" WHERE "doubles_w_l"='8–3'; |
## Task
Generate a SQL query to answer the following question:
`Which year first played with Double W-L of 8–3?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "current_and_former_player_information" (
"name" text,
"total_w_l" text,
"singles_w_l" text,
"doubles_w_l" text,
"no_of_ties" real,
"first_year_played" real,
"no_of_years_played" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which year first played with Double W-L of 8–3?`:
```sql
|
SELECT "height_ft_m" FROM "tallest_buildings" WHERE "year">1983 AND "name"='phoenix tower'; |
## Task
Generate a SQL query to answer the following question:
`What is the height that has a year after 1983 and is named Phoenix Tower?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "tallest_buildings" (
"rank" text,
"name" text,
"height_ft_m" text,
"floors" real,
"year" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the height that has a year after 1983 and is named Phoenix Tower?`:
```sql
|
SELECT MIN("year") FROM "tallest_buildings" WHERE "name"='1500 louisiana street'; |
## Task
Generate a SQL query to answer the following question:
`What is the oldest year listed with the 1500 Louisiana Street name?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "tallest_buildings" (
"rank" text,
"name" text,
"height_ft_m" text,
"floors" real,
"year" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the oldest year listed with the 1500 Louisiana Street name?`:
```sql
|
SELECT "height_ft_m" FROM "tallest_buildings" WHERE "rank"='11'; |
## Task
Generate a SQL query to answer the following question:
`What is the Height of rank 11?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "tallest_buildings" (
"rank" text,
"name" text,
"height_ft_m" text,
"floors" real,
"year" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Height of rank 11?`:
```sql
|
SELECT MAX("enrolment") FROM "winning_head_of_the_river_championship_e" WHERE "denomination"='anglican' AND "day_boarding"='day' AND "founded">1929; |
## Task
Generate a SQL query to answer the following question:
`What is the largest enrollment for anglican day schools founded after 1929?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "winning_head_of_the_river_championship_e" (
"school" text,
"location" text,
"enrolment" real,
"founded" real,
"denomination" text,
"day_boarding" text,
"school_colours" text,
"abbreviation" text,
"in_competition_since" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the largest enrollment for anglican day schools founded after 1929?`:
```sql
|
SELECT "city_of_license" FROM "translators" WHERE "call_sign"='w244bk'; |
## Task
Generate a SQL query to answer the following question:
`What city of license is associated with call sign w244bk?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "translators" (
"call_sign" text,
"frequency_m_hz" real,
"city_of_license" text,
"erp_w" real,
"class" text,
"fcc_info" text
);
### SQL
Given the database schema, here is the SQL query that answers `What city of license is associated with call sign w244bk?`:
```sql
|
SELECT "city_of_license" FROM "translators" WHERE "frequency_m_hz"<107.7 AND "call_sign"='w247aq'; |
## Task
Generate a SQL query to answer the following question:
`What city of license has a Frequency under 107.7, and a call sign of w247aq?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "translators" (
"call_sign" text,
"frequency_m_hz" real,
"city_of_license" text,
"erp_w" real,
"class" text,
"fcc_info" text
);
### SQL
Given the database schema, here is the SQL query that answers `What city of license has a Frequency under 107.7, and a call sign of w247aq?`:
```sql
|
SELECT "team" FROM "game_log" WHERE "high_assists"='earl watson (6)' AND "date"='january 19'; |
## Task
Generate a SQL query to answer the following question:
`Which team was played against on the game where Earl Watson (6) had the highest assists on January 19?`
### 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 team was played against on the game where Earl Watson (6) had the highest assists on January 19?`:
```sql
|
SELECT "singular_word" FROM "plural_forms" WHERE "singular_abbreviation"='p.'; |
## Task
Generate a SQL query to answer the following question:
`A singular abbreviation of p. is used for what singular word?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "plural_forms" (
"singular_abbreviation" text,
"singular_word" text,
"plural_abbreviation" text,
"plural_word" text,
"discipline" text
);
### SQL
Given the database schema, here is the SQL query that answers `A singular abbreviation of p. is used for what singular word?`:
```sql
|
SELECT "singular_word" FROM "plural_forms" WHERE "plural_abbreviation"='pp.'; |
## Task
Generate a SQL query to answer the following question:
`A plural abbreviation of pp. is used for what singular word?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "plural_forms" (
"singular_abbreviation" text,
"singular_word" text,
"plural_abbreviation" text,
"plural_word" text,
"discipline" text
);
### SQL
Given the database schema, here is the SQL query that answers `A plural abbreviation of pp. is used for what singular word?`:
```sql
|
SELECT "singular_word" FROM "plural_forms" WHERE "plural_word"='hands'; |
## Task
Generate a SQL query to answer the following question:
`The plural word of hands uses what singular word?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "plural_forms" (
"singular_abbreviation" text,
"singular_word" text,
"plural_abbreviation" text,
"plural_word" text,
"discipline" text
);
### SQL
Given the database schema, here is the SQL query that answers `The plural word of hands uses what singular word?`:
```sql
|
SELECT "plural_abbreviation" FROM "plural_forms" WHERE "plural_word"='following lines or pages'; |
## Task
Generate a SQL query to answer the following question:
`The plural word of following lines or pages has what plural abbreviation?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "plural_forms" (
"singular_abbreviation" text,
"singular_word" text,
"plural_abbreviation" text,
"plural_word" text,
"discipline" text
);
### SQL
Given the database schema, here is the SQL query that answers `The plural word of following lines or pages has what plural abbreviation?`:
```sql
|
SELECT "plural_word" FROM "plural_forms" WHERE "plural_abbreviation"='ll.'; |
## Task
Generate a SQL query to answer the following question:
`The plural abbreviation of ll. uses what plural word?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "plural_forms" (
"singular_abbreviation" text,
"singular_word" text,
"plural_abbreviation" text,
"plural_word" text,
"discipline" text
);
### SQL
Given the database schema, here is the SQL query that answers `The plural abbreviation of ll. uses what plural word?`:
```sql
|
SELECT "plural_word" FROM "plural_forms" WHERE "singular_word"='hand'; |
## Task
Generate a SQL query to answer the following question:
`The singular word of hand uses what plural word?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "plural_forms" (
"singular_abbreviation" text,
"singular_word" text,
"plural_abbreviation" text,
"plural_word" text,
"discipline" text
);
### SQL
Given the database schema, here is the SQL query that answers `The singular word of hand uses what plural word?`:
```sql
|
SELECT "home_team_score" FROM "round_14" WHERE "home_team"='st kilda'; |
## Task
Generate a SQL query to answer the following question:
`How much did the home team st kilda score?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_14" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `How much did the home team st kilda score?`:
```sql
|
SELECT "away_team_score" FROM "round_14" WHERE "crowd">'7,500'; |
## Task
Generate a SQL query to answer the following question:
`When the crowd was larger than 7,500 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_14" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `When the crowd was larger than 7,500 what was the away teams score?`:
```sql
|
SELECT COUNT("crowd") FROM "round_14" WHERE "venue"='junction oval'; |
## Task
Generate a SQL query to answer the following question:
`What's the total number of people to attend games at junction oval?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_14" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the total number of people to attend games at junction oval?`:
```sql
|
SELECT "crowd" FROM "round_14" WHERE "away_team_score"='11.8 (74)'; |
## Task
Generate a SQL query to answer the following question:
`When the Away team scored 11.8 (74) how many people showed up?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_14" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `When the Away team scored 11.8 (74) how many people showed up?`:
```sql
|
SELECT COUNT("crowd") FROM "round_14" WHERE "venue"='victoria park'; |
## Task
Generate a SQL query to answer the following question:
`How many people have attended victoria park?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_14" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many people have attended victoria park?`:
```sql
|
SELECT "number_of_votes" FROM "president" WHERE "election"=1941; |
## Task
Generate a SQL query to answer the following question:
`How many people voted in the election of 1941?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "president" (
"election" real,
"candidate" text,
"number_of_votes" text,
"share_of_votes" text,
"outcome_of_election" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many people voted in the election of 1941?`:
```sql
|
SELECT "candidate" FROM "president" WHERE "outcome_of_election"='lost' AND "number_of_votes"='770,046'; |
## Task
Generate a SQL query to answer the following question:
`Which candidate lost the election that 770,046 people voted in?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "president" (
"election" real,
"candidate" text,
"number_of_votes" text,
"share_of_votes" text,
"outcome_of_election" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which candidate lost the election that 770,046 people voted in?`:
```sql
|
SELECT "candidate" FROM "president" WHERE "share_of_votes"='61.47%'; |
## Task
Generate a SQL query to answer the following question:
`Which candidate won 61.47% of the votes?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "president" (
"election" real,
"candidate" text,
"number_of_votes" text,
"share_of_votes" text,
"outcome_of_election" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which candidate won 61.47% of the votes?`:
```sql
|
SELECT "share_of_votes" FROM "president" WHERE "election"=1969; |
## Task
Generate a SQL query to answer the following question:
`What percentage of votes did the candidate win in the election of 1969?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "president" (
"election" real,
"candidate" text,
"number_of_votes" text,
"share_of_votes" text,
"outcome_of_election" text
);
### SQL
Given the database schema, here is the SQL query that answers `What percentage of votes did the candidate win in the election of 1969?`:
```sql
|
SELECT "gwr_nos" FROM "locomotives_of_the_great_western_railway" WHERE "quantity"<2 AND "m_swj_nos"='9'; |
## Task
Generate a SQL query to answer the following question:
`Which GWR numbers had a quantity less than 2 when the M&SWJ number was 9?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "locomotives_of_the_great_western_railway" (
"manufacturer" text,
"type" text,
"quantity" real,
"m_swj_nos" text,
"gwr_nos" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which GWR numbers had a quantity less than 2 when the M&SWJ number was 9?`:
```sql
|
SELECT "manufacturer" FROM "locomotives_of_the_great_western_railway" WHERE "type"='2-6-0'; |
## Task
Generate a SQL query to answer the following question:
`Which manucfaturer's type was 2-6-0?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "locomotives_of_the_great_western_railway" (
"manufacturer" text,
"type" text,
"quantity" real,
"m_swj_nos" text,
"gwr_nos" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which manucfaturer's type was 2-6-0?`:
```sql
|
SELECT "score" FROM "december" WHERE "record"='14–10–2'; |
## Task
Generate a SQL query to answer the following question:
`What was the score of the game when the Devils had a record of 14–10–2?`
### 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 of the game when the Devils had a record of 14–10–2?`:
```sql
|
SELECT "date" FROM "december" WHERE "record"='21–14–3'; |
## Task
Generate a SQL query to answer the following question:
`What was the date of the game when the Devils had a record of 21–14–3?`
### 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 date of the game when the Devils had a record of 21–14–3?`:
```sql
|
SELECT "distance" FROM "belmont_stakes_feature_key_prep_races_li" WHERE "winning_horse"='summer doldrums'; |
## Task
Generate a SQL query to answer the following question:
`What distance did the winning horse run in the Summer Doldrums.`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "belmont_stakes_feature_key_prep_races_li" (
"date" text,
"track" text,
"race" text,
"distance" text,
"surface_track" text,
"winning_horse" text,
"winning_jockey" text
);
### SQL
Given the database schema, here is the SQL query that answers `What distance did the winning horse run in the Summer Doldrums.`:
```sql
|
SELECT "winning_horse" FROM "belmont_stakes_feature_key_prep_races_li" WHERE "winning_jockey"='rafael bejarano'; |
## Task
Generate a SQL query to answer the following question:
`Who is the jockey for the winning horse Rafael Bejarano?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "belmont_stakes_feature_key_prep_races_li" (
"date" text,
"track" text,
"race" text,
"distance" text,
"surface_track" text,
"winning_horse" text,
"winning_jockey" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the jockey for the winning horse Rafael Bejarano?`:
```sql
|
SELECT "track" FROM "belmont_stakes_feature_key_prep_races_li" WHERE "distance"='6 furlongs' AND "race"='spectacular bid stakes'; |
## Task
Generate a SQL query to answer the following question:
`What is the race with the track distance of 6 furlongs and spectacular bid stakes?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "belmont_stakes_feature_key_prep_races_li" (
"date" text,
"track" text,
"race" text,
"distance" text,
"surface_track" text,
"winning_horse" text,
"winning_jockey" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the race with the track distance of 6 furlongs and spectacular bid stakes?`:
```sql
|
SELECT "race" FROM "belmont_stakes_feature_key_prep_races_li" WHERE "winning_horse"='dominican' AND "distance"='1-1/16 miles'; |
## Task
Generate a SQL query to answer the following question:
`what race did Dominican win with a distance of 1-1/16 miles?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "belmont_stakes_feature_key_prep_races_li" (
"date" text,
"track" text,
"race" text,
"distance" text,
"surface_track" text,
"winning_horse" text,
"winning_jockey" text
);
### SQL
Given the database schema, here is the SQL query that answers `what race did Dominican win with a distance of 1-1/16 miles?`:
```sql
|
SELECT "tournament" FROM "achievements" WHERE "result"='1st' AND "year">1973; |
## Task
Generate a SQL query to answer the following question:
`What tournament since 1973 has a result of 1st?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "achievements" (
"year" real,
"tournament" text,
"venue" text,
"result" text,
"extra" text
);
### SQL
Given the database schema, here is the SQL query that answers `What tournament since 1973 has a result of 1st?`:
```sql
|
SELECT "tournament" FROM "achievements" WHERE "extra"='400 m hurdles'; |
## Task
Generate a SQL query to answer the following question:
`In what tournament was there an extra of 400 m hurdles?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "achievements" (
"year" real,
"tournament" text,
"venue" text,
"result" text,
"extra" text
);
### SQL
Given the database schema, here is the SQL query that answers `In what tournament was there an extra of 400 m hurdles?`:
```sql
|
SELECT "result" FROM "achievements" WHERE "year"=1973; |
## Task
Generate a SQL query to answer the following question:
`What was the Result in Year 1973?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "achievements" (
"year" real,
"tournament" text,
"venue" text,
"result" text,
"extra" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the Result in Year 1973?`:
```sql
|
SELECT "year" FROM "achievements" WHERE "extra"='800 m' AND "tournament"='european indoor championships' AND "result"='2nd'; |
## Task
Generate a SQL query to answer the following question:
`In which year was the Tournament of european indoor championships played where the Extra was 800 m and the Result was 2nd?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "achievements" (
"year" real,
"tournament" text,
"venue" text,
"result" text,
"extra" text
);
### SQL
Given the database schema, here is the SQL query that answers `In which year was the Tournament of european indoor championships played where the Extra was 800 m and the Result was 2nd?`:
```sql
|
SELECT "player" FROM "2000_team" WHERE "hometown"='chula vista, ca'; |
## Task
Generate a SQL query to answer the following question:
`What player is from Chula Vista, Ca?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2000_team" (
"player" text,
"position" text,
"school" text,
"hometown" text,
"mlb_draft" text
);
### SQL
Given the database schema, here is the SQL query that answers `What player is from Chula Vista, Ca?`:
```sql
|
SELECT "mlb_draft" FROM "2000_team" WHERE "player"='shaun boyd'; |
## Task
Generate a SQL query to answer the following question:
`What MLB draft has Shaun Boyd?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2000_team" (
"player" text,
"position" text,
"school" text,
"hometown" text,
"mlb_draft" text
);
### SQL
Given the database schema, here is the SQL query that answers `What MLB draft has Shaun Boyd?`:
```sql
|
SELECT "college_junior_club_team_league" FROM "draft_picks" WHERE "round">2 AND "player"='bert robertsson (d)'; |
## Task
Generate a SQL query to answer the following question:
`what is the college/junior/club team (league) when the round is more than 2 and the player is bert robertsson (d)?`
### 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 college/junior/club team (league) when the round is more than 2 and the player is bert robertsson (d)?`:
```sql
|
SELECT "college_junior_club_team_league" FROM "draft_picks" WHERE "round"<7; |
## Task
Generate a SQL query to answer the following question:
`what is the college/junior/club team (league) when the round is less than 7?`
### 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 college/junior/club team (league) when the round is less than 7?`:
```sql
|
SELECT "nhl_team" FROM "draft_picks" WHERE "round"=10; |
## Task
Generate a SQL query to answer the following question:
`what is the nhl team for round 10?`
### 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 for round 10?`:
```sql
|
SELECT MAX("round") FROM "draft_picks" WHERE "player"='troy creurer (d)'; |
## Task
Generate a SQL query to answer the following question:
`what is the highest round when the player is troy creurer (d)?`
### 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 highest round when the player is troy creurer (d)?`:
```sql
|
SELECT "opponent" FROM "schedule" WHERE "week"=3; |
## Task
Generate a SQL query to answer the following question:
`Who was the opponent on week 3?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "schedule" (
"week" real,
"date" text,
"opponent" text,
"result" text,
"attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the opponent on week 3?`:
```sql
|
SELECT "chapter" FROM "list_of_college_chapters_and_colonies" WHERE "location"='normal, illinois'; |
## Task
Generate a SQL query to answer the following question:
`What chapter is located in Normal, Illinois?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_college_chapters_and_colonies" (
"number" real,
"chapter" text,
"installation_date" text,
"location" text,
"status" text
);
### SQL
Given the database schema, here is the SQL query that answers `What chapter is located in Normal, Illinois?`:
```sql
|
SELECT AVG("pos") FROM "season_by_season" WHERE "league"='tb2l' AND "postseason"='promoted champion'; |
## Task
Generate a SQL query to answer the following question:
`What is the average position for tb2l teams promoted champion?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "season_by_season" (
"season" text,
"tier" real,
"league" text,
"pos" real,
"postseason" text,
"turkish_cup" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average position for tb2l teams promoted champion?`:
```sql
|
SELECT COUNT("pos") FROM "season_by_season" WHERE "postseason"='promoted' AND "tier"<2; |
## Task
Generate a SQL query to answer the following question:
`How many teams were promoted in the postseason in a tier above 2?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "season_by_season" (
"season" text,
"tier" real,
"league" text,
"pos" real,
"postseason" text,
"turkish_cup" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many teams were promoted in the postseason in a tier above 2?`:
```sql
|
SELECT "home_team_score" FROM "round_15" WHERE "venue"='windy hill'; |
## Task
Generate a SQL query to answer the following question:
`What is the Home team score At Windy Hill?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_15" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Home team score At Windy Hill?`:
```sql
|
SELECT "crowd" FROM "round_15" WHERE "away_team_score"='9.10 (64)'; |
## Task
Generate a SQL query to answer the following question:
`How big of a crowd was attending the game whose Away team scored 9.10 (64)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_15" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `How big of a crowd was attending the game whose Away team scored 9.10 (64)?`:
```sql
|
SELECT "partner" FROM "doubles_finals_19_10_9" WHERE "score_in_the_final"='2–6, 7–6, 7–6'; |
## Task
Generate a SQL query to answer the following question:
`Who is the partner in the final with a score of 2–6, 7–6, 7–6?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_finals_19_10_9" (
"outcome" text,
"date" real,
"tournament" text,
"surface" text,
"partner" text,
"opponents_in_the_final" text,
"score_in_the_final" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the partner in the final with a score of 2–6, 7–6, 7–6?`:
```sql
|
SELECT "surface" FROM "doubles_finals_19_10_9" WHERE "outcome"='runner-up' AND "partner"='ivan lendl' AND "score_in_the_final"='2–6, 6–7'; |
## Task
Generate a SQL query to answer the following question:
`On what surface was Ivan Lendl a partner with a runner-up outcome and final score of 2–6, 6–7?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_finals_19_10_9" (
"outcome" text,
"date" real,
"tournament" text,
"surface" text,
"partner" text,
"opponents_in_the_final" text,
"score_in_the_final" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what surface was Ivan Lendl a partner with a runner-up outcome and final score of 2–6, 6–7?`:
```sql
|
SELECT MAX("crowd") FROM "round_8" WHERE "venue"='mcg'; |
## Task
Generate a SQL query to answer the following question:
`What was the highest crowd at the venue MCG?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_8" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the highest crowd at the venue MCG?`:
```sql
|
SELECT "away_team_score" FROM "round_8" WHERE "venue"='windy hill'; |
## Task
Generate a SQL query to answer the following question:
`What is the away team score at the Windy Hill venue?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_8" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the away team score at the Windy Hill venue?`:
```sql
|
SELECT "score" FROM "game_log" WHERE "attendance">'48,308' AND "opponent"='pirates'; |
## Task
Generate a SQL query to answer the following question:
`What is the score of the game against the pirates with over 48,308 attending?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the score of the game against the pirates with over 48,308 attending?`:
```sql
|
SELECT "venue" FROM "round_13" WHERE "crowd">'18,817' AND "away_team_score"='11.14 (80)'; |
## Task
Generate a SQL query to answer the following question:
`Where was the game with a crowd of 18,817 and an away team score of 11.14 (80) held?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_13" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where was the game with a crowd of 18,817 and an away team score of 11.14 (80) held?`:
```sql
|
SELECT "venue" FROM "round_13" WHERE "home_team_score"='12.21 (93)'; |
## Task
Generate a SQL query to answer the following question:
`Where was the game held when the home team scored 12.21 (93)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_13" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where was the game held when the home team scored 12.21 (93)?`:
```sql
|
SELECT "venue" FROM "round_13" WHERE "away_team"='melbourne'; |
## Task
Generate a SQL query to answer the following question:
`Where was the game when Melbourne was the away team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_13" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where was the game when Melbourne was the away team?`:
```sql
|
SELECT "away_team_score" FROM "round_9" WHERE "venue"='brunswick street oval'; |
## Task
Generate a SQL query to answer the following question:
`What was the away score when the game was at Brunswick Street Oval?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_9" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the away score when the game was at Brunswick Street Oval?`:
```sql
|
SELECT COUNT("round") FROM "calendar" WHERE "circuit"='calder park'; |
## Task
Generate a SQL query to answer the following question:
`How many rounds were run at Calder Park?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "calendar" (
"round" real,
"circuit" text,
"state" text,
"date" text,
"winning_driver" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many rounds were run at Calder Park?`:
```sql
|
SELECT "state" FROM "calendar" WHERE "circuit"='sandown'; |
## Task
Generate a SQL query to answer the following question:
`In which state can you find the Sandown circuit?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "calendar" (
"round" real,
"circuit" text,
"state" text,
"date" text,
"winning_driver" text
);
### SQL
Given the database schema, here is the SQL query that answers `In which state can you find the Sandown circuit?`:
```sql
|
SELECT COUNT("round") FROM "calendar" WHERE "state"='new south wales'; |
## Task
Generate a SQL query to answer the following question:
`How many rounds were run in New South Wales?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "calendar" (
"round" real,
"circuit" text,
"state" text,
"date" text,
"winning_driver" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many rounds were run in New South Wales?`:
```sql
|
SELECT "driver" FROM "by_year" WHERE "year"='1969'; |
## Task
Generate a SQL query to answer the following question:
`Who is the driver from 1969?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "by_year" (
"year" text,
"driver" text,
"constructor" text,
"location" text,
"report" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the driver from 1969?`:
```sql
|
SELECT "driver" FROM "by_year" WHERE "year"='1964'; |
## Task
Generate a SQL query to answer the following question:
`Who was the driver in 1964?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "by_year" (
"year" text,
"driver" text,
"constructor" text,
"location" text,
"report" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the driver in 1964?`:
```sql
|
SELECT MAX("diff") FROM "torneo_apertura_opening_tournament" WHERE "drawn"=6 AND "played">18; |
## Task
Generate a SQL query to answer the following question:
`What is the highest diff with drawn of 6 and play larger than 18?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "torneo_apertura_opening_tournament" (
"team" text,
"points" real,
"played" real,
"drawn" real,
"lost" real,
"against" real,
"diff" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest diff with drawn of 6 and play larger than 18?`:
```sql
|
SELECT SUM("played") FROM "torneo_apertura_opening_tournament" WHERE "lost"<5 AND "points">41; |
## Task
Generate a SQL query to answer the following question:
`How many games were played when the loss is less than 5 and points greater than 41?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "torneo_apertura_opening_tournament" (
"team" text,
"points" real,
"played" real,
"drawn" real,
"lost" real,
"against" real,
"diff" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many games were played when the loss is less than 5 and points greater than 41?`:
```sql
|
SELECT "genes" FROM "list_of_sequenced_bacterial_genomes" WHERE "species"='burkholderia pseudomallei' AND "base_pairs"='4,126,292'; |
## Task
Generate a SQL query to answer the following question:
`How many genes are in species burkholderia pseudomallei with 4,126,292 base pairs?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_sequenced_bacterial_genomes" (
"species" text,
"strain" text,
"type" text,
"base_pairs" text,
"genes" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many genes are in species burkholderia pseudomallei with 4,126,292 base pairs?`:
```sql
|
SELECT "strain" FROM "list_of_sequenced_bacterial_genomes" WHERE "genes"='1,312'; |
## Task
Generate a SQL query to answer the following question:
`Which strain has 1,312 genes?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_sequenced_bacterial_genomes" (
"species" text,
"strain" text,
"type" text,
"base_pairs" text,
"genes" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which strain has 1,312 genes?`:
```sql
|
SELECT "genes" FROM "list_of_sequenced_bacterial_genomes" WHERE "base_pairs"='4,895,836'; |
## Task
Generate a SQL query to answer the following question:
`Which gene has 4,895,836 base pairs?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_sequenced_bacterial_genomes" (
"species" text,
"strain" text,
"type" text,
"base_pairs" text,
"genes" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which gene has 4,895,836 base pairs?`:
```sql
|
SELECT "species" FROM "list_of_sequenced_bacterial_genomes" WHERE "genes"='3,441'; |
## Task
Generate a SQL query to answer the following question:
`Which species has 3,441 genes?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_sequenced_bacterial_genomes" (
"species" text,
"strain" text,
"type" text,
"base_pairs" text,
"genes" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which species has 3,441 genes?`:
```sql
|
SELECT "base_pairs" FROM "list_of_sequenced_bacterial_genomes" WHERE "strain"='tohamai'; |
## Task
Generate a SQL query to answer the following question:
`How many base pairs are there in the tohamai strain?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_sequenced_bacterial_genomes" (
"species" text,
"strain" text,
"type" text,
"base_pairs" text,
"genes" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many base pairs are there in the tohamai strain?`:
```sql
|
SELECT "home_team_score" FROM "round_10" WHERE "venue"='junction oval'; |
## Task
Generate a SQL query to answer the following question:
`What was the home team score at junction oval?`
### 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 was the home team score at junction oval?`:
```sql
|
SELECT "away_team_score" FROM "round_10" WHERE "venue"='western oval'; |
## Task
Generate a SQL query to answer the following question:
`What was the away team score at western oval?`
### 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 was the away team score at western oval?`:
```sql
|
SELECT MIN("crowd") FROM "round_10" WHERE "venue"='kardinia park'; |
## Task
Generate a SQL query to answer the following question:
`what is the lowest crowd at kardinia park`
### 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 lowest crowd at kardinia park`:
```sql
|
SELECT "score" FROM "2008" WHERE "tournament"='budapest'; |
## Task
Generate a SQL query to answer the following question:
`What was the score for the tournament in Budapest?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2008" (
"tournament" text,
"winner" text,
"runner_up" text,
"score" text,
"third_place" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score for the tournament in Budapest?`:
```sql
|
SELECT "tournament" FROM "2008" WHERE "winner"='patrick rafter'; |
## Task
Generate a SQL query to answer the following question:
`Which tournament did Patrick Rafter win?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2008" (
"tournament" text,
"winner" text,
"runner_up" text,
"score" text,
"third_place" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which tournament did Patrick Rafter win?`:
```sql
|
SELECT "winner" FROM "2008" WHERE "score"='6–7(4), 7–6(3), [11–9]'; |
## Task
Generate a SQL query to answer the following question:
`Which winner won by a score of 6–7(4), 7–6(3), [11–9]?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2008" (
"tournament" text,
"winner" text,
"runner_up" text,
"score" text,
"third_place" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which winner won by a score of 6–7(4), 7–6(3), [11–9]?`:
```sql
|
SELECT "score" FROM "2008" WHERE "runner_up"='goran ivanišević' AND "tournament"='algarve'; |
## Task
Generate a SQL query to answer the following question:
`what was the score when goran ivanišević was runner up and the tournament was in algarve?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2008" (
"tournament" text,
"winner" text,
"runner_up" text,
"score" text,
"third_place" text
);
### SQL
Given the database schema, here is the SQL query that answers `what was the score when goran ivanišević was runner up and the tournament was in algarve?`:
```sql
|
SELECT "score" FROM "2008" WHERE "winner"='stefan edberg'; |
## Task
Generate a SQL query to answer the following question:
`What was the score when Stefan Edberg won?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2008" (
"tournament" text,
"winner" text,
"runner_up" text,
"score" text,
"third_place" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score when Stefan Edberg won?`:
```sql
|
SELECT "away_team" FROM "round_5" WHERE "crowd">'15,481' AND "home_team_score"='20.17 (137)'; |
## Task
Generate a SQL query to answer the following question:
`Which Away team that has a Crowd greater than 15,481, and a Home team score of 20.17 (137)?`
### 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 `Which Away team that has a Crowd greater than 15,481, and a Home team score of 20.17 (137)?`:
```sql
|
SELECT "away_team_score" FROM "round_5" WHERE "home_team_score"='10.16 (76)'; |
## Task
Generate a SQL query to answer the following question:
`What is the Away team score when home's score is 10.16 (76)?`
### 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 home's score is 10.16 (76)?`:
```sql
|
SELECT "date" FROM "round_5" WHERE "away_team"='south melbourne'; |
## Task
Generate a SQL query to answer the following question:
`Which Date has an Away team of south melbourne?`
### 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 `Which Date has an Away team of south melbourne?`:
```sql
|
SELECT "away_team_score" FROM "round_5" WHERE "venue"='mcg'; |
## Task
Generate a SQL query to answer the following question:
`What is the Away team score for mcg?`
### 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 for mcg?`:
```sql
|
SELECT SUM("crowd") FROM "round_5" WHERE "home_team"='collingwood'; |
## Task
Generate a SQL query to answer the following question:
`What is the total Crowd with a Home team of collingwood?`
### 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 total Crowd with a Home team of collingwood?`:
```sql
|
SELECT "away_team" FROM "round_16" WHERE "venue"='mcg'; |
## Task
Generate a SQL query to answer the following question:
`When mcg is the Venue what's 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 `When mcg is the Venue what's the Away team?`:
```sql
|
SELECT "crowd" FROM "round_16" WHERE "date"='19 july 1980' AND "away_team"='footscray'; |
## Task
Generate a SQL query to answer the following question:
`When the Away team footscray played on the Date of 19 july 1980, what was the amount of people in the Crowd?`
### 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 `When the Away team footscray played on the Date of 19 july 1980, what was the amount of people in the Crowd?`:
```sql
|
SELECT "away_team_score" FROM "round_16" WHERE "home_team"='collingwood'; |
## Task
Generate a SQL query to answer the following question:
`When the Home team of collingwood played, what was the opposing Away team score?`
### 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 `When the Home team of collingwood played, what was the opposing Away team score?`:
```sql
|
SELECT "home_team" FROM "round_16" WHERE "crowd">'23,327'; |
## Task
Generate a SQL query to answer the following question:
`When the Crowd is larger than 23,327, what Home team is playing?`
### 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 `When the Crowd is larger than 23,327, what Home team is playing?`:
```sql
|
SELECT "away_team" FROM "round_16" WHERE "venue"='vfl park'; |
## Task
Generate a SQL query to answer the following question:
`When vfl park is the venue what's the Away team playing?`
### 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 `When vfl park is the venue what's the Away team playing?`:
```sql
|
SELECT "date" FROM "round_16" WHERE "home_team"='collingwood'; |
## Task
Generate a SQL query to answer the following question:
`If collingwood was the Home team, what Date did they play?`
### 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 `If collingwood was the Home team, what Date did they play?`:
```sql
|
SELECT "division" FROM "existing_stadiums" WHERE "rank_in_respective_divisions"='5' AND "club"='altrincham'; |
## Task
Generate a SQL query to answer the following question:
`What division has a Rank in Respective Divisions of 5, and is the Altrincham club?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "existing_stadiums" (
"stadium" text,
"capacity" text,
"club" text,
"division" text,
"rank_in_respective_divisions" text
);
### SQL
Given the database schema, here is the SQL query that answers `What division has a Rank in Respective Divisions of 5, and is the Altrincham club?`:
```sql
|
SELECT "club" FROM "existing_stadiums" WHERE "capacity"='25138'; |
## Task
Generate a SQL query to answer the following question:
`Which club has a capacity of 25138?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "existing_stadiums" (
"stadium" text,
"capacity" text,
"club" text,
"division" text,
"rank_in_respective_divisions" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which club has a capacity of 25138?`:
```sql
|
SELECT "rank_in_respective_divisions" FROM "existing_stadiums" WHERE "capacity"='4100'; |
## Task
Generate a SQL query to answer the following question:
`What Rank in Respective Divisions has a capacity of 4100?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "existing_stadiums" (
"stadium" text,
"capacity" text,
"club" text,
"division" text,
"rank_in_respective_divisions" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Rank in Respective Divisions has a capacity of 4100?`:
```sql
|
SELECT "stadium" FROM "existing_stadiums" WHERE "club"='west ham united'; |
## Task
Generate a SQL query to answer the following question:
`What stadium has a club of west ham united?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "existing_stadiums" (
"stadium" text,
"capacity" text,
"club" text,
"division" text,
"rank_in_respective_divisions" text
);
### SQL
Given the database schema, here is the SQL query that answers `What stadium has a club of west ham united?`:
```sql
|
SELECT "result" FROM "schedule" WHERE "week"=16; |
## Task
Generate a SQL query to answer the following question:
`What was the result of week 16?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "schedule" (
"week" real,
"date" text,
"opponent" text,
"result" text,
"attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the result of week 16?`:
```sql
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.