cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`What is the earliest year for 9 points?`

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

CREATE TABLE "complete_formula_one_results" (
  "year" real,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the earliest year for 9 points?`:
```sql
                SELECT MIN("year") FROM "complete_formula_one_results" WHERE "points"=9;
```
## Task
Generate a SQL query to answer the following question:
`What is the low score for the jaguar r3 chasis?`

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

CREATE TABLE "complete_formula_one_results" (
  "year" real,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the low score for the jaguar r3 chasis?`:
```sql
                SELECT MIN("points") FROM "complete_formula_one_results" WHERE "chassis"='jaguar r3';
```
## Task
Generate a SQL query to answer the following question:
`What is the notes when the displacement is 220cid (3,604cc)?`

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

CREATE TABLE "engines" (
  "years" text,
  "engine" text,
  "displacement" text,
  "power" text,
  "torque" text,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the notes when the displacement is 220cid (3,604cc)?`:
```sql
                SELECT "notes" FROM "engines" WHERE "displacement"='220cid (3,604cc)';
```
## Task
Generate a SQL query to answer the following question:
`What is then engine when the notes state srt8?`

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

CREATE TABLE "engines" (
  "years" text,
  "engine" text,
  "displacement" text,
  "power" text,
  "torque" text,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is then engine when the notes state srt8?`:
```sql
                SELECT "engine" FROM "engines" WHERE "notes"='srt8';
```
## Task
Generate a SQL query to answer the following question:
`What is the power when the displacement is 182cid (2,988cc) and the notes are eu spec?`

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

CREATE TABLE "engines" (
  "years" text,
  "engine" text,
  "displacement" text,
  "power" text,
  "torque" text,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the power when the displacement is 182cid (2,988cc) and the notes are eu spec?`:
```sql
                SELECT "power" FROM "engines" WHERE "displacement"='182cid (2,988cc)' AND "notes"='eu spec';
```
## Task
Generate a SQL query to answer the following question:
`What is the engine for year 2012-?`

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

CREATE TABLE "engines" (
  "years" text,
  "engine" text,
  "displacement" text,
  "power" text,
  "torque" text,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the engine for year 2012-?`:
```sql
                SELECT "engine" FROM "engines" WHERE "years"='2012-';
```
## Task
Generate a SQL query to answer the following question:
`What is the record of the match with Columbus as the home team on March 7?`

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

CREATE TABLE "march" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "decision" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the record of the match with Columbus as the home team on March 7?`:
```sql
                SELECT "record" FROM "march" WHERE "home"='columbus' AND "date"='march 7';
```
## Task
Generate a SQL query to answer the following question:
`What is the record of the game on March 18?`

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

CREATE TABLE "march" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "decision" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the record of the game on March 18?`:
```sql
                SELECT "record" FROM "march" WHERE "date"='march 18';
```
## Task
Generate a SQL query to answer the following question:
`Which height has a College of wyoming, and a Name of guy frazier?`

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

CREATE TABLE "nfl_professionals" (
  "name" text,
  "position" text,
  "height" text,
  "weight_lbs" real,
  "born" text,
  "college" text,
  "drafted" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which height has a College of wyoming, and a Name of guy frazier?`:
```sql
                SELECT "height" FROM "nfl_professionals" WHERE "college"='wyoming' AND "name"='guy frazier';
```
## Task
Generate a SQL query to answer the following question:
`Which season's winner is Panathinaikos and is located in Athens?`

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

CREATE TABLE "finals" (
  "season" text,
  "date" text,
  "winners" text,
  "score" text,
  "runners_up" text,
  "venue" text,
  "location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which season's winner is Panathinaikos and is located in Athens?`:
```sql
                SELECT "season" FROM "finals" WHERE "location"='athens' AND "winners"='panathinaikos';
```
## Task
Generate a SQL query to answer the following question:
`What date did an Away team score 14.16 (100)?`

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

CREATE TABLE "round_4" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date did an Away team score 14.16 (100)?`:
```sql
                SELECT "date" FROM "round_4" WHERE "away_team_score"='14.16 (100)';
```
## Task
Generate a SQL query to answer the following question:
`What is the score of the Away team that played against a Home team that scored 17.19 (121)?`

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

CREATE TABLE "round_4" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the score of the Away team that played against a Home team that scored 17.19 (121)?`:
```sql
                SELECT "away_team_score" FROM "round_4" WHERE "home_team_score"='17.19 (121)';
```
## Task
Generate a SQL query to answer the following question:
`What Away team scored 14.17 (101) and had a crowd attendance larger than 14,000?`

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

CREATE TABLE "round_4" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Away team scored 14.17 (101) and had a crowd attendance larger than 14,000?`:
```sql
                SELECT "away_team" FROM "round_4" WHERE "crowd">'14,000' AND "home_team_score"='14.17 (101)';
```
## Task
Generate a SQL query to answer the following question:
`What is the date recorded of Hate?`

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

CREATE TABLE "track_listing" (
  "track" real,
  "title" text,
  "translation" text,
  "composer" text,
  "recorded" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the date recorded of Hate?`:
```sql
                SELECT "recorded" FROM "track_listing" WHERE "translation"='hate';
```
## Task
Generate a SQL query to answer the following question:
`Who is the composer on the tracks less than 4?`

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

CREATE TABLE "track_listing" (
  "track" real,
  "title" text,
  "translation" text,
  "composer" text,
  "recorded" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the composer on the tracks less than 4?`:
```sql
                SELECT "composer" FROM "track_listing" WHERE "track"<4;
```
## Task
Generate a SQL query to answer the following question:
`What is the title of track 7?`

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

CREATE TABLE "track_listing" (
  "track" real,
  "title" text,
  "translation" text,
  "composer" text,
  "recorded" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the title of track 7?`:
```sql
                SELECT "title" FROM "track_listing" WHERE "track"=7;
```
## Task
Generate a SQL query to answer the following question:
`What is the recorded date of track 8?`

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

CREATE TABLE "track_listing" (
  "track" real,
  "title" text,
  "translation" text,
  "composer" text,
  "recorded" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the recorded date of track 8?`:
```sql
                SELECT "recorded" FROM "track_listing" WHERE "track"=8;
```
## Task
Generate a SQL query to answer the following question:
`How many number Builts had unit numbers of 375301-310?`

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

CREATE TABLE "fleet_details" (
  "class" text,
  "type" text,
  "operator" text,
  "no_built" real,
  "year_built" text,
  "cars_per_set" real,
  "unit_nos" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many number Builts had unit numbers of 375301-310?`:
```sql
                SELECT SUM("no_built") FROM "fleet_details" WHERE "unit_nos"='375301-310';
```
## Task
Generate a SQL query to answer the following question:
`What was the score of the game where Montreal was the home team and the Devils had a record of 40–24–6?`

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

CREATE TABLE "march" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "decision" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score of the game where Montreal was the home team and the Devils had a record of 40–24–6?`:
```sql
                SELECT "score" FROM "march" WHERE "home"='montreal' AND "record"='40–24–6';
```
## Task
Generate a SQL query to answer the following question:
`Which location has 140 stores?`

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

CREATE TABLE "statistics" (
  "mall_name" text,
  "location" text,
  "retail_space_sq_feet_m" text,
  "stores" text,
  "year_opened" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which location has 140 stores?`:
```sql
                SELECT "location" FROM "statistics" WHERE "stores"='140';
```
## Task
Generate a SQL query to answer the following question:
`Which year did the Short Pump Town Center Mall open?`

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

CREATE TABLE "statistics" (
  "mall_name" text,
  "location" text,
  "retail_space_sq_feet_m" text,
  "stores" text,
  "year_opened" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which year did the Short Pump Town Center Mall open?`:
```sql
                SELECT "year_opened" FROM "statistics" WHERE "mall_name"='short pump town center';
```
## Task
Generate a SQL query to answer the following question:
`What is the retail space of the Stony Point Fashion Park Mall?`

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

CREATE TABLE "statistics" (
  "mall_name" text,
  "location" text,
  "retail_space_sq_feet_m" text,
  "stores" text,
  "year_opened" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the retail space of the Stony Point Fashion Park Mall?`:
```sql
                SELECT "retail_space_sq_feet_m" FROM "statistics" WHERE "mall_name"='stony point fashion park';
```
## Task
Generate a SQL query to answer the following question:
`Which Mall has 140 stores?`

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

CREATE TABLE "statistics" (
  "mall_name" text,
  "location" text,
  "retail_space_sq_feet_m" text,
  "stores" text,
  "year_opened" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Mall has 140 stores?`:
```sql
                SELECT "mall_name" FROM "statistics" WHERE "stores"='140';
```
## Task
Generate a SQL query to answer the following question:
`What match was on 30 january 1938?`

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

CREATE TABLE "list_of_derby_del_sole_results" (
  "season" text,
  "match" text,
  "result" text,
  "league" text,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What match was on 30 january 1938?`:
```sql
                SELECT "match" FROM "list_of_derby_del_sole_results" WHERE "date"='30 january 1938';
```
## Task
Generate a SQL query to answer the following question:
`What was the result of the napoli-roma match?`

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

CREATE TABLE "list_of_derby_del_sole_results" (
  "season" text,
  "match" text,
  "result" text,
  "league" text,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the result of the napoli-roma match?`:
```sql
                SELECT "result" FROM "list_of_derby_del_sole_results" WHERE "match"='napoli-roma';
```
## Task
Generate a SQL query to answer the following question:
`What is the player that is from seattle prep?`

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

CREATE TABLE "2006_boys_team" (
  "player" text,
  "height" text,
  "school" text,
  "hometown" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the player that is from seattle prep?`:
```sql
                SELECT "player" FROM "2006_boys_team" WHERE "school"='seattle prep';
```
## Task
Generate a SQL query to answer the following question:
`What is the hometown of the player which has a height of 6-0?`

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

CREATE TABLE "2006_boys_team" (
  "player" text,
  "height" text,
  "school" text,
  "hometown" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the hometown of the player which has a height of 6-0?`:
```sql
                SELECT "hometown" FROM "2006_boys_team" WHERE "height"='6-0';
```
## Task
Generate a SQL query to answer the following question:
`What is the hometown for the player that went to the college of washington`

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

CREATE TABLE "2006_boys_team" (
  "player" text,
  "height" text,
  "school" text,
  "hometown" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the hometown for the player that went to the college of washington`:
```sql
                SELECT "hometown" FROM "2006_boys_team" WHERE "college"='washington';
```
## Task
Generate a SQL query to answer the following question:
`What was the away team's score at Princes Park?`

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

CREATE TABLE "round_15" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the away team's score at Princes Park?`:
```sql
                SELECT "away_team" FROM "round_15" WHERE "venue"='princes park';
```
## Task
Generate a SQL query to answer the following question:
`When did Richmond play an away game against Collingwood?`

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

CREATE TABLE "round_15" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `When did Richmond play an away game against Collingwood?`:
```sql
                SELECT "date" FROM "round_15" WHERE "away_team"='richmond';
```
## Task
Generate a SQL query to answer the following question:
`How many league cup goals on average for players with over 0 FA cup and 5 league goals?`

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

CREATE TABLE "goalscorers" (
  "name" text,
  "league" real,
  "fa_cup" real,
  "league_cup" real,
  "europe" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many league cup goals on average for players with over 0 FA cup and 5 league goals?`:
```sql
                SELECT AVG("league_cup") FROM "goalscorers" WHERE "fa_cup">0 AND "league"=5;
```
## Task
Generate a SQL query to answer the following question:
`What is the low FA cup goals for viduka with under 2 europe goals?`

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

CREATE TABLE "goalscorers" (
  "name" text,
  "league" real,
  "fa_cup" real,
  "league_cup" real,
  "europe" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the low FA cup goals for viduka with under 2 europe goals?`:
```sql
                SELECT MIN("fa_cup") FROM "goalscorers" WHERE "name"='viduka' AND "europe"<2;
```
## Task
Generate a SQL query to answer the following question:
`Who won the most recent favorite rap/hip-hop new artist at the American music awards?`

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

CREATE TABLE "awards_and_nominations" (
  "year" real,
  "association" text,
  "category" text,
  "nominated_work" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who won the most recent favorite rap/hip-hop new artist at the American music awards?`:
```sql
                SELECT MAX("year") FROM "awards_and_nominations" WHERE "association"='american music awards' AND "category"='favorite rap/hip-hop new artist';
```
## Task
Generate a SQL query to answer the following question:
`What is the Date with a Leading scorer with maurice williams (25), and a Score with 102–105?`

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

CREATE TABLE "january" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "leading_scorer" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Date with a Leading scorer with maurice williams (25), and a Score with 102–105?`:
```sql
                SELECT "date" FROM "january" WHERE "leading_scorer"='maurice williams (25)' AND "score"='102–105';
```
## Task
Generate a SQL query to answer the following question:
`What is the Score with a Home with hornets?`

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

CREATE TABLE "january" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "leading_scorer" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Score with a Home with hornets?`:
```sql
                SELECT "score" FROM "january" WHERE "home"='hornets';
```
## Task
Generate a SQL query to answer the following question:
`What is the Score with a Visitor of bucks, and a Leading scorer with maurice williams (25)?`

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

CREATE TABLE "january" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "leading_scorer" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Score with a Visitor of bucks, and a Leading scorer with maurice williams (25)?`:
```sql
                SELECT "score" FROM "january" WHERE "visitor"='bucks' AND "leading_scorer"='maurice williams (25)';
```
## Task
Generate a SQL query to answer the following question:
`What is the Record with a Leading scorer with andrew bogut (29)?`

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

CREATE TABLE "january" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "leading_scorer" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Record with a Leading scorer with andrew bogut (29)?`:
```sql
                SELECT "record" FROM "january" WHERE "leading_scorer"='andrew bogut (29)';
```
## Task
Generate a SQL query to answer the following question:
`What is the Record with a Leading scorer with maurice williams (25), and a Date with 27 january 2008?`

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

CREATE TABLE "january" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "leading_scorer" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Record with a Leading scorer with maurice williams (25), and a Date with 27 january 2008?`:
```sql
                SELECT "record" FROM "january" WHERE "leading_scorer"='maurice williams (25)' AND "date"='27 january 2008';
```
## Task
Generate a SQL query to answer the following question:
`What is the Record with a Score with 80–87, and a Visitor with bucks?`

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

CREATE TABLE "january" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "leading_scorer" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Record with a Score with 80–87, and a Visitor with bucks?`:
```sql
                SELECT "record" FROM "january" WHERE "score"='80–87' AND "visitor"='bucks';
```
## Task
Generate a SQL query to answer the following question:
`What is the nationality of the player Tom Boswell?`

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

CREATE TABLE "b" (
  "player" text,
  "nationality" text,
  "position" text,
  "years_for_jazz" text,
  "school_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the nationality of the player Tom Boswell?`:
```sql
                SELECT "nationality" FROM "b" WHERE "player"='tom boswell';
```
## Task
Generate a SQL query to answer the following question:
`What is the nationality of the player from Duke?`

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

CREATE TABLE "b" (
  "player" text,
  "nationality" text,
  "position" text,
  "years_for_jazz" text,
  "school_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the nationality of the player from Duke?`:
```sql
                SELECT "nationality" FROM "b" WHERE "school_club_team"='duke';
```
## Task
Generate a SQL query to answer the following question:
`What position did the player from Florida International play?`

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

CREATE TABLE "b" (
  "player" text,
  "nationality" text,
  "position" text,
  "years_for_jazz" text,
  "school_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `What position did the player from Florida International play?`:
```sql
                SELECT "position" FROM "b" WHERE "school_club_team"='florida international';
```
## Task
Generate a SQL query to answer the following question:
`What is the nationality of the player from UCLA?`

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

CREATE TABLE "b" (
  "player" text,
  "nationality" text,
  "position" text,
  "years_for_jazz" text,
  "school_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the nationality of the player from UCLA?`:
```sql
                SELECT "nationality" FROM "b" WHERE "school_club_team"='ucla';
```
## Task
Generate a SQL query to answer the following question:
`What was Attendance/G with Tms more than 18?`

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

CREATE TABLE "record_as_j_league_member" (
  "season" real,
  "div" text,
  "tms" real,
  "pos" real,
  "attendance_g" real,
  "emperor_s_cup" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was Attendance/G with Tms more than 18?`:
```sql
                SELECT AVG("attendance_g") FROM "record_as_j_league_member" WHERE "tms">18;
```
## Task
Generate a SQL query to answer the following question:
`How many seasons did the Div J1 have the Emperor's cup in the 3rd round with Tms of more than 18?`

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

CREATE TABLE "record_as_j_league_member" (
  "season" real,
  "div" text,
  "tms" real,
  "pos" real,
  "attendance_g" real,
  "emperor_s_cup" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many seasons did the Div J1 have the Emperor's cup in the 3rd round with Tms of more than 18?`:
```sql
                SELECT COUNT("season") FROM "record_as_j_league_member" WHERE "emperor_s_cup"='3rd round' AND "div"='j1' AND "tms">18;
```
## Task
Generate a SQL query to answer the following question:
`Which chassis had an entrant of John Mecom?`

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

CREATE TABLE "teams_and_drivers" (
  "entrant" text,
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyre" text,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which chassis had an entrant of John Mecom?`:
```sql
                SELECT "chassis" FROM "teams_and_drivers" WHERE "entrant"='john mecom';
```
## Task
Generate a SQL query to answer the following question:
`What tyre was used for an entrant of Ecurie Nationale Suisse?`

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

CREATE TABLE "teams_and_drivers" (
  "entrant" text,
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyre" text,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What tyre was used for an entrant of Ecurie Nationale Suisse?`:
```sql
                SELECT "tyre" FROM "teams_and_drivers" WHERE "entrant"='ecurie nationale suisse';
```
## Task
Generate a SQL query to answer the following question:
`Which rounds was Hap Sharp a driver in?`

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

CREATE TABLE "teams_and_drivers" (
  "entrant" text,
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyre" text,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which rounds was Hap Sharp a driver in?`:
```sql
                SELECT "rounds" FROM "teams_and_drivers" WHERE "driver"='hap sharp';
```
## Task
Generate a SQL query to answer the following question:
`what is the year when the title is jotei?`

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

CREATE TABLE "drama" (
  "year" real,
  "title" text,
  "original_channel" text,
  "role" text,
  "note" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the year when the title is jotei?`:
```sql
                SELECT SUM("year") FROM "drama" WHERE "title"='jotei';
```
## Task
Generate a SQL query to answer the following question:
`what is the original channel when the year is before 2006 and the note is supporting?`

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

CREATE TABLE "drama" (
  "year" real,
  "title" text,
  "original_channel" text,
  "role" text,
  "note" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the original channel when the year is before 2006 and the note is supporting?`:
```sql
                SELECT "original_channel" FROM "drama" WHERE "year"<2006 AND "note"='supporting';
```
## Task
Generate a SQL query to answer the following question:
`what is the original channel when the note is co-star in year 2012?`

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

CREATE TABLE "drama" (
  "year" real,
  "title" text,
  "original_channel" text,
  "role" text,
  "note" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the original channel when the note is co-star in year 2012?`:
```sql
                SELECT "original_channel" FROM "drama" WHERE "note"='co-star' AND "year"=2012;
```
## Task
Generate a SQL query to answer the following question:
`what is the original channel when the year is after 2012?`

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

CREATE TABLE "drama" (
  "year" real,
  "title" text,
  "original_channel" text,
  "role" text,
  "note" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the original channel when the year is after 2012?`:
```sql
                SELECT "original_channel" FROM "drama" WHERE "year">2012;
```
## Task
Generate a SQL query to answer the following question:
`what is the year when the note is supporting and the title is rokumeikan?`

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

CREATE TABLE "drama" (
  "year" real,
  "title" text,
  "original_channel" text,
  "role" text,
  "note" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the year when the note is supporting and the title is rokumeikan?`:
```sql
                SELECT "year" FROM "drama" WHERE "note"='supporting' AND "title"='rokumeikan';
```
## Task
Generate a SQL query to answer the following question:
`what is the title when the year is after 2011 and the original channel is nhk?`

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

CREATE TABLE "drama" (
  "year" real,
  "title" text,
  "original_channel" text,
  "role" text,
  "note" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the title when the year is after 2011 and the original channel is nhk?`:
```sql
                SELECT "title" FROM "drama" WHERE "year">2011 AND "original_channel"='nhk';
```
## Task
Generate a SQL query to answer the following question:
`On which circuit does lorenzo bandini have the fastest lap as well 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 `On which circuit does lorenzo bandini have the fastest lap as well as the pole position?`:
```sql
                SELECT "circuit" FROM "season_review" WHERE "fastest_lap"='lorenzo bandini' AND "pole_position"='lorenzo bandini';
```
## Task
Generate a SQL query to answer the following question:
`At what race does jim clark has a Pole position on the Circuit of monaco?`

### 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 `At what race does jim clark has a Pole position on the Circuit of monaco?`:
```sql
                SELECT "race" FROM "season_review" WHERE "pole_position"='jim clark' AND "circuit"='monaco';
```
## Task
Generate a SQL query to answer the following question:
`Which Report is on the Circuit of reims?`

### 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 Report is on the Circuit of reims?`:
```sql
                SELECT "report" FROM "season_review" WHERE "circuit"='reims';
```
## Task
Generate a SQL query to answer the following question:
`On what Date is there a race on the Circuit of brands hatch?`

### 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 `On what Date is there a race on the Circuit of brands hatch?`:
```sql
                SELECT "date" FROM "season_review" WHERE "circuit"='brands hatch';
```
## Task
Generate a SQL query to answer the following question:
`Who is the Winnning driver in which lorenzo bandini has the fastest lap as well 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 is the Winnning driver in which lorenzo bandini has the fastest lap as well as the Pole position?`:
```sql
                SELECT "winning_driver" FROM "season_review" WHERE "fastest_lap"='lorenzo bandini' AND "pole_position"='lorenzo bandini';
```
## Task
Generate a SQL query to answer the following question:
`On what date is there a Tryre of d at the Circuit of monaco?`

### 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 `On what date is there a Tryre of d at the Circuit of monaco?`:
```sql
                SELECT "date" FROM "season_review" WHERE "tyre"='d' AND "circuit"='monaco';
```
## Task
Generate a SQL query to answer the following question:
`What's the date that Morocco has an Against along with a surface of hard?`

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

CREATE TABLE "singles_17" (
  "edition" text,
  "round" text,
  "date" text,
  "against" text,
  "surface" text,
  "opponent" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the date that Morocco has an Against along with a surface of hard?`:
```sql
                SELECT "date" FROM "singles_17" WHERE "against"='morocco' AND "surface"='hard';
```
## Task
Generate a SQL query to answer the following question:
`What's Round has a Surface of hard and Opponent of Jelena Simic?`

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

CREATE TABLE "singles_17" (
  "edition" text,
  "round" text,
  "date" text,
  "against" text,
  "surface" text,
  "opponent" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's Round has a Surface of hard and Opponent of Jelena Simic?`:
```sql
                SELECT "round" FROM "singles_17" WHERE "surface"='hard' AND "opponent"='jelena simic';
```
## Task
Generate a SQL query to answer the following question:
`What driver won in the xv grand prix de l'albigeois in a vehicle by ferrari?`

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

CREATE TABLE "non_championship_race_results" (
  "race_name" text,
  "circuit" text,
  "date" text,
  "winning_driver" text,
  "constructor" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What driver won in the xv grand prix de l'albigeois in a vehicle by ferrari?`:
```sql
                SELECT "winning_driver" FROM "non_championship_race_results" WHERE "constructor"='ferrari' AND "race_name"='xv grand prix de l''albigeois';
```
## Task
Generate a SQL query to answer the following question:
`What is the latest death with a description of BR-Built inspection saloon?`

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

CREATE TABLE "lms_coaches" (
  "number_name" text,
  "description" text,
  "current_status" text,
  "livery" text,
  "date" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the latest death with a description of BR-Built inspection saloon?`:
```sql
                SELECT MAX("date") FROM "lms_coaches" WHERE "description"='br-built inspection saloon';
```
## Task
Generate a SQL query to answer the following question:
`What is the identifying number for a description of Stanier (Period III) full brake?`

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

CREATE TABLE "lms_coaches" (
  "number_name" text,
  "description" text,
  "current_status" text,
  "livery" text,
  "date" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the identifying number for a description of Stanier (Period III) full brake?`:
```sql
                SELECT "number_name" FROM "lms_coaches" WHERE "description"='stanier (period iii) full brake';
```
## Task
Generate a SQL query to answer the following question:
`What is the date with identifying number of No. 37817?`

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

CREATE TABLE "lms_coaches" (
  "number_name" text,
  "description" text,
  "current_status" text,
  "livery" text,
  "date" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the date with identifying number of No. 37817?`:
```sql
                SELECT "date" FROM "lms_coaches" WHERE "number_name"='no. 37817';
```
## Task
Generate a SQL query to answer the following question:
`What is the release date for the standard cd release format in north america?`

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

CREATE TABLE "formats" (
  "release_format" text,
  "country" text,
  "label_s" text,
  "cat_no" text,
  "release_date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the release date for the standard cd release format in north america?`:
```sql
                SELECT "release_date" FROM "formats" WHERE "release_format"='standard cd' AND "country"='north america';
```
## Task
Generate a SQL query to answer the following question:
`What is  the cat no for the label mute and the standard cd format?`

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

CREATE TABLE "formats" (
  "release_format" text,
  "country" text,
  "label_s" text,
  "cat_no" text,
  "release_date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is  the cat no for the label mute and the standard cd format?`:
```sql
                SELECT "cat_no" FROM "formats" WHERE "label_s"='mute' AND "release_format"='standard cd';
```
## Task
Generate a SQL query to answer the following question:
`What is the overall rank with rating smaller than 8.2 and rating share of 4.5/11?`

### 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,
  "rating" real,
  "share" real,
  "rating_share_18_49" text,
  "viewers_m" real,
  "timeslot_rank" real,
  "night_rank" text,
  "overall_rank" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the overall rank with rating smaller than 8.2 and rating share of 4.5/11?`:
```sql
                SELECT COUNT("overall_rank") FROM "weekly_ratings" WHERE "rating_share_18_49"='4.5/11' AND "rating"<8.2;
```
## Task
Generate a SQL query to answer the following question:
`What is the rating for the episode with the night rank of 11 and timeslot rank is larger 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,
  "rating" real,
  "share" real,
  "rating_share_18_49" text,
  "viewers_m" real,
  "timeslot_rank" real,
  "night_rank" text,
  "overall_rank" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the rating for the episode with the night rank of 11 and timeslot rank is larger than 4?`:
```sql
                SELECT AVG("rating") FROM "weekly_ratings" WHERE "night_rank"='11' AND "timeslot_rank">4;
```
## Task
Generate a SQL query to answer the following question:
`What is the smallest share for a timeslot ranking less than 4 and fewer viewers than 8.78 million?`

### 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,
  "rating" real,
  "share" real,
  "rating_share_18_49" text,
  "viewers_m" real,
  "timeslot_rank" real,
  "night_rank" text,
  "overall_rank" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the smallest share for a timeslot ranking less than 4 and fewer viewers than 8.78 million?`:
```sql
                SELECT MIN("share") FROM "weekly_ratings" WHERE "viewers_m"<8.78 AND "timeslot_rank"<4;
```
## Task
Generate a SQL query to answer the following question:
`What is the rating of the episode with 13.47 million viewers and overall rank larger than 6?`

### 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,
  "rating" real,
  "share" real,
  "rating_share_18_49" text,
  "viewers_m" real,
  "timeslot_rank" real,
  "night_rank" text,
  "overall_rank" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the rating of the episode with 13.47 million viewers and overall rank larger than 6?`:
```sql
                SELECT SUM("rating") FROM "weekly_ratings" WHERE "viewers_m"=13.47 AND "overall_rank">6;
```
## Task
Generate a SQL query to answer the following question:
`What is the rank of the episode with a share of 6 and timeslot rank smaller 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,
  "rating" real,
  "share" real,
  "rating_share_18_49" text,
  "viewers_m" real,
  "timeslot_rank" real,
  "night_rank" text,
  "overall_rank" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the rank of the episode with a share of 6 and timeslot rank smaller than 4?`:
```sql
                SELECT AVG("overall_rank") FROM "weekly_ratings" WHERE "share"=6 AND "timeslot_rank"<4;
```
## Task
Generate a SQL query to answer the following question:
`How many premierships for the queensland raceway?`

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

CREATE TABLE "brisbane_based" (
  "club_team" text,
  "league" text,
  "venue" text,
  "established" real,
  "premierships" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many premierships for the queensland raceway?`:
```sql
                SELECT "premierships" FROM "brisbane_based" WHERE "venue"='queensland raceway';
```
## Task
Generate a SQL query to answer the following question:
`How many premierships for the commonwealth bank trophy league?`

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

CREATE TABLE "brisbane_based" (
  "club_team" text,
  "league" text,
  "venue" text,
  "established" real,
  "premierships" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many premierships for the commonwealth bank trophy league?`:
```sql
                SELECT "premierships" FROM "brisbane_based" WHERE "league"='commonwealth bank trophy';
```
## Task
Generate a SQL query to answer the following question:
`In which round was there a pick of 4?`

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

CREATE TABLE "nfl_draft" (
  "pick" real,
  "round" real,
  "player" text,
  "position" text,
  "school" text
);
### SQL
Given the database schema, here is the SQL query that answers `In which round was there a pick of 4?`:
```sql
                SELECT MAX("round") FROM "nfl_draft" WHERE "pick"=4;
```
## Task
Generate a SQL query to answer the following question:
`How many rounds were there an offensive tackle position?`

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

CREATE TABLE "nfl_draft" (
  "pick" real,
  "round" real,
  "player" text,
  "position" text,
  "school" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many rounds were there an offensive tackle position?`:
```sql
                SELECT COUNT("round") FROM "nfl_draft" WHERE "position"='offensive tackle';
```
## Task
Generate a SQL query to answer the following question:
`What was the pick number in round 228 for Mike Ford?`

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

CREATE TABLE "nfl_draft" (
  "pick" real,
  "round" real,
  "player" text,
  "position" text,
  "school" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the pick number in round 228 for Mike Ford?`:
```sql
                SELECT MAX("pick") FROM "nfl_draft" WHERE "player"='mike ford' AND "round">228;
```
## Task
Generate a SQL query to answer the following question:
`What year was E. Meyer the driver?`

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

CREATE TABLE "winners_of_the_moroccan_grand_prix" (
  "year" text,
  "driver" text,
  "constructor" text,
  "category" text,
  "location" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year was E. Meyer the driver?`:
```sql
                SELECT "year" FROM "winners_of_the_moroccan_grand_prix" WHERE "driver"='e. meyer';
```