cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`What squad plays at comunale in darfo boario terme?`

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

CREATE TABLE "serie_d" (
  "name" text,
  "short_name" text,
  "city" text,
  "region" text,
  "girone" text,
  "home_venue" text
);
### SQL
Given the database schema, here is the SQL query that answers `What squad plays at comunale in darfo boario terme?`:
```sql
                SELECT "name" FROM "serie_d" WHERE "home_venue"='comunale' AND "city"='darfo boario terme';
```
## Task
Generate a SQL query to answer the following question:
`What pick was Scott Glennie from the Western hockey league`

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

CREATE TABLE "round_one" (
  "pick_num" real,
  "player" text,
  "nationality" text,
  "position" text,
  "league_from" text
);
### SQL
Given the database schema, here is the SQL query that answers `What pick was Scott Glennie from the Western hockey league`:
```sql
                SELECT "pick_num" FROM "round_one" WHERE "league_from"='western hockey league' AND "player"='scott glennie';
```
## Task
Generate a SQL query to answer the following question:
`What player from the United States played in the western collegiate hockey association?`

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

CREATE TABLE "round_one" (
  "pick_num" real,
  "player" text,
  "nationality" text,
  "position" text,
  "league_from" text
);
### SQL
Given the database schema, here is the SQL query that answers `What player from the United States played in the western collegiate hockey association?`:
```sql
                SELECT "player" FROM "round_one" WHERE "nationality"='united states' AND "league_from"='western collegiate hockey association';
```
## Task
Generate a SQL query to answer the following question:
`Where the time/retired is +1 lap, the constructor is BRM, and the grid is above 1, what's the highest laps recorded?`

### 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 `Where the time/retired is +1 lap, the constructor is BRM, and the grid is above 1, what's the highest laps recorded?`:
```sql
                SELECT MAX("laps") FROM "classification" WHERE "time_retired"='+1 lap' AND "constructor"='brm' AND "grid">1;
```
## Task
Generate a SQL query to answer the following question:
`When the laps driven were under 9 and the time/retired recorded was engine, what's the total number of grid values?`

### 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 `When the laps driven were under 9 and the time/retired recorded was engine, what's the total number of grid values?`:
```sql
                SELECT COUNT("grid") FROM "classification" WHERE "laps"<9 AND "time_retired"='engine';
```
## Task
Generate a SQL query to answer the following question:
`Which driver has a grid of 3?`

### 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 `Which driver has a grid of 3?`:
```sql
                SELECT "driver" FROM "classification" WHERE "grid"=3;
```
## Task
Generate a SQL query to answer the following question:
`When the laps are 31 and the constructor was honda, what's the sum of all grid values?`

### 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 `When the laps are 31 and the constructor was honda, what's the sum of all grid values?`:
```sql
                SELECT SUM("grid") FROM "classification" WHERE "constructor"='honda' AND "laps"=31;
```
## Task
Generate a SQL query to answer the following question:
`What is the chassis for all rounds on the entrant Benson and Hedges Jordan driven by Damon Hill?`

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

