cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`What is the away team score where the crowd is greater than 25,000 and the Away team is south 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 `What is the away team score where the crowd is greater than 25,000 and the Away team is south melbourne?`:
```sql
                SELECT "away_team_score" FROM "round_11" WHERE "crowd">'25,000' AND "away_team"='south melbourne';
```
## Task
Generate a SQL query to answer the following question:
`What is the largest crowd with a Home team score of 9.17 (71)?`

### 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 `What is the largest crowd with a Home team score of 9.17 (71)?`:
```sql
                SELECT MAX("crowd") FROM "round_11" WHERE "home_team_score"='9.17 (71)';
```
## Task
Generate a SQL query to answer the following question:
`What day did the VFL play at Junction Oval?`

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

CREATE TABLE "round_18" (
  "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 day did the VFL play at Junction Oval?`:
```sql
                SELECT "date" FROM "round_18" WHERE "venue"='junction oval';
```
## Task
Generate a SQL query to answer the following question:
`Where did Footscray play as the home team?`

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

CREATE TABLE "round_18" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where did Footscray play as the home team?`:
```sql
                SELECT "venue" FROM "round_18" WHERE "home_team"='footscray';
```
## Task
Generate a SQL query to answer the following question:
`Who was the opponent when Footscray played as the home team?`

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

CREATE TABLE "round_18" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the opponent when Footscray played as the home team?`:
```sql
                SELECT "away_team_score" FROM "round_18" WHERE "home_team"='footscray';
```
## Task
Generate a SQL query to answer the following question:
`What was the attendance when the VFL played Arden Street Oval?`

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

CREATE TABLE "round_18" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the attendance when the VFL played Arden Street Oval?`:
```sql
                SELECT COUNT("crowd") FROM "round_18" WHERE "venue"='arden street oval';
```
## Task
Generate a SQL query to answer the following question:
`What was the score June 22?`

### 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,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score June 22?`:
```sql
                SELECT "loss" FROM "game_log" WHERE "date"='june 22';
```
## Task
Generate a SQL query to answer the following question:
`Which school has a hometown of winter park, FL?`

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

CREATE TABLE "2007_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 school has a hometown of winter park, FL?`:
```sql
                SELECT "school" FROM "2007_boys_team" WHERE "hometown"='winter park, fl';
```
## Task
Generate a SQL query to answer the following question:
`What's the college of the player with a height of 6-4 and went to lake howell high school?`

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

CREATE TABLE "2007_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's the college of the player with a height of 6-4 and went to lake howell high school?`:
```sql
                SELECT "college" FROM "2007_boys_team" WHERE "height"='6-4' AND "school"='lake howell high school';
```
## Task
Generate a SQL query to answer the following question:
`What's the hometown of the player with a college of lsu?`

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

CREATE TABLE "2007_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's the hometown of the player with a college of lsu?`:
```sql
                SELECT "hometown" FROM "2007_boys_team" WHERE "college"='lsu';
```
## Task
Generate a SQL query to answer the following question:
`What's the heigh of the player who went to lake howell high school?`

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

CREATE TABLE "2007_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's the heigh of the player who went to lake howell high school?`:
```sql
                SELECT "height" FROM "2007_boys_team" WHERE "school"='lake howell high school';
```
## Task
Generate a SQL query to answer the following question:
`What's the heigh of nolan smith?`

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

CREATE TABLE "2007_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's the heigh of nolan smith?`:
```sql
                SELECT "height" FROM "2007_boys_team" WHERE "player"='nolan smith';
```
## Task
Generate a SQL query to answer the following question:
`What's the height of the player who went to oak hill academy?`

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

CREATE TABLE "2007_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's the height of the player who went to oak hill academy?`:
```sql
                SELECT "height" FROM "2007_boys_team" WHERE "school"='oak hill academy';
```
## Task
Generate a SQL query to answer the following question:
`What tyre did Paul Russo have on his fastest lap?`

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

