cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`What is the total number of Years when the LLWS is 4th place, and when the City is Westport?`

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

CREATE TABLE "llws_results" (
  "year" real,
  "champion" text,
  "city" text,
  "llws" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of Years when the LLWS is 4th place, and when the City is Westport?`:
```sql
                SELECT COUNT("year") FROM "llws_results" WHERE "llws"='4th place' AND "city"='westport';
```
## Task
Generate a SQL query to answer the following question:
`What team has Pony as the kit manufacturer and Gary Mabbutt as the captain?`

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

CREATE TABLE "personnel_and_kits" (
  "team" text,
  "manager_1" text,
  "captain" text,
  "kit_manufacturer" text,
  "shirt_sponsor" text
);
### SQL
Given the database schema, here is the SQL query that answers `What team has Pony as the kit manufacturer and Gary Mabbutt as the captain?`:
```sql
                SELECT "team" FROM "personnel_and_kits" WHERE "kit_manufacturer"='pony' AND "captain"='gary mabbutt';
```
## Task
Generate a SQL query to answer the following question:
`Who is the manager 1 for Leeds United?`

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

CREATE TABLE "personnel_and_kits" (
  "team" text,
  "manager_1" text,
  "captain" text,
  "kit_manufacturer" text,
  "shirt_sponsor" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the manager 1 for Leeds United?`:
```sql
                SELECT "manager_1" FROM "personnel_and_kits" WHERE "team"='leeds united';
```
## Task
Generate a SQL query to answer the following question:
`What is the team with a Pony kit manufacturer and Julian Dicks as the captain?`

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

CREATE TABLE "personnel_and_kits" (
  "team" text,
  "manager_1" text,
  "captain" text,
  "kit_manufacturer" text,
  "shirt_sponsor" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the team with a Pony kit manufacturer and Julian Dicks as the captain?`:
```sql
                SELECT "team" FROM "personnel_and_kits" WHERE "kit_manufacturer"='pony' AND "captain"='julian dicks';
```
## Task
Generate a SQL query to answer the following question:
`What team has a kit manufacturer of Umbro and Eric Cantona as captain?`

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

CREATE TABLE "personnel_and_kits" (
  "team" text,
  "manager_1" text,
  "captain" text,
  "kit_manufacturer" text,
  "shirt_sponsor" text
);
### SQL
Given the database schema, here is the SQL query that answers `What team has a kit manufacturer of Umbro and Eric Cantona as captain?`:
```sql
                SELECT "team" FROM "personnel_and_kits" WHERE "kit_manufacturer"='umbro' AND "captain"='eric cantona';
```
## Task
Generate a SQL query to answer the following question:
`Who is the manager 1 with Puma as the kit manufacturer and Puma as the shirt sponsor?`

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

CREATE TABLE "personnel_and_kits" (
  "team" text,
  "manager_1" text,
  "captain" text,
  "kit_manufacturer" text,
  "shirt_sponsor" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the manager 1 with Puma as the kit manufacturer and Puma as the shirt sponsor?`:
```sql
                SELECT "manager_1" FROM "personnel_and_kits" WHERE "kit_manufacturer"='puma' AND "shirt_sponsor"='puma';
```
## Task
Generate a SQL query to answer the following question:
`What is the kit manufacturer with Walkers as the shirt sponsor?`

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

CREATE TABLE "personnel_and_kits" (
  "team" text,
  "manager_1" text,
  "captain" text,
  "kit_manufacturer" text,
  "shirt_sponsor" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the kit manufacturer with Walkers as the shirt sponsor?`:
```sql
                SELECT "kit_manufacturer" FROM "personnel_and_kits" WHERE "shirt_sponsor"='walkers';
```
## Task
Generate a SQL query to answer the following question:
`Name the average points for dallara 3087 lola t88/50 and year before 1988`

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

CREATE TABLE "complete_international_formula_3000_resu" (
  "year" real,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the average points for dallara 3087 lola t88/50 and year before 1988`:
```sql
                SELECT AVG("points") FROM "complete_international_formula_3000_resu" WHERE "chassis"='dallara 3087 lola t88/50' AND "year"<1988;
```
## Task
Generate a SQL query to answer the following question:
`Name the sum of points for 1992`

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

CREATE TABLE "complete_international_formula_3000_resu" (
  "year" real,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the sum of points for 1992`:
```sql
                SELECT SUM("points") FROM "complete_international_formula_3000_resu" WHERE "year"=1992;
```
## Task
Generate a SQL query to answer the following question:
`Name the points for year more than 1987`

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

CREATE TABLE "complete_international_formula_3000_resu" (
  "year" real,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the points for year more than 1987`:
```sql
                SELECT "points" FROM "complete_international_formula_3000_resu" WHERE "year">1987;
```
## Task
Generate a SQL query to answer the following question:
`Name the year for points less than 20 and chassis of dallara 3087`

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

CREATE TABLE "complete_international_formula_3000_resu" (
  "year" real,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the year for points less than 20 and chassis of dallara 3087`:
```sql
                SELECT "year" FROM "complete_international_formula_3000_resu" WHERE "points"<20 AND "chassis"='dallara 3087';
```
## Task
Generate a SQL query to answer the following question:
`What is the most apps that a has a total season and 3 goals?`

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

CREATE TABLE "international" (
  "national_team" text,
  "club" text,
  "season" text,
  "apps" real,
  "goals" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the most apps that a has a total season and 3 goals?`:
```sql
                SELECT MAX("apps") FROM "international" WHERE "season"='total' AND "goals">3;
```
## Task
Generate a SQL query to answer the following question:
`What is the final number of apps with 2 goals?`

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

CREATE TABLE "international" (
  "national_team" text,
  "club" text,
  "season" text,
  "apps" real,
  "goals" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the final number of apps with 2 goals?`:
```sql
                SELECT COUNT("apps") FROM "international" WHERE "goals"=2;
```
## Task
Generate a SQL query to answer the following question:
`What date did the episode with a weekly ranking of 14 air?`

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

CREATE TABLE "series_4" (
  "episode_no" real,
  "airdate" text,
  "total_viewers" real,
  "share" text,
  "bbc_one_weekly_ranking" real
);
### SQL
Given the database schema, here is the SQL query that answers `What date did the episode with a weekly ranking of 14 air?`:
```sql
                SELECT "airdate" FROM "series_4" WHERE "bbc_one_weekly_ranking"=14;
```
## Task
Generate a SQL query to answer the following question:
`What is the total number of total viewers with a share of 18.8% and a weekly ranking under 16?`

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

CREATE TABLE "series_4" (
  "episode_no" real,
  "airdate" text,
  "total_viewers" real,
  "share" text,
  "bbc_one_weekly_ranking" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of total viewers with a share of 18.8% and a weekly ranking under 16?`:
```sql
                SELECT COUNT("total_viewers") FROM "series_4" WHERE "share"='18.8%' AND "bbc_one_weekly_ranking"<16;
```
## Task
Generate a SQL query to answer the following question:
`Who has 37 grids?`

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

CREATE TABLE "125cc_classification" (
  "rider" text,
  "manufacturer" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `Who has 37 grids?`:
```sql
                SELECT "rider" FROM "125cc_classification" WHERE "grid"=37;
```
## Task
Generate a SQL query to answer the following question:
`What is the average grid with more than 23 laps?`

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

CREATE TABLE "125cc_classification" (
  "rider" text,
  "manufacturer" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average grid with more than 23 laps?`:
```sql
                SELECT AVG("grid") FROM "125cc_classification" WHERE "laps">23;
```
## Task
Generate a SQL query to answer the following question:
`What is the average decile for te puru school?`

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

CREATE TABLE "thames_coromandel_district" (
  "name" text,
  "years" text,
  "gender" text,
  "area" text,
  "authority" text,
  "decile" real,
  "roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average decile for te puru school?`:
```sql
                SELECT AVG("decile") FROM "thames_coromandel_district" WHERE "name"='te puru school';
```
## Task
Generate a SQL query to answer the following question:
`What is the total decile with an Area of whitianga, and a Roll smaller than 835?`

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

CREATE TABLE "thames_coromandel_district" (
  "name" text,
  "years" text,
  "gender" text,
  "area" text,
  "authority" text,
  "decile" real,
  "roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total decile with an Area of whitianga, and a Roll smaller than 835?`:
```sql
                SELECT SUM("decile") FROM "thames_coromandel_district" WHERE "area"='whitianga' AND "roll"<835;
```
## Task
Generate a SQL query to answer the following question:
`Which name has an Area of kennedy bay?`

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

CREATE TABLE "thames_coromandel_district" (
  "name" text,
  "years" text,
  "gender" text,
  "area" text,
  "authority" text,
  "decile" real,
  "roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which name has an Area of kennedy bay?`:
```sql
                SELECT "name" FROM "thames_coromandel_district" WHERE "area"='kennedy bay';
```
## Task
Generate a SQL query to answer the following question:
`Which years have a Decile larger than 4, and an Area of thames?`

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

CREATE TABLE "thames_coromandel_district" (
  "name" text,
  "years" text,
  "gender" text,
  "area" text,
  "authority" text,
  "decile" real,
  "roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which years have a Decile larger than 4, and an Area of thames?`:
```sql
                SELECT "years" FROM "thames_coromandel_district" WHERE "decile">4 AND "area"='thames';
```
## Task
Generate a SQL query to answer the following question:
`Which Authority has a Decile smaller than 6, and an Area of opoutere?`

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

CREATE TABLE "thames_coromandel_district" (
  "name" text,
  "years" text,
  "gender" text,
  "area" text,
  "authority" text,
  "decile" real,
  "roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Authority has a Decile smaller than 6, and an Area of opoutere?`:
```sql
                SELECT "authority" FROM "thames_coromandel_district" WHERE "decile"<6 AND "area"='opoutere';
```
## Task
Generate a SQL query to answer the following question:
`Which gender has Years of 1–8, an Authority of state, a Roll less than 184, and a Name of matatoki school?`

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

CREATE TABLE "thames_coromandel_district" (
  "name" text,
  "years" text,
  "gender" text,
  "area" text,
  "authority" text,
  "decile" real,
  "roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which gender has Years of 1–8, an Authority of state, a Roll less than 184, and a Name of matatoki school?`:
```sql
                SELECT "gender" FROM "thames_coromandel_district" WHERE "years"='1–8' AND "authority"='state' AND "roll"<184 AND "name"='matatoki school';
```
## Task
Generate a SQL query to answer the following question:
`What was the tournament that resulted in a winning score of –4 (71-72-72-69=284)?`

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

CREATE TABLE "nationwide_tour_wins_5" (
  "date" text,
  "tournament" text,
  "winning_score" text,
  "margin_of_victory" text,
  "runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the tournament that resulted in a winning score of –4 (71-72-72-69=284)?`:
```sql
                SELECT "tournament" FROM "nationwide_tour_wins_5" WHERE "winning_score"='–4 (71-72-72-69=284)';
```
## Task
Generate a SQL query to answer the following question:
`What was the winning score of the event where Brian Kamm was the runner-up?`

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

CREATE TABLE "nationwide_tour_wins_5" (
  "date" text,
  "tournament" text,
  "winning_score" text,
  "margin_of_victory" text,
  "runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the winning score of the event where Brian Kamm was the runner-up?`:
```sql
                SELECT "winning_score" FROM "nationwide_tour_wins_5" WHERE "runner_s_up"='brian kamm';
```
## Task
Generate a SQL query to answer the following question:
`Who was the runner-up for the event that ended with a winning score of –15 (66-67-70-70=273)?`

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

CREATE TABLE "nationwide_tour_wins_5" (
  "date" text,
  "tournament" text,
  "winning_score" text,
  "margin_of_victory" text,
  "runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the runner-up for the event that ended with a winning score of –15 (66-67-70-70=273)?`:
```sql
                SELECT "runner_s_up" FROM "nationwide_tour_wins_5" WHERE "winning_score"='–15 (66-67-70-70=273)';
```
## Task
Generate a SQL query to answer the following question:
`On what date was the Nike Colorado Classic held?`

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

CREATE TABLE "nationwide_tour_wins_5" (
  "date" text,
  "tournament" text,
  "winning_score" text,
  "margin_of_victory" text,
  "runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date was the Nike Colorado Classic held?`:
```sql
                SELECT "date" FROM "nationwide_tour_wins_5" WHERE "tournament"='nike colorado classic';
```
## Task
Generate a SQL query to answer the following question:
`What was the winning score of the Buy.com Siouxland Open?`

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

CREATE TABLE "nationwide_tour_wins_5" (
  "date" text,
  "tournament" text,
  "winning_score" text,
  "margin_of_victory" text,
  "runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the winning score of the Buy.com Siouxland Open?`:
```sql
                SELECT "winning_score" FROM "nationwide_tour_wins_5" WHERE "tournament"='buy.com siouxland open';
```
## Task
Generate a SQL query to answer the following question:
`What is the total with lower than rank 8, and higher than 27.6 score and 13.8 difficulty?`

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

CREATE TABLE "qualification" (
  "rank" real,
  "gymnast" text,
  "difficulty_score" text,
  "routine_score" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total with lower than rank 8, and higher than 27.6 score and 13.8 difficulty?`:
```sql
                SELECT MIN("total") FROM "qualification" WHERE "rank">8 AND "routine_score">27.6 AND "difficulty_score"='13.8';
```
## Task
Generate a SQL query to answer the following question:
`What is the average medal total of the country who had 0 silver medals and participated in less than 15 games?`

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

CREATE TABLE "participation_and_medals" (
  "games" real,
  "first" real,
  "last" real,
  "gold" real,
  "silver" real,
  "bronze" real,
  "total" real,
  "best_finish_first_last" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average medal total of the country who had 0 silver medals and participated in less than 15 games?`:
```sql
                SELECT AVG("total") FROM "participation_and_medals" WHERE "games"<15 AND "silver"<0;
```
## Task
Generate a SQL query to answer the following question:
`What is the least Points with Chassis of forti fg01b forti fg03, and a year less than 1996?`

### 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 least Points with Chassis of forti fg01b forti fg03, and a year less than 1996?`:
```sql
                SELECT MIN("points") FROM "complete_formula_one_results" WHERE "chassis"='forti fg01b forti fg03' AND "year"<1996;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest year for an engine of ford zetec-r v8, and points greater than 0?`

### 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 lowest year for an engine of ford zetec-r v8, and points greater than 0?`:
```sql
                SELECT MIN("year") FROM "complete_formula_one_results" WHERE "engine"='ford zetec-r v8' AND "points">0;
```
## Task
Generate a SQL query to answer the following question:
`What are the average points for an engine of ford zetec-r v8?`

### 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 are the average points for an engine of ford zetec-r v8?`:
```sql
                SELECT AVG("points") FROM "complete_formula_one_results" WHERE "engine"='ford zetec-r v8';
```
## Task
Generate a SQL query to answer the following question:
`Name the years for elsthorpe school`

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

CREATE TABLE "central_hawke_s_bay_district" (
  "name" text,
  "years" text,
  "gender" text,
  "area" text,
  "authority" text,
  "decile" real,
  "roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the years for elsthorpe school`:
```sql
                SELECT "years" FROM "central_hawke_s_bay_district" WHERE "name"='elsthorpe school';
```
## Task
Generate a SQL query to answer the following question:
`Name the total number of roll for st joseph's school when decile is less than 5`

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

CREATE TABLE "central_hawke_s_bay_district" (
  "name" text,
  "years" text,
  "gender" text,
  "area" text,
  "authority" text,
  "decile" real,
  "roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the total number of roll for st joseph's school when decile is less than 5`:
```sql
                SELECT COUNT("roll") FROM "central_hawke_s_bay_district" WHERE "name"='st joseph''s school' AND "decile"<5;
```
## Task
Generate a SQL query to answer the following question:
`Name the years for porangahau school`

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

CREATE TABLE "central_hawke_s_bay_district" (
  "name" text,
  "years" text,
  "gender" text,
  "area" text,
  "authority" text,
  "decile" real,
  "roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the years for porangahau school`:
```sql
                SELECT "years" FROM "central_hawke_s_bay_district" WHERE "area"='porangahau' AND "name"='porangahau school';
```
## Task
Generate a SQL query to answer the following question:
`Name the gender for elsthorpe school`

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

CREATE TABLE "central_hawke_s_bay_district" (
  "name" text,
  "years" text,
  "gender" text,
  "area" text,
  "authority" text,
  "decile" real,
  "roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the gender for elsthorpe school`:
```sql
                SELECT "gender" FROM "central_hawke_s_bay_district" WHERE "name"='elsthorpe school';
```
## Task
Generate a SQL query to answer the following question:
`Name the drivers for chassis of season cancelled`

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

CREATE TABLE "summary" (
  "season" text,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "rounds" text,
  "teams" text,
  "drivers" text,
  "champion_points" text,
  "second_points" text,
  "third_points" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the drivers for chassis of season cancelled`:
```sql
                SELECT "drivers" FROM "summary" WHERE "chassis"='season cancelled';
```
## Task
Generate a SQL query to answer the following question:
`Name the teams for third points of season cancelled`

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

CREATE TABLE "summary" (
  "season" text,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "rounds" text,
  "teams" text,
  "drivers" text,
  "champion_points" text,
  "second_points" text,
  "third_points" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the teams for third points of season cancelled`:
```sql
                SELECT "teams" FROM "summary" WHERE "third_points"='season cancelled';
```
## Task
Generate a SQL query to answer the following question:
`Name the engine with rounds of 11 and teams of 25`

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

CREATE TABLE "summary" (
  "season" text,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "rounds" text,
  "teams" text,
  "drivers" text,
  "champion_points" text,
  "second_points" text,
  "third_points" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the engine with rounds of 11 and teams of 25`:
```sql
                SELECT "engine" FROM "summary" WHERE "rounds"='11' AND "teams"='25';
```
## Task
Generate a SQL query to answer the following question:
`What was the score for the loss of McDowell (12-7)?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score for the loss of McDowell (12-7)?`:
```sql
                SELECT "score" FROM "game_log" WHERE "loss"='mcdowell (12-7)';
```
## Task
Generate a SQL query to answer the following question:
`What was the score for the game with an attendance greater than 33,658 and a record of 73-66?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score for the game with an attendance greater than 33,658 and a record of 73-66?`:
```sql
                SELECT "score" FROM "game_log" WHERE "attendance">'33,658' AND "record"='73-66';
```
## Task
Generate a SQL query to answer the following question:
`What is the total laps for the year 2011?`

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

CREATE TABLE "24_hours_of_le_mans_results" (
  "year" real,
  "team" text,
  "co_drivers" text,
  "class" text,
  "laps" real,
  "pos" text,
  "class_pos" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total laps for the year 2011?`:
```sql
                SELECT SUM("laps") FROM "24_hours_of_le_mans_results" WHERE "year"=2011;
```
## Task
Generate a SQL query to answer the following question:
`Which team is in 9th place?`

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

CREATE TABLE "24_hours_of_le_mans_results" (
  "year" real,
  "team" text,
  "co_drivers" text,
  "class" text,
  "laps" real,
  "pos" text,
  "class_pos" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which team is in 9th place?`:
```sql
                SELECT "class_pos" FROM "24_hours_of_le_mans_results" WHERE "pos"='9th';
```
## Task
Generate a SQL query to answer the following question:
`What is the total of the Divison that is from the country Serbia and Montenegro with apps smaller than 12 with more goals than 0?`

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

CREATE TABLE "career_statistics" (
  "season" text,
  "team" text,
  "country" text,
  "division" real,
  "apps" real,
  "goals" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total of the Divison that is from the country Serbia and Montenegro with apps smaller than 12 with more goals than 0?`:
```sql
                SELECT SUM("division") FROM "career_statistics" WHERE "country"='serbia and montenegro' AND "apps"<12 AND "goals">0;
```
## Task
Generate a SQL query to answer the following question:
`What is the total number of goals that the Partizan team from the country of serbia had that was larger than 1?`

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

CREATE TABLE "career_statistics" (
  "season" text,
  "team" text,
  "country" text,
  "division" real,
  "apps" real,
  "goals" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of goals that the Partizan team from the country of serbia had that was larger than 1?`:
```sql
                SELECT SUM("goals") FROM "career_statistics" WHERE "team"='partizan' AND "country"='serbia' AND "division">1;
```
## Task
Generate a SQL query to answer the following question:
`What year was the Honda ra168e 1.5 v6 t engine used?`

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

CREATE TABLE "works_team_entries" (
  "year" real,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "pts" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year was the Honda ra168e 1.5 v6 t engine used?`:
```sql
                SELECT "year" FROM "works_team_entries" WHERE "engine"='honda ra168e 1.5 v6 t';
```
## Task
Generate a SQL query to answer the following question:
`What tyres were used with the mp4/14 chassis?`

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

CREATE TABLE "works_team_entries" (
  "year" real,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "pts" text
);
### SQL
Given the database schema, here is the SQL query that answers `What tyres were used with the mp4/14 chassis?`:
```sql
                SELECT "tyres" FROM "works_team_entries" WHERE "chassis"='mp4/14';
```
## Task
Generate a SQL query to answer the following question:
`How many tickets were there sold/available in Barcelona?`

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

CREATE TABLE "box_office_score_data" (
  "venue" text,
  "city" text,
  "tickets_sold_available" text,
  "gross_revenue_1986" text,
  "gross_revenue_2011" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many tickets were there sold/available in Barcelona?`:
```sql
                SELECT "tickets_sold_available" FROM "box_office_score_data" WHERE "city"='barcelona';
```
## Task
Generate a SQL query to answer the following question:
`How many tickets were sold/available when the gross revenue (2011) was $366,916?`

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

CREATE TABLE "box_office_score_data" (
  "venue" text,
  "city" text,
  "tickets_sold_available" text,
  "gross_revenue_1986" text,
  "gross_revenue_2011" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many tickets were sold/available when the gross revenue (2011) was $366,916?`:
```sql
                SELECT "tickets_sold_available" FROM "box_office_score_data" WHERE "gross_revenue_2011"='$366,916';
```
## Task
Generate a SQL query to answer the following question:
`How many tickets were sold/available when the gross revenue (2011) was $5,948,390?`

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

CREATE TABLE "box_office_score_data" (
  "venue" text,
  "city" text,
  "tickets_sold_available" text,
  "gross_revenue_1986" text,
  "gross_revenue_2011" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many tickets were sold/available when the gross revenue (2011) was $5,948,390?`:
```sql
                SELECT "tickets_sold_available" FROM "box_office_score_data" WHERE "gross_revenue_2011"='$5,948,390';
```
## Task
Generate a SQL query to answer the following question:
`What was the gross revenue (1986) when there were tickets sold/available of 24,000 / 24,000 (100%)?`

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

CREATE TABLE "box_office_score_data" (
  "venue" text,
  "city" text,
  "tickets_sold_available" text,
  "gross_revenue_1986" text,
  "gross_revenue_2011" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the gross revenue (1986) when there were tickets sold/available of 24,000 / 24,000 (100%)?`:
```sql
                SELECT "gross_revenue_1986" FROM "box_office_score_data" WHERE "tickets_sold_available"='24,000 / 24,000 (100%)';
```
## Task
Generate a SQL query to answer the following question:
`What was the score in the 1st leg when Stade d'Abidjan was Team 2?`

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

CREATE TABLE "second_round" (
  "team_1" text,
  "agg" text,
  "team_2" text,
  "1st_leg" text,
  "2nd_leg" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score in the 1st leg when Stade d'Abidjan was Team 2?`:
```sql
                SELECT "1st_leg" FROM "second_round" WHERE "team_2"='stade d''abidjan';
```
## Task
Generate a SQL query to answer the following question:
`What was the aggregate score that had Union Douala as Team 1?`

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

CREATE TABLE "second_round" (
  "team_1" text,
  "agg" text,
  "team_2" text,
  "1st_leg" text,
  "2nd_leg" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the aggregate score that had Union Douala as Team 1?`:
```sql
                SELECT "agg" FROM "second_round" WHERE "team_1"='union douala';
```
## Task
Generate a SQL query to answer the following question:
`What was the 2nd leg score of the aggregate score of 4-9?`

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

CREATE TABLE "second_round" (
  "team_1" text,
  "agg" text,
  "team_2" text,
  "1st_leg" text,
  "2nd_leg" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the 2nd leg score of the aggregate score of 4-9?`:
```sql
                SELECT "2nd_leg" FROM "second_round" WHERE "agg"='4-9';
```
## Task
Generate a SQL query to answer the following question:
`Who was Team 2 when Stationery Stores was Team 1?`

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

CREATE TABLE "second_round" (
  "team_1" text,
  "agg" text,
  "team_2" text,
  "1st_leg" text,
  "2nd_leg" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was Team 2 when Stationery Stores was Team 1?`:
```sql
                SELECT "team_2" FROM "second_round" WHERE "team_1"='stationery stores';
```
## Task
Generate a SQL query to answer the following question:
`Which Team 1 has an aggregate score of 1-1 1?`

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

CREATE TABLE "second_round" (
  "team_1" text,
  "agg" text,
  "team_2" text,
  "1st_leg" text,
  "2nd_leg" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Team 1 has an aggregate score of 1-1 1?`:
```sql
                SELECT "team_1" FROM "second_round" WHERE "agg"='1-1 1';
```
## Task
Generate a SQL query to answer the following question:
`Can you tell me the Chassis that has the Year of 1977?`

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

CREATE TABLE "complete_european_formula_two_championsh" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Can you tell me the Chassis that has the Year of 1977?`:
```sql
                SELECT "chassis" FROM "complete_european_formula_two_championsh" WHERE "year"=1977;
```
## Task
Generate a SQL query to answer the following question:
`Can you tell me the Entrant that has the Chassis of march 742, and the Year larger than 1974?`

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

CREATE TABLE "complete_european_formula_two_championsh" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Can you tell me the Entrant that has the Chassis of march 742, and the Year larger than 1974?`:
```sql
                SELECT "entrant" FROM "complete_european_formula_two_championsh" WHERE "chassis"='march 742' AND "year">1974;
```
## Task
Generate a SQL query to answer the following question:
`Can you tell me the Chassis that has the Entrant of trivellato racing team?`

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

CREATE TABLE "complete_european_formula_two_championsh" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Can you tell me the Chassis that has the Entrant of trivellato racing team?`:
```sql
                SELECT "chassis" FROM "complete_european_formula_two_championsh" WHERE "entrant"='trivellato racing team';
```
## Task
Generate a SQL query to answer the following question:
`Can you tell me the Chassis that has the Points of 13, and the Year of 1975, and the Entrant of scuderia citta del mille?`

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

CREATE TABLE "complete_european_formula_two_championsh" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Can you tell me the Chassis that has the Points of 13, and the Year of 1975, and the Entrant of scuderia citta del mille?`:
```sql
                SELECT "chassis" FROM "complete_european_formula_two_championsh" WHERE "points"=13 AND "year"=1975 AND "entrant"='scuderia citta del mille';
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest value of a team with revenue less than 374 and a debt of 84%?`

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

CREATE TABLE "2007_rankings" (
  "team" text,
  "country" text,
  "value_m" real,
  "debt_as_pctof_value" text,
  "pct_change_on_year" text,
  "revenue_m" real,
  "operating_income_m" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest value of a team with revenue less than 374 and a debt of 84%?`:
```sql
                SELECT MIN("value_m") FROM "2007_rankings" WHERE "revenue_m"<374 AND "debt_as_pctof_value"='84';
```
## Task
Generate a SQL query to answer the following question:
`What is the highest operating income that change by 2% and is less than $1,036m?`

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

CREATE TABLE "2007_rankings" (
  "team" text,
  "country" text,
  "value_m" real,
  "debt_as_pctof_value" text,
  "pct_change_on_year" text,
  "revenue_m" real,
  "operating_income_m" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest operating income that change by 2% and is less than $1,036m?`:
```sql
                SELECT MAX("operating_income_m") FROM "2007_rankings" WHERE "pct_change_on_year"='2' AND "value_m"<'1,036';
```
## Task
Generate a SQL query to answer the following question:
`Which team did they play on September 19?`

### 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 `Which team did they play on September 19?`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "date"='september 19';
```
## Task
Generate a SQL query to answer the following question:
`What's the FCC info with a Frequency MHz thats smaller than 91.9 and has a CIty of license of Dansville, NY?`

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

CREATE TABLE "broadcast_translators_of_wmhr" (
  "call_sign" text,
  "frequency_m_hz" real,
  "city_of_license" text,
  "erp_w" real,
  "height_m_ft" text,
  "class" text,
  "fcc_info" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the FCC info with a Frequency MHz thats smaller than 91.9 and has a CIty of license of Dansville, NY?`:
```sql
                SELECT "fcc_info" FROM "broadcast_translators_of_wmhr" WHERE "frequency_m_hz"<91.9 AND "city_of_license"='dansville, ny';
```
## Task
Generate a SQL query to answer the following question:
`What's the FCC info with a Frequency MHz thats smaller than 100.3 and a City of License as Lowville, NY?`

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

CREATE TABLE "broadcast_translators_of_wmhr" (
  "call_sign" text,
  "frequency_m_hz" real,
  "city_of_license" text,
  "erp_w" real,
  "height_m_ft" text,
  "class" text,
  "fcc_info" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the FCC info with a Frequency MHz thats smaller than 100.3 and a City of License as Lowville, NY?`:
```sql
                SELECT "fcc_info" FROM "broadcast_translators_of_wmhr" WHERE "frequency_m_hz"<100.3 AND "city_of_license"='lowville, ny';
```
## Task
Generate a SQL query to answer the following question:
`What's the Call sign with a Frequency MHz thats smaller than 95.9 and an ERP W of 10?`

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

CREATE TABLE "broadcast_translators_of_wmhr" (
  "call_sign" text,
  "frequency_m_hz" real,
  "city_of_license" text,
  "erp_w" real,
  "height_m_ft" text,
  "class" text,
  "fcc_info" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the Call sign with a Frequency MHz thats smaller than 95.9 and an ERP W of 10?`:
```sql
                SELECT "call_sign" FROM "broadcast_translators_of_wmhr" WHERE "frequency_m_hz"<95.9 AND "erp_w"=10;
```
## Task
Generate a SQL query to answer the following question:
`What is listed as the highest ERP W with a Call sign of W262AC?`

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

CREATE TABLE "broadcast_translators_of_wmhr" (
  "call_sign" text,
  "frequency_m_hz" real,
  "city_of_license" text,
  "erp_w" real,
  "height_m_ft" text,
  "class" text,
  "fcc_info" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is listed as the highest ERP W with a Call sign of W262AC?`:
```sql
                SELECT MAX("erp_w") FROM "broadcast_translators_of_wmhr" WHERE "call_sign"='w262ac';
```
## Task
Generate a SQL query to answer the following question:
`What's the sum of ERP W with a Frequency MHz that larger than 97.7?`

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

CREATE TABLE "broadcast_translators_of_wmhr" (
  "call_sign" text,
  "frequency_m_hz" real,
  "city_of_license" text,
  "erp_w" real,
  "height_m_ft" text,
  "class" text,
  "fcc_info" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the sum of ERP W with a Frequency MHz that larger than 97.7?`:
```sql
                SELECT COUNT("erp_w") FROM "broadcast_translators_of_wmhr" WHERE "frequency_m_hz">97.7;
```
## Task
Generate a SQL query to answer the following question:
`What was the score of the game played on September 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,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score of the game played on September 9?`:
```sql
                SELECT "score" FROM "game_log" WHERE "date"='september 9';
```
## Task
Generate a SQL query to answer the following question:
`Name the overall record for indian river`

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

CREATE TABLE "2006_regular_season_football_standings" (
  "school" text,
  "team" text,
  "division_record" text,
  "overall_record" text,
  "season_outcome" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the overall record for indian river`:
```sql
                SELECT "overall_record" FROM "2006_regular_season_football_standings" WHERE "school"='indian river';
```
## Task
Generate a SQL query to answer the following question:
`What was E.J. "Dutch" Harrison's lowest To Par?`

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

CREATE TABLE "final_round" (
  "place" text,
  "player" text,
  "country" text,
  "score" text,
  "to_par" real,
  "money" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was E.J. "Dutch" Harrison's lowest To Par?`:
```sql
                SELECT MIN("to_par") FROM "final_round" WHERE "player"='e.j. \"dutch\" harrison';
```
## Task
Generate a SQL query to answer the following question:
`How much money was won for the game with a score of 74-76-71-71=292?`

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

CREATE TABLE "final_round" (
  "place" text,
  "player" text,
  "country" text,
  "score" text,
  "to_par" real,
  "money" text
);
### SQL
Given the database schema, here is the SQL query that answers `How much money was won for the game with a score of 74-76-71-71=292?`:
```sql
                SELECT "money" FROM "final_round" WHERE "score"='74-76-71-71=292';
```
## Task
Generate a SQL query to answer the following question:
`What country was the player from with a score of 70-79-74-68=291?`

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

CREATE TABLE "final_round" (
  "place" text,
  "player" text,
  "country" text,
  "score" text,
  "to_par" real,
  "money" text
);
### SQL
Given the database schema, here is the SQL query that answers `What country was the player from with a score of 70-79-74-68=291?`:
```sql
                SELECT "country" FROM "final_round" WHERE "score"='70-79-74-68=291';
```
## Task
Generate a SQL query to answer the following question:
`When To par was less than 2, what was the score?`

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

CREATE TABLE "final_round" (
  "place" text,
  "player" text,
  "country" text,
  "score" text,
  "to_par" real,
  "money" text
);
### SQL
Given the database schema, here is the SQL query that answers `When To par was less than 2, what was the score?`:
```sql
                SELECT "score" FROM "final_round" WHERE "to_par"<2;
```
## Task
Generate a SQL query to answer the following question:
`When was the match with a result of sa by 10 wkts?`

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

CREATE TABLE "england_in_south_africa" (
  "date" text,
  "home_captain" text,
  "away_captain" text,
  "venue" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `When was the match with a result of sa by 10 wkts?`:
```sql
                SELECT "date" FROM "england_in_south_africa" WHERE "result"='sa by 10 wkts';
```