cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`What date is the zürich, switzerland tournament?`

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

CREATE TABLE "singles_wins_5" (
  "date" 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 date is the zürich, switzerland tournament?`:
```sql
                SELECT "date" FROM "singles_wins_5" WHERE "tournament"='zürich, switzerland';
```
## Task
Generate a SQL query to answer the following question:
`What is the date of the Sydney, Australia tournament with a hard surface?`

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

CREATE TABLE "singles_wins_5" (
  "date" 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 is the date of the Sydney, Australia tournament with a hard surface?`:
```sql
                SELECT "date" FROM "singles_wins_5" WHERE "surface"='hard' AND "tournament"='sydney, australia';
```
## Task
Generate a SQL query to answer the following question:
`Which Result has a Date of 4 april 1993?`

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

CREATE TABLE "international_goals" (
  "date" text,
  "venue" text,
  "score" text,
  "result" text,
  "competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Result has a Date of 4 april 1993?`:
```sql
                SELECT "result" FROM "international_goals" WHERE "date"='4 april 1993';
```
## Task
Generate a SQL query to answer the following question:
`Which Venue has a Result of 5-1, and a Score of 3-0?`

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

CREATE TABLE "international_goals" (
  "date" text,
  "venue" text,
  "score" text,
  "result" text,
  "competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Venue has a Result of 5-1, and a Score of 3-0?`:
```sql
                SELECT "venue" FROM "international_goals" WHERE "result"='5-1' AND "score"='3-0';
```
## Task
Generate a SQL query to answer the following question:
`Which Score has a Result of 5-1?`

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

CREATE TABLE "international_goals" (
  "date" text,
  "venue" text,
  "score" text,
  "result" text,
  "competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Score has a Result of 5-1?`:
```sql
                SELECT "score" FROM "international_goals" WHERE "result"='5-1';
```
## Task
Generate a SQL query to answer the following question:
`Which Venue has a Result of 5-1, and a Score of 1-0?`

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

CREATE TABLE "international_goals" (
  "date" text,
  "venue" text,
  "score" text,
  "result" text,
  "competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Venue has a Result of 5-1, and a Score of 1-0?`:
```sql
                SELECT "venue" FROM "international_goals" WHERE "result"='5-1' AND "score"='1-0';
```
## Task
Generate a SQL query to answer the following question:
`Which Venue has a Result of 5-0?`

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

CREATE TABLE "international_goals" (
  "date" text,
  "venue" text,
  "score" text,
  "result" text,
  "competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Venue has a Result of 5-0?`:
```sql
                SELECT "venue" FROM "international_goals" WHERE "result"='5-0';
```
## Task
Generate a SQL query to answer the following question:
`What did winner Gary Player par?`

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

CREATE TABLE "winners" (
  "year" real,
  "date" text,
  "winner" text,
  "score" text,
  "to_par" text,
  "winner_s_share" real
);
### SQL
Given the database schema, here is the SQL query that answers `What did winner Gary Player par?`:
```sql
                SELECT "to_par" FROM "winners" WHERE "winner"='gary player';
```
## Task
Generate a SQL query to answer the following question:
`How many PATAs does an nForce Professional 3400 MCP have?`

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

CREATE TABLE "comparison_of_nvidia_chipsets" (
  "model" text,
  "processors_supported" text,
  "fsb_ht_frequency_m_hz" text,
  "memory" text,
  "pci_express" text,
  "sata" real,
  "pata" real,
  "sound" text,
  "network" text,
  "features" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many PATAs does an nForce Professional 3400 MCP have?`:
```sql
                SELECT SUM("pata") FROM "comparison_of_nvidia_chipsets" WHERE "model"='nforce professional 3400 mcp';
```
## Task
Generate a SQL query to answer the following question:
`Which PCI-Express has a DDR 266/333/400 Registered/ECC memory and Enhanced AC'97 2.3 sound?`

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

CREATE TABLE "comparison_of_nvidia_chipsets" (
  "model" text,
  "processors_supported" text,
  "fsb_ht_frequency_m_hz" text,
  "memory" text,
  "pci_express" text,
  "sata" real,
  "pata" real,
  "sound" text,
  "network" text,
  "features" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which PCI-Express has a DDR 266/333/400 Registered/ECC memory and Enhanced AC'97 2.3 sound?`:
```sql
                SELECT "pci_express" FROM "comparison_of_nvidia_chipsets" WHERE "memory"='ddr 266/333/400 registered/ecc' AND "sound"='enhanced ac''97 2.3';
```
## Task
Generate a SQL query to answer the following question:
`Which FSB/HT frequency (MHz) has a SATA larger than 6 and DDR 266/333/400 Registered/ECC memory?`

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

CREATE TABLE "comparison_of_nvidia_chipsets" (
  "model" text,
  "processors_supported" text,
  "fsb_ht_frequency_m_hz" text,
  "memory" text,
  "pci_express" text,
  "sata" real,
  "pata" real,
  "sound" text,
  "network" text,
  "features" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which FSB/HT frequency (MHz) has a SATA larger than 6 and DDR 266/333/400 Registered/ECC memory?`:
```sql
                SELECT "fsb_ht_frequency_m_hz" FROM "comparison_of_nvidia_chipsets" WHERE "sata">6 AND "memory"='ddr 266/333/400 registered/ecc';
```
## Task
Generate a SQL query to answer the following question:
`Which network has model nForce Professional 3400 MCP?`

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

CREATE TABLE "comparison_of_nvidia_chipsets" (
  "model" text,
  "processors_supported" text,
  "fsb_ht_frequency_m_hz" text,
  "memory" text,
  "pci_express" text,
  "sata" real,
  "pata" real,
  "sound" text,
  "network" text,
  "features" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which network has model nForce Professional 3400 MCP?`:
```sql
                SELECT "network" FROM "comparison_of_nvidia_chipsets" WHERE "model"='nforce professional 3400 mcp';
```
## Task
Generate a SQL query to answer the following question:
`Which institution has more than 19,020 students in london with a research funding of more than 7,734?`

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

CREATE TABLE "members" (
  "institution" text,
  "location" text,
  "established" real,
  "gained_university_status" real,
  "vice_chancellor" text,
  "total_number_of_students" real,
  "research_funding_000" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which institution has more than 19,020 students in london with a research funding of more than 7,734?`:
```sql
                SELECT "institution" FROM "members" WHERE "total_number_of_students">'19,020' AND "location"='london' AND "research_funding_000">'7,734';
```
## Task
Generate a SQL query to answer the following question:
`Which institution gained university status after 1932 and has a research funding more than 7,238?`

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

CREATE TABLE "members" (
  "institution" text,
  "location" text,
  "established" real,
  "gained_university_status" real,
  "vice_chancellor" text,
  "total_number_of_students" real,
  "research_funding_000" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which institution gained university status after 1932 and has a research funding more than 7,238?`:
```sql
                SELECT "institution" FROM "members" WHERE "research_funding_000">'7,238' AND "gained_university_status">1932;
```
## Task
Generate a SQL query to answer the following question:
`What model has an engine of 1,868 cc?`

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

CREATE TABLE "fiat_scudo_engines" (
  "model" text,
  "engine" text,
  "displacement" text,
  "valvetrain" text,
  "fuel_system" text,
  "max_power_at_rpm" text,
  "max_torque_at_rpm" text,
  "years" text
);
### SQL
Given the database schema, here is the SQL query that answers `What model has an engine of 1,868 cc?`:
```sql
                SELECT "model" FROM "fiat_scudo_engines" WHERE "displacement"='1,868 cc';
```
## Task
Generate a SQL query to answer the following question:
`What College team has 8 rounds?`

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

CREATE TABLE "draft_picks" (
  "round" real,
  "player" text,
  "position" text,
  "nationality" text,
  "college_junior_club_team_league" text
);
### SQL
Given the database schema, here is the SQL query that answers `What College team has 8 rounds?`:
```sql
                SELECT "college_junior_club_team_league" FROM "draft_picks" WHERE "round"=8;
```
## Task
Generate a SQL query to answer the following question:
`What nationality is Daryn Fersovich?`

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

CREATE TABLE "draft_picks" (
  "round" real,
  "player" text,
  "position" text,
  "nationality" text,
  "college_junior_club_team_league" text
);
### SQL
Given the database schema, here is the SQL query that answers `What nationality is Daryn Fersovich?`:
```sql
                SELECT "nationality" FROM "draft_picks" WHERE "player"='daryn fersovich';
```
## Task
Generate a SQL query to answer the following question:
`What day was the ground subiaco?`

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

CREATE TABLE "round_17" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "ground" text,
  "crowd" real,
  "date" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What day was the ground subiaco?`:
```sql
                SELECT "date" FROM "round_17" WHERE "ground"='subiaco';
```
## Task
Generate a SQL query to answer the following question:
`Which home team had a score of 11.11 (77)?`

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

CREATE TABLE "round_17" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "ground" text,
  "crowd" real,
  "date" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which home team had a score of 11.11 (77)?`:
```sql
                SELECT "home_team" FROM "round_17" WHERE "home_team_score"='11.11 (77)';
```
## Task
Generate a SQL query to answer the following question:
`What's the average crowd when the away team score was 14.14 (98)?`

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

CREATE TABLE "round_17" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "ground" text,
  "crowd" real,
  "date" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the average crowd when the away team score was 14.14 (98)?`:
```sql
                SELECT AVG("crowd") FROM "round_17" WHERE "away_team_score"='14.14 (98)';
```
## Task
Generate a SQL query to answer the following question:
`Which away team score had a home team score of 15.8 (98)?`

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

CREATE TABLE "round_17" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "ground" text,
  "crowd" real,
  "date" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which away team score had a home team score of 15.8 (98)?`:
```sql
                SELECT "away_team_score" FROM "round_17" WHERE "home_team_score"='15.8 (98)';
```
## Task
Generate a SQL query to answer the following question:
`What was the home team score for essendon?`

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

CREATE TABLE "round_17" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "ground" text,
  "crowd" real,
  "date" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the home team score for essendon?`:
```sql
                SELECT "home_team_score" FROM "round_17" WHERE "home_team"='essendon';
```
## Task
Generate a SQL query to answer the following question:
`What was the crowd size for the Home team of melbourne?`

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

CREATE TABLE "round_17" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "ground" text,
  "crowd" real,
  "date" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the crowd size for the Home team of melbourne?`:
```sql
                SELECT COUNT("crowd") FROM "round_17" WHERE "home_team"='melbourne';
```
## Task
Generate a SQL query to answer the following question:
`Which Score has a Couple of cristián & cheryl, and a Style of cha-cha-cha?`

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

CREATE TABLE "week_10" (
  "couple" text,
  "score" text,
  "style" text,
  "music" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Score has a Couple of cristián & cheryl, and a Style of cha-cha-cha?`:
```sql
                SELECT "score" FROM "week_10" WHERE "couple"='cristián & cheryl' AND "style"='cha-cha-cha';
```
## Task
Generate a SQL query to answer the following question:
`Which Score has a Couple comprised of jason & edyta, and a Style of freestyle?`

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

CREATE TABLE "week_10" (
  "couple" text,
  "score" text,
  "style" text,
  "music" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Score has a Couple comprised of jason & edyta, and a Style of freestyle?`:
```sql
                SELECT "score" FROM "week_10" WHERE "couple"='jason & edyta' AND "style"='freestyle';
```
## Task
Generate a SQL query to answer the following question:
`Which music is jive?`

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

CREATE TABLE "week_10" (
  "couple" text,
  "score" text,
  "style" text,
  "music" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which music is jive?`:
```sql
                SELECT "music" FROM "week_10" WHERE "style"='jive';
```
## Task
Generate a SQL query to answer the following question:
`Which Couple has a Result of third place, and a Style of cha-cha-cha?`

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

CREATE TABLE "week_10" (
  "couple" text,
  "score" text,
  "style" text,
  "music" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Couple has a Result of third place, and a Style of cha-cha-cha?`:
```sql
                SELECT "couple" FROM "week_10" WHERE "result"='third place' AND "style"='cha-cha-cha';
```
## Task
Generate a SQL query to answer the following question:
`Which Score has a Result of third place, and a Style of cha-cha-cha?`

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

CREATE TABLE "week_10" (
  "couple" text,
  "score" text,
  "style" text,
  "music" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Score has a Result of third place, and a Style of cha-cha-cha?`:
```sql
                SELECT "score" FROM "week_10" WHERE "result"='third place' AND "style"='cha-cha-cha';
```
## Task
Generate a SQL query to answer the following question:
`Which Music has a Score of 30 (10, 10, 10), and a Style of cha-cha-cha?`

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

CREATE TABLE "week_10" (
  "couple" text,
  "score" text,
  "style" text,
  "music" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Music has a Score of 30 (10, 10, 10), and a Style of cha-cha-cha?`:
```sql
                SELECT "music" FROM "week_10" WHERE "score"='30 (10, 10, 10)' AND "style"='cha-cha-cha';
```
## Task
Generate a SQL query to answer the following question:
`What is the Australian National Kennel Council Toy Dogs Group with papillon as the Kennel Club breed?`

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

CREATE TABLE "toy_group_breeds_of_major_kennel_clubs_k" (
  "the_kennel_club_uk_toy_group" text,
  "canadian_kennel_club_toy_dogs_group" text,
  "american_kennel_club_toy_group" text,
  "australian_national_kennel_council_toy_dogs_group" text,
  "new_zealand_kennel_club_toy_group" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Australian National Kennel Council Toy Dogs Group with papillon as the Kennel Club breed?`:
```sql
                SELECT "australian_national_kennel_council_toy_dogs_group" FROM "toy_group_breeds_of_major_kennel_clubs_k" WHERE "the_kennel_club_uk_toy_group"='papillon';
```
## Task
Generate a SQL query to answer the following question:
`What is the New Zealand Kennel Club Toy Group with papillon as the Australian National Kennel Council Toy Dogs Group breed?`

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

CREATE TABLE "toy_group_breeds_of_major_kennel_clubs_k" (
  "the_kennel_club_uk_toy_group" text,
  "canadian_kennel_club_toy_dogs_group" text,
  "american_kennel_club_toy_group" text,
  "australian_national_kennel_council_toy_dogs_group" text,
  "new_zealand_kennel_club_toy_group" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the New Zealand Kennel Club Toy Group with papillon as the Australian National Kennel Council Toy Dogs Group breed?`:
```sql
                SELECT "new_zealand_kennel_club_toy_group" FROM "toy_group_breeds_of_major_kennel_clubs_k" WHERE "australian_national_kennel_council_toy_dogs_group"='papillon';
```
## Task
Generate a SQL query to answer the following question:
`What is the Canadian Kennel Club Toy Dogs Group with the australian silky terrier as the Australian National Kennel Council Toy Dogs Group breed?`

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

CREATE TABLE "toy_group_breeds_of_major_kennel_clubs_k" (
  "the_kennel_club_uk_toy_group" text,
  "canadian_kennel_club_toy_dogs_group" text,
  "american_kennel_club_toy_group" text,
  "australian_national_kennel_council_toy_dogs_group" text,
  "new_zealand_kennel_club_toy_group" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Canadian Kennel Club Toy Dogs Group with the australian silky terrier as the Australian National Kennel Council Toy Dogs Group breed?`:
```sql
                SELECT "canadian_kennel_club_toy_dogs_group" FROM "toy_group_breeds_of_major_kennel_clubs_k" WHERE "australian_national_kennel_council_toy_dogs_group"='australian silky terrier';
```
## Task
Generate a SQL query to answer the following question:
`What is the Kennel Club (UK) Toy Group with the shih-tzu as the American Kennel Club Toy Group breed?`

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

CREATE TABLE "toy_group_breeds_of_major_kennel_clubs_k" (
  "the_kennel_club_uk_toy_group" text,
  "canadian_kennel_club_toy_dogs_group" text,
  "american_kennel_club_toy_group" text,
  "australian_national_kennel_council_toy_dogs_group" text,
  "new_zealand_kennel_club_toy_group" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Kennel Club (UK) Toy Group with the shih-tzu as the American Kennel Club Toy Group breed?`:
```sql
                SELECT "the_kennel_club_uk_toy_group" FROM "toy_group_breeds_of_major_kennel_clubs_k" WHERE "american_kennel_club_toy_group"='shih-tzu';
```
## Task
Generate a SQL query to answer the following question:
`What prize amount was awarded at the event with 453 entrants?`

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

CREATE TABLE "event_schedule" (
  "entrants" real,
  "winner" text,
  "prize" text,
  "runner_up" text,
  "results" text
);
### SQL
Given the database schema, here is the SQL query that answers `What prize amount was awarded at the event with 453 entrants?`:
```sql
                SELECT "prize" FROM "event_schedule" WHERE "entrants"=453;
```
## Task
Generate a SQL query to answer the following question:
`What were the overall event results when Michael Demichele was runner-up?`

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

CREATE TABLE "event_schedule" (
  "entrants" real,
  "winner" text,
  "prize" text,
  "runner_up" text,
  "results" text
);
### SQL
Given the database schema, here is the SQL query that answers `What were the overall event results when Michael Demichele was runner-up?`:
```sql
                SELECT "results" FROM "event_schedule" WHERE "runner_up"='michael demichele';
```
## Task
Generate a SQL query to answer the following question:
`What were the results of the event where $817,781 was awarded to less than 1,236 entrants?`

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

CREATE TABLE "event_schedule" (
  "entrants" real,
  "winner" text,
  "prize" text,
  "runner_up" text,
  "results" text
);
### SQL
Given the database schema, here is the SQL query that answers `What were the results of the event where $817,781 was awarded to less than 1,236 entrants?`:
```sql
                SELECT "results" FROM "event_schedule" WHERE "entrants"<'1,236' AND "prize"='$817,781';
```
## Task
Generate a SQL query to answer the following question:
`What was the fewest entrants in an event won by Grant Hinkle?`

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

CREATE TABLE "event_schedule" (
  "entrants" real,
  "winner" text,
  "prize" text,
  "runner_up" text,
  "results" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the fewest entrants in an event won by Grant Hinkle?`:
```sql
                SELECT MIN("entrants") FROM "event_schedule" WHERE "winner"='grant hinkle';
```
## Task
Generate a SQL query to answer the following question:
`How many entrants did the events won by Frank Gary average?`

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

CREATE TABLE "event_schedule" (
  "entrants" real,
  "winner" text,
  "prize" text,
  "runner_up" text,
  "results" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many entrants did the events won by Frank Gary average?`:
```sql
                SELECT AVG("entrants") FROM "event_schedule" WHERE "winner"='frank gary';
```
## Task
Generate a SQL query to answer the following question:
`What medal was won in the 1996 Atlanta games in wrestling?`

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

CREATE TABLE "list_of_medalists" (
  "medal" text,
  "name" text,
  "games" text,
  "sport" text,
  "event" text
);
### SQL
Given the database schema, here is the SQL query that answers `What medal was won in the 1996 Atlanta games in wrestling?`:
```sql
                SELECT "medal" FROM "list_of_medalists" WHERE "games"='1996 atlanta' AND "sport"='wrestling';
```
## Task
Generate a SQL query to answer the following question:
`Who won a medal at the 2008 Beijing Olympics?`

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

CREATE TABLE "list_of_medalists" (
  "medal" text,
  "name" text,
  "games" text,
  "sport" text,
  "event" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who won a medal at the 2008 Beijing Olympics?`:
```sql
                SELECT "name" FROM "list_of_medalists" WHERE "games"='2008 beijing';
```
## Task
Generate a SQL query to answer the following question:
`What event did Cristina Iovu participate in?`

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

CREATE TABLE "list_of_medalists" (
  "medal" text,
  "name" text,
  "games" text,
  "sport" text,
  "event" text
);
### SQL
Given the database schema, here is the SQL query that answers `What event did Cristina Iovu participate in?`:
```sql
                SELECT "event" FROM "list_of_medalists" WHERE "name"='cristina iovu';
```
## Task
Generate a SQL query to answer the following question:
`At which games was a bronze medal won in the 94kg men's weightlifting event?`

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

CREATE TABLE "list_of_medalists" (
  "medal" text,
  "name" text,
  "games" text,
  "sport" text,
  "event" text
);
### SQL
Given the database schema, here is the SQL query that answers `At which games was a bronze medal won in the 94kg men's weightlifting event?`:
```sql
                SELECT "games" FROM "list_of_medalists" WHERE "medal"='bronze' AND "sport"='weightlifting' AND "event"='94kg men''s weightlifting';
```
## Task
Generate a SQL query to answer the following question:
`Which sport has 94kg men's weightlifting as one of its events?`

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

CREATE TABLE "list_of_medalists" (
  "medal" text,
  "name" text,
  "games" text,
  "sport" text,
  "event" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which sport has 94kg men's weightlifting as one of its events?`:
```sql
                SELECT "sport" FROM "list_of_medalists" WHERE "event"='94kg men''s weightlifting';
```
## Task
Generate a SQL query to answer the following question:
`What is the Name of the Quarterback with a Pick # less than 11?`

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

CREATE TABLE "atlanta_falcons_draft_history" (
  "round" real,
  "pick_num" real,
  "overall" real,
  "name" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Name of the Quarterback with a Pick # less than 11?`:
```sql
                SELECT "name" FROM "atlanta_falcons_draft_history" WHERE "pick_num"<11 AND "position"='quarterback';
```
## Task
Generate a SQL query to answer the following question:
`What is donovan's surname?`

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

CREATE TABLE "player_roster" (
  "surname" text,
  "first" text,
  "d_o_b" text,
  "bats" text,
  "throws" text,
  "position" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is donovan's surname?`:
```sql
                SELECT "surname" FROM "player_roster" WHERE "first"='donovan';
```
## Task
Generate a SQL query to answer the following question:
`How many throws did james get?`

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

CREATE TABLE "player_roster" (
  "surname" text,
  "first" text,
  "d_o_b" text,
  "bats" text,
  "throws" text,
  "position" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many throws did james get?`:
```sql
                SELECT "throws" FROM "player_roster" WHERE "first"='james';
```
## Task
Generate a SQL query to answer the following question:
`When is Biddle's DOB?`

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

CREATE TABLE "player_roster" (
  "surname" text,
  "first" text,
  "d_o_b" text,
  "bats" text,
  "throws" text,
  "position" text
);
### SQL
Given the database schema, here is the SQL query that answers `When is Biddle's DOB?`:
```sql
                SELECT "d_o_b" FROM "player_roster" WHERE "surname"='biddle';
```
## Task
Generate a SQL query to answer the following question:
`Average larger than 2,279, and a Team of queen of the south, and a Capacity larger than 6,412 has what lowest of the sum?`

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

CREATE TABLE "attendances" (
  "team" text,
  "stadium" text,
  "capacity" real,
  "highest" real,
  "lowest" real,
  "average" real
);
### SQL
Given the database schema, here is the SQL query that answers `Average larger than 2,279, and a Team of queen of the south, and a Capacity larger than 6,412 has what lowest of the sum?`:
```sql
                SELECT SUM("lowest") FROM "attendances" WHERE "average">'2,279' AND "team"='queen of the south' AND "capacity">'6,412';
```
## Task
Generate a SQL query to answer the following question:
`Highest larger than 2,169, and a Average larger than 3,502 involves which team?`

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

CREATE TABLE "attendances" (
  "team" text,
  "stadium" text,
  "capacity" real,
  "highest" real,
  "lowest" real,
  "average" real
);
### SQL
Given the database schema, here is the SQL query that answers `Highest larger than 2,169, and a Average larger than 3,502 involves which team?`:
```sql
                SELECT "team" FROM "attendances" WHERE "highest">'2,169' AND "average">'3,502';
```
## Task
Generate a SQL query to answer the following question:
`Highest smaller than 3,378, and a Stadium of cappielow has what average capacity?`

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

CREATE TABLE "attendances" (
  "team" text,
  "stadium" text,
  "capacity" real,
  "highest" real,
  "lowest" real,
  "average" real
);
### SQL
Given the database schema, here is the SQL query that answers `Highest smaller than 3,378, and a Stadium of cappielow has what average capacity?`:
```sql
                SELECT AVG("capacity") FROM "attendances" WHERE "highest"<'3,378' AND "stadium"='cappielow';
```
## Task
Generate a SQL query to answer the following question:
`Who is the opponent of the game with 33,628 folks in attendance?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the opponent of the game with 33,628 folks in attendance?`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "attendance"='33,628';
```
## Task
Generate a SQL query to answer the following question:
`What is the loss of the game with 38,062 folks in attendance?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the loss of the game with 38,062 folks in attendance?`:
```sql
                SELECT "loss" FROM "game_log" WHERE "attendance"='38,062';
```
## Task
Generate a SQL query to answer the following question:
`What is the score of the game that 33,531 people went too?`

### 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" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the score of the game that 33,531 people went too?`:
```sql
                SELECT "score" FROM "game_log" WHERE "attendance"='33,531';
```
## Task
Generate a SQL query to answer the following question:
`What is the date of the game with 38,062 people in attendance?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the date of the game with 38,062 people in attendance?`:
```sql
                SELECT "date" FROM "game_log" WHERE "attendance"='38,062';
```
## Task
Generate a SQL query to answer the following question:
`What is Brendan Locke's College/Junior/Club Team (League)?`

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

CREATE TABLE "draft_picks" (
  "round" text,
  "player" text,
  "position" text,
  "nationality" text,
  "college_junior_club_team_league" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is Brendan Locke's College/Junior/Club Team (League)?`:
```sql
                SELECT "college_junior_club_team_league" FROM "draft_picks" WHERE "player"='brendan locke';
```
## Task
Generate a SQL query to answer the following question:
`What League's Round is Sup and Position is Right Wing?`

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

CREATE TABLE "draft_picks" (
  "round" text,
  "player" text,
  "position" text,
  "nationality" text,
  "college_junior_club_team_league" text
);
### SQL
Given the database schema, here is the SQL query that answers `What League's Round is Sup and Position is Right Wing?`:
```sql
                SELECT "college_junior_club_team_league" FROM "draft_picks" WHERE "position"='right wing' AND "round"='sup';
```
## Task
Generate a SQL query to answer the following question:
`In what Round is the Position Goaltender?`

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

CREATE TABLE "draft_picks" (
  "round" text,
  "player" text,
  "position" text,
  "nationality" text,
  "college_junior_club_team_league" text
);
### SQL
Given the database schema, here is the SQL query that answers `In what Round is the Position Goaltender?`:
```sql
                SELECT "round" FROM "draft_picks" WHERE "position"='goaltender';
```
## Task
Generate a SQL query to answer the following question:
`In what League is Left Wing Yanick Dupre?`

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

CREATE TABLE "draft_picks" (
  "round" text,
  "player" text,
  "position" text,
  "nationality" text,
  "college_junior_club_team_league" text
);
### SQL
Given the database schema, here is the SQL query that answers `In what League is Left Wing Yanick Dupre?`:
```sql
                SELECT "college_junior_club_team_league" FROM "draft_picks" WHERE "position"='left wing' AND "player"='yanick dupre';
```
## Task
Generate a SQL query to answer the following question:
`In what League in Round 6 is the Position Right Wing?`

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

CREATE TABLE "draft_picks" (
  "round" text,
  "player" text,
  "position" text,
  "nationality" text,
  "college_junior_club_team_league" text
);
### SQL
Given the database schema, here is the SQL query that answers `In what League in Round 6 is the Position Right Wing?`:
```sql
                SELECT "college_junior_club_team_league" FROM "draft_picks" WHERE "position"='right wing' AND "round"='6';
```
## Task
Generate a SQL query to answer the following question:
`In what Round is John Parco a Center?`

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

CREATE TABLE "draft_picks" (
  "round" text,
  "player" text,
  "position" text,
  "nationality" text,
  "college_junior_club_team_league" text
);
### SQL
Given the database schema, here is the SQL query that answers `In what Round is John Parco a Center?`:
```sql
                SELECT "round" FROM "draft_picks" WHERE "position"='center' AND "player"='john parco';
```
## Task
Generate a SQL query to answer the following question:
`Which team had 15 draws?`

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

CREATE TABLE "county_cricket" (
  "season" text,
  "team" text,
  "wins" text,
  "losses" text,
  "draws" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which team had 15 draws?`:
```sql
                SELECT "team" FROM "county_cricket" WHERE "draws"='15';
```
## Task
Generate a SQL query to answer the following question:
`Which season had 16 losses for the Hampshire team?`

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

CREATE TABLE "county_cricket" (
  "season" text,
  "team" text,
  "wins" text,
  "losses" text,
  "draws" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which season had 16 losses for the Hampshire team?`:
```sql
                SELECT "season" FROM "county_cricket" WHERE "losses"='16' AND "team"='hampshire';
```
## Task
Generate a SQL query to answer the following question:
`Which season had 0 wins and 5 losses for the Surrey team?`

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

CREATE TABLE "county_cricket" (
  "season" text,
  "team" text,
  "wins" text,
  "losses" text,
  "draws" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which season had 0 wins and 5 losses for the Surrey team?`:
```sql
                SELECT "season" FROM "county_cricket" WHERE "wins"='0' AND "losses"='5' AND "team"='surrey';
```
## Task
Generate a SQL query to answer the following question:
`Which season had 10 draws?`

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

CREATE TABLE "county_cricket" (
  "season" text,
  "team" text,
  "wins" text,
  "losses" text,
  "draws" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which season had 10 draws?`:
```sql
                SELECT "season" FROM "county_cricket" WHERE "draws"='10';
```
## Task
Generate a SQL query to answer the following question:
`How many draws did Durham have?`

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

CREATE TABLE "county_cricket" (
  "season" text,
  "team" text,
  "wins" text,
  "losses" text,
  "draws" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many draws did Durham have?`:
```sql
                SELECT "draws" FROM "county_cricket" WHERE "team"='durham';
```
## Task
Generate a SQL query to answer the following question:
`How many wins happened with 8 draws?`

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

CREATE TABLE "county_cricket" (
  "season" text,
  "team" text,
  "wins" text,
  "losses" text,
  "draws" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many wins happened with 8 draws?`:
```sql
                SELECT "wins" FROM "county_cricket" WHERE "draws"='8';
```
## Task
Generate a SQL query to answer the following question:
`What was the grid of Jenson Button?`

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

CREATE TABLE "race" (
  "driver" text,
  "constructor" text,
  "laps" text,
  "time_retired" text,
  "grid" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the grid of Jenson Button?`:
```sql
                SELECT "grid" FROM "race" WHERE "driver"='jenson button';
```
## Task
Generate a SQL query to answer the following question:
`Who was the constructor of the car that went 56 laps and had a grid of 15?`

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

CREATE TABLE "race" (
  "driver" text,
  "constructor" text,
  "laps" text,
  "time_retired" text,
  "grid" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the constructor of the car that went 56 laps and had a grid of 15?`:
```sql
                SELECT "constructor" FROM "race" WHERE "laps"='56' AND "grid"='15';
```
## Task
Generate a SQL query to answer the following question:
`Who was the contstructor of the car having a grid of 20?`

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

CREATE TABLE "race" (
  "driver" text,
  "constructor" text,
  "laps" text,
  "time_retired" text,
  "grid" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the contstructor of the car having a grid of 20?`:
```sql
                SELECT "constructor" FROM "race" WHERE "grid"='20';
```
## Task
Generate a SQL query to answer the following question:
`What was the time of the car having a constructor of Renault, which went 40 laps?`

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

CREATE TABLE "race" (
  "driver" text,
  "constructor" text,
  "laps" text,
  "time_retired" text,
  "grid" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the time of the car having a constructor of Renault, which went 40 laps?`:
```sql
                SELECT "time_retired" FROM "race" WHERE "constructor"='renault' AND "laps"='40';
```
## Task
Generate a SQL query to answer the following question:
`Who constructed the car that had a grid of 6?`

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

CREATE TABLE "race" (
  "driver" text,
  "constructor" text,
  "laps" text,
  "time_retired" text,
  "grid" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who constructed the car that had a grid of 6?`:
```sql
                SELECT "constructor" FROM "race" WHERE "grid"='6';
```
## Task
Generate a SQL query to answer the following question:
`Can you tell me the sum of Podiums that has the Season of 2006, and the Races larger than 16?`

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

CREATE TABLE "by_season" (
  "season" text,
  "races" real,
  "podiums" real,
  "pole" real,
  "f_lap" real
);
### SQL
Given the database schema, here is the SQL query that answers `Can you tell me the sum of Podiums that has the Season of 2006, and the Races larger than 16?`:
```sql
                SELECT SUM("podiums") FROM "by_season" WHERE "season"='2006' AND "races">16;
```
## Task
Generate a SQL query to answer the following question:
`Can you tell me the sum of FLap that has the Pole larger than 0, and the Podiums of 6?`

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

CREATE TABLE "by_season" (
  "season" text,
  "races" real,
  "podiums" real,
  "pole" real,
  "f_lap" real
);
### SQL
Given the database schema, here is the SQL query that answers `Can you tell me the sum of FLap that has the Pole larger than 0, and the Podiums of 6?`:
```sql
                SELECT SUM("f_lap") FROM "by_season" WHERE "pole">0 AND "podiums"=6;
```
## Task
Generate a SQL query to answer the following question:
`Name the home with record of 33-18-9`

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

CREATE TABLE "february" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the home with record of 33-18-9`:
```sql
                SELECT "home" FROM "february" WHERE "record"='33-18-9';
```
## Task
Generate a SQL query to answer the following question:
`Name the score for detroit home and record of 33-18-9`

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

CREATE TABLE "february" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the score for detroit home and record of 33-18-9`:
```sql
                SELECT "score" FROM "february" WHERE "home"='detroit' AND "record"='33-18-9';
```
## Task
Generate a SQL query to answer the following question:
`Name the score for toronto visitor and record of 29-17-8`

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

CREATE TABLE "february" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the score for toronto visitor and record of 29-17-8`:
```sql
                SELECT "score" FROM "february" WHERE "visitor"='toronto' AND "record"='29-17-8';
```
## Task
Generate a SQL query to answer the following question:
`Name the home for detroit visitor and date of february 29`

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

CREATE TABLE "february" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the home for detroit visitor and date of february 29`:
```sql
                SELECT "home" FROM "february" WHERE "visitor"='detroit' AND "date"='february 29';
```
## Task
Generate a SQL query to answer the following question:
`Which Music has a Record label of moviebox/ speed records / music waves?`

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

CREATE TABLE "discography" (
  "year" real,
  "album" text,
  "record_label" text,
  "info" text,
  "music" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Music has a Record label of moviebox/ speed records / music waves?`:
```sql
                SELECT "music" FROM "discography" WHERE "record_label"='moviebox/ speed records / music waves';
```
## Task
Generate a SQL query to answer the following question:
`Which Year is the highest one that has a Record label of supertone melodies?`

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

CREATE TABLE "discography" (
  "year" real,
  "album" text,
  "record_label" text,
  "info" text,
  "music" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Year is the highest one that has a Record label of supertone melodies?`:
```sql
                SELECT MAX("year") FROM "discography" WHERE "record_label"='supertone melodies';
```