CREATE TABLE "season_review" (
  "race" text,
  "circuit" text,
  "date" text,
  "pole_position" text,
  "fastest_lap" text,
  "winning_driver" text,
  "constructor" text,
  "tyre" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What tyre did Paul Russo have on his fastest lap?`:
```sql
                SELECT "tyre" FROM "season_review" WHERE "fastest_lap"='paul russo';
```
## Task
Generate a SQL query to answer the following question:
`What is the date that Stirling Moss had his fastest lap in a Maserati?`

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

CREATE TABLE "season_review" (
  "race" text,
  "circuit" text,
  "date" text,
  "pole_position" text,
  "fastest_lap" text,
  "winning_driver" text,
  "constructor" text,
  "tyre" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the date that Stirling Moss had his fastest lap in a Maserati?`:
```sql
                SELECT "date" FROM "season_review" WHERE "constructor"='maserati' AND "fastest_lap"='stirling moss';
```
## Task
Generate a SQL query to answer the following question:
`Who was the winning driver on 30 May?`

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

CREATE TABLE "season_review" (
  "race" text,
  "circuit" text,
  "date" text,
  "pole_position" text,
  "fastest_lap" text,
  "winning_driver" text,
  "constructor" text,
  "tyre" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the winning driver on 30 May?`:
```sql
                SELECT "winning_driver" FROM "season_review" WHERE "date"='30 may';
```
## Task
Generate a SQL query to answer the following question:
`What was the fastest lap in the Belgian Grand Prix?`

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

CREATE TABLE "season_review" (
  "race" text,
  "circuit" text,
  "date" text,
  "pole_position" text,
  "fastest_lap" text,
  "winning_driver" text,
  "constructor" text,
  "tyre" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the fastest lap in the Belgian Grand Prix?`:
```sql
                SELECT "fastest_lap" FROM "season_review" WHERE "race"='belgian grand prix';
```
## Task
Generate a SQL query to answer the following question:
`Who was the home team when the away team was Hawthorn?`

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

CREATE TABLE "round_18" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the home team when the away team was Hawthorn?`:
```sql
                SELECT "home_team" FROM "round_18" WHERE "away_team"='hawthorn';
```
## Task
Generate a SQL query to answer the following question:
`On what date did the game at Windy Hill take place?`

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

CREATE TABLE "round_18" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date did the game at Windy Hill take place?`:
```sql
                SELECT "date" FROM "round_18" WHERE "venue"='windy hill';
```
## Task
Generate a SQL query to answer the following question:
`What was the venue when the away team was Hawthorn?`

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

CREATE TABLE "round_18" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the venue when the away team was Hawthorn?`:
```sql
                SELECT "venue" FROM "round_18" WHERE "away_team"='hawthorn';
```
## Task
Generate a SQL query to answer the following question:
`What was the home team when the game was at Windy Hill?`

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

CREATE TABLE "round_18" (
  "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 when the game was at Windy Hill?`:
```sql
                SELECT "home_team" FROM "round_18" WHERE "venue"='windy hill';
```
## Task
Generate a SQL query to answer the following question:
`What position has less than 343 laps in 2010?`

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

CREATE TABLE "24_hours_of_le_mans_results" (
  "year" real,
  "team" text,
  "co_drivers" text,
  "class" text,
  "laps" real,
  "pos" text,
  "class_pos" text
);
### SQL
Given the database schema, here is the SQL query that answers `What position has less than 343 laps in 2010?`:
```sql
                SELECT "pos" FROM "24_hours_of_le_mans_results" WHERE "laps"<343 AND "year"=2010;
```
## Task
Generate a SQL query to answer the following question:
`What are panoz motor sports' lowest number of laps before 2002?`

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

CREATE TABLE "24_hours_of_le_mans_results" (
  "year" real,
  "team" text,
  "co_drivers" text,
  "class" text,
  "laps" real,
  "pos" text,
  "class_pos" text
);
### SQL
Given the database schema, here is the SQL query that answers `What are panoz motor sports' lowest number of laps before 2002?`:
```sql
                SELECT MIN("laps") FROM "24_hours_of_le_mans_results" WHERE "team"='panoz motor sports' AND "year"<2002;
```
## Task
Generate a SQL query to answer the following question:
`What's the sum of the games that had paul (9) for high assists?`

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

CREATE TABLE "playoffs" (
  "game" real,
  "date" text,
  "team" text,
  "score" text,
  "high_points" text,
  "high_rebounds" text,
  "high_assists" text,
  "location_attendance" text,
  "series" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the sum of the games that had paul (9) for high assists?`:
```sql
                SELECT SUM("game") FROM "playoffs" WHERE "high_assists"='paul (9)';
```
## Task
Generate a SQL query to answer the following question:
`What team had a high points of west (20)?`

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

CREATE TABLE "playoffs" (
  "game" real,
  "date" text,
  "team" text,
  "score" text,
  "high_points" text,
  "high_rebounds" text,
  "high_assists" text,
  "location_attendance" text,
  "series" text
);
### SQL
Given the database schema, here is the SQL query that answers `What team had a high points of west (20)?`:
```sql
                SELECT "team" FROM "playoffs" WHERE "high_points"='west (20)';
```
## Task
Generate a SQL query to answer the following question:
`What week was the game played at Robert f. Kennedy memorial stadium with more than 54,633 people in attendance?`

### 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,
  "game_site" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What week was the game played at Robert f. Kennedy memorial stadium with more than 54,633 people in attendance?`:
```sql
                SELECT COUNT("week") FROM "schedule" WHERE "game_site"='robert f. kennedy memorial stadium' AND "attendance">'54,633';
```
## Task
Generate a SQL query to answer the following question:
`What was the result of the game played in texas stadium with more than 46,267 in the crowd and against the pittsburgh steelers?`

### 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,
  "game_site" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the result of the game played in texas stadium with more than 46,267 in the crowd and against the pittsburgh steelers?`:
```sql
                SELECT "result" FROM "schedule" WHERE "game_site"='texas stadium' AND "attendance">'46,267' AND "opponent"='pittsburgh steelers';
```
## Task
Generate a SQL query to answer the following question:
`What opponent had a game with more than 50,705 in attendace on September 13, 1982?`

### 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,
  "game_site" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What opponent had a game with more than 50,705 in attendace on September 13, 1982?`:
```sql
                SELECT "opponent" FROM "schedule" WHERE "attendance">'50,705' AND "date"='september 13, 1982';
```
## Task
Generate a SQL query to answer the following question:
`What is the time/retired associated with a grid of 5 and under 73 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 time/retired associated with a grid of 5 and under 73 laps?`:
```sql
                SELECT "time_retired" FROM "race" WHERE "laps"<73 AND "grid"=5;
```
## Task
Generate a SQL query to answer the following question:
`What was the free score of the skater with a total of 156.67?`

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

CREATE TABLE "men" (
  "rank" real,
  "name" text,
  "nation" text,
  "placings" real,
  "figures" real,
  "free" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the free score of the skater with a total of 156.67?`:
```sql
                SELECT "free" FROM "men" WHERE "total"=156.67;
```
## Task
Generate a SQL query to answer the following question:
`What was the average figure score of the skater with a free score under 56.35?`

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

CREATE TABLE "men" (
  "rank" real,
  "name" text,
  "nation" text,
  "placings" real,
  "figures" real,
  "free" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the average figure score of the skater with a free score under 56.35?`:
```sql
                SELECT AVG("figures") FROM "men" WHERE "free"<56.35;
```
## Task
Generate a SQL query to answer the following question:
`Which opponent had round 1?`

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

CREATE TABLE "competitive" (
  "date" text,
  "tournament" text,
  "round" text,
  "ground" text,
  "opponent" text,
  "score_1" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which opponent had round 1?`:
```sql
                SELECT "opponent" FROM "competitive" WHERE "round"='1';
```
## Task
Generate a SQL query to answer the following question:
`Which date's opponent was Dender when the tournament was in the Jupiler League and the ground was a?`

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

CREATE TABLE "competitive" (
  "date" text,
  "tournament" text,
  "round" text,
  "ground" text,
  "opponent" text,
  "score_1" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which date's opponent was Dender when the tournament was in the Jupiler League and the ground was a?`:
```sql
                SELECT "date" FROM "competitive" WHERE "opponent"='dender' AND "tournament"='jupiler league' AND "ground"='a';
```
## Task
Generate a SQL query to answer the following question:
`Which ground's round was 33?`

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

CREATE TABLE "competitive" (
  "date" text,
  "tournament" text,
  "round" text,
  "ground" text,
  "opponent" text,
  "score_1" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which ground's round was 33?`:
```sql
                SELECT "ground" FROM "competitive" WHERE "round"='33';
```
## Task
Generate a SQL query to answer the following question:
`Which competition had a final position/round of 2?`

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

CREATE TABLE "competitions" (
  "competition" text,
  "current_position_round" text,
  "final_position_round" text,
  "first_match" text,
  "last_match" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which competition had a final position/round of 2?`:
```sql
                SELECT "competition" FROM "competitions" WHERE "final_position_round"='2';
```
## Task
Generate a SQL query to answer the following question:
`Which first match had a final position/round in the third qualifying round?`

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

CREATE TABLE "competitions" (
  "competition" text,
  "current_position_round" text,
  "final_position_round" text,
  "first_match" text,
  "last_match" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which first match had a final position/round in the third qualifying round?`:
```sql
                SELECT "first_match" FROM "competitions" WHERE "final_position_round"='third qualifying round';
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest number of bronze medals for nations with over 6 total and 2 golds?`

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

CREATE TABLE "multiple_asian_games_gold_medalists" (
  "athlete" text,
  "sport" text,
  "asian_games" text,
  "gold" real,
  "silver" real,
  "bronze" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest number of bronze medals for nations with over 6 total and 2 golds?`:
```sql
                SELECT MIN("bronze") FROM "multiple_asian_games_gold_medalists" WHERE "gold"=2 AND "total">6;
```
## Task
Generate a SQL query to answer the following question:
`What is the total number of silver medals for karate athletes with over 2 golds?`

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

CREATE TABLE "multiple_asian_games_gold_medalists" (
  "athlete" text,
  "sport" text,
  "asian_games" text,
  "gold" real,
  "silver" real,
  "bronze" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of silver medals for karate athletes with over 2 golds?`:
```sql
                SELECT COUNT("silver") FROM "multiple_asian_games_gold_medalists" WHERE "sport"='karate' AND "gold">2;
```
## Task
Generate a SQL query to answer the following question:
`What is the 2009 value with a 1r in 2010 and A in 2011?`

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

CREATE TABLE "doubles" (
  "tournament" text,
  "2007" text,
  "2008" text,
  "2009" text,
  "2010" text,
  "2011" text,
  "2012" text,
  "career_win_loss" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the 2009 value with a 1r in 2010 and A in 2011?`:
```sql
                SELECT "2009" FROM "doubles" WHERE "2010"='1r' AND "2011"='a';
```
## Task
Generate a SQL query to answer the following question:
`What is the 2009 value with a 2010 A value?`

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

CREATE TABLE "doubles" (
  "tournament" text,
  "2007" text,
  "2008" text,
  "2009" text,
  "2010" text,
  "2011" text,
  "2012" text,
  "career_win_loss" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the 2009 value with a 2010 A value?`:
```sql
                SELECT "2009" FROM "doubles" WHERE "2010"='a';
```
## Task
Generate a SQL query to answer the following question:
`What is the 2010 value with A in 2008, A in 2011, and 2r in 2012?`

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

CREATE TABLE "doubles" (
  "tournament" text,
  "2007" text,
  "2008" text,
  "2009" text,
  "2010" text,
  "2011" text,
  "2012" text,
  "career_win_loss" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the 2010 value with A in 2008, A in 2011, and 2r in 2012?`:
```sql
                SELECT "2010" FROM "doubles" WHERE "2008"='a' AND "2011"='a' AND "2012"='2r';
```
## Task
Generate a SQL query to answer the following question:
`What is the average attendance on april 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 is the average attendance on april 24?`:
```sql
                SELECT AVG("attendance") FROM "game_log" WHERE "date"='april 24';
```
## Task
Generate a SQL query to answer the following question:
`What was the score of the away team when Richmond played?`

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

CREATE TABLE "round_12" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score of the away team when Richmond played?`:
```sql
                SELECT "away_team_score" FROM "round_12" WHERE "away_team"='richmond';
```
## Task
Generate a SQL query to answer the following question:
`What company was Constructor when there were 16 laps and grid was 9?`

### 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 company was Constructor when there were 16 laps and grid was 9?`:
```sql
                SELECT "constructor" FROM "race" WHERE "laps"=16 AND "grid"=9;
```
## Task
Generate a SQL query to answer the following question:
`What is the Time/Retired when lotus - ford was constructor and the laps were less than 17?`

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

CREATE TABLE "race" (
  "driver" text,
  "constructor" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Time/Retired when lotus - ford was constructor and the laps were less than 17?`:
```sql
                SELECT "time_retired" FROM "race" WHERE "constructor"='lotus - ford' AND "laps"<17;
```
## Task
Generate a SQL query to answer the following question:
`What is the number of the grid when there was a Time/Retired of engine and less than 9 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 number of the grid when there was a Time/Retired of engine and less than 9 laps?`:
```sql
                SELECT SUM("grid") FROM "race" WHERE "time_retired"='engine' AND "laps"<9;
```
## Task
Generate a SQL query to answer the following question:
`what was the attendance for a home venue and a w 3-0 result?`

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

CREATE TABLE "2007_08_peterborough_united_f_c_season" (
  "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 attendance for a home venue and a w 3-0 result?`:
```sql
                SELECT AVG("attendance") FROM "2007_08_peterborough_united_f_c_season" WHERE "venue"='home' AND "result"='w 3-0';
```
## Task
Generate a SQL query to answer the following question:
`what was the attendance at the home venue with result w 3-1?`

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

CREATE TABLE "2007_08_peterborough_united_f_c_season" (
  "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 attendance at the home venue with result w 3-1?`:
```sql
                SELECT MAX("attendance") FROM "2007_08_peterborough_united_f_c_season" WHERE "venue"='home' AND "result"='w 3-1';
```
## Task
Generate a SQL query to answer the following question:
`where did rochdale play as opponent?`

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

CREATE TABLE "2007_08_peterborough_united_f_c_season" (
  "date" text,
  "opponent" text,
  "venue" text,
  "result" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `where did rochdale play as opponent?`:
```sql
                SELECT "venue" FROM "2007_08_peterborough_united_f_c_season" WHERE "opponent"='rochdale';
```
## Task
Generate a SQL query to answer the following question:
`Which home team played in front of 18,345 people in Adelaide Oval?`

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

CREATE TABLE "fixtures" (
  "round" real,
  "date" text,
  "home_team" text,
  "score" text,
  "away_team" text,
  "crowd" real,
  "stadium" text,
  "match_details" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which home team played in front of 18,345 people in Adelaide Oval?`:
```sql
                SELECT "home_team" FROM "fixtures" WHERE "crowd">'18,345' AND "stadium"='adelaide oval';
```
## Task
Generate a SQL query to answer the following question:
`Which team was hosted at Adelaide Oval?`

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

CREATE TABLE "fixtures" (
  "round" real,
  "date" text,
  "home_team" text,
  "score" text,
  "away_team" text,
  "crowd" real,
  "stadium" text,
  "match_details" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which team was hosted at Adelaide Oval?`:
```sql
                SELECT "away_team" FROM "fixtures" WHERE "stadium"='adelaide oval';
```
## Task
Generate a SQL query to answer the following question:
`When was a report not held?`

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

CREATE TABLE "by_year" (
  "year" text,
  "driver" text,
  "constructor" text,
  "location" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `When was a report not held?`:
```sql
                SELECT "year" FROM "by_year" WHERE "report"='not held';
```
## Task
Generate a SQL query to answer the following question:
`Who was the visitor when vancouver was at home?`

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

CREATE TABLE "game_log" (
  "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 `Who was the visitor when vancouver was at home?`:
```sql
                SELECT "visitor" FROM "game_log" WHERE "home"='vancouver';
```
## Task
Generate a SQL query to answer the following question:
`What is the decision when new jersey was away?`

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

CREATE TABLE "game_log" (
  "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 decision when new jersey was away?`:
```sql
                SELECT "decision" FROM "game_log" WHERE "visitor"='new jersey';
```
## Task
Generate a SQL query to answer the following question:
`What is URA Index scale?`

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

CREATE TABLE "message_format" (
  "subframe_num" real,
  "page_num" text,
  "name" text,
  "word_num" real,
  "bits" text,
  "scale" text,
  "signed" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is URA Index scale?`:
```sql
                SELECT "scale" FROM "message_format" WHERE "name"='ura index';
```
## Task
Generate a SQL query to answer the following question:
`What is the scale of sv_health with a word number smaller than 4?`

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

CREATE TABLE "message_format" (
  "subframe_num" real,
  "page_num" text,
  "name" text,
  "word_num" real,
  "bits" text,
  "scale" text,
  "signed" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the scale of sv_health with a word number smaller than 4?`:
```sql
                SELECT "scale" FROM "message_format" WHERE "word_num"<4 AND "name"='sv_health';
```
## Task
Generate a SQL query to answer the following question:
`Which tennis team is from the United States?`

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

CREATE TABLE "list_of_winners" (
  "year_of_award" real,
  "athlete" text,
  "nation_of_citizenship" text,
  "team" text,
  "competition_governing_body_or_league" text,
  "sport" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which tennis team is from the United States?`:
```sql
                SELECT "team" FROM "list_of_winners" WHERE "sport"='tennis' AND "nation_of_citizenship"='united states';
```
## Task
Generate a SQL query to answer the following question:
`What is the nation of citizenship for athletes later than 2011 year of award?`

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

CREATE TABLE "list_of_winners" (
  "year_of_award" real,
  "athlete" text,
  "nation_of_citizenship" text,
  "team" text,
  "competition_governing_body_or_league" text,
  "sport" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the nation of citizenship for athletes later than 2011 year of award?`:
```sql
                SELECT "nation_of_citizenship" FROM "list_of_winners" WHERE "year_of_award">2011;
```
## Task
Generate a SQL query to answer the following question:
`What Constructor did Michael Schumacher have with a Grid smaller than 5?`

### 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 Constructor did Michael Schumacher have with a Grid smaller than 5?`:
```sql
                SELECT "constructor" FROM "race" WHERE "grid"<5 AND "driver"='michael schumacher';
```
## Task
Generate a SQL query to answer the following question:
`Which driver has a Time/Retired of +1 lap?`

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

CREATE TABLE "race" (
  "driver" text,
  "constructor" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which driver has a Time/Retired of +1 lap?`:
```sql
                SELECT "driver" FROM "race" WHERE "time_retired"='+1 lap';
```
## Task
Generate a SQL query to answer the following question:
`Which apparatus had a final score that was more than 17.75?`

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

CREATE TABLE "detailed_olympic_results" (
  "year" real,
  "competition_description" text,
  "location" text,
  "apparatus" text,
  "score_final" real,
  "score_qualifying" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which apparatus had a final score that was more than 17.75?`:
```sql
                SELECT "apparatus" FROM "detailed_olympic_results" WHERE "score_final">17.75;
```
## Task
Generate a SQL query to answer the following question:
`Which competition description's apparatus was ribbon?`

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

CREATE TABLE "detailed_olympic_results" (
  "year" real,
  "competition_description" text,
  "location" text,
  "apparatus" text,
  "score_final" real,
  "score_qualifying" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which competition description's apparatus was ribbon?`:
```sql
                SELECT "competition_description" FROM "detailed_olympic_results" WHERE "apparatus"='ribbon';
```
## Task
Generate a SQL query to answer the following question:
`Which Qualifying score had hoop as an apparatus?`

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

CREATE TABLE "detailed_olympic_results" (
  "year" real,
  "competition_description" text,
  "location" text,
  "apparatus" text,
  "score_final" real,
  "score_qualifying" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Qualifying score had hoop as an apparatus?`:
```sql
                SELECT "score_qualifying" FROM "detailed_olympic_results" WHERE "apparatus"='hoop';
```
## Task
Generate a SQL query to answer the following question:
`What is the sum of qualifying scores when the final score is 16.625?`

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

CREATE TABLE "detailed_olympic_results" (
  "year" real,
  "competition_description" text,
  "location" text,
  "apparatus" text,
  "score_final" real,
  "score_qualifying" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the sum of qualifying scores when the final score is 16.625?`:
```sql
                SELECT COUNT("score_qualifying") FROM "detailed_olympic_results" WHERE "score_final"=16.625;
```
## Task
Generate a SQL query to answer the following question:
`When was the game played at Princes Park?`

### 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 `When was the game played at Princes Park?`:
```sql
                SELECT "date" FROM "round_9" WHERE "venue"='princes park';
```
## Task
Generate a SQL query to answer the following question:
`What did Melbourne score as the home team?`

### 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 did Melbourne score as the home team?`:
```sql
                SELECT "home_team_score" FROM "round_9" WHERE "home_team"='melbourne';
```
## Task
Generate a SQL query to answer the following question:
`What position does the player from malvern prep play?`

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

CREATE TABLE "high_school_players_and_coaches_of_the_y" (
  "year" real,
  "player" text,
  "position" text,
  "high_school" text,
  "hometown" text,
  "mlb_draft" text
);
### SQL
Given the database schema, here is the SQL query that answers `What position does the player from malvern prep play?`:
```sql
                SELECT "position" FROM "high_school_players_and_coaches_of_the_y" WHERE "high_school"='malvern prep';
```
## Task
Generate a SQL query to answer the following question:
`What team scored more than 572 points and had more than 29 games?`

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

CREATE TABLE "points" (
  "rank" real,
  "name" text,
  "team" text,
  "games" real,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What team scored more than 572 points and had more than 29 games?`:
```sql
                SELECT "team" FROM "points" WHERE "points">572 AND "games">29;
```
## Task
Generate a SQL query to answer the following question:
`What is the least amount of games for Luis scola with a rank greater than 1?`

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

CREATE TABLE "points" (
  "rank" real,
  "name" text,
  "team" text,
  "games" real,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the least amount of games for Luis scola with a rank greater than 1?`:
```sql
                SELECT MIN("games") FROM "points" WHERE "rank">1 AND "name"='luis scola';
```
## Task
Generate a SQL query to answer the following question:
`What is the identity of the brighton works built train?`

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

CREATE TABLE "steam_locomotives" (
  "identity" text,
  "builder" text,
  "built" real,
  "wheel_arrangement" text,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the identity of the brighton works built train?`:
```sql
                SELECT "identity" FROM "steam_locomotives" WHERE "builder"='brighton works';
```
## Task
Generate a SQL query to answer the following question:
`What was the attendance on May 13?`

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

CREATE TABLE "smythe_division_final_vs_3" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "decision" text,
  "attendance" real,
  "series" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the attendance on May 13?`:
```sql
                SELECT "attendance" FROM "smythe_division_final_vs_3" WHERE "date"='may 13';
```
## Task
Generate a SQL query to answer the following question:
`What is the highest Quantity for PTRD Nos. 3, 15?`

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

CREATE TABLE "locomotives_of_the_great_western_railway" (
  "manufacturer" text,
  "type" text,
  "quantity" real,
  "ptrd_nos" text,
  "gwr_nos" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest Quantity for PTRD Nos. 3, 15?`:
```sql
                SELECT MAX("quantity") FROM "locomotives_of_the_great_western_railway" WHERE "ptrd_nos"='3, 15';
```
## Task
Generate a SQL query to answer the following question:
`How many were hosted whene the average attendance was 27,638?`

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

CREATE TABLE "match_attendance" (
  "team" text,
  "hosted" real,
  "average" real,
  "highest" real,
  "lowest" real,
  "total" real,
  "last_year" real,
  "up_down" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many were hosted whene the average attendance was 27,638?`:
```sql
                SELECT COUNT("hosted") FROM "match_attendance" WHERE "average"='27,638';
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest attendance last year when more than 176 were hosted?`

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

CREATE TABLE "match_attendance" (
  "team" text,
  "hosted" real,
  "average" real,
  "highest" real,
  "lowest" real,
  "total" real,
  "last_year" real,
  "up_down" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest attendance last year when more than 176 were hosted?`:
```sql
                SELECT MIN("last_year") FROM "match_attendance" WHERE "hosted">176;
```
## Task
Generate a SQL query to answer the following question:
`Of 2010 est. with less than 171,750 and 2000 less than 131,714, what is the 1970 population average?`

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

CREATE TABLE "population_growth_history" (
  "city" text,
  "1970" real,
  "1980" real,
  "1990" real,
  "2000" real,
  "2010_est" real
);
### SQL
Given the database schema, here is the SQL query that answers `Of 2010 est. with less than 171,750 and 2000 less than 131,714, what is the 1970 population average?`:
```sql
                SELECT AVG("1970") FROM "population_growth_history" WHERE "2010_est"='171,750' AND "2000"<'131,714';
```
## Task
Generate a SQL query to answer the following question:
`With 1990 growth greater than 19,988 and 1970 growth less than 10,522, what is the 1980 average?`

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

CREATE TABLE "population_growth_history" (
  "city" text,
  "1970" real,
  "1980" real,
  "1990" real,
  "2000" real,
  "2010_est" real
);
### SQL
Given the database schema, here is the SQL query that answers `With 1990 growth greater than 19,988 and 1970 growth less than 10,522, what is the 1980 average?`:
```sql
                SELECT AVG("1980") FROM "population_growth_history" WHERE "1990">'19,988' AND "1970"<'10,522';
```
## Task
Generate a SQL query to answer the following question:
`Of 2000 growth less than 32,093 and 1980 growth over 64,975, what is the 1970 total number?`

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

CREATE TABLE "population_growth_history" (
  "city" text,
  "1970" real,
  "1980" real,
  "1990" real,
  "2000" real,
  "2010_est" real
);
### SQL
Given the database schema, here is the SQL query that answers `Of 2000 growth less than 32,093 and 1980 growth over 64,975, what is the 1970 total number?`:
```sql
                SELECT COUNT("1970") FROM "population_growth_history" WHERE "2000"<'32,093' AND "1980">'64,975';
```
## Task
Generate a SQL query to answer the following question:
`How many 1990 growth numbers had less than 10,522 in 1970?`

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

CREATE TABLE "population_growth_history" (
  "city" text,
  "1970" real,
  "1980" real,
  "1990" real,
  "2000" real,
  "2010_est" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many 1990 growth numbers had less than 10,522 in 1970?`:
```sql
                SELECT COUNT("1990") FROM "population_growth_history" WHERE "1970"<'10,522';
```
## Task
Generate a SQL query to answer the following question:
`Which is the lowest 1980 growth that had 2,610 in 1970?`

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

CREATE TABLE "population_growth_history" (
  "city" text,
  "1970" real,
  "1980" real,
  "1990" real,
  "2000" real,
  "2010_est" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which is the lowest 1980 growth that had 2,610 in 1970?`:
```sql
                SELECT MIN("1980") FROM "population_growth_history" WHERE "1970"='2,610';
```