cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`What was the 1st leg for Team 2 Concepto Egile?`

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

CREATE TABLE "matches" (
  "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 1st leg for Team 2 Concepto Egile?`:
```sql
                SELECT "1st_leg" FROM "matches" WHERE "team_2"='concepto egile';
```
## Task
Generate a SQL query to answer the following question:
`Which team 1 has team 2, Gomera?`

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

CREATE TABLE "matches" (
  "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 team 2, Gomera?`:
```sql
                SELECT "team_1" FROM "matches" WHERE "team_2"='gomera';
```
## Task
Generate a SQL query to answer the following question:
`What public team was founded prior to 1883?`

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

CREATE TABLE "naia_football_independents" (
  "institution" text,
  "location" text,
  "founded" real,
  "type" text,
  "enrollment" real,
  "team" text,
  "primary_conference" text
);
### SQL
Given the database schema, here is the SQL query that answers `What public team was founded prior to 1883?`:
```sql
                SELECT "team" FROM "naia_football_independents" WHERE "founded"<1883 AND "type"='public';
```
## Task
Generate a SQL query to answer the following question:
`Who has exactly 342 spikes?`

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

CREATE TABLE "volleyball_at_the_2004_summer_olympics_m" (
  "name" text,
  "date_of_birth" text,
  "height" real,
  "weight" real,
  "spike" real
);
### SQL
Given the database schema, here is the SQL query that answers `Who has exactly 342 spikes?`:
```sql
                SELECT "name" FROM "volleyball_at_the_2004_summer_olympics_m" WHERE "spike"=342;
```
## Task
Generate a SQL query to answer the following question:
`What is the smallest number of spikes for players with a weight of 83 and height over 190?`

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

CREATE TABLE "volleyball_at_the_2004_summer_olympics_m" (
  "name" text,
  "date_of_birth" text,
  "height" real,
  "weight" real,
  "spike" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the smallest number of spikes for players with a weight of 83 and height over 190?`:
```sql
                SELECT MIN("spike") FROM "volleyball_at_the_2004_summer_olympics_m" WHERE "weight"=83 AND "height">190;
```
## Task
Generate a SQL query to answer the following question:
`What is Class, when Power is 78 Watts?`

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

CREATE TABLE "s_rebroadcaster_of_cbqt_fm" (
  "city_of_license" text,
  "identifier" text,
  "frequency" text,
  "power" text,
  "class" text,
  "rec_net" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is Class, when Power is 78 Watts?`:
```sql
                SELECT "class" FROM "s_rebroadcaster_of_cbqt_fm" WHERE "power"='78 watts';
```
## Task
Generate a SQL query to answer the following question:
`What is Power, when Identifier is CBEB-FM?`

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

CREATE TABLE "s_rebroadcaster_of_cbqt_fm" (
  "city_of_license" text,
  "identifier" text,
  "frequency" text,
  "power" text,
  "class" text,
  "rec_net" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is Power, when Identifier is CBEB-FM?`:
```sql
                SELECT "power" FROM "s_rebroadcaster_of_cbqt_fm" WHERE "identifier"='cbeb-fm';
```
## Task
Generate a SQL query to answer the following question:
`What is Identifier, when City of License is Terrace Bay?`

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

CREATE TABLE "s_rebroadcaster_of_cbqt_fm" (
  "city_of_license" text,
  "identifier" text,
  "frequency" text,
  "power" text,
  "class" text,
  "rec_net" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is Identifier, when City of License is Terrace Bay?`:
```sql
                SELECT "identifier" FROM "s_rebroadcaster_of_cbqt_fm" WHERE "city_of_license"='terrace bay';
```
## Task
Generate a SQL query to answer the following question:
`What is Power, when City of License is Sioux Lookout?`

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

CREATE TABLE "s_rebroadcaster_of_cbqt_fm" (
  "city_of_license" text,
  "identifier" text,
  "frequency" text,
  "power" text,
  "class" text,
  "rec_net" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is Power, when City of License is Sioux Lookout?`:
```sql
                SELECT "power" FROM "s_rebroadcaster_of_cbqt_fm" WHERE "city_of_license"='sioux lookout';
```
## Task
Generate a SQL query to answer the following question:
`What is Identifier, when City of License is Hornepayne?`

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

CREATE TABLE "s_rebroadcaster_of_cbqt_fm" (
  "city_of_license" text,
  "identifier" text,
  "frequency" text,
  "power" text,
  "class" text,
  "rec_net" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is Identifier, when City of License is Hornepayne?`:
```sql
                SELECT "identifier" FROM "s_rebroadcaster_of_cbqt_fm" WHERE "city_of_license"='hornepayne';
```
## Task
Generate a SQL query to answer the following question:
`What is City of License, when Frequency is 101.1?`

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

CREATE TABLE "s_rebroadcaster_of_cbqt_fm" (
  "city_of_license" text,
  "identifier" text,
  "frequency" text,
  "power" text,
  "class" text,
  "rec_net" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is City of License, when Frequency is 101.1?`:
```sql
                SELECT "city_of_license" FROM "s_rebroadcaster_of_cbqt_fm" WHERE "frequency"='101.1';
```
## Task
Generate a SQL query to answer the following question:
`Which LE-5 Model has an LE-5A of 130?`

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

CREATE TABLE "le_5_model_specifications" (
  "le_5_model" text,
  "le_5" text,
  "le_5_a" text,
  "le_5_b" text,
  "le_5_b_2" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which LE-5 Model has an LE-5A of 130?`:
```sql
                SELECT "le_5_model" FROM "le_5_model_specifications" WHERE "le_5_a"='130';
```
## Task
Generate a SQL query to answer the following question:
`What Series had 14 races and 12th position?`

### 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" real,
  "wins" real,
  "poles" real,
  "podiums" real,
  "points" text,
  "position" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Series had 14 races and 12th position?`:
```sql
                SELECT "series" FROM "career_summary" WHERE "races"=14 AND "position"='12th';
```
## Task
Generate a SQL query to answer the following question:
`What season was the Formula BMW USA in?`

### 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" real,
  "wins" real,
  "poles" real,
  "podiums" real,
  "points" text,
  "position" text
);
### SQL
Given the database schema, here is the SQL query that answers `What season was the Formula BMW USA in?`:
```sql
                SELECT "season" FROM "career_summary" WHERE "series"='formula bmw usa';
```
## Task
Generate a SQL query to answer the following question:
`What series had more than 10 Podiums?`

### 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" real,
  "wins" real,
  "poles" real,
  "podiums" real,
  "points" text,
  "position" text
);
### SQL
Given the database schema, here is the SQL query that answers `What series had more than 10 Podiums?`:
```sql
                SELECT "series" FROM "career_summary" WHERE "podiums">10;
```
## Task
Generate a SQL query to answer the following question:
`What is the Status with an Author that is colbert?`

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

CREATE TABLE "newly_named_dinosaurs" (
  "name" text,
  "novelty" text,
  "status" text,
  "authors" text,
  "unit" text,
  "location" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Status with an Author that is colbert?`:
```sql
                SELECT "status" FROM "newly_named_dinosaurs" WHERE "authors"='colbert';
```
## Task
Generate a SQL query to answer the following question:
`What college was the draft pick number larger than 18 that went to the Barangay ginebra kings?`

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

CREATE TABLE "round_3" (
  "pick" real,
  "player" text,
  "country_of_origin" text,
  "pba_team" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What college was the draft pick number larger than 18 that went to the Barangay ginebra kings?`:
```sql
                SELECT "college" FROM "round_3" WHERE "pick">18 AND "pba_team"='barangay ginebra kings';
```
## Task
Generate a SQL query to answer the following question:
`What is the sum of the pick numbers for the player that went to San Miguel Beermen who played at San Sebastian?`

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

CREATE TABLE "round_3" (
  "pick" real,
  "player" text,
  "country_of_origin" text,
  "pba_team" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the sum of the pick numbers for the player that went to San Miguel Beermen who played at San Sebastian?`:
```sql
                SELECT SUM("pick") FROM "round_3" WHERE "pba_team"='san miguel beermen' AND "college"='san sebastian';
```
## Task
Generate a SQL query to answer the following question:
`What is the total number of picks for PBA team san miguel beermen who picked rommel daep?`

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

CREATE TABLE "round_3" (
  "pick" real,
  "player" text,
  "country_of_origin" text,
  "pba_team" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of picks for PBA team san miguel beermen who picked rommel daep?`:
```sql
                SELECT COUNT("pick") FROM "round_3" WHERE "pba_team"='san miguel beermen' AND "player"='rommel daep';
```
## Task
Generate a SQL query to answer the following question:
`What player came from the United States and went to Ohlone college?`

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

CREATE TABLE "round_3" (
  "pick" real,
  "player" text,
  "country_of_origin" text,
  "pba_team" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What player came from the United States and went to Ohlone college?`:
```sql
                SELECT "player" FROM "round_3" WHERE "country_of_origin"='united states' AND "college"='ohlone';
```
## Task
Generate a SQL query to answer the following question:
`Who won after 1999 with changwon lg sakers as runners-up?`

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

CREATE TABLE "results" (
  "year" real,
  "champions" text,
  "result" text,
  "runners_up" text,
  "playoffs_mvp" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who won after 1999 with changwon lg sakers as runners-up?`:
```sql
                SELECT "champions" FROM "results" WHERE "year">1999 AND "runners_up"='changwon lg sakers';
```
## Task
Generate a SQL query to answer the following question:
`What is the result for the champions jeonju kcc egis with runners-up seoul samsung thunders after 2007?`

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

CREATE TABLE "results" (
  "year" real,
  "champions" text,
  "result" text,
  "runners_up" text,
  "playoffs_mvp" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the result for the champions jeonju kcc egis with runners-up seoul samsung thunders after 2007?`:
```sql
                SELECT "result" FROM "results" WHERE "year">2007 AND "runners_up"='seoul samsung thunders' AND "champions"='jeonju kcc egis';
```
## Task
Generate a SQL query to answer the following question:
`What was the winning team in 2013?`

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

CREATE TABLE "results" (
  "year" real,
  "venue" text,
  "winning_team" text,
  "score" text,
  "usa_captain" text,
  "europe_captain" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the winning team in 2013?`:
```sql
                SELECT "winning_team" FROM "results" WHERE "year"=2013;
```
## Task
Generate a SQL query to answer the following question:
`What is the highest year that Europe won, when the USA's Captain was Kathy Whitworth?`

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

CREATE TABLE "results" (
  "year" real,
  "venue" text,
  "winning_team" text,
  "score" text,
  "usa_captain" text,
  "europe_captain" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest year that Europe won, when the USA's Captain was Kathy Whitworth?`:
```sql
                SELECT MAX("year") FROM "results" WHERE "winning_team"='europe' AND "usa_captain"='kathy whitworth';
```
## Task
Generate a SQL query to answer the following question:
`When the USA's captain was Beth Daniel, who was the winning team?`

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

CREATE TABLE "results" (
  "year" real,
  "venue" text,
  "winning_team" text,
  "score" text,
  "usa_captain" text,
  "europe_captain" text
);
### SQL
Given the database schema, here is the SQL query that answers `When the USA's captain was Beth Daniel, who was the winning team?`:
```sql
                SELECT "winning_team" FROM "results" WHERE "usa_captain"='beth daniel';
```
## Task
Generate a SQL query to answer the following question:
`What is the Season when league shows bundesliga, and a European competition of played korac cup?`

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

CREATE TABLE "season_by_season" (
  "season" text,
  "tier" real,
  "league" text,
  "postseason" text,
  "european_competitions" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Season when league shows bundesliga, and a European competition of played korac cup?`:
```sql
                SELECT "season" FROM "season_by_season" WHERE "league"='bundesliga' AND "european_competitions"='played korac cup';
```
## Task
Generate a SQL query to answer the following question:
`What is the average Tier when the postseason shows -, and the season is 2012–13?`

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

CREATE TABLE "season_by_season" (
  "season" text,
  "tier" real,
  "league" text,
  "postseason" text,
  "european_competitions" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average Tier when the postseason shows -, and the season is 2012–13?`:
```sql
                SELECT AVG("tier") FROM "season_by_season" WHERE "postseason"='–' AND "season"='2012–13';
```
## Task
Generate a SQL query to answer the following question:
`What is the European competition when the tier is more than 2?`

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

CREATE TABLE "season_by_season" (
  "season" text,
  "tier" real,
  "league" text,
  "postseason" text,
  "european_competitions" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the European competition when the tier is more than 2?`:
```sql
                SELECT "european_competitions" FROM "season_by_season" WHERE "tier">2;
```
## Task
Generate a SQL query to answer the following question:
`What was the outcome of the match played on grass?`

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

CREATE TABLE "singles_7_4_titles_3_runner_ups" (
  "outcome" text,
  "date_final" text,
  "tournament" text,
  "surface" text,
  "opponent_in_the_final" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the outcome of the match played on grass?`:
```sql
                SELECT "outcome" FROM "singles_7_4_titles_3_runner_ups" WHERE "surface"='grass';
```
## Task
Generate a SQL query to answer the following question:
`What was the outcome of the match on February 17, 2003?`

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

CREATE TABLE "singles_7_4_titles_3_runner_ups" (
  "outcome" text,
  "date_final" text,
  "tournament" text,
  "surface" text,
  "opponent_in_the_final" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the outcome of the match on February 17, 2003?`:
```sql
                SELECT "outcome" FROM "singles_7_4_titles_3_runner_ups" WHERE "date_final"='february 17, 2003';
```
## Task
Generate a SQL query to answer the following question:
`How many average wins have USA as the team?`

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

CREATE TABLE "group_b" (
  "pos" real,
  "team" text,
  "wins" real,
  "ties" real,
  "losses" real,
  "goals" text,
  "diff" text,
  "points" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many average wins have USA as the team?`:
```sql
                SELECT AVG("wins") FROM "group_b" WHERE "team"='usa';
```
## Task
Generate a SQL query to answer the following question:
`What are the average wins that have great britain as the team?`

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

CREATE TABLE "group_b" (
  "pos" real,
  "team" text,
  "wins" real,
  "ties" real,
  "losses" real,
  "goals" text,
  "diff" text,
  "points" text
);
### SQL
Given the database schema, here is the SQL query that answers `What are the average wins that have great britain as the team?`:
```sql
                SELECT AVG("wins") FROM "group_b" WHERE "team"='great britain';
```
## Task
Generate a SQL query to answer the following question:
`What's the average draft pick number from Carson-Newman College before Round 7?`

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

CREATE TABLE "nfl_draft" (
  "round" real,
  "pick_num" real,
  "player" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the average draft pick number from Carson-Newman College before Round 7?`:
```sql
                SELECT AVG("pick_num") FROM "nfl_draft" WHERE "college"='carson-newman' AND "round"<7;
```
## Task
Generate a SQL query to answer the following question:
`Which college has a pick number of 155?`

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

CREATE TABLE "nfl_draft" (
  "round" real,
  "pick_num" real,
  "player" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which college has a pick number of 155?`:
```sql
                SELECT "college" FROM "nfl_draft" WHERE "pick_num"=155;
```
## Task
Generate a SQL query to answer the following question:
`What score in the final has november 3, 2002 as the date?`

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

CREATE TABLE "itf_circuit_doubles_9_4_5" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponent_in_the_final" text,
  "score_in_the_final" text
);
### SQL
Given the database schema, here is the SQL query that answers `What score in the final has november 3, 2002 as the date?`:
```sql
                SELECT "score_in_the_final" FROM "itf_circuit_doubles_9_4_5" WHERE "date"='november 3, 2002';
```
## Task
Generate a SQL query to answer the following question:
`What surface has natalia gussoni as the partner?`

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

CREATE TABLE "itf_circuit_doubles_9_4_5" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponent_in_the_final" text,
  "score_in_the_final" text
);
### SQL
Given the database schema, here is the SQL query that answers `What surface has natalia gussoni as the partner?`:
```sql
                SELECT "surface" FROM "itf_circuit_doubles_9_4_5" WHERE "partner"='natalia gussoni';
```
## Task
Generate a SQL query to answer the following question:
`What outcome has September 23, 2013 as the date?`

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

CREATE TABLE "itf_circuit_doubles_9_4_5" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponent_in_the_final" text,
  "score_in_the_final" text
);
### SQL
Given the database schema, here is the SQL query that answers `What outcome has September 23, 2013 as the date?`:
```sql
                SELECT "outcome" FROM "itf_circuit_doubles_9_4_5" WHERE "date"='september 23, 2013';
```
## Task
Generate a SQL query to answer the following question:
`What score in the final has hard as the surface, and june 13, 2011 as the date?`

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

CREATE TABLE "itf_circuit_doubles_9_4_5" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponent_in_the_final" text,
  "score_in_the_final" text
);
### SQL
Given the database schema, here is the SQL query that answers `What score in the final has hard as the surface, and june 13, 2011 as the date?`:
```sql
                SELECT "score_in_the_final" FROM "itf_circuit_doubles_9_4_5" WHERE "surface"='hard' AND "date"='june 13, 2011';
```
## Task
Generate a SQL query to answer the following question:
`What date has elke clijsters as the partner?`

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

CREATE TABLE "itf_circuit_doubles_9_4_5" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponent_in_the_final" text,
  "score_in_the_final" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date has elke clijsters as the partner?`:
```sql
                SELECT "date" FROM "itf_circuit_doubles_9_4_5" WHERE "partner"='elke clijsters';
```
## Task
Generate a SQL query to answer the following question:
`What is the Round with a Prize of money that is £120,000?`

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

CREATE TABLE "calendar" (
  "round" text,
  "date_weekend_of" text,
  "matches" real,
  "clubs" text,
  "prize_money" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Round with a Prize of money that is £120,000?`:
```sql
                SELECT "round" FROM "calendar" WHERE "prize_money"='£120,000';
```
## Task
Generate a SQL query to answer the following question:
`What is the Match with a Prize of money that is £1,000,000?`

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

CREATE TABLE "calendar" (
  "round" text,
  "date_weekend_of" text,
  "matches" real,
  "clubs" text,
  "prize_money" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Match with a Prize of money that is £1,000,000?`:
```sql
                SELECT "matches" FROM "calendar" WHERE "prize_money"='£1,000,000';
```
## Task
Generate a SQL query to answer the following question:
`When alvin and the chipmunks meet frankenstein, what was the role?`

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

CREATE TABLE "film" (
  "year" real,
  "title" text,
  "producer" text,
  "actor" text,
  "role" text
);
### SQL
Given the database schema, here is the SQL query that answers `When alvin and the chipmunks meet frankenstein, what was the role?`:
```sql
                SELECT "role" FROM "film" WHERE "title"='alvin and the chipmunks meet frankenstein';
```
## Task
Generate a SQL query to answer the following question:
`What's the earliest year with a role of alvin seville simon seville david 'dave' seville, and a Title of alvin and the chipmunks meet the wolfman?`

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

CREATE TABLE "film" (
  "year" real,
  "title" text,
  "producer" text,
  "actor" text,
  "role" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the earliest year with a role of alvin seville simon seville david 'dave' seville, and a Title of alvin and the chipmunks meet the wolfman?`:
```sql
                SELECT MIN("year") FROM "film" WHERE "role"='alvin seville simon seville david ''dave'' seville' AND "title"='alvin and the chipmunks meet the wolfman';
```
## Task
Generate a SQL query to answer the following question:
`What's the average year for the Role of alvin seville simon seville david 'dave' seville, and a Title of the chipmunk adventure?`

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

CREATE TABLE "film" (
  "year" real,
  "title" text,
  "producer" text,
  "actor" text,
  "role" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the average year for the Role of alvin seville simon seville david 'dave' seville, and a Title of the chipmunk adventure?`:
```sql
                SELECT AVG("year") FROM "film" WHERE "role"='alvin seville simon seville david ''dave'' seville' AND "title"='the chipmunk adventure';
```
## Task
Generate a SQL query to answer the following question:
`What was the role in the chipmunk adventure?`

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

CREATE TABLE "film" (
  "year" real,
  "title" text,
  "producer" text,
  "actor" text,
  "role" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the role in the chipmunk adventure?`:
```sql
                SELECT "role" FROM "film" WHERE "title"='the chipmunk adventure';
```
## Task
Generate a SQL query to answer the following question:
`What role was played in 2007?`

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

CREATE TABLE "film" (
  "year" real,
  "title" text,
  "producer" text,
  "actor" text,
  "role" text
);
### SQL
Given the database schema, here is the SQL query that answers `What role was played in 2007?`:
```sql
                SELECT "role" FROM "film" WHERE "year"=2007;
```
## Task
Generate a SQL query to answer the following question:
`What is the total number of points for the KV Racing Technology team when they use a chevrolet engine?`

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

CREATE TABLE "indy_car_series" (
  "year" real,
  "team" text,
  "chassis" text,
  "engine" text,
  "rank" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of points for the KV Racing Technology team when they use a chevrolet engine?`:
```sql
                SELECT COUNT("points") FROM "indy_car_series" WHERE "engine"='chevrolet' AND "team"='kv racing technology';
```
## Task
Generate a SQL query to answer the following question:
`Which engine has a chassis of dallara, is ranked 6th, and has 384 points?`

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

CREATE TABLE "indy_car_series" (
  "year" real,
  "team" text,
  "chassis" text,
  "engine" text,
  "rank" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which engine has a chassis of dallara, is ranked 6th, and has 384 points?`:
```sql
                SELECT "engine" FROM "indy_car_series" WHERE "chassis"='dallara' AND "rank"='6th' AND "points"=384;
```
## Task
Generate a SQL query to answer the following question:
`Which engine is used when there is a 3rd place rank and 513 points?`

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

CREATE TABLE "indy_car_series" (
  "year" real,
  "team" text,
  "chassis" text,
  "engine" text,
  "rank" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which engine is used when there is a 3rd place rank and 513 points?`:
```sql
                SELECT "engine" FROM "indy_car_series" WHERE "rank"='3rd' AND "points"=513;
```
## Task
Generate a SQL query to answer the following question:
`What is the chassis when the rank is 3rd?`

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

CREATE TABLE "indy_car_series" (
  "year" real,
  "team" text,
  "chassis" text,
  "engine" text,
  "rank" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the chassis when the rank is 3rd?`:
```sql
                SELECT "chassis" FROM "indy_car_series" WHERE "rank"='3rd';
```
## Task
Generate a SQL query to answer the following question:
`What are the years that Andretti Autosport is a team?`

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

CREATE TABLE "indy_car_series" (
  "year" real,
  "team" text,
  "chassis" text,
  "engine" text,
  "rank" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What are the years that Andretti Autosport is a team?`:
```sql
                SELECT COUNT("year") FROM "indy_car_series" WHERE "team"='andretti autosport';
```
## Task
Generate a SQL query to answer the following question:
`Which team is ranked 3rd in 2008?`

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

CREATE TABLE "indy_car_series" (
  "year" real,
  "team" text,
  "chassis" text,
  "engine" text,
  "rank" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which team is ranked 3rd in 2008?`:
```sql
                SELECT "team" FROM "indy_car_series" WHERE "rank"='3rd' AND "year"=2008;
```
## Task
Generate a SQL query to answer the following question:
`Which Oilers points have a Record of 10–6, and Oilers first downs larger than 14?`

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

CREATE TABLE "schedule" (
  "game" real,
  "date" text,
  "opponent" text,
  "result" text,
  "oilers_points" real,
  "opponents" real,
  "oilers_first_downs" real,
  "record" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Oilers points have a Record of 10–6, and Oilers first downs larger than 14?`:
```sql
                SELECT AVG("oilers_points") FROM "schedule" WHERE "record"='10–6' AND "oilers_first_downs">14;
```
## Task
Generate a SQL query to answer the following question:
`Which Oilers points have an Opponent of san francisco 49ers, and Opponents larger than 19?`

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

CREATE TABLE "schedule" (
  "game" real,
  "date" text,
  "opponent" text,
  "result" text,
  "oilers_points" real,
  "opponents" real,
  "oilers_first_downs" real,
  "record" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Oilers points have an Opponent of san francisco 49ers, and Opponents larger than 19?`:
```sql
                SELECT MAX("oilers_points") FROM "schedule" WHERE "opponent"='san francisco 49ers' AND "opponents">19;
```
## Task
Generate a SQL query to answer the following question:
`Which Game has an Opponent of at kansas city chiefs, and an Attendance smaller than 40,213?`

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

CREATE TABLE "schedule" (
  "game" real,
  "date" text,
  "opponent" text,
  "result" text,
  "oilers_points" real,
  "opponents" real,
  "oilers_first_downs" real,
  "record" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Game has an Opponent of at kansas city chiefs, and an Attendance smaller than 40,213?`:
```sql
                SELECT SUM("game") FROM "schedule" WHERE "opponent"='at kansas city chiefs' AND "attendance"<'40,213';
```
## Task
Generate a SQL query to answer the following question:
`What is the name of the country that has 18 May 2004 as the date?`

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

CREATE TABLE "release_history" (
  "country" text,
  "date" text,
  "label" text,
  "format" text,
  "catalog" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the name of the country that has 18 May 2004 as the date?`:
```sql
                SELECT "country" FROM "release_history" WHERE "date"='18 may 2004';
```
## Task
Generate a SQL query to answer the following question:
`What catalog has Australia as the country?`

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

CREATE TABLE "release_history" (
  "country" text,
  "date" text,
  "label" text,
  "format" text,
  "catalog" text
);
### SQL
Given the database schema, here is the SQL query that answers `What catalog has Australia as the country?`:
```sql
                SELECT "catalog" FROM "release_history" WHERE "country"='australia';
```
## Task
Generate a SQL query to answer the following question:
`In what format was the release that was dated 7 April 2003 from catalog 584 2112?`

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

CREATE TABLE "release_history" (
  "country" text,
  "date" text,
  "label" text,
  "format" text,
  "catalog" text
);
### SQL
Given the database schema, here is the SQL query that answers `In what format was the release that was dated 7 April 2003 from catalog 584 2112?`:
```sql
                SELECT "format" FROM "release_history" WHERE "date"='7 april 2003' AND "catalog"='584 2112';
```
## Task
Generate a SQL query to answer the following question:
`What date was the release when the format was lp?`

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

CREATE TABLE "release_history" (
  "country" text,
  "date" text,
  "label" text,
  "format" text,
  "catalog" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date was the release when the format was lp?`:
```sql
                SELECT "date" FROM "release_history" WHERE "format"='lp';
```
## Task
Generate a SQL query to answer the following question:
`What date is the release when the label was Parlophone and the catalog was 582 2912?`

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

CREATE TABLE "release_history" (
  "country" text,
  "date" text,
  "label" text,
  "format" text,
  "catalog" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date is the release when the label was Parlophone and the catalog was 582 2912?`:
```sql
                SELECT "date" FROM "release_history" WHERE "label"='parlophone' AND "catalog"='582 2912';
```
## Task
Generate a SQL query to answer the following question:
`What catalog has the United Kingdom as the country?`

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

CREATE TABLE "release_history" (
  "country" text,
  "date" text,
  "label" text,
  "format" text,
  "catalog" text
);
### SQL
Given the database schema, here is the SQL query that answers `What catalog has the United Kingdom as the country?`:
```sql
                SELECT "catalog" FROM "release_history" WHERE "country"='united kingdom';
```
## Task
Generate a SQL query to answer the following question:
`What is the nationality of the guard for the chool/Club Team in Virginia?`

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

CREATE TABLE "a" (
  "player" text,
  "nationality" text,
  "position" text,
  "years_in_orlando" text,
  "school_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the nationality of the guard for the chool/Club Team in Virginia?`:
```sql
                SELECT "nationality" FROM "a" WHERE "position"='guard' AND "school_club_team"='virginia';
```
## Task
Generate a SQL query to answer the following question:
`What is the School/Club Team with a nationality of United States for Arron Afflalo?`

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

CREATE TABLE "a" (
  "player" text,
  "nationality" text,
  "position" text,
  "years_in_orlando" text,
  "school_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the School/Club Team with a nationality of United States for Arron Afflalo?`:
```sql
                SELECT "school_club_team" FROM "a" WHERE "nationality"='united states' AND "player"='arron afflalo';
```
## Task
Generate a SQL query to answer the following question:
`What is the Years in Orlando for carlos arroyo?`

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

CREATE TABLE "a" (
  "player" text,
  "nationality" text,
  "position" text,
  "years_in_orlando" text,
  "school_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Years in Orlando for carlos arroyo?`:
```sql
                SELECT "years_in_orlando" FROM "a" WHERE "player"='carlos arroyo';
```
## Task
Generate a SQL query to answer the following question:
`What is the Player for Orlando in 1989–1991?`

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

CREATE TABLE "a" (
  "player" text,
  "nationality" text,
  "position" text,
  "years_in_orlando" text,
  "school_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Player for Orlando in 1989–1991?`:
```sql
                SELECT "player" FROM "a" WHERE "years_in_orlando"='1989–1991';
```
## Task
Generate a SQL query to answer the following question:
`What is the Position for Orlando for 1989–1999?`

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

CREATE TABLE "a" (
  "player" text,
  "nationality" text,
  "position" text,
  "years_in_orlando" text,
  "school_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Position for Orlando for 1989–1999?`:
```sql
                SELECT "position" FROM "a" WHERE "years_in_orlando"='1989–1999';
```
## Task
Generate a SQL query to answer the following question:
`Which player was from Western Washington University, played midfield, and was from years after 2009?`

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

CREATE TABLE "mcla_division_2" (
  "year" real,
  "team" text,
  "player" text,
  "position" text,
  "school" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which player was from Western Washington University, played midfield, and was from years after 2009?`:
```sql
                SELECT "player" FROM "mcla_division_2" WHERE "school"='western washington university' AND "position"='midfield' AND "year">2009;
```
## Task
Generate a SQL query to answer the following question:
`Which team was Bubba Vanegdom from?`

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

CREATE TABLE "mcla_division_2" (
  "year" real,
  "team" text,
  "player" text,
  "position" text,
  "school" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which team was Bubba Vanegdom from?`:
```sql
                SELECT "team" FROM "mcla_division_2" WHERE "player"='bubba vanegdom';
```
## Task
Generate a SQL query to answer the following question:
`What was the position of the player from Pacific Lutheran University named Greg Fredlund in years after 2010?`

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

CREATE TABLE "mcla_division_2" (
  "year" real,
  "team" text,
  "player" text,
  "position" text,
  "school" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the position of the player from Pacific Lutheran University named Greg Fredlund in years after 2010?`:
```sql
                SELECT "position" FROM "mcla_division_2" WHERE "school"='pacific lutheran university' AND "player"='greg fredlund' AND "year">2010;
```
## Task
Generate a SQL query to answer the following question:
`What was the position of Greg Fredlund in years after 2008?`

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

CREATE TABLE "mcla_division_2" (
  "year" real,
  "team" text,
  "player" text,
  "position" text,
  "school" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the position of Greg Fredlund in years after 2008?`:
```sql
                SELECT "position" FROM "mcla_division_2" WHERE "year">2008 AND "player"='greg fredlund';
```
## Task
Generate a SQL query to answer the following question:
`What home team has 8 ties?`

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

CREATE TABLE "fifth_round_proper" (
  "tie_no" text,
  "home_team" text,
  "score" text,
  "away_team" text,
  "date" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What home team has 8 ties?`:
```sql
                SELECT "home_team" FROM "fifth_round_proper" WHERE "tie_no"='8';
```
## Task
Generate a SQL query to answer the following question:
`What year had Kim Gevaert as the female winner and Xavier de Baerdemaeker as the male talent?`

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

CREATE TABLE "winners" (
  "year" real,
  "winner_male" text,
  "winner_female" text,
  "talent_male" text,
  "talent_female" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year had Kim Gevaert as the female winner and Xavier de Baerdemaeker as the male talent?`:
```sql
                SELECT "year" FROM "winners" WHERE "winner_female"='kim gevaert' AND "talent_male"='xavier de baerdemaeker';
```
## Task
Generate a SQL query to answer the following question:
`Who is the female talent in 1999?`

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

CREATE TABLE "winners" (
  "year" real,
  "winner_male" text,
  "winner_female" text,
  "talent_male" text,
  "talent_female" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the female talent in 1999?`:
```sql
                SELECT "talent_female" FROM "winners" WHERE "year"=1999;
```
## Task
Generate a SQL query to answer the following question:
`Who is the male talent in 1991?`

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

CREATE TABLE "winners" (
  "year" real,
  "winner_male" text,
  "winner_female" text,
  "talent_male" text,
  "talent_female" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the male talent in 1991?`:
```sql
                SELECT "talent_male" FROM "winners" WHERE "year"=1991;
```
## Task
Generate a SQL query to answer the following question:
`Who is the male winner the year after 1998 with Marleen Renders as the female winner?`

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

CREATE TABLE "winners" (
  "year" real,
  "winner_male" text,
  "winner_female" text,
  "talent_male" text,
  "talent_female" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the male winner the year after 1998 with Marleen Renders as the female winner?`:
```sql
                SELECT "winner_male" FROM "winners" WHERE "winner_female"='marleen renders' AND "year">1998;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest avg/g that has an effic greater than 34.36, with wesley carroll as the name?`

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

CREATE TABLE "passing" (
  "name" text,
  "gp_gs" text,
  "effic" real,
  "att_cmp_int" text,
  "avg_g" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest avg/g that has an effic greater than 34.36, with wesley carroll as the name?`:
```sql
                SELECT MIN("avg_g") FROM "passing" WHERE "effic">34.36 AND "name"='wesley carroll';
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest avg/g that has 2-9-0 for the att-cmp-int?`

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

CREATE TABLE "passing" (
  "name" text,
  "gp_gs" text,
  "effic" real,
  "att_cmp_int" text,
  "avg_g" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest avg/g that has 2-9-0 for the att-cmp-int?`:
```sql
                SELECT MIN("avg_g") FROM "passing" WHERE "att_cmp_int"='2-9-0';
```
## Task
Generate a SQL query to answer the following question:
`What is the att-cmp-int that has 12 for the gp-gs and 174.3 as the avg/g?`

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

CREATE TABLE "passing" (
  "name" text,
  "gp_gs" text,
  "effic" real,
  "att_cmp_int" text,
  "avg_g" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the att-cmp-int that has 12 for the gp-gs and 174.3 as the avg/g?`:
```sql
                SELECT "att_cmp_int" FROM "passing" WHERE "gp_gs"='12' AND "avg_g"=174.3;
```
## Task
Generate a SQL query to answer the following question:
`What is the Song with an Issue Date(s) that is 19 june?`

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

CREATE TABLE "see_also" (
  "volume_issue" text,
  "issue_date_s" text,
  "weeks_on_top" real,
  "song" text,
  "artist" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Song with an Issue Date(s) that is 19 june?`:
```sql
                SELECT "song" FROM "see_also" WHERE "issue_date_s"='19 june';
```