output stringlengths 27 479 | instruction stringlengths 407 1.39k |
|---|---|
SELECT "phoneme" FROM "tamazight_vowel_allophony" WHERE "realization"='[Ι]'; |
## Task
Generate a SQL query to answer the following question:
`Name the phoneme when the realizationis [Ι]`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "tamazight_vowel_allophony" (
"phoneme" text,
"realization" text,
"environment" text,
"example" text,
"gloss" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the phoneme when the realizationis [Ι]`:
```sql
|
SELECT "power" FROM "engines_and_performance" WHERE "engine_code"='m44b19'; |
## Task
Generate a SQL query to answer the following question:
`What is the power of the engine with an engine code m44b19?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "engines_and_performance" (
"name" text,
"power" text,
"torque" text,
"size" text,
"engine_code" text,
"0_100km_h_s" real,
"top_speed" text,
"years" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the power of the engine with an engine code m44b19?`:
```sql
|
SELECT MAX("grid") FROM "classification" WHERE "driver"='piercarlo ghinzani' AND "laps">3; |
## Task
Generate a SQL query to answer the following question:
`What is the highest numbered grid for piercarlo ghinzani with over 3 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 `What is the highest numbered grid for piercarlo ghinzani with over 3 laps?`:
```sql
|
SELECT SUM("laps") FROM "classification" WHERE "grid">18 AND "time_retired"='electrical'; |
## Task
Generate a SQL query to answer the following question:
`How many laps for a grid of over 18 and retired due to electrical failure?`
### 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 for a grid of over 18 and retired due to electrical failure?`:
```sql
|
SELECT SUM("crowd") FROM "round_2" WHERE "away_team_score"='14.10 (94)'; |
## Task
Generate a SQL query to answer the following question:
`What was the crowd attendance for the game with an away team score of 14.10 (94)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_2" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the crowd attendance for the game with an away team score of 14.10 (94)?`:
```sql
|
SELECT AVG("crowd") FROM "round_2" WHERE "venue"='junction oval'; |
## Task
Generate a SQL query to answer the following question:
`What was the average crowd attendance for the Junction Oval venue?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_2" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the average crowd attendance for the Junction Oval venue?`:
```sql
|
SELECT "home_team" FROM "round_2" WHERE "venue"='princes park'; |
## Task
Generate a SQL query to answer the following question:
`What is the home team for the Princes Park venue?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_2" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the home team for the Princes Park venue?`:
```sql
|
SELECT "home_team_score" FROM "round_2" WHERE "home_team"='footscray'; |
## Task
Generate a SQL query to answer the following question:
`What is the average home team score for Footscray?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_2" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average home team score for Footscray?`:
```sql
|
SELECT "home_team" FROM "round_2" WHERE "away_team"='geelong'; |
## Task
Generate a SQL query to answer the following question:
`Which home teams had Geelong as the away team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_2" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which home teams had Geelong as the away team?`:
```sql
|
SELECT "date" FROM "game_log" WHERE "opponent"='giants' AND "attendance">'24,100'; |
## Task
Generate a SQL query to answer the following question:
`When did the Rockies play the Giants with an attendance over 24,100?`
### 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 `When did the Rockies play the Giants with an attendance over 24,100?`:
```sql
|
SELECT "date" FROM "game_log" WHERE "record"='61β66'; |
## Task
Generate a SQL query to answer the following question:
`What is the date of the game when the Rockies had a record of 61β66?`
### 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 date of the game when the Rockies had a record of 61β66?`:
```sql
|
SELECT COUNT("seasons") FROM "data_prior_to_the_2012_ncaa_tournament" WHERE "coach"='john mcfadden'; |
## Task
Generate a SQL query to answer the following question:
`How many seasons has John Mcfadden coached?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "data_prior_to_the_2012_ncaa_tournament" (
"coach" text,
"years" text,
"seasons" real,
"lost" real,
"pct" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many seasons has John Mcfadden coached?`:
```sql
|
SELECT MAX("stations") FROM "see_also" WHERE "annual_ridership_2012"='4,445,100' AND "lines"<1; |
## Task
Generate a SQL query to answer the following question:
`What is the station with the most riders that has an annaul ridership of 4,445,100 and line smaller than 1??`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "see_also" (
"annual_ridership_2012" real,
"rider_per_mile" real,
"opened" real,
"stations" real,
"lines" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the station with the most riders that has an annaul ridership of 4,445,100 and line smaller than 1??`:
```sql
|
SELECT SUM("annual_ridership_2012") FROM "see_also" WHERE "stations"=13 AND "lines">4; |
## Task
Generate a SQL query to answer the following question:
`What is the number of annual ridership with a station that has more than 13 stations and larger than 4 lines?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "see_also" (
"annual_ridership_2012" real,
"rider_per_mile" real,
"opened" real,
"stations" real,
"lines" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the number of annual ridership with a station that has more than 13 stations and larger than 4 lines?`:
```sql
|
SELECT COUNT("lines") FROM "see_also" WHERE "stations"<44 AND "rider_per_mile"<881; |
## Task
Generate a SQL query to answer the following question:
`How many lines have fewer than 44 stations and fewer than 881 riders per mile?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "see_also" (
"annual_ridership_2012" real,
"rider_per_mile" real,
"opened" real,
"stations" real,
"lines" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many lines have fewer than 44 stations and fewer than 881 riders per mile?`:
```sql
|
SELECT MAX("stations") FROM "see_also" WHERE "rider_per_mile"='3,871' AND "annual_ridership_2012">'15,399,400'; |
## Task
Generate a SQL query to answer the following question:
`Which station has 3,871 riders per mile, and an annual ridership in 2012 of larger than 15,399,400?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "see_also" (
"annual_ridership_2012" real,
"rider_per_mile" real,
"opened" real,
"stations" real,
"lines" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which station has 3,871 riders per mile, and an annual ridership in 2012 of larger than 15,399,400?`:
```sql
|
SELECT MAX("season") FROM "season_to_season" WHERE "position"='7th'; |
## Task
Generate a SQL query to answer the following question:
`What is the highest season for the 7th position?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "season_to_season" (
"season" real,
"level" text,
"division" text,
"administration" text,
"position" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest season for the 7th position?`:
```sql
|
SELECT "opponent_in_the_final" FROM "singles_titles" WHERE "tournament"='blenheim'; |
## Task
Generate a SQL query to answer the following question:
`Who is the opponent in the final of the Tournament of Blenheim?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_titles" (
"date" text,
"tournament" text,
"surface" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the opponent in the final of the Tournament of Blenheim?`:
```sql
|
SELECT "opponent_in_the_final" FROM "singles_titles" WHERE "date"='august 14, 2006'; |
## Task
Generate a SQL query to answer the following question:
`Who is the opponent in the final on August 14, 2006?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_titles" (
"date" text,
"tournament" text,
"surface" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the opponent in the final on August 14, 2006?`:
```sql
|
SELECT "opponent_in_the_final" FROM "singles_titles" WHERE "surface"='clay' AND "tournament"='lyneham'; |
## Task
Generate a SQL query to answer the following question:
`Who is the opponent in the final with a clay surface at the Tournament of Lyneham?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_titles" (
"date" text,
"tournament" text,
"surface" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the opponent in the final with a clay surface at the Tournament of Lyneham?`:
```sql
|
SELECT "surface" FROM "singles_titles" WHERE "score"='6β2, 6β1'; |
## Task
Generate a SQL query to answer the following question:
`On what surface was the score 6β2, 6β1?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_titles" (
"date" text,
"tournament" text,
"surface" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what surface was the score 6β2, 6β1?`:
```sql
|
SELECT "score" FROM "singles_titles" WHERE "tournament"='cordenons'; |
## Task
Generate a SQL query to answer the following question:
`What is the score for the Tournament of Cordenons?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_titles" (
"date" text,
"tournament" text,
"surface" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the score for the Tournament of Cordenons?`:
```sql
|
SELECT "date" FROM "singles_titles" WHERE "surface"='clay' AND "opponent_in_the_final"='cyril saulnier'; |
## Task
Generate a SQL query to answer the following question:
`On what date was the surface clay with Cyril Saulnier as the opponent in the final?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_titles" (
"date" text,
"tournament" text,
"surface" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date was the surface clay with Cyril Saulnier as the opponent in the final?`:
```sql
|
SELECT "artist" FROM "provincial_coat_of_arms" WHERE "mintage"=500; |
## Task
Generate a SQL query to answer the following question:
`Which artist has a Mintage of 500?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "provincial_coat_of_arms" (
"year" real,
"theme" text,
"artist" text,
"composition" text,
"mintage" real,
"issue_price" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which artist has a Mintage of 500?`:
```sql
|
SELECT "artist" FROM "provincial_coat_of_arms" WHERE "issue_price"='$1,541.95'; |
## Task
Generate a SQL query to answer the following question:
`Which Artist has an Issue Price of $1,541.95?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "provincial_coat_of_arms" (
"year" real,
"theme" text,
"artist" text,
"composition" text,
"mintage" real,
"issue_price" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Artist has an Issue Price of $1,541.95?`:
```sql
|
SELECT "opponent_in_the_final" FROM "singles_titles" WHERE "surface"='hard' AND "score"='6β3 7β6(5)'; |
## Task
Generate a SQL query to answer the following question:
`Who is the opponent in the final on a hard surface with a score of 6β3 7β6(5)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_titles" (
"date" text,
"tournament" text,
"surface" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the opponent in the final on a hard surface with a score of 6β3 7β6(5)?`:
```sql
|
SELECT "opponent_in_the_final" FROM "singles_titles" WHERE "tournament"='lahore'; |
## Task
Generate a SQL query to answer the following question:
`Who is the opponent in the Tournament of Lahore final?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_titles" (
"date" text,
"tournament" text,
"surface" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the opponent in the Tournament of Lahore final?`:
```sql
|
SELECT "date" FROM "singles_titles" WHERE "opponent_in_the_final"='toshiaki sakai' AND "surface"='grass'; |
## Task
Generate a SQL query to answer the following question:
`On what date did the opponent in the Toshiaki Sakai final play on a grass surface?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_titles" (
"date" text,
"tournament" text,
"surface" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date did the opponent in the Toshiaki Sakai final play on a grass surface?`:
```sql
|
SELECT "surface" FROM "singles_titles" WHERE "tournament"='lahore' AND "score"='4β6 6β3 6β4'; |
## Task
Generate a SQL query to answer the following question:
`On what surface did a score of 4β6 6β3 6β4 occur at the Tournament of Lahore?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_titles" (
"date" text,
"tournament" text,
"surface" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what surface did a score of 4β6 6β3 6β4 occur at the Tournament of Lahore?`:
```sql
|
SELECT "tournament" FROM "singles_titles" WHERE "opponent_in_the_final"='toshiaki sakai' AND "surface"='grass'; |
## Task
Generate a SQL query to answer the following question:
`Which tournament had Toshiaki Sakai as an opponent in the final on a grass surface?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_titles" (
"date" text,
"tournament" text,
"surface" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which tournament had Toshiaki Sakai as an opponent in the final on a grass surface?`:
```sql
|
SELECT "score" FROM "eastern_conference_semi_finals_vs_4_wash" WHERE "date"='may 15'; |
## Task
Generate a SQL query to answer the following question:
`what was the score on the game that happened on May 15?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "eastern_conference_semi_finals_vs_4_wash" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `what was the score on the game that happened on May 15?`:
```sql
|
SELECT "status" FROM "loaned_out" WHERE "country"='bel' AND "transfer_window"='winter'; |
## Task
Generate a SQL query to answer the following question:
`What is the status of bel with a Transfer window of winter?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "loaned_out" (
"name" text,
"country" text,
"status" text,
"moving_to" text,
"transfer_window" text,
"transfer_fee" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the status of bel with a Transfer window of winter?`:
```sql
|
SELECT "name" FROM "loaned_out" WHERE "moving_to"='union' AND "country"='cmr'; |
## Task
Generate a SQL query to answer the following question:
`What is the union moving name and is from cmr?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "loaned_out" (
"name" text,
"country" text,
"status" text,
"moving_to" text,
"transfer_window" text,
"transfer_fee" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the union moving name and is from cmr?`:
```sql
|
SELECT "transfer_window" FROM "loaned_out" WHERE "country"='bel'; |
## Task
Generate a SQL query to answer the following question:
`What is the transfer window for bel?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "loaned_out" (
"name" text,
"country" text,
"status" text,
"moving_to" text,
"transfer_window" text,
"transfer_fee" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the transfer window for bel?`:
```sql
|
SELECT "transfer_window" FROM "loaned_out" WHERE "name"='habarugira'; |
## Task
Generate a SQL query to answer the following question:
`What is the transfer period for habarugira?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "loaned_out" (
"name" text,
"country" text,
"status" text,
"moving_to" text,
"transfer_window" text,
"transfer_fee" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the transfer period for habarugira?`:
```sql
|
SELECT "crowd" FROM "round_11" WHERE "away_team"='north melbourne'; |
## Task
Generate a SQL query to answer the following question:
`How big was the crowd in game that featured the visiting team of north melbourne?`
### 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 `How big was the crowd in game that featured the visiting team of north melbourne?`:
```sql
|
SELECT MAX("bronze") FROM "medals_table" WHERE "total"<1; |
## Task
Generate a SQL query to answer the following question:
`How many bronze medals for the nation with less than 1 total?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medals_table" (
"rank" real,
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many bronze medals for the nation with less than 1 total?`:
```sql
|
SELECT COUNT("bronze") FROM "medals_table" WHERE "rank"<2 AND "gold"<0; |
## Task
Generate a SQL query to answer the following question:
`How many bronze medals for the nation ranked above 2, and under 0 golds?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medals_table" (
"rank" real,
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many bronze medals for the nation ranked above 2, and under 0 golds?`:
```sql
|
SELECT SUM("silver") FROM "medals_table" WHERE "nation"='japan' AND "gold">1; |
## Task
Generate a SQL query to answer the following question:
`How many silvers for japan (1 gold)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medals_table" (
"rank" real,
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many silvers for japan (1 gold)?`:
```sql
|
SELECT "authority" FROM "papakura_local_board" WHERE "roll"=651; |
## Task
Generate a SQL query to answer the following question:
`Which authority had a role of 651?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "papakura_local_board" (
"name" text,
"years" text,
"gender" text,
"area" text,
"authority" text,
"decile" real,
"roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which authority had a role of 651?`:
```sql
|
SELECT MIN("decile") FROM "papakura_local_board" WHERE "roll"=651; |
## Task
Generate a SQL query to answer the following question:
`For the roll of 651, what was the lowest Decile?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "papakura_local_board" (
"name" text,
"years" text,
"gender" text,
"area" text,
"authority" text,
"decile" real,
"roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `For the roll of 651, what was the lowest Decile?`:
```sql
|
SELECT "years" FROM "papakura_local_board" WHERE "authority"='state' AND "name"='redhill school'; |
## Task
Generate a SQL query to answer the following question:
`What were the years for Redhill school, authority of state?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "papakura_local_board" (
"name" text,
"years" text,
"gender" text,
"area" text,
"authority" text,
"decile" real,
"roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `What were the years for Redhill school, authority of state?`:
```sql
|
SELECT SUM("roll") FROM "papakura_local_board" WHERE "area"='karaka'; |
## Task
Generate a SQL query to answer the following question:
`What was the sum roll of Karaka area?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "papakura_local_board" (
"name" text,
"years" text,
"gender" text,
"area" text,
"authority" text,
"decile" real,
"roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the sum roll of Karaka area?`:
```sql
|
SELECT "home_team" FROM "round_16" WHERE "away_team"='north melbourne'; |
## Task
Generate a SQL query to answer the following question:
`What home team played North 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 home team played North Melbourne?`:
```sql
|
SELECT AVG("crowd") FROM "round_9" WHERE "home_team_score"='8.15 (63)'; |
## Task
Generate a SQL query to answer the following question:
`What is the average crowd where the home team scored 8.15 (63)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_9" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average crowd where the home team scored 8.15 (63)?`:
```sql
|
SELECT "nationality" FROM "draft_picks" WHERE "round">4 AND "position"='right wing'; |
## Task
Generate a SQL query to answer the following question:
`What is the nationality of the player with a round after 4 and plays right wing?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "draft_picks" (
"round" real,
"player" text,
"position" text,
"nationality" text,
"college_junior_club_team_league" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the nationality of the player with a round after 4 and plays right wing?`:
```sql
|
SELECT "college_junior_club_team_league" FROM "draft_picks" WHERE "position"='left wing' AND "player"='ondrej roman'; |
## Task
Generate a SQL query to answer the following question:
`What is the college/junior/club team (league) of left wing Ondrej Roman?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "draft_picks" (
"round" real,
"player" text,
"position" text,
"nationality" text,
"college_junior_club_team_league" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the college/junior/club team (league) of left wing Ondrej Roman?`:
```sql
|
SELECT "away_team" FROM "round_14" WHERE "venue"='lake oval'; |
## Task
Generate a SQL query to answer the following question:
`Who played in lake oval while away?`
### 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 `Who played in lake oval while away?`:
```sql
|
SELECT "home_team" FROM "round_14" WHERE "away_team_score"='16.11 (107)'; |
## Task
Generate a SQL query to answer the following question:
`What was the home score when the away team scored 16.11 (107)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_14" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the home score when the away team scored 16.11 (107)?`:
```sql
|
SELECT "home_team" FROM "round_14" WHERE "away_team_score"='5.9 (39)'; |
## Task
Generate a SQL query to answer the following question:
`What was the home score when the away team scored 5.9 (39)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_14" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the home score when the away team scored 5.9 (39)?`:
```sql
|
SELECT "date" FROM "round_14" WHERE "away_team_score"='17.11 (113)'; |
## Task
Generate a SQL query to answer the following question:
`When did the away team score 17.11 (113)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_14" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `When did the away team score 17.11 (113)?`:
```sql
|
SELECT MIN("crowd") FROM "round_14" WHERE "away_team_score"='17.11 (113)'; |
## Task
Generate a SQL query to answer the following question:
`What is the low crowd size when the away team scored 17.11 (113)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_14" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the low crowd size when the away team scored 17.11 (113)?`:
```sql
|
SELECT MIN("week") FROM "schedule" WHERE "result"='w 31-16'; |
## Task
Generate a SQL query to answer the following question:
`What week number saw a w 31-16 result?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "schedule" (
"week" real,
"date" text,
"opponent" text,
"result" text,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What week number saw a w 31-16 result?`:
```sql
|
SELECT "date" FROM "schedule" WHERE "week"<8 AND "result"='bye'; |
## Task
Generate a SQL query to answer the following question:
`When was the game before week 8 with a result of bye?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "schedule" (
"week" real,
"date" text,
"opponent" text,
"result" text,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `When was the game before week 8 with a result of bye?`:
```sql
|
SELECT COUNT("week") FROM "schedule" WHERE "opponent"='new york giants'; |
## Task
Generate a SQL query to answer the following question:
`What week number had the New York Giants as opponent?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "schedule" (
"week" real,
"date" text,
"opponent" text,
"result" text,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What week number had the New York Giants as opponent?`:
```sql
|
SELECT "constructor" FROM "race" WHERE "grid"<6 AND "laps"<49; |
## Task
Generate a SQL query to answer the following question:
`Who built the under grid 6 car with under 49 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 `Who built the under grid 6 car with under 49 laps?`:
```sql
|
SELECT "constructor" FROM "race" WHERE "grid"=2; |
## Task
Generate a SQL query to answer the following question:
`Who built the grid 2 car?`
### 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 built the grid 2 car?`:
```sql
|
SELECT "constructor" FROM "race" WHERE "laps"<65 AND "time_retired"='suspension'; |
## Task
Generate a SQL query to answer the following question:
`Who built the car that retired due to suspension before 65 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 `Who built the car that retired due to suspension before 65 laps?`:
```sql
|
SELECT "valley_vista" FROM "high_schools_in_dysart_usd" WHERE "dysart"='1668'; |
## Task
Generate a SQL query to answer the following question:
`What Valley Vista has a Dysart of 1668?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "high_schools_in_dysart_usd" (
"information" text,
"dysart" text,
"shadow_ridge" text,
"valley_vista" text,
"willow_canyon" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Valley Vista has a Dysart of 1668?`:
```sql
|
SELECT "valley_vista" FROM "high_schools_in_dysart_usd" WHERE "willow_canyon"='2169'; |
## Task
Generate a SQL query to answer the following question:
`What Valley Vista has a Willow Canyon of 2169?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "high_schools_in_dysart_usd" (
"information" text,
"dysart" text,
"shadow_ridge" text,
"valley_vista" text,
"willow_canyon" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Valley Vista has a Willow Canyon of 2169?`:
```sql
|
SELECT "crowd" FROM "round_14" WHERE "venue"='lake oval'; |
## Task
Generate a SQL query to answer the following question:
`How many people were in the crowd at Lake 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 `How many people were in the crowd at Lake Oval?`:
```sql
|
SELECT "venue" FROM "round_14" WHERE "away_team"='geelong'; |
## Task
Generate a SQL query to answer the following question:
`Where was the game played when Geelong was the away team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_14" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where was the game played when Geelong was the away team?`:
```sql
|
SELECT "home_team" FROM "round_14" WHERE "date"='27 june 1981' AND "venue"='vfl park'; |
## Task
Generate a SQL query to answer the following question:
`What team was the home team on 27 june 1981, at vfl 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 `What team was the home team on 27 june 1981, at vfl park?`:
```sql
|
SELECT "tyre" FROM "teams_and_drivers" WHERE "chassis"='56'; |
## Task
Generate a SQL query to answer the following question:
`What is the tyre with a 56 chassis?`
### 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 `What is the tyre with a 56 chassis?`:
```sql
|
SELECT "country" FROM "prospective_members" WHERE "gdp_nominal"='$29.9 billion'; |
## Task
Generate a SQL query to answer the following question:
`Which country has a GDP (nominal) of $29.9 billion?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "prospective_members" (
"country" text,
"population" text,
"area_km" text,
"gdp_nominal" text,
"gdp_per_capita_nominal" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which country has a GDP (nominal) of $29.9 billion?`:
```sql
|
SELECT "country" FROM "prospective_members" WHERE "gdp_nominal"='$29.9 billion'; |
## Task
Generate a SQL query to answer the following question:
`Which country has a GDP (nominal) of $29.9 billion?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "prospective_members" (
"country" text,
"population" text,
"area_km" text,
"gdp_nominal" text,
"gdp_per_capita_nominal" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which country has a GDP (nominal) of $29.9 billion?`:
```sql
|
SELECT "gdp_nominal" FROM "prospective_members" WHERE "population"='5,550,239'; |
## Task
Generate a SQL query to answer the following question:
`Which GDP (nominal) has a Population of 5,550,239?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "prospective_members" (
"country" text,
"population" text,
"area_km" text,
"gdp_nominal" text,
"gdp_per_capita_nominal" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which GDP (nominal) has a Population of 5,550,239?`:
```sql
|
SELECT "population" FROM "prospective_members" WHERE "gdp_nominal"='$6.4 billion'; |
## Task
Generate a SQL query to answer the following question:
`Which population has a GDP (nominal) of $6.4 billion?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "prospective_members" (
"country" text,
"population" text,
"area_km" text,
"gdp_nominal" text,
"gdp_per_capita_nominal" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which population has a GDP (nominal) of $6.4 billion?`:
```sql
|
SELECT "country" FROM "prospective_members" WHERE "gdp_nominal"='$29.9 billion'; |
## Task
Generate a SQL query to answer the following question:
`Which country has a GDP (nominal) of $29.9 billion?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "prospective_members" (
"country" text,
"population" text,
"area_km" text,
"gdp_nominal" text,
"gdp_per_capita_nominal" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which country has a GDP (nominal) of $29.9 billion?`:
```sql
|
SELECT "gdp_per_capita_nominal" FROM "prospective_members" WHERE "population"='5,125,693'; |
## Task
Generate a SQL query to answer the following question:
`What is the GDP (nominal) with Population of 5,125,693?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "prospective_members" (
"country" text,
"population" text,
"area_km" text,
"gdp_nominal" text,
"gdp_per_capita_nominal" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the GDP (nominal) with Population of 5,125,693?`:
```sql
|
SELECT MIN("year") FROM "complete_formula_one_results" WHERE "points"=9; |
## Task
Generate a SQL query to answer the following question:
`What is the earliest year for 9 points?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "complete_formula_one_results" (
"year" real,
"chassis" text,
"engine" text,
"tyres" text,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the earliest year for 9 points?`:
```sql
|
SELECT MIN("points") FROM "complete_formula_one_results" WHERE "chassis"='jaguar r3'; |
## Task
Generate a SQL query to answer the following question:
`What is the low score for the jaguar r3 chasis?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "complete_formula_one_results" (
"year" real,
"chassis" text,
"engine" text,
"tyres" text,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the low score for the jaguar r3 chasis?`:
```sql
|
SELECT "notes" FROM "engines" WHERE "displacement"='220cid (3,604cc)'; |
## Task
Generate a SQL query to answer the following question:
`What is the notes when the displacement is 220cid (3,604cc)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "engines" (
"years" text,
"engine" text,
"displacement" text,
"power" text,
"torque" text,
"notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the notes when the displacement is 220cid (3,604cc)?`:
```sql
|
SELECT "engine" FROM "engines" WHERE "notes"='srt8'; |
## Task
Generate a SQL query to answer the following question:
`What is then engine when the notes state srt8?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "engines" (
"years" text,
"engine" text,
"displacement" text,
"power" text,
"torque" text,
"notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is then engine when the notes state srt8?`:
```sql
|
SELECT "power" FROM "engines" WHERE "displacement"='182cid (2,988cc)' AND "notes"='eu spec'; |
## Task
Generate a SQL query to answer the following question:
`What is the power when the displacement is 182cid (2,988cc) and the notes are eu spec?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "engines" (
"years" text,
"engine" text,
"displacement" text,
"power" text,
"torque" text,
"notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the power when the displacement is 182cid (2,988cc) and the notes are eu spec?`:
```sql
|
SELECT "engine" FROM "engines" WHERE "years"='2012-'; |
## Task
Generate a SQL query to answer the following question:
`What is the engine for year 2012-?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "engines" (
"years" text,
"engine" text,
"displacement" text,
"power" text,
"torque" text,
"notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the engine for year 2012-?`:
```sql
|
SELECT "record" FROM "march" WHERE "home"='columbus' AND "date"='march 7'; |
## Task
Generate a SQL query to answer the following question:
`What is the record of the match with Columbus as the home team on March 7?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "march" (
"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 is the record of the match with Columbus as the home team on March 7?`:
```sql
|
SELECT "record" FROM "march" WHERE "date"='march 18'; |
## Task
Generate a SQL query to answer the following question:
`What is the record of the game on March 18?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "march" (
"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 is the record of the game on March 18?`:
```sql
|
SELECT "height" FROM "nfl_professionals" WHERE "college"='wyoming' AND "name"='guy frazier'; |
## Task
Generate a SQL query to answer the following question:
`Which height has a College of wyoming, and a Name of guy frazier?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "nfl_professionals" (
"name" text,
"position" text,
"height" text,
"weight_lbs" real,
"born" text,
"college" text,
"drafted" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which height has a College of wyoming, and a Name of guy frazier?`:
```sql
|
SELECT "season" FROM "finals" WHERE "location"='athens' AND "winners"='panathinaikos'; |
## Task
Generate a SQL query to answer the following question:
`Which season's winner is Panathinaikos and is located in Athens?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "finals" (
"season" text,
"date" text,
"winners" text,
"score" text,
"runners_up" text,
"venue" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which season's winner is Panathinaikos and is located in Athens?`:
```sql
|
SELECT "date" FROM "round_4" WHERE "away_team_score"='14.16 (100)'; |
## Task
Generate a SQL query to answer the following question:
`What date did an Away team score 14.16 (100)?`
### 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 date did an Away team score 14.16 (100)?`:
```sql
|
SELECT "away_team_score" FROM "round_4" WHERE "home_team_score"='17.19 (121)'; |
## Task
Generate a SQL query to answer the following question:
`What is the score of the Away team that played against a Home team that scored 17.19 (121)?`
### 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 is the score of the Away team that played against a Home team that scored 17.19 (121)?`:
```sql
|
SELECT "away_team" FROM "round_4" WHERE "crowd">'14,000' AND "home_team_score"='14.17 (101)'; |
## Task
Generate a SQL query to answer the following question:
`What Away team scored 14.17 (101) and had a crowd attendance larger than 14,000?`
### 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 Away team scored 14.17 (101) and had a crowd attendance larger than 14,000?`:
```sql
|
SELECT "recorded" FROM "track_listing" WHERE "translation"='hate'; |
## Task
Generate a SQL query to answer the following question:
`What is the date recorded of Hate?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "track_listing" (
"track" real,
"title" text,
"translation" text,
"composer" text,
"recorded" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the date recorded of Hate?`:
```sql
|
SELECT "composer" FROM "track_listing" WHERE "track"<4; |
## Task
Generate a SQL query to answer the following question:
`Who is the composer on the tracks less than 4?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "track_listing" (
"track" real,
"title" text,
"translation" text,
"composer" text,
"recorded" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the composer on the tracks less than 4?`:
```sql
|
SELECT "title" FROM "track_listing" WHERE "track"=7; |
## Task
Generate a SQL query to answer the following question:
`What is the title of track 7?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "track_listing" (
"track" real,
"title" text,
"translation" text,
"composer" text,
"recorded" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the title of track 7?`:
```sql
|
SELECT "recorded" FROM "track_listing" WHERE "track"=8; |
## Task
Generate a SQL query to answer the following question:
`What is the recorded date of track 8?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "track_listing" (
"track" real,
"title" text,
"translation" text,
"composer" text,
"recorded" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the recorded date of track 8?`:
```sql
|
SELECT SUM("no_built") FROM "fleet_details" WHERE "unit_nos"='375301-310'; |
## Task
Generate a SQL query to answer the following question:
`How many number Builts had unit numbers of 375301-310?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "fleet_details" (
"class" text,
"type" text,
"operator" text,
"no_built" real,
"year_built" text,
"cars_per_set" real,
"unit_nos" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many number Builts had unit numbers of 375301-310?`:
```sql
|
SELECT "score" FROM "march" WHERE "home"='montreal' AND "record"='40β24β6'; |
## Task
Generate a SQL query to answer the following question:
`What was the score of the game where Montreal was the home team and the Devils had a record of 40β24β6?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "march" (
"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 where Montreal was the home team and the Devils had a record of 40β24β6?`:
```sql
|
SELECT "location" FROM "statistics" WHERE "stores"='140'; |
## Task
Generate a SQL query to answer the following question:
`Which location has 140 stores?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "statistics" (
"mall_name" text,
"location" text,
"retail_space_sq_feet_m" text,
"stores" text,
"year_opened" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which location has 140 stores?`:
```sql
|
SELECT "year_opened" FROM "statistics" WHERE "mall_name"='short pump town center'; |
## Task
Generate a SQL query to answer the following question:
`Which year did the Short Pump Town Center Mall open?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "statistics" (
"mall_name" text,
"location" text,
"retail_space_sq_feet_m" text,
"stores" text,
"year_opened" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which year did the Short Pump Town Center Mall open?`:
```sql
|
SELECT "retail_space_sq_feet_m" FROM "statistics" WHERE "mall_name"='stony point fashion park'; |
## Task
Generate a SQL query to answer the following question:
`What is the retail space of the Stony Point Fashion Park Mall?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "statistics" (
"mall_name" text,
"location" text,
"retail_space_sq_feet_m" text,
"stores" text,
"year_opened" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the retail space of the Stony Point Fashion Park Mall?`:
```sql
|
SELECT "mall_name" FROM "statistics" WHERE "stores"='140'; |
## Task
Generate a SQL query to answer the following question:
`Which Mall has 140 stores?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "statistics" (
"mall_name" text,
"location" text,
"retail_space_sq_feet_m" text,
"stores" text,
"year_opened" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Mall has 140 stores?`:
```sql
|
SELECT "match" FROM "list_of_derby_del_sole_results" WHERE "date"='30 january 1938'; |
## Task
Generate a SQL query to answer the following question:
`What match was on 30 january 1938?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_derby_del_sole_results" (
"season" text,
"match" text,
"result" text,
"league" text,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What match was on 30 january 1938?`:
```sql
|
SELECT "result" FROM "list_of_derby_del_sole_results" WHERE "match"='napoli-roma'; |
## Task
Generate a SQL query to answer the following question:
`What was the result of the napoli-roma match?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_derby_del_sole_results" (
"season" text,
"match" text,
"result" text,
"league" text,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the result of the napoli-roma match?`:
```sql
|
SELECT "player" FROM "2006_boys_team" WHERE "school"='seattle prep'; |
## Task
Generate a SQL query to answer the following question:
`What is the player that is from seattle prep?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2006_boys_team" (
"player" text,
"height" text,
"school" text,
"hometown" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the player that is from seattle prep?`:
```sql
|
SELECT "hometown" FROM "2006_boys_team" WHERE "height"='6-0'; |
## Task
Generate a SQL query to answer the following question:
`What is the hometown of the player which has a height of 6-0?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2006_boys_team" (
"player" text,
"height" text,
"school" text,
"hometown" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the hometown of the player which has a height of 6-0?`:
```sql
|
SELECT "hometown" FROM "2006_boys_team" WHERE "college"='washington'; |
## Task
Generate a SQL query to answer the following question:
`What is the hometown for the player that went to the college of washington`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2006_boys_team" (
"player" text,
"height" text,
"school" text,
"hometown" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the hometown for the player that went to the college of washington`:
```sql
|
SELECT "away_team" FROM "round_15" WHERE "venue"='princes park'; |
## Task
Generate a SQL query to answer the following question:
`What was the away team's score at Princes Park?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_15" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the away team's score at Princes Park?`:
```sql
|
SELECT "date" FROM "round_15" WHERE "away_team"='richmond'; |
## Task
Generate a SQL query to answer the following question:
`When did Richmond play an away game against Collingwood?`
### 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 `When did Richmond play an away game against Collingwood?`:
```sql
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.