cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`What is the final score of the game at lambeau field?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "2007" (
  "date" text,
  "visiting_team" text,
  "final_score" text,
  "host_team" text,
  "stadium" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the final score of the game at lambeau field?`:
```sql
                SELECT "final_score" FROM "2007" WHERE "stadium"='lambeau field';
```
## Task
Generate a SQL query to answer the following question:
`What rank is aliyya qadi with less than 1421 votes?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "unsuccessful_candidates" (
  "rank" real,
  "list" text,
  "candidate_name" text,
  "gender" text,
  "religion" text,
  "votes" real
);
### SQL
Given the database schema, here is the SQL query that answers `What rank is aliyya qadi with less than 1421 votes?`:
```sql
                SELECT MIN("rank") FROM "unsuccessful_candidates" WHERE "candidate_name"='aliyya qadi' AND "votes"<1421;
```
## Task
Generate a SQL query to answer the following question:
`Which candidate has more than 279 votes, rank less than 50, is ♀ and al-ahd?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "unsuccessful_candidates" (
  "rank" real,
  "list" text,
  "candidate_name" text,
  "gender" text,
  "religion" text,
  "votes" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which candidate has more than 279 votes, rank less than 50, is ♀ and al-ahd?`:
```sql
                SELECT "candidate_name" FROM "unsuccessful_candidates" WHERE "votes">279 AND "rank"<50 AND "gender"='♀' AND "list"='al-ahd';
```
## Task
Generate a SQL query to answer the following question:
`What is the first year that the Favorite Male Replacement category had Ben Vereen as a nominee?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "original_broadway_production" (
  "year" real,
  "award_ceremony" text,
  "category" text,
  "nominee" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the first year that the Favorite Male Replacement category had Ben Vereen as a nominee?`:
```sql
                SELECT MIN("year") FROM "original_broadway_production" WHERE "category"='favorite male replacement' AND "nominee"='ben vereen';
```
## Task
Generate a SQL query to answer the following question:
`What year was Kristin Chenoweth nominated in the category of outstanding actress in a musical?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "original_broadway_production" (
  "year" real,
  "award_ceremony" text,
  "category" text,
  "nominee" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year was Kristin Chenoweth nominated in the category of outstanding actress in a musical?`:
```sql
                SELECT "award_ceremony" FROM "original_broadway_production" WHERE "category"='outstanding actress in a musical' AND "nominee"='kristin chenoweth';
```
## Task
Generate a SQL query to answer the following question:
`What year was Aaron Tveit nominated in the Favorite Male Replacement category?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "original_broadway_production" (
  "year" real,
  "award_ceremony" text,
  "category" text,
  "nominee" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year was Aaron Tveit nominated in the Favorite Male Replacement category?`:
```sql
                SELECT AVG("year") FROM "original_broadway_production" WHERE "result"='nominated' AND "category"='favorite male replacement' AND "nominee"='aaron tveit';
```
## Task
Generate a SQL query to answer the following question:
`What is the date an away ream scored 6.16 (52)?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "round_17" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the date an away ream scored 6.16 (52)?`:
```sql
                SELECT "date" FROM "round_17" WHERE "away_team_score"='6.16 (52)';
```
## Task
Generate a SQL query to answer the following question:
`What is the away team that played when the home team scored 10.17 (77)?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "round_17" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the away team that played when the home team scored 10.17 (77)?`:
```sql
                SELECT "away_team" FROM "round_17" WHERE "home_team_score"='10.17 (77)';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the sum of rank for placings of 58`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "pairs" (
  "rank" real,
  "name" text,
  "nation" text,
  "points" real,
  "placings" real
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the sum of rank for placings of 58`:
```sql
                SELECT SUM("rank") FROM "pairs" WHERE "placings"=58;
```
## Task
Generate a SQL query to answer the following question:
`Tell me the lowest placings for United Kingdom and rank less than 13`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "pairs" (
  "rank" real,
  "name" text,
  "nation" text,
  "points" real,
  "placings" real
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the lowest placings for United Kingdom and rank less than 13`:
```sql
                SELECT MIN("placings") FROM "pairs" WHERE "nation"='united kingdom' AND "rank"<13;
```
## Task
Generate a SQL query to answer the following question:
`I want to know the highest rank with placings more than 123 and points greater than 88.06`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "pairs" (
  "rank" real,
  "name" text,
  "nation" text,
  "points" real,
  "placings" real
);
### SQL
Given the database schema, here is the SQL query that answers `I want to know the highest rank with placings more than 123 and points greater than 88.06`:
```sql
                SELECT MAX("rank") FROM "pairs" WHERE "placings">123 AND "points">88.06;
```
## Task
Generate a SQL query to answer the following question:
`Who is the drive for an Entrant of Scuderia Ambrosiana?`

### 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,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the drive for an Entrant of Scuderia Ambrosiana?`:
```sql
                SELECT "driver" FROM "teams_and_drivers" WHERE "entrant"='scuderia ambrosiana';
```
## Task
Generate a SQL query to answer the following question:
`Which of the Rounds has an Entrant of automobiles Talbot-Darracq, and Pierre Levegh as the driver?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "teams_and_drivers" (
  "entrant" text,
  "constructor" text,
  "chassis" text,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which of the Rounds has an Entrant of automobiles Talbot-Darracq, and Pierre Levegh as the driver?`:
```sql
                SELECT "rounds" FROM "teams_and_drivers" WHERE "entrant"='automobiles talbot-darracq' AND "driver"='pierre levegh';
```
## Task
Generate a SQL query to answer the following question:
`Who is the driver for the Entract of Enrico Platé?`

### 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,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the driver for the Entract of Enrico Platé?`:
```sql
                SELECT "driver" FROM "teams_and_drivers" WHERE "entrant"='enrico platé';
```
## Task
Generate a SQL query to answer the following question:
`Which of the entrants had Luigi Fagioli as a driver?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "teams_and_drivers" (
  "entrant" text,
  "constructor" text,
  "chassis" text,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which of the entrants had Luigi Fagioli as a driver?`:
```sql
                SELECT "entrant" FROM "teams_and_drivers" WHERE "driver"='luigi fagioli';
```
## Task
Generate a SQL query to answer the following question:
`Who is the driver whose Constructor was Era, and whose entrant was T.A.S.O. Mathieson?`

### 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,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the driver whose Constructor was Era, and whose entrant was T.A.S.O. Mathieson?`:
```sql
                SELECT "driver" FROM "teams_and_drivers" WHERE "constructor"='era' AND "entrant"='t.a.s.o. mathieson';
```
## Task
Generate a SQL query to answer the following question:
`Which chassis had Rounds of 7, and an Entrant of Ecurie Rosier?`

### 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,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which chassis had Rounds of 7, and an Entrant of Ecurie Rosier?`:
```sql
                SELECT "chassis" FROM "teams_and_drivers" WHERE "rounds"='7' AND "entrant"='ecurie rosier';
```
## Task
Generate a SQL query to answer the following question:
`Who is the winner constructor with driver riccardo patrese?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "grands_prix" (
  "round" real,
  "grand_prix" text,
  "date" text,
  "location" text,
  "pole_position" text,
  "fastest_lap" text,
  "winning_driver" text,
  "winning_constructor" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the winner constructor with driver riccardo patrese?`:
```sql
                SELECT "winning_constructor" FROM "grands_prix" WHERE "winning_driver"='riccardo patrese';
```
## Task
Generate a SQL query to answer the following question:
`What is the highest round on 5 april?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "grands_prix" (
  "round" real,
  "grand_prix" text,
  "date" text,
  "location" text,
  "pole_position" text,
  "fastest_lap" text,
  "winning_driver" text,
  "winning_constructor" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest round on 5 april?`:
```sql
                SELECT MAX("round") FROM "grands_prix" WHERE "date"='5 april';
```
## Task
Generate a SQL query to answer the following question:
`Which date was hermanos rodríguez the location?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "grands_prix" (
  "round" real,
  "grand_prix" text,
  "date" text,
  "location" text,
  "pole_position" text,
  "fastest_lap" text,
  "winning_driver" text,
  "winning_constructor" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which date was hermanos rodríguez the location?`:
```sql
                SELECT "date" FROM "grands_prix" WHERE "location"='hermanos rodríguez';
```
## Task
Generate a SQL query to answer the following question:
`Name the record for may 3`

### 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 `Name the record for may 3`:
```sql
                SELECT "record" FROM "game_log" WHERE "date"='may 3';
```
## Task
Generate a SQL query to answer the following question:
`Name the total number in attendance for may 1`

### 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 `Name the total number in attendance for may 1`:
```sql
                SELECT COUNT("attendance") FROM "game_log" WHERE "date"='may 1';
```
## Task
Generate a SQL query to answer the following question:
`Name the loss on may 29`

### 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 `Name the loss on may 29`:
```sql
                SELECT "loss" FROM "game_log" WHERE "date"='may 29';
```
## Task
Generate a SQL query to answer the following question:
`How many cuts were made when there weren't any wins but had a top-5 of 1 and a top 10 larger than 4?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "summary" (
  "tournament" text,
  "wins" real,
  "top_5" real,
  "top_10" real,
  "top_25" real,
  "events" real,
  "cuts_made" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many cuts were made when there weren't any wins but had a top-5 of 1 and a top 10 larger than 4?`:
```sql
                SELECT SUM("cuts_made") FROM "summary" WHERE "wins"<1 AND "top_5"=1 AND "top_10">4;
```
## Task
Generate a SQL query to answer the following question:
`Which college has a Player of shabazz muhammad?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "2012_boys_team" (
  "player" text,
  "height" text,
  "school" text,
  "hometown" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which college has a Player of shabazz muhammad?`:
```sql
                SELECT "college" FROM "2012_boys_team" WHERE "player"='shabazz muhammad';
```
## Task
Generate a SQL query to answer the following question:
`How tall is nerlens noel?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "2012_boys_team" (
  "player" text,
  "height" text,
  "school" text,
  "hometown" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `How tall is nerlens noel?`:
```sql
                SELECT "height" FROM "2012_boys_team" WHERE "player"='nerlens noel';
```
## Task
Generate a SQL query to answer the following question:
`Who is from flower mound, tx?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "2012_boys_team" (
  "player" text,
  "height" text,
  "school" text,
  "hometown" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is from flower mound, tx?`:
```sql
                SELECT "player" FROM "2012_boys_team" WHERE "hometown"='flower mound, tx';
```
## Task
Generate a SQL query to answer the following question:
`Where is shabazz muhammad from?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "2012_boys_team" (
  "player" text,
  "height" text,
  "school" text,
  "hometown" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where is shabazz muhammad from?`:
```sql
                SELECT "hometown" FROM "2012_boys_team" WHERE "player"='shabazz muhammad';
```
## Task
Generate a SQL query to answer the following question:
`What was the opponent for july 21?`

### 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 was the opponent for july 21?`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "date"='july 21';
```
## Task
Generate a SQL query to answer the following question:
`What was the record on july 24?`

### 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 was the record on july 24?`:
```sql
                SELECT "record" FROM "game_log" WHERE "date"='july 24';
```
## Task
Generate a SQL query to answer the following question:
`Who constructed the car with a grid under 15, 77 laps, and a Time/Retired of + 0.771?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "race" (
  "driver" text,
  "constructor" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `Who constructed the car with a grid under 15, 77 laps, and a Time/Retired of + 0.771?`:
```sql
                SELECT "constructor" FROM "race" WHERE "grid"<15 AND "laps"=77 AND "time_retired"='+ 0.771';
```
## Task
Generate a SQL query to answer the following question:
`What is the average grid for damon hill with over 74 laps?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "race" (
  "driver" text,
  "constructor" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average grid for damon hill with over 74 laps?`:
```sql
                SELECT AVG("grid") FROM "race" WHERE "laps">74 AND "driver"='damon hill';
```
## Task
Generate a SQL query to answer the following question:
`Which position has a School/club team of jacksonville?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "draft" (
  "round" real,
  "pick" real,
  "player" text,
  "pos" text,
  "nationality" text,
  "team" text,
  "school_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which position has a School/club team of jacksonville?`:
```sql
                SELECT "pos" FROM "draft" WHERE "school_club_team"='jacksonville';
```
## Task
Generate a SQL query to answer the following question:
`How many rounds have a Pick of 13?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "draft" (
  "round" real,
  "pick" real,
  "player" text,
  "pos" text,
  "nationality" text,
  "team" text,
  "school_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many rounds have a Pick of 13?`:
```sql
                SELECT SUM("round") FROM "draft" WHERE "pick"=13;
```
## Task
Generate a SQL query to answer the following question:
`How many rounds have School/club team of pan american?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "draft" (
  "round" real,
  "pick" real,
  "player" text,
  "pos" text,
  "nationality" text,
  "team" text,
  "school_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many rounds have School/club team of pan american?`:
```sql
                SELECT SUM("round") FROM "draft" WHERE "school_club_team"='pan american';
```
## Task
Generate a SQL query to answer the following question:
`What is the earliest year a chassis of ferrari 312t and results of 31 points occurred?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "complete_formula_one_world_championship_" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the earliest year a chassis of ferrari 312t and results of 31 points occurred?`:
```sql
                SELECT MIN("year") FROM "complete_formula_one_world_championship_" WHERE "chassis"='ferrari 312t' AND "points"='31';
```
## Task
Generate a SQL query to answer the following question:
`What is the chassis when there is 25 points?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "complete_formula_one_world_championship_" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the chassis when there is 25 points?`:
```sql
                SELECT "chassis" FROM "complete_formula_one_world_championship_" WHERE "points"='25';
```
## Task
Generate a SQL query to answer the following question:
`How many points were there before 1979 with a ferrari 312b2 chassis?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "complete_formula_one_world_championship_" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many points were there before 1979 with a ferrari 312b2 chassis?`:
```sql
                SELECT "points" FROM "complete_formula_one_world_championship_" WHERE "year"<1979 AND "chassis"='ferrari 312b2';
```
## Task
Generate a SQL query to answer the following question:
`What year were there 29 (32) points?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "complete_formula_one_world_championship_" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year were there 29 (32) points?`:
```sql
                SELECT "year" FROM "complete_formula_one_world_championship_" WHERE "points"='29 (32)';
```
## Task
Generate a SQL query to answer the following question:
`What result occurs when the round is 4 leg 2?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "2004_05_middlesbrough_f_c_season" (
  "round" text,
  "date" text,
  "opponent" text,
  "venue" text,
  "result" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What result occurs when the round is 4 leg 2?`:
```sql
                SELECT "result" FROM "2004_05_middlesbrough_f_c_season" WHERE "round"='4 leg 2';
```
## Task
Generate a SQL query to answer the following question:
`What was the result for the round of 4 leg 2 when the attendance was less than 20,371?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "2004_05_middlesbrough_f_c_season" (
  "round" text,
  "date" text,
  "opponent" text,
  "venue" text,
  "result" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the result for the round of 4 leg 2 when the attendance was less than 20,371?`:
```sql
                SELECT "result" FROM "2004_05_middlesbrough_f_c_season" WHERE "attendance">'20,371' AND "round"='4 leg 2';
```
## Task
Generate a SQL query to answer the following question:
`What did fitzroy score at their home game?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "round_1" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What did fitzroy score at their home game?`:
```sql
                SELECT "home_team_score" FROM "round_1" WHERE "home_team"='fitzroy';
```
## Task
Generate a SQL query to answer the following question:
`Which away team played at western oval?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "round_1" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which away team played at western oval?`:
```sql
                SELECT "away_team" FROM "round_1" WHERE "venue"='western oval';
```
## Task
Generate a SQL query to answer the following question:
`How big was the crowd when the opponent was essendon?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "round_1" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `How big was the crowd when the opponent was essendon?`:
```sql
                SELECT SUM("crowd") FROM "round_1" WHERE "away_team"='essendon';
```
## Task
Generate a SQL query to answer the following question:
`Which surface had Yew-Ming Si as a partner?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "doubles_runner_up" (
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponents_in_the_final" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which surface had Yew-Ming Si as a partner?`:
```sql
                SELECT "surface" FROM "doubles_runner_up" WHERE "partner"='yew-ming si';
```
## Task
Generate a SQL query to answer the following question:
`What was the result of rank 1?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "labour_targets" (
  "rank" real,
  "constituency" text,
  "winning_party_2007" text,
  "swing_to_gain" real,
  "labour_s_place_2007" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the result of rank 1?`:
```sql
                SELECT "result" FROM "labour_targets" WHERE "rank"=1;
```
## Task
Generate a SQL query to answer the following question:
`What type has a date of 1 june?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "stage_results" (
  "date" text,
  "course" text,
  "distance" text,
  "type" text,
  "winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `What type has a date of 1 june?`:
```sql
                SELECT "type" FROM "stage_results" WHERE "date"='1 june';
```
## Task
Generate a SQL query to answer the following question:
`What was the date with a hilly stage?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "stage_results" (
  "date" text,
  "course" text,
  "distance" text,
  "type" text,
  "winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the date with a hilly stage?`:
```sql
                SELECT "date" FROM "stage_results" WHERE "type"='hilly stage';
```
## Task
Generate a SQL query to answer the following question:
`What is the name of the winner on 18 may?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "stage_results" (
  "date" text,
  "course" text,
  "distance" text,
  "type" text,
  "winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the name of the winner on 18 may?`:
```sql
                SELECT "winner" FROM "stage_results" WHERE "date"='18 may';
```
## Task
Generate a SQL query to answer the following question:
`What date was moena to aprica the course?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "stage_results" (
  "date" text,
  "course" text,
  "distance" text,
  "type" text,
  "winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date was moena to aprica the course?`:
```sql
                SELECT "date" FROM "stage_results" WHERE "course"='moena to aprica';
```
## Task
Generate a SQL query to answer the following question:
`What is the name of the winner with a type of plain stage and a Course of nola to sora?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "stage_results" (
  "date" text,
  "course" text,
  "distance" text,
  "type" text,
  "winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the name of the winner with a type of plain stage and a Course of nola to sora?`:
```sql
                SELECT "winner" FROM "stage_results" WHERE "type"='plain stage' AND "course"='nola to sora';
```
## Task
Generate a SQL query to answer the following question:
`Which sign has a red border and a warning sign?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "colours_and_shapes" (
  "type_of_sign" text,
  "shape" text,
  "border" text,
  "background_colour" text,
  "text_symbol" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which sign has a red border and a warning sign?`:
```sql
                SELECT "text_symbol" FROM "colours_and_shapes" WHERE "border"='red' AND "type_of_sign"='warning';
```
## Task
Generate a SQL query to answer the following question:
`Which sign had a yellow background and a triangular shape?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "colours_and_shapes" (
  "type_of_sign" text,
  "shape" text,
  "border" text,
  "background_colour" text,
  "text_symbol" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which sign had a yellow background and a triangular shape?`:
```sql
                SELECT "border" FROM "colours_and_shapes" WHERE "background_colour"='yellow' AND "shape"='triangular';
```
## Task
Generate a SQL query to answer the following question:
`Which sign has a red border?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "colours_and_shapes" (
  "type_of_sign" text,
  "shape" text,
  "border" text,
  "background_colour" text,
  "text_symbol" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which sign has a red border?`:
```sql
                SELECT "text_symbol" FROM "colours_and_shapes" WHERE "border"='red';
```
## Task
Generate a SQL query to answer the following question:
`Which color is the background of the mandatory instructions?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "colours_and_shapes" (
  "type_of_sign" text,
  "shape" text,
  "border" text,
  "background_colour" text,
  "text_symbol" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which color is the background of the mandatory instructions?`:
```sql
                SELECT "background_colour" FROM "colours_and_shapes" WHERE "type_of_sign"='mandatory instructions';
```
## Task
Generate a SQL query to answer the following question:
`What is the color of the background of the white border and sign of information?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "colours_and_shapes" (
  "type_of_sign" text,
  "shape" text,
  "border" text,
  "background_colour" text,
  "text_symbol" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the color of the background of the white border and sign of information?`:
```sql
                SELECT "background_colour" FROM "colours_and_shapes" WHERE "border"='white' AND "type_of_sign"='information';
```
## Task
Generate a SQL query to answer the following question:
`What was the away team score when the home team score was 9.10 (64)?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "round_6" (
  "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 when the home team score was 9.10 (64)?`:
```sql
                SELECT "away_team_score" FROM "round_6" WHERE "home_team_score"='9.10 (64)';
```
## Task
Generate a SQL query to answer the following question:
`What is the average total of Italy and has a bronze larger than 1?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "medal_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 `What is the average total of Italy and has a bronze larger than 1?`:
```sql
                SELECT AVG("total") FROM "medal_table" WHERE "nation"='italy' AND "bronze">1;
```
## Task
Generate a SQL query to answer the following question:
`What amount of Gold does Russia have and have a rank larger than 1?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "medal_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 `What amount of Gold does Russia have and have a rank larger than 1?`:
```sql
                SELECT SUM("gold") FROM "medal_table" WHERE "nation"='russia' AND "rank">1;
```
## Task
Generate a SQL query to answer the following question:
`What is the sum of the ranks with a total of 1 and silver less than 0.`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "medal_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 `What is the sum of the ranks with a total of 1 and silver less than 0.`:
```sql
                SELECT SUM("rank") FROM "medal_table" WHERE "total"=1 AND "silver"<0;
```
## Task
Generate a SQL query to answer the following question:
`Which Player is linebacker and has a pick larger than 28?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "nfl_draft" (
  "pick" real,
  "round" real,
  "player" text,
  "position" text,
  "school" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Player is linebacker and has a pick larger than 28?`:
```sql
                SELECT "player" FROM "nfl_draft" WHERE "position"='linebacker' AND "pick">28;
```
## Task
Generate a SQL query to answer the following question:
`What was the lowest round that Melvin Johnson played?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "nfl_draft" (
  "pick" real,
  "round" real,
  "player" text,
  "position" text,
  "school" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the lowest round that Melvin Johnson played?`:
```sql
                SELECT MIN("round") FROM "nfl_draft" WHERE "player"='melvin johnson';
```
## Task
Generate a SQL query to answer the following question:
`Who was the runner-up at the South Florida Semi-Finalist #1?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "division_i" (
  "year" text,
  "champion" text,
  "score" text,
  "runner_up" text,
  "location" text,
  "semi_finalist_num1" text,
  "semi_finalist_num2" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the runner-up at the South Florida Semi-Finalist #1?`:
```sql
                SELECT "runner_up" FROM "division_i" WHERE "semi_finalist_num1"='south florida';
```
## Task
Generate a SQL query to answer the following question:
`Who was the Champion in Snellville, GA in 2006?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "division_i" (
  "year" text,
  "champion" text,
  "score" text,
  "runner_up" text,
  "location" text,
  "semi_finalist_num1" text,
  "semi_finalist_num2" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the Champion in Snellville, GA in 2006?`:
```sql
                SELECT "champion" FROM "division_i" WHERE "location"='snellville, ga' AND "year"='2006';
```
## Task
Generate a SQL query to answer the following question:
`Who won when Elon was the runner-up?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "division_i" (
  "year" text,
  "champion" text,
  "score" text,
  "runner_up" text,
  "location" text,
  "semi_finalist_num1" text,
  "semi_finalist_num2" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who won when Elon was the runner-up?`:
```sql
                SELECT "champion" FROM "division_i" WHERE "runner_up"='elon';
```
## Task
Generate a SQL query to answer the following question:
`What year saw a score of 8-5?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "division_i" (
  "year" text,
  "champion" text,
  "score" text,
  "runner_up" text,
  "location" text,
  "semi_finalist_num1" text,
  "semi_finalist_num2" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year saw a score of 8-5?`:
```sql
                SELECT "year" FROM "division_i" WHERE "score"='8-5';
```
## Task
Generate a SQL query to answer the following question:
`Who was the Semi-Finalist #2 in 2007?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "division_i" (
  "year" text,
  "champion" text,
  "score" text,
  "runner_up" text,
  "location" text,
  "semi_finalist_num1" text,
  "semi_finalist_num2" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the Semi-Finalist #2 in 2007?`:
```sql
                SELECT "semi_finalist_num2" FROM "division_i" WHERE "year"='2007';
```
## Task
Generate a SQL query to answer the following question:
`Who was the Semi-Finalist #2 in 2001?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "division_i" (
  "year" text,
  "champion" text,
  "score" text,
  "runner_up" text,
  "location" text,
  "semi_finalist_num1" text,
  "semi_finalist_num2" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the Semi-Finalist #2 in 2001?`:
```sql
                SELECT "semi_finalist_num2" FROM "division_i" WHERE "year"='2001';
```
## Task
Generate a SQL query to answer the following question:
`What tournament is in Arizona?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "tournament_results" (
  "date" text,
  "tournament" text,
  "location" text,
  "purse" real,
  "winner" text,
  "score" text,
  "1st_prize" real
);
### SQL
Given the database schema, here is the SQL query that answers `What tournament is in Arizona?`:
```sql
                SELECT "tournament" FROM "tournament_results" WHERE "location"='arizona';
```
## Task
Generate a SQL query to answer the following question:
`When did an away team have a score of 12.9 (81)?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "round_1" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `When did an away team have a score of 12.9 (81)?`:
```sql
                SELECT "date" FROM "round_1" WHERE "away_team_score"='12.9 (81)';
```
## Task
Generate a SQL query to answer the following question:
`What was the home team that had an opponent of footscray?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "round_1" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the home team that had an opponent of footscray?`:
```sql
                SELECT "home_team" FROM "round_1" WHERE "away_team"='footscray';
```
## Task
Generate a SQL query to answer the following question:
`Which away team had a crowd bigger than 21,000?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "round_1" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which away team had a crowd bigger than 21,000?`:
```sql
                SELECT "away_team" FROM "round_1" WHERE "crowd">'21,000';
```
## Task
Generate a SQL query to answer the following question:
`When the home team scored 15.22 (112), what 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 `When the home team scored 15.22 (112), what was the away team?`:
```sql
                SELECT "away_team" FROM "round_13" WHERE "home_team_score"='15.22 (112)';
```
## Task
Generate a SQL query to answer the following question:
`When the away team scored 7.13 (55), what was the home 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 `When the away team scored 7.13 (55), what was the home team?`:
```sql
                SELECT "home_team" FROM "round_13" WHERE "away_team_score"='7.13 (55)';
```
## Task
Generate a SQL query to answer the following question:
`When an away team scored 10.8 (68), what was the crowd size?`

### 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 `When an away team scored 10.8 (68), what was the crowd size?`:
```sql
                SELECT "crowd" FROM "round_13" WHERE "away_team_score"='10.8 (68)';
```
## Task
Generate a SQL query to answer the following question:
`What was the smallest crowd size when a home team scored 6.11 (47)?`

### 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 `What was the smallest crowd size when a home team scored 6.11 (47)?`:
```sql
                SELECT MIN("crowd") FROM "round_13" WHERE "home_team_score"='6.11 (47)';
```
## Task
Generate a SQL query to answer the following question:
`What is the rank for points less than 166.96, and a Places of 166?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "ladies" (
  "rank" real,
  "name" text,
  "nation" text,
  "sp_fs" real,
  "points" real,
  "places" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the rank for points less than 166.96, and a Places of 166?`:
```sql
                SELECT AVG("rank") FROM "ladies" WHERE "points"<166.96 AND "places"='166';
```
## Task
Generate a SQL query to answer the following question:
`What is the rank for more than 120.44 points in East Germany and a SP+FS of 3?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "ladies" (
  "rank" real,
  "name" text,
  "nation" text,
  "sp_fs" real,
  "points" real,
  "places" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the rank for more than 120.44 points in East Germany and a SP+FS of 3?`:
```sql
                SELECT COUNT("rank") FROM "ladies" WHERE "points">120.44 AND "nation"='east germany' AND "sp_fs"=3;
```
## Task
Generate a SQL query to answer the following question:
`What is the rank when 233 shows for places and SP+FS smaller than 27?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "ladies" (
  "rank" real,
  "name" text,
  "nation" text,
  "sp_fs" real,
  "points" real,
  "places" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the rank when 233 shows for places and SP+FS smaller than 27?`:
```sql
                SELECT COUNT("rank") FROM "ladies" WHERE "places"='233' AND "sp_fs"<27;
```
## Task
Generate a SQL query to answer the following question:
`What is the average SP+FS for Denise Biellmann, and a Rank larger than 5?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "ladies" (
  "rank" real,
  "name" text,
  "nation" text,
  "sp_fs" real,
  "points" real,
  "places" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average SP+FS for Denise Biellmann, and a Rank larger than 5?`:
```sql
                SELECT AVG("sp_fs") FROM "ladies" WHERE "name"='denise biellmann' AND "rank">5;
```
## Task
Generate a SQL query to answer the following question:
`What is the number of points for east germany, and a Places of 88?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "ladies" (
  "rank" real,
  "name" text,
  "nation" text,
  "sp_fs" real,
  "points" real,
  "places" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the number of points for east germany, and a Places of 88?`:
```sql
                SELECT SUM("points") FROM "ladies" WHERE "nation"='east germany' AND "places"='88';
```