cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`What is the age group for figure skating?`

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

CREATE TABLE "women" (
  "sport" text,
  "competition_name" text,
  "competing_entities" text,
  "age_groups" text,
  "held_every" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the age group for figure skating?`:
```sql
                SELECT "age_groups" FROM "women" WHERE "sport"='figure skating';
```
## Task
Generate a SQL query to answer the following question:
`what is the sport when the age group is 21 or younger and the competition name is world youth netball championships?`

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

CREATE TABLE "women" (
  "sport" text,
  "competition_name" text,
  "competing_entities" text,
  "age_groups" text,
  "held_every" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the sport when the age group is 21 or younger and the competition name is world youth netball championships?`:
```sql
                SELECT "sport" FROM "women" WHERE "age_groups"='21 or younger' AND "competition_name"='world youth netball championships';
```
## Task
Generate a SQL query to answer the following question:
`what is the competition name when the age group is 17 or younger for athletics?`

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

CREATE TABLE "women" (
  "sport" text,
  "competition_name" text,
  "competing_entities" text,
  "age_groups" text,
  "held_every" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the competition name when the age group is 17 or younger for athletics?`:
```sql
                SELECT "competition_name" FROM "women" WHERE "age_groups"='17 or younger' AND "sport"='athletics';
```
## Task
Generate a SQL query to answer the following question:
`what is the competing entities when the age group is 18 or younger, held every is one year and the sport is table tennis?`

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

CREATE TABLE "women" (
  "sport" text,
  "competition_name" text,
  "competing_entities" text,
  "age_groups" text,
  "held_every" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the competing entities when the age group is 18 or younger, held every is one year and the sport is table tennis?`:
```sql
                SELECT "competing_entities" FROM "women" WHERE "age_groups"='18 or younger' AND "held_every"='one year' AND "sport"='table tennis';
```
## Task
Generate a SQL query to answer the following question:
`What result did Janis Ian have in the episode of top 3?`

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

CREATE TABLE "performances" (
  "episode" text,
  "song_choice" text,
  "original_artist" text,
  "order_num" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What result did Janis Ian have in the episode of top 3?`:
```sql
                SELECT "result" FROM "performances" WHERE "episode"='top 3' AND "original_artist"='janis ian';
```
## Task
Generate a SQL query to answer the following question:
`What was the result of the singer with the top 8?`

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

CREATE TABLE "performances" (
  "episode" text,
  "song_choice" text,
  "original_artist" text,
  "order_num" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the result of the singer with the top 8?`:
```sql
                SELECT "result" FROM "performances" WHERE "episode"='top 8';
```
## Task
Generate a SQL query to answer the following question:
`What song was chosen for the episode with the top 8?`

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

CREATE TABLE "performances" (
  "episode" text,
  "song_choice" text,
  "original_artist" text,
  "order_num" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What song was chosen for the episode with the top 8?`:
```sql
                SELECT "song_choice" FROM "performances" WHERE "episode"='top 8';
```
## Task
Generate a SQL query to answer the following question:
`Which episode had Hoagy carmichael safe with an order of 5?`

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

CREATE TABLE "performances" (
  "episode" text,
  "song_choice" text,
  "original_artist" text,
  "order_num" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which episode had Hoagy carmichael safe with an order of 5?`:
```sql
                SELECT "episode" FROM "performances" WHERE "result"='safe' AND "order_num"='5' AND "original_artist"='hoagy carmichael';
```
## Task
Generate a SQL query to answer the following question:
`In what order were the Bee Gees as the artist when it was a result of bottom 3?`

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

CREATE TABLE "performances" (
  "episode" text,
  "song_choice" text,
  "original_artist" text,
  "order_num" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `In what order were the Bee Gees as the artist when it was a result of bottom 3?`:
```sql
                SELECT "order_num" FROM "performances" WHERE "result"='bottom 3' AND "original_artist"='bee gees';
```
## Task
Generate a SQL query to answer the following question:
`Name the total number of drawn for danish and mathias`

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

CREATE TABLE "final" (
  "draw" real,
  "country" text,
  "language" text,
  "artist" text,
  "song" text,
  "english_translation" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the total number of drawn for danish and mathias`:
```sql
                SELECT COUNT("draw") FROM "final" WHERE "language"='danish' AND "artist"='mathias';
```
## Task
Generate a SQL query to answer the following question:
`Name the result for linn nygård`

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

CREATE TABLE "final" (
  "draw" real,
  "country" text,
  "language" text,
  "artist" text,
  "song" text,
  "english_translation" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the result for linn nygård`:
```sql
                SELECT "result" FROM "final" WHERE "artist"='linn nygård';
```
## Task
Generate a SQL query to answer the following question:
`Name the song for draw less than 7 and artists of martin & johannes`

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

CREATE TABLE "final" (
  "draw" real,
  "country" text,
  "language" text,
  "artist" text,
  "song" text,
  "english_translation" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the song for draw less than 7 and artists of martin & johannes`:
```sql
                SELECT "song" FROM "final" WHERE "draw"<7 AND "artist"='martin & johannes';
```
## Task
Generate a SQL query to answer the following question:
`Name the NP/NNP for ACDP of 1 and others of 1 and DP/DA of 5`

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

CREATE TABLE "election" (
  "event" text,
  "date" text,
  "dp_da" real,
  "np_nnp" text,
  "cope" text,
  "acdp" real,
  "others" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the NP/NNP for ACDP of 1 and others of 1 and DP/DA of 5`:
```sql
                SELECT "np_nnp" FROM "election" WHERE "acdp"=1 AND "others"=1 AND "dp_da"=5;
```
## Task
Generate a SQL query to answer the following question:
`Which player won less than $335?`

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

CREATE TABLE "final_leaderboard" (
  "place" text,
  "player" text,
  "country" text,
  "score" text,
  "to_par" text,
  "money" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which player won less than $335?`:
```sql
                SELECT "player" FROM "final_leaderboard" WHERE "money"<335;
```
## Task
Generate a SQL query to answer the following question:
`What was the place ranking for the player from Australia?`

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

CREATE TABLE "final_leaderboard" (
  "place" text,
  "player" text,
  "country" text,
  "score" text,
  "to_par" text,
  "money" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the place ranking for the player from Australia?`:
```sql
                SELECT "place" FROM "final_leaderboard" WHERE "country"='australia';
```
## Task
Generate a SQL query to answer the following question:
`How much money did the player Ed Oliver win?`

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

CREATE TABLE "final_leaderboard" (
  "place" text,
  "player" text,
  "country" text,
  "score" text,
  "to_par" text,
  "money" real
);
### SQL
Given the database schema, here is the SQL query that answers `How much money did the player Ed Oliver win?`:
```sql
                SELECT SUM("money") FROM "final_leaderboard" WHERE "player"='ed oliver';
```
## Task
Generate a SQL query to answer the following question:
`What competition did Parramatta Eels join after 1982?`

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

CREATE TABLE "runner_ups_10_62" (
  "year" real,
  "opponent" text,
  "competition" text,
  "score" text,
  "venue" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What competition did Parramatta Eels join after 1982?`:
```sql
                SELECT "competition" FROM "runner_ups_10_62" WHERE "year">1982 AND "opponent"='parramatta eels';
```
## Task
Generate a SQL query to answer the following question:
`When did nswrfl has a score of 8-21?`

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

CREATE TABLE "runner_ups_10_62" (
  "year" real,
  "opponent" text,
  "competition" text,
  "score" text,
  "venue" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `When did nswrfl has a score of 8-21?`:
```sql
                SELECT "year" FROM "runner_ups_10_62" WHERE "competition"='nswrfl' AND "score"='8-21';
```
## Task
Generate a SQL query to answer the following question:
`How many years have less than 28,505 attendance?`

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

CREATE TABLE "runner_ups_10_62" (
  "year" real,
  "opponent" text,
  "competition" text,
  "score" text,
  "venue" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many years have less than 28,505 attendance?`:
```sql
                SELECT AVG("year") FROM "runner_ups_10_62" WHERE "attendance"<'28,505';
```
## Task
Generate a SQL query to answer the following question:
`What Date is listed for the Region of France and Catalog of 82876-70291-2?`

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

CREATE TABLE "release_history" (
  "region" text,
  "date" text,
  "label" text,
  "format" text,
  "catalog" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Date is listed for the Region of France and Catalog of 82876-70291-2?`:
```sql
                SELECT "date" FROM "release_history" WHERE "region"='france' AND "catalog"='82876-70291-2';
```
## Task
Generate a SQL query to answer the following question:
`Which Format is listed that has a Region of China?`

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

CREATE TABLE "release_history" (
  "region" text,
  "date" text,
  "label" text,
  "format" text,
  "catalog" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Format is listed that has a Region of China?`:
```sql
                SELECT "format" FROM "release_history" WHERE "region"='china';
```
## Task
Generate a SQL query to answer the following question:
`What's the Date for the Label of Bertelsmann Music group and has a Region of Europe?`

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

CREATE TABLE "release_history" (
  "region" text,
  "date" text,
  "label" text,
  "format" text,
  "catalog" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the Date for the Label of Bertelsmann Music group and has a Region of Europe?`:
```sql
                SELECT "date" FROM "release_history" WHERE "label"='bertelsmann music group' AND "region"='europe';
```
## Task
Generate a SQL query to answer the following question:
`How many people attended the Royals game with a score of 17 - 6?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many people attended the Royals game with a score of 17 - 6?`:
```sql
                SELECT SUM("attendance") FROM "game_log" WHERE "opponent"='royals' AND "score"='17 - 6';
```
## Task
Generate a SQL query to answer the following question:
`What was the result of April 27's game?`

### 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 result of April 27's game?`:
```sql
                SELECT "score" FROM "game_log" WHERE "date"='april 27';
```
## Task
Generate a SQL query to answer the following question:
`Which of the .308 Winchester cartridge type has a 100 m group of 14 and also a 300 m group of 0.63?`

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

CREATE TABLE "design_details" (
  "308_winchester_cartridge_type" text,
  "100_m_group_mm" text,
  "100_m_group_moa" text,
  "300_m_group_mm" text,
  "300_m_group_moa" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which of the .308 Winchester cartridge type has a 100 m group of 14 and also a 300 m group of 0.63?`:
```sql
                SELECT "308_winchester_cartridge_type" FROM "design_details" WHERE "100_m_group_mm"='14' AND "300_m_group_moa"='0.63';
```
## Task
Generate a SQL query to answer the following question:
`For the strategy game in 1992, how many players were allowed per console?`

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

CREATE TABLE "licensed_titles" (
  "title" text,
  "year" real,
  "developer" text,
  "publisher" text,
  "players_per_console" text,
  "genre" text
);
### SQL
Given the database schema, here is the SQL query that answers `For the strategy game in 1992, how many players were allowed per console?`:
```sql
                SELECT "players_per_console" FROM "licensed_titles" WHERE "genre"='strategy' AND "year"=1992;
```
## Task
Generate a SQL query to answer the following question:
`Which Genre was published by Atari and developed by NuFX in 1991?`

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

CREATE TABLE "licensed_titles" (
  "title" text,
  "year" real,
  "developer" text,
  "publisher" text,
  "players_per_console" text,
  "genre" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Genre was published by Atari and developed by NuFX in 1991?`:
```sql
                SELECT "genre" FROM "licensed_titles" WHERE "publisher"='atari' AND "year"=1991 AND "developer"='nufx';
```
## Task
Generate a SQL query to answer the following question:
`Which year was the game developed by Music Comp in?`

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

CREATE TABLE "licensed_titles" (
  "title" text,
  "year" real,
  "developer" text,
  "publisher" text,
  "players_per_console" text,
  "genre" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which year was the game developed by Music Comp in?`:
```sql
                SELECT "year" FROM "licensed_titles" WHERE "developer"='music comp';
```
## Task
Generate a SQL query to answer the following question:
`Name the record for august 31`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the record for august 31`:
```sql
                SELECT "record" FROM "game_log" WHERE "date"='august 31';
```
## Task
Generate a SQL query to answer the following question:
`Name the opponent for august 6`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the opponent for august 6`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "date"='august 6';
```
## Task
Generate a SQL query to answer the following question:
`Name the opponent with record of 52-58`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the opponent with record of 52-58`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "record"='52-58';
```
## Task
Generate a SQL query to answer the following question:
`What Class has a Quantity made of 5?`

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

CREATE TABLE "belfast_and_northern_counties_railway_18" (
  "class" text,
  "type" text,
  "fleet_numbers" text,
  "quantity_made" real,
  "manufacturer" text,
  "date_made" text,
  "date_withdrawn" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Class has a Quantity made of 5?`:
```sql
                SELECT "class" FROM "belfast_and_northern_counties_railway_18" WHERE "quantity_made"=5;
```
## Task
Generate a SQL query to answer the following question:
`What is listed as the Date made with a Quantity made of 13?`

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

CREATE TABLE "belfast_and_northern_counties_railway_18" (
  "class" text,
  "type" text,
  "fleet_numbers" text,
  "quantity_made" real,
  "manufacturer" text,
  "date_made" text,
  "date_withdrawn" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is listed as the Date made with a Quantity made of 13?`:
```sql
                SELECT "date_made" FROM "belfast_and_northern_counties_railway_18" WHERE "quantity_made"=13;
```
## Task
Generate a SQL query to answer the following question:
`What year shows 4 points?`

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

CREATE TABLE "complete_formula_one_results" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What year shows 4 points?`:
```sql
                SELECT "year" FROM "complete_formula_one_results" WHERE "points"=4;
```
## Task
Generate a SQL query to answer the following question:
`What is the most points when the entrant was Jaguar racing earlier than 2001?`

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

CREATE TABLE "complete_formula_one_results" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the most points when the entrant was Jaguar racing earlier than 2001?`:
```sql
                SELECT MAX("points") FROM "complete_formula_one_results" WHERE "entrant"='jaguar racing' AND "year"<2001;
```
## Task
Generate a SQL query to answer the following question:
`What is the entrant in 1999?`

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

CREATE TABLE "complete_formula_one_results" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the entrant in 1999?`:
```sql
                SELECT "entrant" FROM "complete_formula_one_results" WHERE "year"=1999;
```
## Task
Generate a SQL query to answer the following question:
`What is the most points when the chassis was Jaguar R3 later than 2002?`

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

CREATE TABLE "complete_formula_one_results" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the most points when the chassis was Jaguar R3 later than 2002?`:
```sql
                SELECT MAX("points") FROM "complete_formula_one_results" WHERE "chassis"='jaguar r3' AND "year">2002;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest relative permeability with a skin depth larger than 0.112 inches?`

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

CREATE TABLE "skin_depth_at_24_k_hz" (
  "material" text,
  "resistivity_10_6_ohm_inches" real,
  "relative_permeability" real,
  "skin_depth_inches" real,
  "surface_resistance_relative_to_copper" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest relative permeability with a skin depth larger than 0.112 inches?`:
```sql
                SELECT MIN("relative_permeability") FROM "skin_depth_at_24_k_hz" WHERE "skin_depth_inches">0.112;
```
## Task
Generate a SQL query to answer the following question:
`What is the average relative permeability with a resistivity smaller than 1.12 and a surface resistance relative to copper smaller than 1?`

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

CREATE TABLE "skin_depth_at_24_k_hz" (
  "material" text,
  "resistivity_10_6_ohm_inches" real,
  "relative_permeability" real,
  "skin_depth_inches" real,
  "surface_resistance_relative_to_copper" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average relative permeability with a resistivity smaller than 1.12 and a surface resistance relative to copper smaller than 1?`:
```sql
                SELECT AVG("relative_permeability") FROM "skin_depth_at_24_k_hz" WHERE "resistivity_10_6_ohm_inches"<1.12 AND "surface_resistance_relative_to_copper"<1;
```
## Task
Generate a SQL query to answer the following question:
`What is the sum of skin depth with a resistivity of 1.12 and a relative permeability larger than 1?`

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

CREATE TABLE "skin_depth_at_24_k_hz" (
  "material" text,
  "resistivity_10_6_ohm_inches" real,
  "relative_permeability" real,
  "skin_depth_inches" real,
  "surface_resistance_relative_to_copper" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the sum of skin depth with a resistivity of 1.12 and a relative permeability larger than 1?`:
```sql
                SELECT SUM("skin_depth_inches") FROM "skin_depth_at_24_k_hz" WHERE "resistivity_10_6_ohm_inches"=1.12 AND "relative_permeability">1;
```
## Task
Generate a SQL query to answer the following question:
`How much does Jonathan Bender weigh?`

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

CREATE TABLE "contestants" (
  "pos" text,
  "player" text,
  "team" text,
  "height" text,
  "weight" real
);
### SQL
Given the database schema, here is the SQL query that answers `How much does Jonathan Bender weigh?`:
```sql
                SELECT "weight" FROM "contestants" WHERE "player"='jonathan bender';
```
## Task
Generate a SQL query to answer the following question:
`Of those with a height of 7-0, who weighs the most?`

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

CREATE TABLE "contestants" (
  "pos" text,
  "player" text,
  "team" text,
  "height" text,
  "weight" real
);
### SQL
Given the database schema, here is the SQL query that answers `Of those with a height of 7-0, who weighs the most?`:
```sql
                SELECT MAX("weight") FROM "contestants" WHERE "height"='7-0';
```
## Task
Generate a SQL query to answer the following question:
`What does DeShawn Stevenson weigh?`

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

CREATE TABLE "contestants" (
  "pos" text,
  "player" text,
  "team" text,
  "height" text,
  "weight" real
);
### SQL
Given the database schema, here is the SQL query that answers `What does DeShawn Stevenson weigh?`:
```sql
                SELECT SUM("weight") FROM "contestants" WHERE "player"='deshawn stevenson';
```
## Task
Generate a SQL query to answer the following question:
`Name the highest roll for coed and authority of state integrated with sacred heart school`

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

CREATE TABLE "timaru_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 highest roll for coed and authority of state integrated with sacred heart school`:
```sql
                SELECT MAX("roll") FROM "timaru_district" WHERE "gender"='coed' AND "authority"='state integrated' AND "name"='sacred heart school';
```
## Task
Generate a SQL query to answer the following question:
`What is the displacement of the engine that has a Redline rpm higher than 4750, from 2005?`

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

CREATE TABLE "models" (
  "engine_code" text,
  "displacement" text,
  "power_torque_rpm" text,
  "redline_rpm" real,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the displacement of the engine that has a Redline rpm higher than 4750, from 2005?`:
```sql
                SELECT "displacement" FROM "models" WHERE "redline_rpm">4750 AND "year"=2005;
```
## Task
Generate a SQL query to answer the following question:
`From what year is the engine with engine code M57D30?`

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

CREATE TABLE "models" (
  "engine_code" text,
  "displacement" text,
  "power_torque_rpm" text,
  "redline_rpm" real,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `From what year is the engine with engine code M57D30?`:
```sql
                SELECT "year" FROM "models" WHERE "engine_code"='m57d30';
```
## Task
Generate a SQL query to answer the following question:
`What is the average Redline RPM of engines with engine code M57TUD30, made after 2002?`

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

CREATE TABLE "models" (
  "engine_code" text,
  "displacement" text,
  "power_torque_rpm" text,
  "redline_rpm" real,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average Redline RPM of engines with engine code M57TUD30, made after 2002?`:
```sql
                SELECT AVG("redline_rpm") FROM "models" WHERE "engine_code"='m57tud30' AND "year">2002;
```
## Task
Generate a SQL query to answer the following question:
`What was the result against Beijing Hyundai?`

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

CREATE TABLE "pre_season_and_friendlies" (
  "date" text,
  "opponents" text,
  "h_a" text,
  "result_f_a" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the result against Beijing Hyundai?`:
```sql
                SELECT "result_f_a" FROM "pre_season_and_friendlies" WHERE "opponents"='beijing hyundai';
```
## Task
Generate a SQL query to answer the following question:
`Was the game with Kashima antlers at home or away?`

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

CREATE TABLE "pre_season_and_friendlies" (
  "date" text,
  "opponents" text,
  "h_a" text,
  "result_f_a" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Was the game with Kashima antlers at home or away?`:
```sql
                SELECT "h_a" FROM "pre_season_and_friendlies" WHERE "opponents"='kashima antlers';
```
## Task
Generate a SQL query to answer the following question:
`What date was the game against Royal Antwerp?`

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

CREATE TABLE "pre_season_and_friendlies" (
  "date" text,
  "opponents" text,
  "h_a" text,
  "result_f_a" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What date was the game against Royal Antwerp?`:
```sql
                SELECT "date" FROM "pre_season_and_friendlies" WHERE "opponents"='royal antwerp';
```
## Task
Generate a SQL query to answer the following question:
`What Records Time is 3:38?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "time" text,
  "att" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Records Time is 3:38?`:
```sql
                SELECT "record" FROM "game_log" WHERE "time"='3:38';
```
## Task
Generate a SQL query to answer the following question:
`What Country has a number smaller than 56 in 2005 and of 14 in 2006?`

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

CREATE TABLE "list" (
  "country" text,
  "2006" real,
  "2005" real,
  "2004" real,
  "2003" real
);
### SQL
Given the database schema, here is the SQL query that answers `What Country has a number smaller than 56 in 2005 and of 14 in 2006?`:
```sql
                SELECT COUNT("2004") FROM "list" WHERE "2005"<56 AND "2006"=14;
```
## Task
Generate a SQL query to answer the following question:
`What Country has a number smaller than 3 in 2004 and larger than 1 in 2005?`

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

CREATE TABLE "list" (
  "country" text,
  "2006" real,
  "2005" real,
  "2004" real,
  "2003" real
);
### SQL
Given the database schema, here is the SQL query that answers `What Country has a number smaller than 3 in 2004 and larger than 1 in 2005?`:
```sql
                SELECT COUNT("2006") FROM "list" WHERE "2004"<3 AND "2005">1;
```
## Task
Generate a SQL query to answer the following question:
`The building with 48 floors has an address in Las Vegas of what?`

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

CREATE TABLE "timeline_of_tallest_buildings" (
  "name" text,
  "street_address" text,
  "years_as_tallest" text,
  "height_ft_m" text,
  "floors" real
);
### SQL
Given the database schema, here is the SQL query that answers `The building with 48 floors has an address in Las Vegas of what?`:
```sql
                SELECT "street_address" FROM "timeline_of_tallest_buildings" WHERE "floors"=48;
```
## Task
Generate a SQL query to answer the following question:
`The Palazzo's street address is listed as what?`

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

CREATE TABLE "timeline_of_tallest_buildings" (
  "name" text,
  "street_address" text,
  "years_as_tallest" text,
  "height_ft_m" text,
  "floors" real
);
### SQL
Given the database schema, here is the SQL query that answers `The Palazzo's street address is listed as what?`:
```sql
                SELECT "street_address" FROM "timeline_of_tallest_buildings" WHERE "name"='the palazzo';
```
## Task
Generate a SQL query to answer the following question:
`What's the title of the song by Winger?`

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

CREATE TABLE "main_setlist" (
  "year" real,
  "song_title" text,
  "artist" text,
  "master_recording" text,
  "tier" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the title of the song by Winger?`:
```sql
                SELECT "song_title" FROM "main_setlist" WHERE "artist"='winger';
```
## Task
Generate a SQL query to answer the following question:
`What shows for 3rd place when Runner-up shows as runner-up?`

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

CREATE TABLE "winners" (
  "year" text,
  "venue" text,
  "winners" text,
  "runner_up" text,
  "3rd_place" text
);
### SQL
Given the database schema, here is the SQL query that answers `What shows for 3rd place when Runner-up shows as runner-up?`:
```sql
                SELECT "3rd_place" FROM "winners" WHERE "runner_up"='runner-up';
```
## Task
Generate a SQL query to answer the following question:
`What year shows as Runner-up of england (24 pts)?`

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

CREATE TABLE "winners" (
  "year" text,
  "venue" text,
  "winners" text,
  "runner_up" text,
  "3rd_place" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year shows as Runner-up of england (24 pts)?`:
```sql
                SELECT "year" FROM "winners" WHERE "runner_up"='england (24 pts)';
```
## Task
Generate a SQL query to answer the following question:
`What shows for Winners when it shows 3rd place of [[|]] (21 pts), and a Runner-up of united states (23 pts)?`

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

CREATE TABLE "winners" (
  "year" text,
  "venue" text,
  "winners" text,
  "runner_up" text,
  "3rd_place" text
);
### SQL
Given the database schema, here is the SQL query that answers `What shows for Winners when it shows 3rd place of [[|]] (21 pts), and a Runner-up of united states (23 pts)?`:
```sql
                SELECT "winners" FROM "winners" WHERE "3rd_place"='[[|]] (21 pts)' AND "runner_up"='united states (23 pts)';
```
## Task
Generate a SQL query to answer the following question:
`What shows for 3rd place when the venue was Pardubice?`

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

CREATE TABLE "winners" (
  "year" text,
  "venue" text,
  "winners" text,
  "runner_up" text,
  "3rd_place" text
);
### SQL
Given the database schema, here is the SQL query that answers `What shows for 3rd place when the venue was Pardubice?`:
```sql
                SELECT "3rd_place" FROM "winners" WHERE "venue"='pardubice';
```
## Task
Generate a SQL query to answer the following question:
`what shows for 3rd place in 1990?`

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

CREATE TABLE "winners" (
  "year" text,
  "venue" text,
  "winners" text,
  "runner_up" text,
  "3rd_place" text
);
### SQL
Given the database schema, here is the SQL query that answers `what shows for 3rd place in 1990?`:
```sql
                SELECT "3rd_place" FROM "winners" WHERE "year"='1990';
```
## Task
Generate a SQL query to answer the following question:
`What year was the venue Landshut?`

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

CREATE TABLE "winners" (
  "year" text,
  "venue" text,
  "winners" text,
  "runner_up" text,
  "3rd_place" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year was the venue Landshut?`:
```sql
                SELECT "year" FROM "winners" WHERE "venue"='landshut';
```
## Task
Generate a SQL query to answer the following question:
`What is the record when Tampa Bay is the visitor?`

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

CREATE TABLE "march" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "decision" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the record when Tampa Bay is the visitor?`:
```sql
                SELECT "record" FROM "march" WHERE "visitor"='tampa bay';
```
## Task
Generate a SQL query to answer the following question:
`What is the date when Joseph is the decision and San Jose is the home team?`

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

CREATE TABLE "march" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "decision" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the date when Joseph is the decision and San Jose is the home team?`:
```sql
                SELECT "date" FROM "march" WHERE "decision"='joseph' AND "home"='san jose';
```
## Task
Generate a SQL query to answer the following question:
`What is the date of the match when Detroit is the home team and Colorado is the visiting team?`

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

CREATE TABLE "march" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "decision" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the date of the match when Detroit is the home team and Colorado is the visiting team?`:
```sql
                SELECT "date" FROM "march" WHERE "home"='detroit' AND "visitor"='colorado';
```
## Task
Generate a SQL query to answer the following question:
`Who is the opponent with attendance greater than 73,984 with a result of w 28–14?`

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

CREATE TABLE "schedule" (
  "week" real,
  "date" text,
  "opponent" text,
  "result" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the opponent with attendance greater than 73,984 with a result of w 28–14?`:
```sql
                SELECT "opponent" FROM "schedule" WHERE "attendance">'73,984' AND "result"='w 28–14';
```
## Task
Generate a SQL query to answer the following question:
`How many people were in attendance in a week over 4 on December 6, 1981?`

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

CREATE TABLE "schedule" (
  "week" real,
  "date" text,
  "opponent" text,
  "result" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many people were in attendance in a week over 4 on December 6, 1981?`:
```sql
                SELECT COUNT("attendance") FROM "schedule" WHERE "week">4 AND "date"='december 6, 1981';
```
## Task
Generate a SQL query to answer the following question:
`Name the least game for october 10 at shibe park`

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

CREATE TABLE "summary" (
  "game" real,
  "date" text,
  "location" text,
  "time" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the least game for october 10 at shibe park`:
```sql
                SELECT MIN("game") FROM "summary" WHERE "location"='shibe park' AND "date"='october 10';
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest bronze total that has a rank of 1 and more than 34 total medals?`

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

CREATE TABLE "medal_table" (
  "rank" text,
  "nation" text,
  "gold" text,
  "silver" text,
  "bronze" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest bronze total that has a rank of 1 and more than 34 total medals?`:
```sql
                SELECT MIN("bronze") FROM "medal_table" WHERE "rank"='1' AND "total">34;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest bronze total that has a silver total of 13 medals?`

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

CREATE TABLE "medal_table" (
  "rank" text,
  "nation" text,
  "gold" text,
  "silver" text,
  "bronze" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest bronze total that has a silver total of 13 medals?`:
```sql
                SELECT MIN("bronze") FROM "medal_table" WHERE "silver"='13';
```
## Task
Generate a SQL query to answer the following question:
`With Appearances larger than 1, what is the Wins for the Reno Aces Team?`

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

CREATE TABLE "appearances_by_team" (
  "appearances" real,
  "team" text,
  "wins" real,
  "losses" real,
  "winning_percentage" real,
  "season_s" text
);
### SQL
Given the database schema, here is the SQL query that answers `With Appearances larger than 1, what is the Wins for the Reno Aces Team?`:
```sql
                SELECT MIN("wins") FROM "appearances_by_team" WHERE "team"='reno aces' AND "appearances">1;
```
## Task
Generate a SQL query to answer the following question:
`For the Reno Aces, what are the Losses when they had 1 Appearances and a Winning Percentage of 1?`

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

CREATE TABLE "appearances_by_team" (
  "appearances" real,
  "team" text,
  "wins" real,
  "losses" real,
  "winning_percentage" real,
  "season_s" text
);
### SQL
Given the database schema, here is the SQL query that answers `For the Reno Aces, what are the Losses when they had 1 Appearances and a Winning Percentage of 1?`:
```sql
                SELECT SUM("losses") FROM "appearances_by_team" WHERE "appearances"=1 AND "winning_percentage"=1 AND "team"='reno aces';
```
## Task
Generate a SQL query to answer the following question:
`In 2009, what Appearances had a Winning Percentage of less than 0?`

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

CREATE TABLE "appearances_by_team" (
  "appearances" real,
  "team" text,
  "wins" real,
  "losses" real,
  "winning_percentage" real,
  "season_s" text
);
### SQL
Given the database schema, here is the SQL query that answers `In 2009, what Appearances had a Winning Percentage of less than 0?`:
```sql
                SELECT AVG("appearances") FROM "appearances_by_team" WHERE "season_s"='2009' AND "winning_percentage"<0;
```
## Task
Generate a SQL query to answer the following question:
`What is the chassis for the year of 1969?`

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

CREATE TABLE "complete_world_championship_formula_one_" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the chassis for the year of 1969?`:
```sql
                SELECT "chassis" FROM "complete_world_championship_formula_one_" WHERE "year"=1969;
```
## Task
Generate a SQL query to answer the following question:
`Which Occupation has a Rank of 5th, a Gender of M, with a Residence of orono?`

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

CREATE TABLE "4_seats" (
  "riding" text,
  "candidate_s_name" text,
  "gender" text,
  "residence" text,
  "occupation" text,
  "votes" real,
  "rank" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Occupation has a Rank of 5th, a Gender of M, with a Residence of orono?`:
```sql
                SELECT "occupation" FROM "4_seats" WHERE "rank"='5th' AND "gender"='m' AND "residence"='orono';
```
## Task
Generate a SQL query to answer the following question:
`Which Gender has a Residence of Haliburton?`

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

CREATE TABLE "4_seats" (
  "riding" text,
  "candidate_s_name" text,
  "gender" text,
  "residence" text,
  "occupation" text,
  "votes" real,
  "rank" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Gender has a Residence of Haliburton?`:
```sql
                SELECT "gender" FROM "4_seats" WHERE "residence"='haliburton';
```
## Task
Generate a SQL query to answer the following question:
`What's the lowest in Votes with a Rank of 5th, has an Occupation of retired, along with a Riding of Brant?`

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

CREATE TABLE "4_seats" (
  "riding" text,
  "candidate_s_name" text,
  "gender" text,
  "residence" text,
  "occupation" text,
  "votes" real,
  "rank" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the lowest in Votes with a Rank of 5th, has an Occupation of retired, along with a Riding of Brant?`:
```sql
                SELECT MIN("votes") FROM "4_seats" WHERE "rank"='5th' AND "occupation"='retired' AND "riding"='brant';
```
## Task
Generate a SQL query to answer the following question:
`What Occupation has the Rank of 5th and has a Candidate's Name of Henry Zekveld?`

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

CREATE TABLE "4_seats" (
  "riding" text,
  "candidate_s_name" text,
  "gender" text,
  "residence" text,
  "occupation" text,
  "votes" real,
  "rank" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Occupation has the Rank of 5th and has a Candidate's Name of Henry Zekveld?`:
```sql
                SELECT "occupation" FROM "4_seats" WHERE "rank"='5th' AND "candidate_s_name"='henry zekveld';
```
## Task
Generate a SQL query to answer the following question:
`What is the sum of the people in attendance when there was a Loss of clement (5–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 is the sum of the people in attendance when there was a Loss of clement (5–7)?`:
```sql
                SELECT SUM("attendance") FROM "game_log" WHERE "loss"='clement (5–7)';
```
## Task
Generate a SQL query to answer the following question:
`What place was Corey Pavin in?`

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

CREATE TABLE "second_round" (
  "place" text,
  "player" text,
  "country" text,
  "score" text,
  "to_par" text
);
### SQL
Given the database schema, here is the SQL query that answers `What place was Corey Pavin in?`:
```sql
                SELECT "place" FROM "second_round" WHERE "player"='corey pavin';
```