CREATE TABLE "drivers_and_constructors" (
  "entrant" text,
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyre" text,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the chassis for all rounds on the entrant Benson and Hedges Jordan driven by Damon Hill?`:
```sql
                SELECT "chassis" FROM "drivers_and_constructors" WHERE "rounds"='all' AND "entrant"='benson and hedges jordan' AND "driver"='damon hill';
```
## Task
Generate a SQL query to answer the following question:
`What is the constructor of driver Alexander Wurz?`

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

CREATE TABLE "drivers_and_constructors" (
  "entrant" text,
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyre" text,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the constructor of driver Alexander Wurz?`:
```sql
                SELECT "constructor" FROM "drivers_and_constructors" WHERE "driver"='alexander wurz';
```
## Task
Generate a SQL query to answer the following question:
`Who was the driver that had all rounds and a f399 chassis?`

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

CREATE TABLE "drivers_and_constructors" (
  "entrant" text,
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyre" text,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the driver that had all rounds and a f399 chassis?`:
```sql
                SELECT "driver" FROM "drivers_and_constructors" WHERE "rounds"='all' AND "chassis"='f399';
```
## Task
Generate a SQL query to answer the following question:
`What were the rounds on the Engine † of the Ferrari 048?`

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

CREATE TABLE "drivers_and_constructors" (
  "entrant" text,
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyre" text,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What were the rounds on the Engine † of the Ferrari 048?`:
```sql
                SELECT "rounds" FROM "drivers_and_constructors" WHERE "engine"='ferrari 048';
```
## Task
Generate a SQL query to answer the following question:
`Which Semifinal has an Event of team?`

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

CREATE TABLE "badminton" (
  "event" text,
  "2nd_round" text,
  "quarterfinal" text,
  "semifinal" text,
  "final" text,
  "rank" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Semifinal has an Event of team?`:
```sql
                SELECT "semifinal" FROM "badminton" WHERE "event"='team';
```
## Task
Generate a SQL query to answer the following question:
`Which Quarterfinal has a Rank larger than 9?`

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

CREATE TABLE "badminton" (
  "event" text,
  "2nd_round" text,
  "quarterfinal" text,
  "semifinal" text,
  "final" text,
  "rank" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Quarterfinal has a Rank larger than 9?`:
```sql
                SELECT "quarterfinal" FROM "badminton" WHERE "rank">9;
```
## Task
Generate a SQL query to answer the following question:
`What is the pick number of the DB?`

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

CREATE TABLE "round_two" (
  "pick_num" real,
  "cfl_team" text,
  "player" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the pick number of the DB?`:
```sql
                SELECT COUNT("pick_num") FROM "round_two" WHERE "position"='db';
```
## Task
Generate a SQL query to answer the following question:
`What college did the T who was pick after 13 go to?`

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

CREATE TABLE "round_two" (
  "pick_num" real,
  "cfl_team" text,
  "player" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What college did the T who was pick after 13 go to?`:
```sql
                SELECT "college" FROM "round_two" WHERE "pick_num">13 AND "position"='t';
```
## Task
Generate a SQL query to answer the following question:
`Which CFL team drafted a pick from Boston College?`

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

CREATE TABLE "round_two" (
  "pick_num" real,
  "cfl_team" text,
  "player" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which CFL team drafted a pick from Boston College?`:
```sql
                SELECT "cfl_team" FROM "round_two" WHERE "college"='boston college';
```
## Task
Generate a SQL query to answer the following question:
`What position did the Saskatchewan player get drafted as?`

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

CREATE TABLE "round_two" (
  "pick_num" real,
  "cfl_team" text,
  "player" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What position did the Saskatchewan player get drafted as?`:
```sql
                SELECT "position" FROM "round_two" WHERE "college"='saskatchewan';
```
## Task
Generate a SQL query to answer the following question:
`When the laps are over 53, what's the average grid?`

### 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 `When the laps are over 53, what's the average grid?`:
```sql
                SELECT AVG("grid") FROM "classification" WHERE "laps">53;
```
## Task
Generate a SQL query to answer the following question:
`What's the average laps driven by david coulthard?`

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

CREATE TABLE "classification" (
  "driver" text,
  "constructor" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the average laps driven by david coulthard?`:
```sql
                SELECT AVG("laps") FROM "classification" WHERE "driver"='david coulthard';
```
## Task
Generate a SQL query to answer the following question:
`who is the opponent in the final when the year is before 1883?`

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

CREATE TABLE "singles_5" (
  "outcome" text,
  "year" real,
  "tournament" text,
  "surface" text,
  "opponent_in_the_final" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `who is the opponent in the final when the year is before 1883?`:
```sql
                SELECT "opponent_in_the_final" FROM "singles_5" WHERE "year"<1883;
```
## Task
Generate a SQL query to answer the following question:
`what is the outcome for the 1887?`

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

CREATE TABLE "singles_5" (
  "outcome" text,
  "year" real,
  "tournament" text,
  "surface" text,
  "opponent_in_the_final" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the outcome for the 1887?`:
```sql
                SELECT "outcome" FROM "singles_5" WHERE "year"=1887;
```
## Task
Generate a SQL query to answer the following question:
`what is the outcome when the opponent in the final is william renshaw after year 1882?`

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

CREATE TABLE "singles_5" (
  "outcome" text,
  "year" real,
  "tournament" text,
  "surface" text,
  "opponent_in_the_final" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the outcome when the opponent in the final is william renshaw after year 1882?`:
```sql
                SELECT "outcome" FROM "singles_5" WHERE "year">1882 AND "opponent_in_the_final"='william renshaw';
```
## Task
Generate a SQL query to answer the following question:
`what is the score when the outcome is runner-up, the opponent in the final is herbert lawford and the year is after 1882?`

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

CREATE TABLE "singles_5" (
  "outcome" text,
  "year" real,
  "tournament" text,
  "surface" text,
  "opponent_in_the_final" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the score when the outcome is runner-up, the opponent in the final is herbert lawford and the year is after 1882?`:
```sql
                SELECT "score" FROM "singles_5" WHERE "year">1882 AND "outcome"='runner-up' AND "opponent_in_the_final"='herbert lawford';
```
## Task
Generate a SQL query to answer the following question:
`What artist has a mintage of greater than 34,135?`

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

CREATE TABLE "natural_wonders" (
  "year" real,
  "design" text,
  "issue" text,
  "artist" text,
  "mintage" real,
  "issue_price" text
);
### SQL
Given the database schema, here is the SQL query that answers `What artist has a mintage of greater than 34,135?`:
```sql
                SELECT "artist" FROM "natural_wonders" WHERE "mintage">'34,135';
```
## Task
Generate a SQL query to answer the following question:
`What artist was released in 2005?`

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

CREATE TABLE "natural_wonders" (
  "year" real,
  "design" text,
  "issue" text,
  "artist" text,
  "mintage" real,
  "issue_price" text
);
### SQL
Given the database schema, here is the SQL query that answers `What artist was released in 2005?`:
```sql
                SELECT "artist" FROM "natural_wonders" WHERE "year"=2005;
```
## Task
Generate a SQL query to answer the following question:
`What's melbourne's average year?`

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

CREATE TABLE "goal_to_draw" (
  "player" text,
  "team" text,
  "opponent" text,
  "year" real,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's melbourne's average year?`:
```sql
                SELECT AVG("year") FROM "goal_to_draw" WHERE "team"='melbourne';
```
## Task
Generate a SQL query to answer the following question:
`Who was ashley sampi's opponent?`

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

CREATE TABLE "goal_to_draw" (
  "player" text,
  "team" text,
  "opponent" text,
  "year" real,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was ashley sampi's opponent?`:
```sql
                SELECT "opponent" FROM "goal_to_draw" WHERE "player"='ashley sampi';
```
## Task
Generate a SQL query to answer the following question:
`Which team did daniel bradshaw play for after 1935?`

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

CREATE TABLE "goal_to_draw" (
  "player" text,
  "team" text,
  "opponent" text,
  "year" real,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which team did daniel bradshaw play for after 1935?`:
```sql
                SELECT "team" FROM "goal_to_draw" WHERE "year">1935 AND "player"='daniel bradshaw';
```
## Task
Generate a SQL query to answer the following question:
`Who played in 1992?`

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

CREATE TABLE "goal_to_draw" (
  "player" text,
  "team" text,
  "opponent" text,
  "year" real,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who played in 1992?`:
```sql
                SELECT "player" FROM "goal_to_draw" WHERE "year"=1992;
```
## Task
Generate a SQL query to answer the following question:
`What date was fitzroy the away team?`

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

CREATE TABLE "round_4" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date was fitzroy the away team?`:
```sql
                SELECT "date" FROM "round_4" WHERE "away_team"='fitzroy';
```
## Task
Generate a SQL query to answer the following question:
`Name the surface when the partner is carlos berlocq`

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

CREATE TABLE "doubles_7_2_titles_5_runners_up" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponents" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the surface when the partner is carlos berlocq`:
```sql
                SELECT "surface" FROM "doubles_7_2_titles_5_runners_up" WHERE "partner"='carlos berlocq';
```
## Task
Generate a SQL query to answer the following question:
`Name the date for clay surface and score of 0–6, 0–6`

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

CREATE TABLE "doubles_7_2_titles_5_runners_up" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponents" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the date for clay surface and score of 0–6, 0–6`:
```sql
                SELECT "date" FROM "doubles_7_2_titles_5_runners_up" WHERE "surface"='clay' AND "score"='0–6, 0–6';
```
## Task
Generate a SQL query to answer the following question:
`Name the partner with score of 6–3, 6–2`

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

CREATE TABLE "doubles_7_2_titles_5_runners_up" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponents" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the partner with score of 6–3, 6–2`:
```sql
                SELECT "partner" FROM "doubles_7_2_titles_5_runners_up" WHERE "score"='6–3, 6–2';
```
## Task
Generate a SQL query to answer the following question:
`Name the tournament for clay surface and outcome is winner with score is 6–3, 6–2`

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

CREATE TABLE "doubles_7_2_titles_5_runners_up" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponents" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the tournament for clay surface and outcome is winner with score is 6–3, 6–2`:
```sql
                SELECT "tournament" FROM "doubles_7_2_titles_5_runners_up" WHERE "surface"='clay' AND "outcome"='winner' AND "score"='6–3, 6–2';
```
## Task
Generate a SQL query to answer the following question:
`Name the outcome on 6 october 2013`

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

CREATE TABLE "doubles_7_2_titles_5_runners_up" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponents" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the outcome on 6 october 2013`:
```sql
                SELECT "outcome" FROM "doubles_7_2_titles_5_runners_up" WHERE "date"='6 october 2013';
```
## Task
Generate a SQL query to answer the following question:
`What is the song with more than 9 points and 44 (11) jury (points)?`

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

CREATE TABLE "national_final" (
  "draw" real,
  "song" text,
  "artist" text,
  "jury_points" text,
  "televotes_points" text,
  "total_points" real,
  "place" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the song with more than 9 points and 44 (11) jury (points)?`:
```sql
                SELECT "song" FROM "national_final" WHERE "total_points">9 AND "jury_points"='44 (11)';
```
## Task
Generate a SQL query to answer the following question:
`Who is the artist with 2153 (5) televotes (points)?`

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

CREATE TABLE "national_final" (
  "draw" real,
  "song" text,
  "artist" text,
  "jury_points" text,
  "televotes_points" text,
  "total_points" real,
  "place" real
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the artist with 2153 (5) televotes (points)?`:
```sql
                SELECT "artist" FROM "national_final" WHERE "televotes_points"='2153 (5)';
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest total points Karine Trécy has with less than 4 draws?`

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

CREATE TABLE "national_final" (
  "draw" real,
  "song" text,
  "artist" text,
  "jury_points" text,
  "televotes_points" text,
  "total_points" real,
  "place" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest total points Karine Trécy has with less than 4 draws?`:
```sql
                SELECT MIN("total_points") FROM "national_final" WHERE "draw"<4 AND "artist"='karine trécy';
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest total points Karine Trécy has with a less than 12 place?`

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

CREATE TABLE "national_final" (
  "draw" real,
  "song" text,
  "artist" text,
  "jury_points" text,
  "televotes_points" text,
  "total_points" real,
  "place" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest total points Karine Trécy has with a less than 12 place?`:
```sql
                SELECT MIN("total_points") FROM "national_final" WHERE "artist"='karine trécy' AND "place"<12;
```
## Task
Generate a SQL query to answer the following question:
`What is the average rating of viewers 18 to 49 where the total viewer count is 3.93 million and share less than 4?`

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

CREATE TABLE "weekly_ratings" (
  "episode" text,
  "air_date" text,
  "timeslot_est" text,
  "season" real,
  "rating" real,
  "share" real,
  "18_49" real,
  "viewers_m" real,
  "rank_num" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average rating of viewers 18 to 49 where the total viewer count is 3.93 million and share less than 4?`:
```sql
                SELECT AVG("18_49") FROM "weekly_ratings" WHERE "viewers_m"=3.93 AND "share"<4;
```
## Task
Generate a SQL query to answer the following question:
`What is the total number of ratings among the 18 to 49 group that was aired on January 7, 2009?`

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

CREATE TABLE "weekly_ratings" (
  "episode" text,
  "air_date" text,
  "timeslot_est" text,
  "season" real,
  "rating" real,
  "share" real,
  "18_49" real,
  "viewers_m" real,
  "rank_num" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of ratings among the 18 to 49 group that was aired on January 7, 2009?`:
```sql
                SELECT COUNT("18_49") FROM "weekly_ratings" WHERE "air_date"='january 7, 2009';
```
## Task
Generate a SQL query to answer the following question:
`What is the total number of viewers for the show that was aired on December 10, 2008 with an 18 to 49 rating less than 1.2?`

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

CREATE TABLE "weekly_ratings" (
  "episode" text,
  "air_date" text,
  "timeslot_est" text,
  "season" real,
  "rating" real,
  "share" real,
  "18_49" real,
  "viewers_m" real,
  "rank_num" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of viewers for the show that was aired on December 10, 2008 with an 18 to 49 rating less than 1.2?`:
```sql
                SELECT COUNT("viewers_m") FROM "weekly_ratings" WHERE "air_date"='december 10, 2008' AND "18_49"<1.2;
```
## Task
Generate a SQL query to answer the following question:
`What was Mike Hailwood's highest laps when he had a grid more than 7?`

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

CREATE TABLE "classification" (
  "driver" text,
  "constructor" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was Mike Hailwood's highest laps when he had a grid more than 7?`:
```sql
                SELECT MAX("laps") FROM "classification" WHERE "driver"='mike hailwood' AND "grid">7;
```
## Task
Generate a SQL query to answer the following question:
`What is the name of the site with a CERCLIS ID of prd980512362?`

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

CREATE TABLE "superfund_sites" (
  "cerclis_id" text,
  "name" text,
  "municipality" text,
  "proposed" text,
  "listed" text,
  "construction_completed" text,
  "partially_deleted" text,
  "deleted" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the name of the site with a CERCLIS ID of prd980512362?`:
```sql
                SELECT "name" FROM "superfund_sites" WHERE "cerclis_id"='prd980512362';
```
## Task
Generate a SQL query to answer the following question:
`What is the site for Florida?`

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

CREATE TABLE "superfund_sites" (
  "cerclis_id" text,
  "name" text,
  "municipality" text,
  "proposed" text,
  "listed" text,
  "construction_completed" text,
  "partially_deleted" text,
  "deleted" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the site for Florida?`:
```sql
                SELECT "listed" FROM "superfund_sites" WHERE "municipality"='florida';
```
## Task
Generate a SQL query to answer the following question:
`What site in the RCA Del Caribe was deleted?`

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

CREATE TABLE "superfund_sites" (
  "cerclis_id" text,
  "name" text,
  "municipality" text,
  "proposed" text,
  "listed" text,
  "construction_completed" text,
  "partially_deleted" text,
  "deleted" text
);
### SQL
Given the database schema, here is the SQL query that answers `What site in the RCA Del Caribe was deleted?`:
```sql
                SELECT "deleted" FROM "superfund_sites" WHERE "name"='rca del caribe';
```
## Task
Generate a SQL query to answer the following question:
`Where is the partially deleted site of fibers public supply wells located?`

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

CREATE TABLE "superfund_sites" (
  "cerclis_id" text,
  "name" text,
  "municipality" text,
  "proposed" text,
  "listed" text,
  "construction_completed" text,
  "partially_deleted" text,
  "deleted" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where is the partially deleted site of fibers public supply wells located?`:
```sql
                SELECT "partially_deleted" FROM "superfund_sites" WHERE "name"='fibers public supply wells';
```
## Task
Generate a SQL query to answer the following question:
`The proposed 03/08/2004 site is in what municipality?`

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

CREATE TABLE "superfund_sites" (
  "cerclis_id" text,
  "name" text,
  "municipality" text,
  "proposed" text,
  "listed" text,
  "construction_completed" text,
  "partially_deleted" text,
  "deleted" text
);
### SQL
Given the database schema, here is the SQL query that answers `The proposed 03/08/2004 site is in what municipality?`:
```sql
                SELECT "municipality" FROM "superfund_sites" WHERE "proposed"='03/08/2004';
```
## Task
Generate a SQL query to answer the following question:
`What is the release format for titles after 1983?`

### 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 `What is the release format for titles after 1983?`:
```sql
                SELECT "release_format" FROM "release_history" WHERE "release_date">1983;
```
## Task
Generate a SQL query to answer the following question:
`Which crowd had an Away team score of 7.12 (54)?`

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

CREATE TABLE "round_13" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which crowd had an Away team score of 7.12 (54)?`:
```sql
                SELECT AVG("crowd") FROM "round_13" WHERE "away_team_score"='7.12 (54)';
```
## Task
Generate a SQL query to answer the following question:
`What venue is the home of the Carlton team?`

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

CREATE TABLE "round_13" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What venue is the home of the Carlton team?`:
```sql
                SELECT "venue" FROM "round_13" WHERE "home_team"='carlton';
```
## Task
Generate a SQL query to answer the following question:
`Which driver had a grid of 18 with 68 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" text,
  "time_retired" text,
  "grid" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which driver had a grid of 18 with 68 laps?`:
```sql
                SELECT "driver" FROM "race" WHERE "laps"='68' AND "grid"='18';
```
## Task
Generate a SQL query to answer the following question:
`Which driver had a grid of 18?`

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

CREATE TABLE "race" (
  "driver" text,
  "constructor" text,
  "laps" text,
  "time_retired" text,
  "grid" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which driver had a grid of 18?`:
```sql
                SELECT "driver" FROM "race" WHERE "grid"='18';
```
## Task
Generate a SQL query to answer the following question:
`Which driver had a grid of 22?`

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

CREATE TABLE "race" (
  "driver" text,
  "constructor" text,
  "laps" text,
  "time_retired" text,
  "grid" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which driver had a grid of 22?`:
```sql
                SELECT "driver" FROM "race" WHERE "grid"='22';
```
## Task
Generate a SQL query to answer the following question:
`Which season is the wicket 2nd partnership in?`

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

CREATE TABLE "partnership_records" (
  "wicket_partnership" text,
  "runs" text,
  "batsmen" text,
  "opponents" text,
  "venue" text,
  "season" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which season is the wicket 2nd partnership in?`:
```sql
                SELECT "season" FROM "partnership_records" WHERE "wicket_partnership"='2nd';
```
## Task
Generate a SQL query to answer the following question:
`Where did v kent play?`

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

CREATE TABLE "partnership_records" (
  "wicket_partnership" text,
  "runs" text,
  "batsmen" text,
  "opponents" text,
  "venue" text,
  "season" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where did v kent play?`:
```sql
                SELECT "venue" FROM "partnership_records" WHERE "opponents"='v kent';
```
## Task
Generate a SQL query to answer the following question:
`Which runs had james bryant graeme welch as Batsmen?`

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

CREATE TABLE "partnership_records" (
  "wicket_partnership" text,
  "runs" text,
  "batsmen" text,
  "opponents" text,
  "venue" text,
  "season" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which runs had james bryant graeme welch as Batsmen?`:
```sql
                SELECT "runs" FROM "partnership_records" WHERE "batsmen"='james bryant graeme welch';
```
## Task
Generate a SQL query to answer the following question:
`Which clay has a Record of 2–0, and a Hard 1–0?`

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

CREATE TABLE "head_to_head_record" (
  "record" text,
  "hard" text,
  "clay" text,
  "grass" text,
  "carpet" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which clay has a Record of 2–0, and a Hard 1–0?`:
```sql
                SELECT "clay" FROM "head_to_head_record" WHERE "record"='2–0' AND "hard"='1–0';
```
## Task
Generate a SQL query to answer the following question:
`Which hard has a Clay of 0–0, Grass of 0–0,  Carpet of 0–0, and a Record of 1–0?`

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

CREATE TABLE "head_to_head_record" (
  "record" text,
  "hard" text,
  "clay" text,
  "grass" text,
  "carpet" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which hard has a Clay of 0–0, Grass of 0–0,  Carpet of 0–0, and a Record of 1–0?`:
```sql
                SELECT "hard" FROM "head_to_head_record" WHERE "clay"='0–0' AND "grass"='0–0' AND "carpet"='0–0' AND "record"='1–0';
```
## Task
Generate a SQL query to answer the following question:
`Which carpet has a Clay of 1–0 and a Hard 1–1?`

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

CREATE TABLE "head_to_head_record" (
  "record" text,
  "hard" text,
  "clay" text,
  "grass" text,
  "carpet" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which carpet has a Clay of 1–0 and a Hard 1–1?`:
```sql
                SELECT "carpet" FROM "head_to_head_record" WHERE "clay"='1–0' AND "hard"='1–1';
```
## Task
Generate a SQL query to answer the following question:
`Name the most rank for population more than 93,378`

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

CREATE TABLE "references" (
  "rank" real,
  "council_area" text,
  "speakers" real,
  "population" real,
  "percentage_pct" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the most rank for population more than 93,378`:
```sql
                SELECT MAX("rank") FROM "references" WHERE "population">'93,378';
```
## Task
Generate a SQL query to answer the following question:
`What award is featured in 1992?`

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

CREATE TABLE "feature_film" (
  "year" real,
  "award" text,
  "category" text,
  "type" text,
  "title" text
);
### SQL
Given the database schema, here is the SQL query that answers `What award is featured in 1992?`:
```sql
                SELECT "award" FROM "feature_film" WHERE "year"=1992;
```
## Task
Generate a SQL query to answer the following question:
`What award was won in the best sound category for the exorcist before 1998?`

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

CREATE TABLE "feature_film" (
  "year" real,
  "award" text,
  "category" text,
  "type" text,
  "title" text
);
### SQL
Given the database schema, here is the SQL query that answers `What award was won in the best sound category for the exorcist before 1998?`:
```sql
                SELECT "award" FROM "feature_film" WHERE "year"<1998 AND "type"='won' AND "category"='best sound' AND "title"='the exorcist';
```
## Task
Generate a SQL query to answer the following question:
`What was the candidate that got 1,019 votes for staten island?`

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

CREATE TABLE "1953" (
  "1953" text,
  "party" text,
  "manhattan" text,
  "the_bronx" text,
  "brooklyn" text,
  "queens" text,
  "richmond_staten_is" text,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the candidate that got 1,019 votes for staten island?`:
```sql
                SELECT "1953" FROM "1953" WHERE "richmond_staten_is"='1,019';
```
## Task
Generate a SQL query to answer the following question:
`What was the opposing team for the game on August 29?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the opposing team for the game on August 29?`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "date"='august 29';
```
## Task
Generate a SQL query to answer the following question:
`which spans had a drop of 0?`

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

CREATE TABLE "most_tries" (
  "player" text,
  "span" text,
  "start" text,
  "tries" text,
  "conv" text,
  "pens" text,
  "drop" text
);
### SQL
Given the database schema, here is the SQL query that answers `which spans had a drop of 0?`:
```sql
                SELECT "span" FROM "most_tries" WHERE "drop"='0';
```
## Task
Generate a SQL query to answer the following question:
`which player has 11 tries?`

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

CREATE TABLE "most_tries" (
  "player" text,
  "span" text,
  "start" text,
  "tries" text,
  "conv" text,
  "pens" text,
  "drop" text
);
### SQL
Given the database schema, here is the SQL query that answers `which player has 11 tries?`:
```sql
                SELECT "player" FROM "most_tries" WHERE "tries"='11';
```
## Task
Generate a SQL query to answer the following question:
`which player has a conv of 14?`

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

CREATE TABLE "most_tries" (
  "player" text,
  "span" text,
  "start" text,
  "tries" text,
  "conv" text,
  "pens" text,
  "drop" text
);
### SQL
Given the database schema, here is the SQL query that answers `which player has a conv of 14?`:
```sql
                SELECT "player" FROM "most_tries" WHERE "conv"='14';
```
## Task
Generate a SQL query to answer the following question:
`on the span of 1992-2000, what was the conv ?`

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

CREATE TABLE "most_tries" (
  "player" text,
  "span" text,
  "start" text,
  "tries" text,
  "conv" text,
  "pens" text,
  "drop" text
);
### SQL
Given the database schema, here is the SQL query that answers `on the span of 1992-2000, what was the conv ?`:
```sql
                SELECT "conv" FROM "most_tries" WHERE "span"='1992-2000';
```
## Task
Generate a SQL query to answer the following question:
`What is the high point toal for martine foubert placing below 2?`

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

CREATE TABLE "semi_final_3_21_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 is the high point toal for martine foubert placing below 2?`:
```sql
                SELECT MAX("points") FROM "semi_final_3_21_february_1999" WHERE "artist"='martine foubert' AND "place">2;
```
## Task
Generate a SQL query to answer the following question:
`How much did the away team Melbourne score?`

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

CREATE TABLE "round_1" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `How much did the away team Melbourne score?`:
```sql
                SELECT "away_team_score" FROM "round_1" WHERE "away_team"='melbourne';
```
## Task
Generate a SQL query to answer the following question:
`What is the highest crowd number for the home team Richmond?`

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

CREATE TABLE "round_1" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest crowd number for the home team Richmond?`:
```sql
                SELECT MAX("crowd") FROM "round_1" WHERE "home_team"='richmond';
```
## Task
Generate a SQL query to answer the following question:
`What home team played at Glenferrie Oval?`

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

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

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

CREATE TABLE "round_1" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `How much did the away team St Kilda score?`:
```sql
                SELECT "away_team_score" FROM "round_1" WHERE "away_team"='st kilda';
```
## Task
Generate a SQL query to answer the following question:
`Which Home team score has an Away team score of 11.9 (75)?`

### 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 `Which Home team score has an Away team score of 11.9 (75)?`:
```sql
                SELECT "home_team_score" FROM "round_12" WHERE "away_team_score"='11.9 (75)';
```
## Task
Generate a SQL query to answer the following question:
`Which Crowd has an Away team of st kilda?`

### 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 `Which Crowd has an Away team of st kilda?`:
```sql
                SELECT "crowd" FROM "round_12" WHERE "away_team"='st kilda';
```
## Task
Generate a SQL query to answer the following question:
`Which Away team has an Away team score of 15.13 (103)?`

### 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 `Which Away team has an Away team score of 15.13 (103)?`:
```sql
                SELECT "away_team" FROM "round_12" WHERE "away_team_score"='15.13 (103)';
```
## Task
Generate a SQL query to answer the following question:
`What stadium has a final score of 26–21?`

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

CREATE TABLE "2006" (
  "date" text,
  "visiting_team" text,
  "final_score" text,
  "host_team" text,
  "stadium" text
);
### SQL
Given the database schema, here is the SQL query that answers `What stadium has a final score of 26–21?`:
```sql
                SELECT "stadium" FROM "2006" WHERE "final_score"='26–21';
```
## Task
Generate a SQL query to answer the following question:
`When the new orleans saints were visiting texas stadium, what was the final score?`

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

CREATE TABLE "2006" (
  "date" text,
  "visiting_team" text,
  "final_score" text,
  "host_team" text,
  "stadium" text
);
### SQL
Given the database schema, here is the SQL query that answers `When the new orleans saints were visiting texas stadium, what was the final score?`:
```sql
                SELECT "final_score" FROM "2006" WHERE "stadium"='texas stadium' AND "visiting_team"='new orleans saints';
```
## Task
Generate a SQL query to answer the following question:
`What was the final score at texas stadium on September 17?`

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

CREATE TABLE "2006" (
  "date" text,
  "visiting_team" text,
  "final_score" text,
  "host_team" text,
  "stadium" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the final score at texas stadium on September 17?`:
```sql
                SELECT "final_score" FROM "2006" WHERE "stadium"='texas stadium' AND "date"='september 17';
```