cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`Which Game has an Opponent of detroit red wings, and a March smaller than 12?`

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

CREATE TABLE "regular_season" (
  "game" real,
  "march" real,
  "opponent" text,
  "score" text,
  "record" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Game has an Opponent of detroit red wings, and a March smaller than 12?`:
```sql
                SELECT COUNT("game") FROM "regular_season" WHERE "opponent"='detroit red wings' AND "march"<12;
```
## Task
Generate a SQL query to answer the following question:
`Which Points have a Game smaller than 70, and a Score of 4–8?`

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

CREATE TABLE "regular_season" (
  "game" real,
  "march" real,
  "opponent" text,
  "score" text,
  "record" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Points have a Game smaller than 70, and a Score of 4–8?`:
```sql
                SELECT MIN("points") FROM "regular_season" WHERE "game"<70 AND "score"='4–8';
```
## Task
Generate a SQL query to answer the following question:
`Which segment a's Netflix is S05E22?`

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

CREATE TABLE "season_10_2007_2008" (
  "series_ep" text,
  "episode" real,
  "netflix" text,
  "segment_a" text,
  "segment_b" text,
  "segment_c" text,
  "segment_d" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which segment a's Netflix is S05E22?`:
```sql
                SELECT "segment_a" FROM "season_10_2007_2008" WHERE "netflix"='s05e22';
```
## Task
Generate a SQL query to answer the following question:
`Which series episode has a segment c that is Electric pole s transformer?`

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

CREATE TABLE "season_10_2007_2008" (
  "series_ep" text,
  "episode" real,
  "netflix" text,
  "segment_a" text,
  "segment_b" text,
  "segment_c" text,
  "segment_d" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which series episode has a segment c that is Electric pole s transformer?`:
```sql
                SELECT "series_ep" FROM "season_10_2007_2008" WHERE "segment_c"='electric pole s transformer';
```
## Task
Generate a SQL query to answer the following question:
`What largest episode number's Netflix is S05E23?`

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

CREATE TABLE "season_10_2007_2008" (
  "series_ep" text,
  "episode" real,
  "netflix" text,
  "segment_a" text,
  "segment_b" text,
  "segment_c" text,
  "segment_d" text
);
### SQL
Given the database schema, here is the SQL query that answers `What largest episode number's Netflix is S05E23?`:
```sql
                SELECT MAX("episode") FROM "season_10_2007_2008" WHERE "netflix"='s05e23';
```
## Task
Generate a SQL query to answer the following question:
`Which segment c's segment b is refrigerators?`

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

CREATE TABLE "season_10_2007_2008" (
  "series_ep" text,
  "episode" real,
  "netflix" text,
  "segment_a" text,
  "segment_b" text,
  "segment_c" text,
  "segment_d" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which segment c's segment b is refrigerators?`:
```sql
                SELECT "segment_c" FROM "season_10_2007_2008" WHERE "segment_b"='refrigerators';
```
## Task
Generate a SQL query to answer the following question:
`Which races did they accumulate at least 125 points?`

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

CREATE TABLE "career_summary" (
  "season" text,
  "series" text,
  "team" text,
  "races" text,
  "wins" text,
  "points" text,
  "position" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which races did they accumulate at least 125 points?`:
```sql
                SELECT "races" FROM "career_summary" WHERE "points"='125';
```
## Task
Generate a SQL query to answer the following question:
`Which Series has a Score of 3 – 8?`

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

CREATE TABLE "playoffs" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "decision" text,
  "attendance" real,
  "series" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Series has a Score of 3 – 8?`:
```sql
                SELECT "series" FROM "playoffs" WHERE "score"='3 – 8';
```
## Task
Generate a SQL query to answer the following question:
`Which Date has a Decision of myre?`

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

CREATE TABLE "playoffs" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "decision" text,
  "attendance" real,
  "series" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Date has a Decision of myre?`:
```sql
                SELECT "date" FROM "playoffs" WHERE "decision"='myre';
```
## Task
Generate a SQL query to answer the following question:
`How many Attendances on may 24?`

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

CREATE TABLE "playoffs" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "decision" text,
  "attendance" real,
  "series" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many Attendances on may 24?`:
```sql
                SELECT MIN("attendance") FROM "playoffs" WHERE "date"='may 24';
```
## Task
Generate a SQL query to answer the following question:
`Which Series are on may 18?`

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

CREATE TABLE "playoffs" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "decision" text,
  "attendance" real,
  "series" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Series are on may 18?`:
```sql
                SELECT "series" FROM "playoffs" WHERE "date"='may 18';
```
## Task
Generate a SQL query to answer the following question:
`How many Attendances that has a Visitor of philadelphia on may 20?`

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

CREATE TABLE "playoffs" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "decision" text,
  "attendance" real,
  "series" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many Attendances that has a Visitor of philadelphia on may 20?`:
```sql
                SELECT AVG("attendance") FROM "playoffs" WHERE "visitor"='philadelphia' AND "date"='may 20';
```
## Task
Generate a SQL query to answer the following question:
`who is the Visitor that has a Series of series tied 2–2?`

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

CREATE TABLE "playoffs" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "decision" text,
  "attendance" real,
  "series" text
);
### SQL
Given the database schema, here is the SQL query that answers `who is the Visitor that has a Series of series tied 2–2?`:
```sql
                SELECT "visitor" FROM "playoffs" WHERE "series"='series tied 2–2';
```
## Task
Generate a SQL query to answer the following question:
`How many Attendances have a Score of 4 – 5? Question 4`

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

CREATE TABLE "playoffs" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "decision" text,
  "attendance" real,
  "series" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many Attendances have a Score of 4 – 5? Question 4`:
```sql
                SELECT MAX("attendance") FROM "playoffs" WHERE "score"='4 – 5';
```
## Task
Generate a SQL query to answer the following question:
`WHo has a Home of philadelphia and a Series of flyers lead 1–0?`

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

CREATE TABLE "playoffs" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "decision" text,
  "attendance" real,
  "series" text
);
### SQL
Given the database schema, here is the SQL query that answers `WHo has a Home of philadelphia and a Series of flyers lead 1–0?`:
```sql
                SELECT "visitor" FROM "playoffs" WHERE "home"='philadelphia' AND "series"='flyers lead 1–0';
```
## Task
Generate a SQL query to answer the following question:
`What is the class of the Charlotte Camel gt 500 race?`

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

CREATE TABLE "schedule" (
  "race" text,
  "length" text,
  "class" text,
  "circuit" text,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the class of the Charlotte Camel gt 500 race?`:
```sql
                SELECT "class" FROM "schedule" WHERE "race"='charlotte camel gt 500';
```
## Task
Generate a SQL query to answer the following question:
`What is the race 12 hours in length?`

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

CREATE TABLE "schedule" (
  "race" text,
  "length" text,
  "class" text,
  "circuit" text,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the race 12 hours in length?`:
```sql
                SELECT "race" FROM "schedule" WHERE "length"='12 hours';
```
## Task
Generate a SQL query to answer the following question:
`What is the class of the Coca-cola classic 12 hours of sebring race?`

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

CREATE TABLE "schedule" (
  "race" text,
  "length" text,
  "class" text,
  "circuit" text,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the class of the Coca-cola classic 12 hours of sebring race?`:
```sql
                SELECT "class" FROM "schedule" WHERE "race"='coca-cola classic 12 hours of sebring';
```
## Task
Generate a SQL query to answer the following question:
`What is the class of the Budweiser Grand Prix of Miami race with a length of 3 hours?`

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

CREATE TABLE "schedule" (
  "race" text,
  "length" text,
  "class" text,
  "circuit" text,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the class of the Budweiser Grand Prix of Miami race with a length of 3 hours?`:
```sql
                SELECT "class" FROM "schedule" WHERE "race"='budweiser grand prix of miami' AND "length"='3 hours';
```
## Task
Generate a SQL query to answer the following question:
`What is the date of the Paul Revere 250 race in the Daytona International Speedway circuit?`

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

CREATE TABLE "schedule" (
  "race" text,
  "length" text,
  "class" text,
  "circuit" text,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the date of the Paul Revere 250 race in the Daytona International Speedway circuit?`:
```sql
                SELECT "date" FROM "schedule" WHERE "circuit"='daytona international speedway' AND "race"='paul revere 250';
```
## Task
Generate a SQL query to answer the following question:
`What race is 12 hours in length?`

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

CREATE TABLE "schedule" (
  "race" text,
  "length" text,
  "class" text,
  "circuit" text,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What race is 12 hours in length?`:
```sql
                SELECT "race" FROM "schedule" WHERE "length"='12 hours';
```
## Task
Generate a SQL query to answer the following question:
`What is the highest round for the pick from Finland?`

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

CREATE TABLE "nhl_draft" (
  "round" real,
  "player" text,
  "position" text,
  "nationality" text,
  "college_junior_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest round for the pick from Finland?`:
```sql
                SELECT MAX("round") FROM "nhl_draft" WHERE "nationality"='finland';
```
## Task
Generate a SQL query to answer the following question:
`What is the total number of rounds that Joe Barnes was picked?`

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

CREATE TABLE "nhl_draft" (
  "round" real,
  "player" text,
  "position" text,
  "nationality" text,
  "college_junior_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of rounds that Joe Barnes was picked?`:
```sql
                SELECT COUNT("round") FROM "nhl_draft" WHERE "player"='joe barnes';
```
## Task
Generate a SQL query to answer the following question:
`What is the total 2nd of Thomas Morgenstern, who has a 1st less than 132.5?`

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

CREATE TABLE "engelberg" (
  "rank" real,
  "name" text,
  "nationality" text,
  "1st_m" real,
  "2nd_m" real,
  "points" real,
  "overall_wc_points_rank" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total 2nd of Thomas Morgenstern, who has a 1st less than 132.5?`:
```sql
                SELECT COUNT("2nd_m") FROM "engelberg" WHERE "name"='thomas morgenstern' AND "1st_m"<132.5;
```
## Task
Generate a SQL query to answer the following question:
`What was the order of the Tokyo olympic games?`

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

CREATE TABLE "iaba_olympic_medals" (
  "order" text,
  "year" real,
  "olympic_games" text,
  "medal" text,
  "weight" text,
  "boxer" text,
  "club" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the order of the Tokyo olympic games?`:
```sql
                SELECT "order" FROM "iaba_olympic_medals" WHERE "olympic_games"='tokyo';
```
## Task
Generate a SQL query to answer the following question:
`What was the 15th club in 2012?`

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

CREATE TABLE "iaba_olympic_medals" (
  "order" text,
  "year" real,
  "olympic_games" text,
  "medal" text,
  "weight" text,
  "boxer" text,
  "club" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the 15th club in 2012?`:
```sql
                SELECT "club" FROM "iaba_olympic_medals" WHERE "year"=2012 AND "order"='15th';
```
## Task
Generate a SQL query to answer the following question:
`What medal did Michael Conlon, with a weight of fly, win?`

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

CREATE TABLE "iaba_olympic_medals" (
  "order" text,
  "year" real,
  "olympic_games" text,
  "medal" text,
  "weight" text,
  "boxer" text,
  "club" text
);
### SQL
Given the database schema, here is the SQL query that answers `What medal did Michael Conlon, with a weight of fly, win?`:
```sql
                SELECT "medal" FROM "iaba_olympic_medals" WHERE "weight"='fly' AND "boxer"='michael conlon';
```
## Task
Generate a SQL query to answer the following question:
`How many losses have more than 45,036 attendance?`

### 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 `How many losses have more than 45,036 attendance?`:
```sql
                SELECT "loss" FROM "game_log" WHERE "attendance">'45,036';
```
## Task
Generate a SQL query to answer the following question:
`on april 29, what was the attendance?`

### 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 `on april 29, what was the attendance?`:
```sql
                SELECT SUM("attendance") FROM "game_log" WHERE "date"='april 29';
```
## Task
Generate a SQL query to answer the following question:
`on april 9 what was the attendance?`

### 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 `on april 9 what was the attendance?`:
```sql
                SELECT AVG("attendance") FROM "game_log" WHERE "date"='april 9';
```
## Task
Generate a SQL query to answer the following question:
`What date has postponed (rain) rescheduled for august 7 as the score?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date has postponed (rain) rescheduled for august 7 as the score?`:
```sql
                SELECT "date" FROM "game_log" WHERE "score"='postponed (rain) rescheduled for august 7';
```
## Task
Generate a SQL query to answer the following question:
`Failures larger than 0, and a Successes of 1 has what lowest partial failures?`

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

CREATE TABLE "by_country" (
  "country" text,
  "launches" real,
  "successes" real,
  "failures" real,
  "partial_failures" real
);
### SQL
Given the database schema, here is the SQL query that answers `Failures larger than 0, and a Successes of 1 has what lowest partial failures?`:
```sql
                SELECT MIN("partial_failures") FROM "by_country" WHERE "failures">0 AND "successes"=1;
```
## Task
Generate a SQL query to answer the following question:
`Successes smaller than 6, and Launches larger than 1, and a Failures of 2 is what sum of the partial failures?`

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

CREATE TABLE "by_country" (
  "country" text,
  "launches" real,
  "successes" real,
  "failures" real,
  "partial_failures" real
);
### SQL
Given the database schema, here is the SQL query that answers `Successes smaller than 6, and Launches larger than 1, and a Failures of 2 is what sum of the partial failures?`:
```sql
                SELECT SUM("partial_failures") FROM "by_country" WHERE "successes"<6 AND "launches">1 AND "failures"=2;
```
## Task
Generate a SQL query to answer the following question:
`Who was the opposing team during a game in the Pontiac Silverdome?`

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

CREATE TABLE "game_log" (
  "game" real,
  "date" text,
  "opponent" text,
  "score" text,
  "location" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the opposing team during a game in the Pontiac Silverdome?`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "location"='pontiac silverdome';
```
## Task
Generate a SQL query to answer the following question:
`What was the final score for the January 23 game?`

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

CREATE TABLE "game_log" (
  "game" real,
  "date" text,
  "opponent" text,
  "score" text,
  "location" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the final score for the January 23 game?`:
```sql
                SELECT "score" FROM "game_log" WHERE "date"='january 23';
```
## Task
Generate a SQL query to answer the following question:
`What is the highest Feb value having an opponent of the Philadelphia Flyers and is after game 63?`

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

CREATE TABLE "schedule_and_results" (
  "game" real,
  "february" real,
  "opponent" text,
  "score" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest Feb value having an opponent of the Philadelphia Flyers and is after game 63?`:
```sql
                SELECT MAX("february") FROM "schedule_and_results" WHERE "opponent"='philadelphia flyers' AND "game">63;
```
## Task
Generate a SQL query to answer the following question:
`Who was the opponent in games over 58, after Feb 16, and having a record of 40-20-4?`

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

CREATE TABLE "schedule_and_results" (
  "game" real,
  "february" real,
  "opponent" text,
  "score" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the opponent in games over 58, after Feb 16, and having a record of 40-20-4?`:
```sql
                SELECT "opponent" FROM "schedule_and_results" WHERE "game">58 AND "february">16 AND "record"='40-20-4';
```
## Task
Generate a SQL query to answer the following question:
`Which Year has a Genre of rock (track)?`

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

CREATE TABLE "grammy_hall_of_fame" (
  "year" real,
  "title" text,
  "genre" text,
  "label" text,
  "year_inducted" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Year has a Genre of rock (track)?`:
```sql
                SELECT SUM("year") FROM "grammy_hall_of_fame" WHERE "genre"='rock (track)';
```
## Task
Generate a SQL query to answer the following question:
`Which Year Inducted is the highest one that has a Year smaller than 1965?`

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

CREATE TABLE "grammy_hall_of_fame" (
  "year" real,
  "title" text,
  "genre" text,
  "label" text,
  "year_inducted" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Year Inducted is the highest one that has a Year smaller than 1965?`:
```sql
                SELECT MAX("year_inducted") FROM "grammy_hall_of_fame" WHERE "year"<1965;
```
## Task
Generate a SQL query to answer the following question:
`Which Overall is the highest one that has a Pick # smaller than 9, and a Name of mike pearson?`

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

CREATE TABLE "jacksonville_jaguars_draft_history" (
  "round" real,
  "pick_num" real,
  "overall" real,
  "name" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Overall is the highest one that has a Pick # smaller than 9, and a Name of mike pearson?`:
```sql
                SELECT MAX("overall") FROM "jacksonville_jaguars_draft_history" WHERE "pick_num"<9 AND "name"='mike pearson';
```
## Task
Generate a SQL query to answer the following question:
`Which Round is the lowest one that has a Position of wide receiver, and an Overall smaller than 222?`

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

CREATE TABLE "jacksonville_jaguars_draft_history" (
  "round" real,
  "pick_num" real,
  "overall" real,
  "name" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Round is the lowest one that has a Position of wide receiver, and an Overall smaller than 222?`:
```sql
                SELECT MIN("round") FROM "jacksonville_jaguars_draft_history" WHERE "position"='wide receiver' AND "overall"<222;
```
## Task
Generate a SQL query to answer the following question:
`What was the Record on September 21?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "save" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the Record on September 21?`:
```sql
                SELECT "record" FROM "game_log" WHERE "date"='september 21';
```
## Task
Generate a SQL query to answer the following question:
`What was the record the day David Weathers (15) had a save?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "save" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the record the day David Weathers (15) had a save?`:
```sql
                SELECT "record" FROM "game_log" WHERE "save"='david weathers (15)';
```
## Task
Generate a SQL query to answer the following question:
`Who had a save on September 2?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "save" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who had a save on September 2?`:
```sql
                SELECT "save" FROM "game_log" WHERE "date"='september 2';
```
## Task
Generate a SQL query to answer the following question:
`What was the loss on September 2?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "save" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the loss on September 2?`:
```sql
                SELECT "loss" FROM "game_log" WHERE "date"='september 2';
```
## Task
Generate a SQL query to answer the following question:
`What is the total number of byes that are associated with 1 draw, 5 wins, and fewer than 12 losses?`

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

CREATE TABLE "2010_ladder" (
  "ntfa_div_1" text,
  "wins" real,
  "byes" real,
  "losses" real,
  "draws" real,
  "against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of byes that are associated with 1 draw, 5 wins, and fewer than 12 losses?`:
```sql
                SELECT SUM("byes") FROM "2010_ladder" WHERE "draws"=1 AND "wins"=5 AND "losses"<12;
```
## Task
Generate a SQL query to answer the following question:
`What is the total number of byes associated with fewer than 8 wins and fewer than 1 draw?`

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

CREATE TABLE "2010_ladder" (
  "ntfa_div_1" text,
  "wins" real,
  "byes" real,
  "losses" real,
  "draws" real,
  "against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of byes associated with fewer than 8 wins and fewer than 1 draw?`:
```sql
                SELECT COUNT("byes") FROM "2010_ladder" WHERE "draws"<1 AND "wins"<8;
```
## Task
Generate a SQL query to answer the following question:
`What is the NTFA Div 1 team that has 15 wins and less than 1 draw?`

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

CREATE TABLE "2010_ladder" (
  "ntfa_div_1" text,
  "wins" real,
  "byes" real,
  "losses" real,
  "draws" real,
  "against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the NTFA Div 1 team that has 15 wins and less than 1 draw?`:
```sql
                SELECT "ntfa_div_1" FROM "2010_ladder" WHERE "draws"<1 AND "wins"=15;
```
## Task
Generate a SQL query to answer the following question:
`What is the average number of losses for teams with 0 draws and 0 byes?`

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

CREATE TABLE "2010_ladder" (
  "ntfa_div_1" text,
  "wins" real,
  "byes" real,
  "losses" real,
  "draws" real,
  "against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average number of losses for teams with 0 draws and 0 byes?`:
```sql
                SELECT AVG("losses") FROM "2010_ladder" WHERE "draws"=0 AND "byes"<0;
```
## Task
Generate a SQL query to answer the following question:
`What is the most number of losses for teams with 5 wins and an against value under 1607?`

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

CREATE TABLE "2010_ladder" (
  "ntfa_div_1" text,
  "wins" real,
  "byes" real,
  "losses" real,
  "draws" real,
  "against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the most number of losses for teams with 5 wins and an against value under 1607?`:
```sql
                SELECT MAX("losses") FROM "2010_ladder" WHERE "wins"=5 AND "against"<1607;
```
## Task
Generate a SQL query to answer the following question:
`Race that has a Podium larger than 1, and a Season of 1982, and a flap smaller than 1 had how many number of races?`

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

CREATE TABLE "by_season" (
  "season" text,
  "race" real,
  "podium" real,
  "pole" real,
  "f_lap" real
);
### SQL
Given the database schema, here is the SQL query that answers `Race that has a Podium larger than 1, and a Season of 1982, and a flap smaller than 1 had how many number of races?`:
```sql
                SELECT COUNT("race") FROM "by_season" WHERE "podium">1 AND "season"='1982' AND "f_lap"<1;
```
## Task
Generate a SQL query to answer the following question:
`Pole smaller than 0 had what lowest podium?`

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

CREATE TABLE "by_season" (
  "season" text,
  "race" real,
  "podium" real,
  "pole" real,
  "f_lap" real
);
### SQL
Given the database schema, here is the SQL query that answers `Pole smaller than 0 had what lowest podium?`:
```sql
                SELECT MIN("podium") FROM "by_season" WHERE "pole"<0;
```
## Task
Generate a SQL query to answer the following question:
`Flap of 0, and a Race smaller than 2, and a Season of 1989, and a Pole smaller than 0 had what average podium?`

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

CREATE TABLE "by_season" (
  "season" text,
  "race" real,
  "podium" real,
  "pole" real,
  "f_lap" real
);
### SQL
Given the database schema, here is the SQL query that answers `Flap of 0, and a Race smaller than 2, and a Season of 1989, and a Pole smaller than 0 had what average podium?`:
```sql
                SELECT AVG("podium") FROM "by_season" WHERE "f_lap"=0 AND "race"<2 AND "season"='1989' AND "pole"<0;
```
## Task
Generate a SQL query to answer the following question:
`What was the record on august 24?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "stadium" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the record on august 24?`:
```sql
                SELECT "record" FROM "game_log" WHERE "date"='august 24';
```
## Task
Generate a SQL query to answer the following question:
`Elevation of 11,158 feet 3401 m had what route?`

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

CREATE TABLE "colorado_highway_summits_not_on_a_pass" (
  "rank" real,
  "highway" text,
  "elevation" text,
  "surface" text,
  "route" real
);
### SQL
Given the database schema, here is the SQL query that answers `Elevation of 11,158 feet 3401 m had what route?`:
```sql
                SELECT "route" FROM "colorado_highway_summits_not_on_a_pass" WHERE "elevation"='11,158 feet 3401 m';
```
## Task
Generate a SQL query to answer the following question:
`Route larger than 24, and a Highway of trail ridge road had what elevation?`

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

CREATE TABLE "colorado_highway_summits_not_on_a_pass" (
  "rank" real,
  "highway" text,
  "elevation" text,
  "surface" text,
  "route" real
);
### SQL
Given the database schema, here is the SQL query that answers `Route larger than 24, and a Highway of trail ridge road had what elevation?`:
```sql
                SELECT "elevation" FROM "colorado_highway_summits_not_on_a_pass" WHERE "route">24 AND "highway"='trail ridge road';
```
## Task
Generate a SQL query to answer the following question:
`Elevation of 12,183 feet 3713 m is what average route?`

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

CREATE TABLE "colorado_highway_summits_not_on_a_pass" (
  "rank" real,
  "highway" text,
  "elevation" text,
  "surface" text,
  "route" real
);
### SQL
Given the database schema, here is the SQL query that answers `Elevation of 12,183 feet 3713 m is what average route?`:
```sql
                SELECT AVG("route") FROM "colorado_highway_summits_not_on_a_pass" WHERE "elevation"='12,183 feet 3713 m';
```
## Task
Generate a SQL query to answer the following question:
`What Opponent has a Results¹ of 1:3?`

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

CREATE TABLE "1982" (
  "date" text,
  "city" text,
  "opponent" text,
  "results" text,
  "type_of_game" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Opponent has a Results¹ of 1:3?`:
```sql
                SELECT "opponent" FROM "1982" WHERE "results"='1:3';
```
## Task
Generate a SQL query to answer the following question:
`On what Date was the Results¹ 1:2?`

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

CREATE TABLE "1982" (
  "date" text,
  "city" text,
  "opponent" text,
  "results" text,
  "type_of_game" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what Date was the Results¹ 1:2?`:
```sql
                SELECT "date" FROM "1982" WHERE "results"='1:2';
```
## Task
Generate a SQL query to answer the following question:
`What City had Results¹ of 1:2?`

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

CREATE TABLE "1982" (
  "date" text,
  "city" text,
  "opponent" text,
  "results" text,
  "type_of_game" text
);
### SQL
Given the database schema, here is the SQL query that answers `What City had Results¹ of 1:2?`:
```sql
                SELECT "city" FROM "1982" WHERE "results"='1:2';
```
## Task
Generate a SQL query to answer the following question:
`On what Date was Wales the Opponent?`

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

CREATE TABLE "1982" (
  "date" text,
  "city" text,
  "opponent" text,
  "results" text,
  "type_of_game" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what Date was Wales the Opponent?`:
```sql
                SELECT "date" FROM "1982" WHERE "opponent"='wales';
```
## Task
Generate a SQL query to answer the following question:
`In what City was Bulgaria the Opponent with Results¹ of 1:0?`

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

CREATE TABLE "1982" (
  "date" text,
  "city" text,
  "opponent" text,
  "results" text,
  "type_of_game" text
);
### SQL
Given the database schema, here is the SQL query that answers `In what City was Bulgaria the Opponent with Results¹ of 1:0?`:
```sql
                SELECT "city" FROM "1982" WHERE "results"='1:0' AND "opponent"='bulgaria';
```
## Task
Generate a SQL query to answer the following question:
`What Vancouver canucks game was on a date closest to November 4?`

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

CREATE TABLE "regular_season" (
  "game" real,
  "november" real,
  "opponent" text,
  "score" text,
  "record" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What Vancouver canucks game was on a date closest to November 4?`:
```sql
                SELECT MAX("game") FROM "regular_season" WHERE "opponent"='vancouver canucks' AND "november"<4;
```
## Task
Generate a SQL query to answer the following question:
`Name the year for jerry sichting`

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

CREATE TABLE "1990s" (
  "year" text,
  "flagship_station" text,
  "play_by_play" text,
  "color_commentator_s" text,
  "studio_host" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the year for jerry sichting`:
```sql
                SELECT "year" FROM "1990s" WHERE "color_commentator_s"='jerry sichting';
```
## Task
Generate a SQL query to answer the following question:
`Name the studio host for glenn ordway and jerry sichting with year of 1993-94`

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

CREATE TABLE "1990s" (
  "year" text,
  "flagship_station" text,
  "play_by_play" text,
  "color_commentator_s" text,
  "studio_host" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the studio host for glenn ordway and jerry sichting with year of 1993-94`:
```sql
                SELECT "studio_host" FROM "1990s" WHERE "play_by_play"='glenn ordway' AND "color_commentator_s"='jerry sichting' AND "year"='1993-94';
```
## Task
Generate a SQL query to answer the following question:
`Name the flagship station for cedric maxwell and year of 1995-96`

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

CREATE TABLE "1990s" (
  "year" text,
  "flagship_station" text,
  "play_by_play" text,
  "color_commentator_s" text,
  "studio_host" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the flagship station for cedric maxwell and year of 1995-96`:
```sql
                SELECT "flagship_station" FROM "1990s" WHERE "color_commentator_s"='cedric maxwell' AND "year"='1995-96';
```
## Task
Generate a SQL query to answer the following question:
`Who was the architect of the 10 floor building with a height of 42 M?`

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

CREATE TABLE "manitoba" (
  "building" text,
  "height_m" real,
  "floors" real,
  "built" real,
  "city" text,
  "architect" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the architect of the 10 floor building with a height of 42 M?`:
```sql
                SELECT "architect" FROM "manitoba" WHERE "height_m"=42 AND "floors"=10;
```
## Task
Generate a SQL query to answer the following question:
`What is the height of the building built by architects Ross and Macfarlane?`

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

CREATE TABLE "manitoba" (
  "building" text,
  "height_m" real,
  "floors" real,
  "built" real,
  "city" text,
  "architect" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the height of the building built by architects Ross and Macfarlane?`:
```sql
                SELECT "height_m" FROM "manitoba" WHERE "architect"='ross and macfarlane';
```
## Task
Generate a SQL query to answer the following question:
`Who was the architect that built the Electric Railway Chambers before 1915?`

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

CREATE TABLE "manitoba" (
  "building" text,
  "height_m" real,
  "floors" real,
  "built" real,
  "city" text,
  "architect" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the architect that built the Electric Railway Chambers before 1915?`:
```sql
                SELECT "architect" FROM "manitoba" WHERE "built"<1915 AND "building"='electric railway chambers';
```
## Task
Generate a SQL query to answer the following question:
`What is the Time on july 18 that has a Loss of lilly (3-3)?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "time" text,
  "att" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Time on july 18 that has a Loss of lilly (3-3)?`:
```sql
                SELECT "time" FROM "game_log" WHERE "date"='july 18' AND "loss"='lilly (3-3)';
```
## Task
Generate a SQL query to answer the following question:
`Which Opponent has a Record of 43-56?`

### 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,
  "time" text,
  "att" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Opponent has a Record of 43-56?`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "record"='43-56';
```
## Task
Generate a SQL query to answer the following question:
`What is the Score on July 18 that has Record of 41-51?`

### 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,
  "time" text,
  "att" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Score on July 18 that has Record of 41-51?`:
```sql
                SELECT "score" FROM "game_log" WHERE "date"='july 18' AND "record"='41-51';
```
## Task
Generate a SQL query to answer the following question:
`Which Record is on july 31?`

### 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,
  "time" text,
  "att" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Record is on july 31?`:
```sql
                SELECT "record" FROM "game_log" WHERE "date"='july 31';
```
## Task
Generate a SQL query to answer the following question:
`Which Opponent has a Loss of weaver (9-9)?`

### 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,
  "time" text,
  "att" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Opponent has a Loss of weaver (9-9)?`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "loss"='weaver (9-9)';
```
## Task
Generate a SQL query to answer the following question:
`Which Season was the Poles greater than 14?`

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

CREATE TABLE "highest_percentage_of_pole_positions_in_" (
  "driver" text,
  "season" real,
  "races" real,
  "poles" real,
  "percentage" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Season was the Poles greater than 14?`:
```sql
                SELECT "season" FROM "highest_percentage_of_pole_positions_in_" WHERE "poles">14;
```
## Task
Generate a SQL query to answer the following question:
`Which is the highest Season with a Percentage of 67% and Alberto Ascari as a Driver?`

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

CREATE TABLE "highest_percentage_of_pole_positions_in_" (
  "driver" text,
  "season" real,
  "races" real,
  "poles" real,
  "percentage" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which is the highest Season with a Percentage of 67% and Alberto Ascari as a Driver?`:
```sql
                SELECT MAX("season") FROM "highest_percentage_of_pole_positions_in_" WHERE "percentage"='67%' AND "driver"='alberto ascari';
```
## Task
Generate a SQL query to answer the following question:
`Name the Driver that has Races greater than 16?`

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

CREATE TABLE "highest_percentage_of_pole_positions_in_" (
  "driver" text,
  "season" real,
  "races" real,
  "poles" real,
  "percentage" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the Driver that has Races greater than 16?`:
```sql
                SELECT "driver" FROM "highest_percentage_of_pole_positions_in_" WHERE "races">16;
```
## Task
Generate a SQL query to answer the following question:
`What is the average Long that has a GP-GS less than 14, a AVg/G less than 0.8 and a Gain less than 3 and a Loss greater than 8?`

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

CREATE TABLE "rushing" (
  "name" text,
  "gp_gs" real,
  "gain" real,
  "loss" real,
  "long" real,
  "avg_g" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average Long that has a GP-GS less than 14, a AVg/G less than 0.8 and a Gain less than 3 and a Loss greater than 8?`:
```sql
                SELECT AVG("long") FROM "rushing" WHERE "gp_gs"<14 AND "avg_g"<0.8 AND "gain"<3 AND "loss">8;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest Avg/G with a Long less than 0?`

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

CREATE TABLE "rushing" (
  "name" text,
  "gp_gs" real,
  "gain" real,
  "loss" real,
  "long" real,
  "avg_g" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest Avg/G with a Long less than 0?`:
```sql
                SELECT MIN("avg_g") FROM "rushing" WHERE "long"<0;
```
## Task
Generate a SQL query to answer the following question:
`What is the amount of Avg/G with a Name of blaine gabbert and a Long greater than 30?`

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

CREATE TABLE "rushing" (
  "name" text,
  "gp_gs" real,
  "gain" real,
  "loss" real,
  "long" real,
  "avg_g" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the amount of Avg/G with a Name of blaine gabbert and a Long greater than 30?`:
```sql
                SELECT SUM("avg_g") FROM "rushing" WHERE "name"='blaine gabbert' AND "long">30;
```
## Task
Generate a SQL query to answer the following question:
`What is the total number of Long with a Av/g of 124.9 but Loss greater than 0?`

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

CREATE TABLE "rushing" (
  "name" text,
  "gp_gs" real,
  "gain" real,
  "loss" real,
  "long" real,
  "avg_g" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of Long with a Av/g of 124.9 but Loss greater than 0?`:
```sql
                SELECT COUNT("long") FROM "rushing" WHERE "loss">0 AND "avg_g"=124.9;
```