cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`What is the status of the Hamaoka-3 unit?`

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

CREATE TABLE "reactor_data" (
  "unit" text,
  "reactor_type" text,
  "net_capacity" text,
  "gross_capacity" text,
  "construction_start" text,
  "grid_connection" text,
  "commercial_operation" text,
  "status" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the status of the Hamaoka-3 unit?`:
```sql
                SELECT "status" FROM "reactor_data" WHERE "unit"='hamaoka-3';
```
## Task
Generate a SQL query to answer the following question:
`What is the gross capacity of the unit that started commercial operation on August 28, 1987?`

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

CREATE TABLE "reactor_data" (
  "unit" text,
  "reactor_type" text,
  "net_capacity" text,
  "gross_capacity" text,
  "construction_start" text,
  "grid_connection" text,
  "commercial_operation" text,
  "status" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the gross capacity of the unit that started commercial operation on August 28, 1987?`:
```sql
                SELECT "gross_capacity" FROM "reactor_data" WHERE "commercial_operation"='august 28, 1987';
```
## Task
Generate a SQL query to answer the following question:
`When was commercial operation where construction started June 10, 1971?`

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

CREATE TABLE "reactor_data" (
  "unit" text,
  "reactor_type" text,
  "net_capacity" text,
  "gross_capacity" text,
  "construction_start" text,
  "grid_connection" text,
  "commercial_operation" text,
  "status" text
);
### SQL
Given the database schema, here is the SQL query that answers `When was commercial operation where construction started June 10, 1971?`:
```sql
                SELECT "commercial_operation" FROM "reactor_data" WHERE "construction_start"='june 10, 1971';
```
## Task
Generate a SQL query to answer the following question:
`What is the gross capacity where the reactor is ABWR type?`

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

CREATE TABLE "reactor_data" (
  "unit" text,
  "reactor_type" text,
  "net_capacity" text,
  "gross_capacity" text,
  "construction_start" text,
  "grid_connection" text,
  "commercial_operation" text,
  "status" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the gross capacity where the reactor is ABWR type?`:
```sql
                SELECT "gross_capacity" FROM "reactor_data" WHERE "reactor_type"='abwr';
```
## Task
Generate a SQL query to answer the following question:
`When was the Hamaoka-4 unit commercial operation date?`

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

CREATE TABLE "reactor_data" (
  "unit" text,
  "reactor_type" text,
  "net_capacity" text,
  "gross_capacity" text,
  "construction_start" text,
  "grid_connection" text,
  "commercial_operation" text,
  "status" text
);
### SQL
Given the database schema, here is the SQL query that answers `When was the Hamaoka-4 unit commercial operation date?`:
```sql
                SELECT "commercial_operation" FROM "reactor_data" WHERE "unit"='hamaoka-4';
```
## Task
Generate a SQL query to answer the following question:
`What is the status of the unit with a net capacity of 1212 MW?`

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

CREATE TABLE "reactor_data" (
  "unit" text,
  "reactor_type" text,
  "net_capacity" text,
  "gross_capacity" text,
  "construction_start" text,
  "grid_connection" text,
  "commercial_operation" text,
  "status" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the status of the unit with a net capacity of 1212 MW?`:
```sql
                SELECT "status" FROM "reactor_data" WHERE "net_capacity"='1212 mw';
```
## Task
Generate a SQL query to answer the following question:
`Which school did player Rodney Purvis belong to?`

### 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,
  "nba_draft" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which school did player Rodney Purvis belong to?`:
```sql
                SELECT "school" FROM "2012_boys_team" WHERE "player"='rodney purvis';
```
## Task
Generate a SQL query to answer the following question:
`What was the NBA draft status for Northeast High School?`

### 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,
  "nba_draft" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the NBA draft status for Northeast High School?`:
```sql
                SELECT "nba_draft" FROM "2012_boys_team" WHERE "school"='northeast high school';
```
## Task
Generate a SQL query to answer the following question:
`Which players college was Baylor?`

### 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,
  "nba_draft" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which players college was Baylor?`:
```sql
                SELECT "player" FROM "2012_boys_team" WHERE "college"='baylor';
```
## Task
Generate a SQL query to answer the following question:
`What was the college for Alex Poythress?`

### 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,
  "nba_draft" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the college for Alex Poythress?`:
```sql
                SELECT "college" FROM "2012_boys_team" WHERE "player"='alex poythress';
```
## Task
Generate a SQL query to answer the following question:
`What is Alex Poythress height?`

### 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,
  "nba_draft" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is Alex Poythress height?`:
```sql
                SELECT "height" FROM "2012_boys_team" WHERE "player"='alex poythress';
```
## Task
Generate a SQL query to answer the following question:
`What was Allison Fouch score in the year larger than 2000?`

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

CREATE TABLE "winners" (
  "year" real,
  "champion" text,
  "winning_score" text,
  "low_amateur" text,
  "low_professional" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was Allison Fouch score in the year larger than 2000?`:
```sql
                SELECT "winning_score" FROM "winners" WHERE "year">2000 AND "champion"='allison fouch';
```
## Task
Generate a SQL query to answer the following question:
`How many release dates have a Country of west germany, and a Release format of vinyl?`

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

CREATE TABLE "release_history" (
  "release_format" text,
  "country" text,
  "label" text,
  "cat_no" text,
  "release_date" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many release dates have a Country of west germany, and a Release format of vinyl?`:
```sql
                SELECT COUNT("release_date") FROM "release_history" WHERE "country"='west germany' AND "release_format"='vinyl';
```
## Task
Generate a SQL query to answer the following question:
`Which label is from Spain?`

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

CREATE TABLE "release_history" (
  "release_format" text,
  "country" text,
  "label" text,
  "cat_no" text,
  "release_date" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which label is from Spain?`:
```sql
                SELECT "label" FROM "release_history" WHERE "country"='spain';
```
## Task
Generate a SQL query to answer the following question:
`What's the save when the loss was santiago (2–2)?`

### 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,
  "save" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the save when the loss was santiago (2–2)?`:
```sql
                SELECT "save" FROM "game_log" WHERE "loss"='santiago (2–2)';
```
## Task
Generate a SQL query to answer the following question:
`Which season was 2nd position?`

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

CREATE TABLE "season_by_season_national_league_records" (
  "season" text,
  "division" text,
  "position" text,
  "played" text,
  "lost" text,
  "points" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which season was 2nd position?`:
```sql
                SELECT "season" FROM "season_by_season_national_league_records" WHERE "position"='2nd';
```
## Task
Generate a SQL query to answer the following question:
`What's the value for played when the division is nbl div2 with 12th position?`

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

CREATE TABLE "season_by_season_national_league_records" (
  "season" text,
  "division" text,
  "position" text,
  "played" text,
  "lost" text,
  "points" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the value for played when the division is nbl div2 with 12th position?`:
```sql
                SELECT "played" FROM "season_by_season_national_league_records" WHERE "division"='nbl div2' AND "position"='12th';
```
## Task
Generate a SQL query to answer the following question:
`What's the points when the division is ebl div1 with 22 played?`

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

CREATE TABLE "season_by_season_national_league_records" (
  "season" text,
  "division" text,
  "position" text,
  "played" text,
  "lost" text,
  "points" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the points when the division is ebl div1 with 22 played?`:
```sql
                SELECT "points" FROM "season_by_season_national_league_records" WHERE "division"='ebl div1' AND "played"='22';
```
## Task
Generate a SQL query to answer the following question:
`What's the value for played when points is 8 and position is 11th?`

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

CREATE TABLE "season_by_season_national_league_records" (
  "season" text,
  "division" text,
  "position" text,
  "played" text,
  "lost" text,
  "points" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the value for played when points is 8 and position is 11th?`:
```sql
                SELECT "played" FROM "season_by_season_national_league_records" WHERE "position"='11th' AND "points"='8';
```
## Task
Generate a SQL query to answer the following question:
`Who was driving with a Grid of 13?`

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

CREATE TABLE "classification" (
  "driver" text,
  "constructor" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `Who was driving with a Grid of 13?`:
```sql
                SELECT "driver" FROM "classification" WHERE "grid"=13;
```
## Task
Generate a SQL query to answer the following question:
`For Laps smaller than 6, what does the Grid add up to?`

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

CREATE TABLE "classification" (
  "driver" text,
  "constructor" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `For Laps smaller than 6, what does the Grid add up to?`:
```sql
                SELECT SUM("grid") FROM "classification" WHERE "laps"<6;
```
## Task
Generate a SQL query to answer the following question:
`What is the report status of Hockenheimring circuit?`

### 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 report status of Hockenheimring circuit?`:
```sql
                SELECT "report" FROM "season_review" WHERE "circuit"='hockenheimring';
```
## Task
Generate a SQL query to answer the following question:
`Who was the winning driver of the race with Clay Regazzoni as the fastest lap and Jackie stewart as the pole position?`

### 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 of the race with Clay Regazzoni as the fastest lap and Jackie stewart as the pole position?`:
```sql
                SELECT "winning_driver" FROM "season_review" WHERE "fastest_lap"='clay regazzoni' AND "pole_position"='jackie stewart';
```
## Task
Generate a SQL query to answer the following question:
`Which race had Jacky Ickx as the winner and Clay Regazzoni with the 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 `Which race had Jacky Ickx as the winner and Clay Regazzoni with the fastest lap?`:
```sql
                SELECT "race" FROM "season_review" WHERE "winning_driver"='jacky ickx' AND "fastest_lap"='clay regazzoni';
```
## Task
Generate a SQL query to answer the following question:
`What was the military rank for the person killed in 1918, born after 1865, and has a MP's Seat in Edinburgh South?`

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

CREATE TABLE "first_world_war" (
  "rank_in_military" text,
  "name" text,
  "born" real,
  "killed" real,
  "political_party" text,
  "mp_s_seat" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the military rank for the person killed in 1918, born after 1865, and has a MP's Seat in Edinburgh South?`:
```sql
                SELECT "rank_in_military" FROM "first_world_war" WHERE "killed"=1918 AND "born">1865 AND "mp_s_seat"='edinburgh south';
```
## Task
Generate a SQL query to answer the following question:
`How much time does it take for jean alesi and grids lesser 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 `How much time does it take for jean alesi and grids lesser than 5?`:
```sql
                SELECT "time_retired" FROM "race" WHERE "grid"<5 AND "driver"='jean alesi';
```
## Task
Generate a SQL query to answer the following question:
`What is the low grid for gerhard berger for laps over 56?`

### 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 low grid for gerhard berger for laps over 56?`:
```sql
                SELECT MIN("grid") FROM "race" WHERE "driver"='gerhard berger' AND "laps">56;
```
## Task
Generate a SQL query to answer the following question:
`If the grid is 13 who is driving?`

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

CREATE TABLE "classification" (
  "driver" text,
  "constructor" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `If the grid is 13 who is driving?`:
```sql
                SELECT "driver" FROM "classification" WHERE "grid"=13;
```
## Task
Generate a SQL query to answer the following question:
`What is the purse total for the royal caribbean golf classic?`

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

CREATE TABLE "tournament_results" (
  "date" text,
  "tournament" text,
  "location" text,
  "purse" real,
  "winner" text,
  "score" text,
  "1st_prize" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the purse total for the royal caribbean golf classic?`:
```sql
                SELECT SUM("purse") FROM "tournament_results" WHERE "tournament"='royal caribbean golf classic';
```
## Task
Generate a SQL query to answer the following question:
`Which home team scored a 15.16 (106)?`

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

CREATE TABLE "round_21" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which home team scored a 15.16 (106)?`:
```sql
                SELECT "home_team" FROM "round_21" WHERE "home_team_score"='15.16 (106)';
```
## Task
Generate a SQL query to answer the following question:
`Which away team scored at 15.17 (107) at an away game?`

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

CREATE TABLE "round_21" (
  "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 scored at 15.17 (107) at an away game?`:
```sql
                SELECT "away_team" FROM "round_21" WHERE "away_team_score"='15.17 (107)';
```
## Task
Generate a SQL query to answer the following question:
`Which title is 3:38 long?`

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

CREATE TABLE "track_listing" (
  "track" real,
  "title" text,
  "author_s" text,
  "recorded" text,
  "length" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which title is 3:38 long?`:
```sql
                SELECT "title" FROM "track_listing" WHERE "length"='3:38';
```
## Task
Generate a SQL query to answer the following question:
`Which title is 3:43 long?`

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

CREATE TABLE "track_listing" (
  "track" real,
  "title" text,
  "author_s" text,
  "recorded" text,
  "length" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which title is 3:43 long?`:
```sql
                SELECT "title" FROM "track_listing" WHERE "length"='3:43';
```
## Task
Generate a SQL query to answer the following question:
`What Dance has the Visual Arts of Bryon Kim?`

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

CREATE TABLE "references" (
  "year" real,
  "film_video" text,
  "visual_arts" text,
  "theatre" text,
  "dance" text,
  "music" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Dance has the Visual Arts of Bryon Kim?`:
```sql
                SELECT "dance" FROM "references" WHERE "visual_arts"='bryon kim';
```
## Task
Generate a SQL query to answer the following question:
`In 2004, what is the Dance?`

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

CREATE TABLE "references" (
  "year" real,
  "film_video" text,
  "visual_arts" text,
  "theatre" text,
  "dance" text,
  "music" text
);
### SQL
Given the database schema, here is the SQL query that answers `In 2004, what is the Dance?`:
```sql
                SELECT "dance" FROM "references" WHERE "year"=2004;
```
## Task
Generate a SQL query to answer the following question:
`What artist had 1 draw?`

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

CREATE TABLE "national_final_7_february_1999" (
  "draw" real,
  "artist" text,
  "song" text,
  "points" real,
  "place" real
);
### SQL
Given the database schema, here is the SQL query that answers `What artist had 1 draw?`:
```sql
                SELECT "artist" FROM "national_final_7_february_1999" WHERE "draw"=1;
```
## Task
Generate a SQL query to answer the following question:
`Name the IATA for jeddah`

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

CREATE TABLE "destinations" (
  "city" text,
  "country" text,
  "airport" text,
  "iata" text,
  "icao" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the IATA for jeddah`:
```sql
                SELECT "iata" FROM "destinations" WHERE "city"='jeddah';
```
## Task
Generate a SQL query to answer the following question:
`Name the IATA for jessore`

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

CREATE TABLE "destinations" (
  "city" text,
  "country" text,
  "airport" text,
  "iata" text,
  "icao" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the IATA for jessore`:
```sql
                SELECT "iata" FROM "destinations" WHERE "city"='jessore';
```
## Task
Generate a SQL query to answer the following question:
`Name the city for thailand`

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

CREATE TABLE "destinations" (
  "city" text,
  "country" text,
  "airport" text,
  "iata" text,
  "icao" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the city for thailand`:
```sql
                SELECT "city" FROM "destinations" WHERE "country"='thailand';
```
## Task
Generate a SQL query to answer the following question:
`Name the IATA of wmkk`

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

CREATE TABLE "destinations" (
  "city" text,
  "country" text,
  "airport" text,
  "iata" text,
  "icao" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the IATA of wmkk`:
```sql
                SELECT "iata" FROM "destinations" WHERE "icao"='wmkk';
```
## Task
Generate a SQL query to answer the following question:
`When did the away team carlton play?`

### 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 `When did the away team carlton play?`:
```sql
                SELECT "date" FROM "round_18" WHERE "away_team"='carlton';
```
## Task
Generate a SQL query to answer the following question:
`Where did a home team score 8.14 (62)?`

### 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 a home team score 8.14 (62)?`:
```sql
                SELECT "venue" FROM "round_18" WHERE "home_team_score"='8.14 (62)';
```
## Task
Generate a SQL query to answer the following question:
`Which constructor is from ITA with a rank less than 13?`

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

CREATE TABLE "by_constructor" (
  "rank" real,
  "country" text,
  "constructor" text,
  "wins" real,
  "active" text,
  "first_win" text,
  "last_win" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which constructor is from ITA with a rank less than 13?`:
```sql
                SELECT "constructor" FROM "by_constructor" WHERE "country"='ita' AND "rank"<13;
```
## Task
Generate a SQL query to answer the following question:
`Who was the opponent in the Week 4 game?`

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

CREATE TABLE "season_schedule" (
  "week" real,
  "date" text,
  "opponent" text,
  "score" text,
  "result" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the opponent in the Week 4 game?`:
```sql
                SELECT "opponent" FROM "season_schedule" WHERE "week"=4;
```
## Task
Generate a SQL query to answer the following question:
`Who are the co-drivers before 2010 with under 326 laps?`

### 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 `Who are the co-drivers before 2010 with under 326 laps?`:
```sql
                SELECT "co_drivers" FROM "24_hours_of_le_mans_results" WHERE "year"<2010 AND "laps"<326;
```
## Task
Generate a SQL query to answer the following question:
`Who are the co-drivers the risi competizione gt2 class that went under 329 laps and recorded a DNF?`

### 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 `Who are the co-drivers the risi competizione gt2 class that went under 329 laps and recorded a DNF?`:
```sql
                SELECT "co_drivers" FROM "24_hours_of_le_mans_results" WHERE "laps"<329 AND "class"='gt2' AND "team"='risi competizione' AND "pos"='dnf';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the highest laps for time/retired of +2 laps and driver of felice bonetto`

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

CREATE TABLE "race" (
  "driver" text,
  "constructor" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the highest laps for time/retired of +2 laps and driver of felice bonetto`:
```sql
                SELECT MAX("laps") FROM "race" WHERE "time_retired"='+2 laps' AND "driver"='felice bonetto';
```
## Task
Generate a SQL query to answer the following question:
`I want to know the driver when grid is greater than 13 and laps is less than 60 with time/retired of accident`

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

CREATE TABLE "race" (
  "driver" text,
  "constructor" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `I want to know the driver when grid is greater than 13 and laps is less than 60 with time/retired of accident`:
```sql
                SELECT "driver" FROM "race" WHERE "grid">13 AND "laps"<60 AND "time_retired"='accident';
```
## Task
Generate a SQL query to answer the following question:
`Name the album for years after 2007`

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

CREATE TABLE "singles" (
  "year" real,
  "song" text,
  "aria_singles_chart" text,
  "triple_j_hottest_100" text,
  "uk_indie_singles_chart" text,
  "uk_singles_chart" text,
  "album" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the album for years after 2007`:
```sql
                SELECT "album" FROM "singles" WHERE "year">2007;
```
## Task
Generate a SQL query to answer the following question:
`What was the score on october 17, 2007?`

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

CREATE TABLE "national_team" (
  "date" text,
  "venue" text,
  "score" text,
  "competition" text,
  "turkey_scorers" text,
  "match_report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score on october 17, 2007?`:
```sql
                SELECT "score" FROM "national_team" WHERE "date"='october 17, 2007';
```
## Task
Generate a SQL query to answer the following question:
`What was the competition for score of 3-0`

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

CREATE TABLE "national_team" (
  "date" text,
  "venue" text,
  "score" text,
  "competition" text,
  "turkey_scorers" text,
  "match_report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the competition for score of 3-0`:
```sql
                SELECT "competition" FROM "national_team" WHERE "score"='3-0';
```
## Task
Generate a SQL query to answer the following question:
`Which venue had a score of 1-1?`

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

CREATE TABLE "national_team" (
  "date" text,
  "venue" text,
  "score" text,
  "competition" text,
  "turkey_scorers" text,
  "match_report" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which venue had a score of 1-1?`:
```sql
                SELECT "venue" FROM "national_team" WHERE "score"='1-1';
```
## Task
Generate a SQL query to answer the following question:
`I want the date for nihat kahveci`

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

CREATE TABLE "national_team" (
  "date" text,
  "venue" text,
  "score" text,
  "competition" text,
  "turkey_scorers" text,
  "match_report" text
);
### SQL
Given the database schema, here is the SQL query that answers `I want the date for nihat kahveci`:
```sql
                SELECT "date" FROM "national_team" WHERE "turkey_scorers"='nihat kahveci';
```
## Task
Generate a SQL query to answer the following question:
`What is the smallest pick with a Reg GP less than 0?`

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

CREATE TABLE "list_of_vancouver_canucks_draft_picks" (
  "rd_num" real,
  "pick_num" real,
  "player" text,
  "team_league" text,
  "reg_gp" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the smallest pick with a Reg GP less than 0?`:
```sql
                SELECT MIN("pick_num") FROM "list_of_vancouver_canucks_draft_picks" WHERE "reg_gp"<0;
```
## Task
Generate a SQL query to answer the following question:
`What is the total of pick numbers with a Reg GP larger than 0?`

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

CREATE TABLE "list_of_vancouver_canucks_draft_picks" (
  "rd_num" real,
  "pick_num" real,
  "player" text,
  "team_league" text,
  "reg_gp" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total of pick numbers with a Reg GP larger than 0?`:
```sql
                SELECT COUNT("pick_num") FROM "list_of_vancouver_canucks_draft_picks" WHERE "reg_gp">0;
```
## Task
Generate a SQL query to answer the following question:
`What is the total points when there is a refusal fault and the rider is H.R.H. Prince Abdullah Al-Soud?`

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

CREATE TABLE "round_1" (
  "rider" text,
  "horse" text,
  "time_s" text,
  "faults" text,
  "total_time_s" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total points when there is a refusal fault and the rider is H.R.H. Prince Abdullah Al-Soud?`:
```sql
                SELECT SUM("points") FROM "round_1" WHERE "faults"='refusal' AND "rider"='h.r.h. prince abdullah al-soud';
```
## Task
Generate a SQL query to answer the following question:
`What is the total points when the horse is Chippison?`

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

CREATE TABLE "round_1" (
  "rider" text,
  "horse" text,
  "time_s" text,
  "faults" text,
  "total_time_s" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total points when the horse is Chippison?`:
```sql
                SELECT COUNT("points") FROM "round_1" WHERE "horse"='chippison';
```
## Task
Generate a SQL query to answer the following question:
`What is the total time (s) for the horse Pinot Grigio?`

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

CREATE TABLE "round_1" (
  "rider" text,
  "horse" text,
  "time_s" text,
  "faults" text,
  "total_time_s" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total time (s) for the horse Pinot Grigio?`:
```sql
                SELECT "total_time_s" FROM "round_1" WHERE "horse"='pinot grigio';
```
## Task
Generate a SQL query to answer the following question:
`What is the average amount of points when the time (s) is 81.78?`

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

CREATE TABLE "round_1" (
  "rider" text,
  "horse" text,
  "time_s" text,
  "faults" text,
  "total_time_s" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average amount of points when the time (s) is 81.78?`:
```sql
                SELECT AVG("points") FROM "round_1" WHERE "time_s"='81.78';
```
## Task
Generate a SQL query to answer the following question:
`What is the position of the player from Glades Day School?`

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

CREATE TABLE "2012_team" (
  "player" text,
  "position" text,
  "school" text,
  "hometown" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the position of the player from Glades Day School?`:
```sql
                SELECT "position" FROM "2012_team" WHERE "school"='glades day school';
```
## Task
Generate a SQL query to answer the following question:
`What is the position of the player who went to college of notre dame?`

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

CREATE TABLE "2012_team" (
  "player" text,
  "position" text,
  "school" text,
  "hometown" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the position of the player who went to college of notre dame?`:
```sql
                SELECT "position" FROM "2012_team" WHERE "college"='notre dame';
```
## Task
Generate a SQL query to answer the following question:
`What is the school of the player who went to the college of michigan and originally comes from Wheaton, Illinois?`

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

CREATE TABLE "2012_team" (
  "player" text,
  "position" text,
  "school" text,
  "hometown" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the school of the player who went to the college of michigan and originally comes from Wheaton, Illinois?`:
```sql
                SELECT "school" FROM "2012_team" WHERE "college"='michigan' AND "hometown"='wheaton, illinois';
```
## Task
Generate a SQL query to answer the following question:
`What Chassis was driven by Otto Stuppacher?`

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

CREATE TABLE "teams_and_drivers" (
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyre" text,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Chassis was driven by Otto Stuppacher?`:
```sql
                SELECT "chassis" FROM "teams_and_drivers" WHERE "driver"='otto stuppacher';
```
## Task
Generate a SQL query to answer the following question:
`Who drove the car with the n175 chassis in round 13?`

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

CREATE TABLE "teams_and_drivers" (
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyre" text,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who drove the car with the n175 chassis in round 13?`:
```sql
                SELECT "driver" FROM "teams_and_drivers" WHERE "chassis"='n175' AND "rounds"='13';
```
## Task
Generate a SQL query to answer the following question:
`What chassis did John Watson drive?`

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

CREATE TABLE "teams_and_drivers" (
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyre" text,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What chassis did John Watson drive?`:
```sql
                SELECT "chassis" FROM "teams_and_drivers" WHERE "driver"='john watson';
```
## Task
Generate a SQL query to answer the following question:
`what is the right ascension (j2000) when the constellation is sextans and the declination (j2000) is °28′01″?`

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

CREATE TABLE "3101_3200" (
  "ngc_number" real,
  "object_type" text,
  "constellation" text,
  "right_ascension_j2000" text,
  "declination_j2000" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the right ascension (j2000) when the constellation is sextans and the declination (j2000) is °28′01″?`:
```sql
                SELECT "right_ascension_j2000" FROM "3101_3200" WHERE "constellation"='sextans' AND "declination_j2000"='°28′01″';
```
## Task
Generate a SQL query to answer the following question:
`what is the constellation when the Right ascension ( J2000 ) is 10h18m58.4s?`

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

CREATE TABLE "3101_3200" (
  "ngc_number" real,
  "object_type" text,
  "constellation" text,
  "right_ascension_j2000" text,
  "declination_j2000" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the constellation when the Right ascension ( J2000 ) is 10h18m58.4s?`:
```sql
                SELECT "constellation" FROM "3101_3200" WHERE "right_ascension_j2000"='10h18m58.4s';
```
## Task
Generate a SQL query to answer the following question:
`what is the highest ngc number when the declination (j2000) is °25′26″?`

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

CREATE TABLE "3101_3200" (
  "ngc_number" real,
  "object_type" text,
  "constellation" text,
  "right_ascension_j2000" text,
  "declination_j2000" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the highest ngc number when the declination (j2000) is °25′26″?`:
```sql
                SELECT MAX("ngc_number") FROM "3101_3200" WHERE "declination_j2000"='°25′26″';
```
## Task
Generate a SQL query to answer the following question:
`What is the score for Collingwood as the home team?`

### 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 is the score for Collingwood as the home team?`:
```sql
                SELECT "home_team_score" FROM "round_6" WHERE "home_team"='collingwood';
```
## Task
Generate a SQL query to answer the following question:
`What away team had a score of 14.14 (98)?`

### 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 away team had a score of 14.14 (98)?`:
```sql
                SELECT "away_team" FROM "round_6" WHERE "away_team_score"='14.14 (98)';
```
## Task
Generate a SQL query to answer the following question:
`What did the home team score at Princes Park?`

### 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 did the home team score at Princes Park?`:
```sql
                SELECT "home_team_score" FROM "round_6" WHERE "venue"='princes park';
```
## Task
Generate a SQL query to answer the following question:
`What is the home team score when the away team scored 13.12 (90)?`

### 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 is the home team score when the away team scored 13.12 (90)?`:
```sql
                SELECT "home_team_score" FROM "round_6" WHERE "away_team_score"='13.12 (90)';
```
## Task
Generate a SQL query to answer the following question:
`When did the home team score 14.22 (106)?`

### 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 `When did the home team score 14.22 (106)?`:
```sql
                SELECT "date" FROM "round_6" WHERE "home_team_score"='14.22 (106)';
```
## Task
Generate a SQL query to answer the following question:
`What's the sum of the population for the place simplified 上杭县 with an area smaller than 2,879?`

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

CREATE TABLE "administration" (
  "english_name" text,
  "simplified" text,
  "traditional" text,
  "pinyin" text,
  "hakka" text,
  "area" real,
  "population" real,
  "density" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the sum of the population for the place simplified 上杭县 with an area smaller than 2,879?`:
```sql
                SELECT SUM("population") FROM "administration" WHERE "simplified"='上杭县' AND "area"<'2,879';
```
## Task
Generate a SQL query to answer the following question:
`What's the total number of density for the place with a population over 393,390?`

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

CREATE TABLE "administration" (
  "english_name" text,
  "simplified" text,
  "traditional" text,
  "pinyin" text,
  "hakka" text,
  "area" real,
  "population" real,
  "density" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the total number of density for the place with a population over 393,390?`:
```sql
                SELECT COUNT("density") FROM "administration" WHERE "population">'393,390';
```
## Task
Generate a SQL query to answer the following question:
`What's the average area for the xinluo district?`

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

CREATE TABLE "administration" (
  "english_name" text,
  "simplified" text,
  "traditional" text,
  "pinyin" text,
  "hakka" text,
  "area" real,
  "population" real,
  "density" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the average area for the xinluo district?`:
```sql
                SELECT AVG("area") FROM "administration" WHERE "english_name"='xinluo district';
```
## Task
Generate a SQL query to answer the following question:
`What was the attendance on July 30?`

### 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 attendance on July 30?`:
```sql
                SELECT AVG("attendance") FROM "game_log" WHERE "date"='july 30';
```
## Task
Generate a SQL query to answer the following question:
`How many Goals have a Result of 0 – 4?`

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

CREATE TABLE "international_career" (
  "date" text,
  "venue" text,
  "result" text,
  "goals" real,
  "competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many Goals have a Result of 0 – 4?`:
```sql
                SELECT AVG("goals") FROM "international_career" WHERE "result"='0 – 4';
```
## Task
Generate a SQL query to answer the following question:
`How many goals have a Result of 12 – 0?`

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

CREATE TABLE "international_career" (
  "date" text,
  "venue" text,
  "result" text,
  "goals" real,
  "competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many goals have a Result of 12 – 0?`:
```sql
                SELECT "goals" FROM "international_career" WHERE "result"='12 – 0';
```
## Task
Generate a SQL query to answer the following question:
`Which Result has a Date of 9 october 2009?`

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

CREATE TABLE "international_career" (
  "date" text,
  "venue" text,
  "result" text,
  "goals" real,
  "competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Result has a Date of 9 october 2009?`:
```sql
                SELECT "result" FROM "international_career" WHERE "date"='9 october 2009';
```
## Task
Generate a SQL query to answer the following question:
`Which Goals have a Date of 7 february 2010?`

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

CREATE TABLE "international_career" (
  "date" text,
  "venue" text,
  "result" text,
  "goals" real,
  "competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Goals have a Date of 7 february 2010?`:
```sql
                SELECT MAX("goals") FROM "international_career" WHERE "date"='7 february 2010';
```