output stringlengths 27 479 | instruction stringlengths 407 1.39k |
|---|---|
SELECT AVG("week") FROM "schedule" WHERE "result"='l 10-7' AND "attendance"<'37,500'; |
## Task
Generate a SQL query to answer the following question:
`What was the average week of a game with a result of l 10-7 attended by 37,500?`
### 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 `What was the average week of a game with a result of l 10-7 attended by 37,500?`:
```sql
|
SELECT AVG("attendance") FROM "schedule" WHERE "date"='october 30, 1938'; |
## Task
Generate a SQL query to answer the following question:
`What was the average attendance on October 30, 1938?`
### 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 `What was the average attendance on October 30, 1938?`:
```sql
|
SELECT "date" FROM "1974" WHERE "city"='belgrade' AND "type_of_game"='friendly'; |
## Task
Generate a SQL query to answer the following question:
`When did Yugoslavia play a friendly game in Belgrade?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1974" (
"date" text,
"city" text,
"opponent" text,
"results" text,
"type_of_game" text
);
### SQL
Given the database schema, here is the SQL query that answers `When did Yugoslavia play a friendly game in Belgrade?`:
```sql
|
SELECT "date" FROM "1974" WHERE "type_of_game"='wc 1974 qualifying'; |
## Task
Generate a SQL query to answer the following question:
`When was the WC 1974 Qualifying game?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1974" (
"date" text,
"city" text,
"opponent" text,
"results" text,
"type_of_game" text
);
### SQL
Given the database schema, here is the SQL query that answers `When was the WC 1974 Qualifying game?`:
```sql
|
SELECT "city" FROM "1974" WHERE "opponent"='norway'; |
## Task
Generate a SQL query to answer the following question:
`What city did Yugoslavia play Norway in?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1974" (
"date" text,
"city" text,
"opponent" text,
"results" text,
"type_of_game" text
);
### SQL
Given the database schema, here is the SQL query that answers `What city did Yugoslavia play Norway in?`:
```sql
|
SELECT "opponent" FROM "1974" WHERE "results"='2:3'; |
## Task
Generate a SQL query to answer the following question:
`Who did Yugoslavia play against that led to a result of 2:3?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1974" (
"date" text,
"city" text,
"opponent" text,
"results" text,
"type_of_game" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who did Yugoslavia play against that led to a result of 2:3?`:
```sql
|
SELECT "score_in_final" FROM "doubles_10_6_4" WHERE "outcome"='runner-up' AND "date"='9 february 1992'; |
## Task
Generate a SQL query to answer the following question:
`What is the final score of the runner-up on 9 February 1992?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_10_6_4" (
"outcome" text,
"date" text,
"tournament" text,
"surface" text,
"partner" text,
"opponents_in_final" text,
"score_in_final" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the final score of the runner-up on 9 February 1992?`:
```sql
|
SELECT "opponent" FROM "mixed_martial_arts_record" WHERE "time"='1:50'; |
## Task
Generate a SQL query to answer the following question:
`Which opponent has a time of 1:50?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "mixed_martial_arts_record" (
"res" text,
"record" text,
"opponent" text,
"method" text,
"event" text,
"round" real,
"time" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which opponent has a time of 1:50?`:
```sql
|
SELECT "opponent" FROM "mixed_martial_arts_record" WHERE "time"='2:35'; |
## Task
Generate a SQL query to answer the following question:
`Which opponent has a time of 2:35?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "mixed_martial_arts_record" (
"res" text,
"record" text,
"opponent" text,
"method" text,
"event" text,
"round" real,
"time" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which opponent has a time of 2:35?`:
```sql
|
SELECT "time" FROM "mixed_martial_arts_record" WHERE "opponent"='stephanie palmer'; |
## Task
Generate a SQL query to answer the following question:
`What is the time when the opponent is stephanie palmer?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "mixed_martial_arts_record" (
"res" text,
"record" text,
"opponent" text,
"method" text,
"event" text,
"round" real,
"time" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the time when the opponent is stephanie palmer?`:
```sql
|
SELECT "tournament" FROM "singles_wins_5" WHERE "opponent_in_the_final"='samantha stosur'; |
## Task
Generate a SQL query to answer the following question:
`What tournament has Samantha Stosur as the opponent in the final?`
### 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 tournament has Samantha Stosur as the opponent in the final?`:
```sql
|
SELECT "date" FROM "singles_wins_5" WHERE "tournament"='zürich, switzerland'; |
## 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 "surface"='hard' AND "tournament"='sydney, australia'; |
## 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 "result" FROM "international_goals" WHERE "date"='4 april 1993'; |
## 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 "venue" FROM "international_goals" WHERE "result"='5-1' AND "score"='3-0'; |
## 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 "score" FROM "international_goals" WHERE "result"='5-1'; |
## 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 "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-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-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 "to_par" FROM "winners" WHERE "winner"='gary player'; |
## 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 SUM("pata") FROM "comparison_of_nvidia_chipsets" WHERE "model"='nforce professional 3400 mcp'; |
## 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 "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 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 "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 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 "network" FROM "comparison_of_nvidia_chipsets" WHERE "model"='nforce professional 3400 mcp'; |
## 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 "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 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 "research_funding_000">'7,238' AND "gained_university_status">1932; |
## 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 "model" FROM "fiat_scudo_engines" WHERE "displacement"='1,868 cc'; |
## 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 "college_junior_club_team_league" FROM "draft_picks" WHERE "round"=8; |
## 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 "nationality" FROM "draft_picks" WHERE "player"='daryn fersovich'; |
## 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 "date" FROM "round_17" WHERE "ground"='subiaco'; |
## 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 "home_team" FROM "round_17" WHERE "home_team_score"='11.11 (77)'; |
## 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 AVG("crowd") FROM "round_17" WHERE "away_team_score"='14.14 (98)'; |
## 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 "away_team_score" FROM "round_17" WHERE "home_team_score"='15.8 (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 "home_team_score" FROM "round_17" WHERE "home_team"='essendon'; |
## 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 COUNT("crowd") FROM "round_17" WHERE "home_team"='melbourne'; |
## 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 "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 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"='jason & edyta' AND "style"='freestyle'; |
## 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 "music" FROM "week_10" WHERE "style"='jive'; |
## 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 "couple" FROM "week_10" WHERE "result"='third place' AND "style"='cha-cha-cha'; |
## 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 "score" 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 "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:
`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 "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 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 "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 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 "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 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 "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 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 "prize" FROM "event_schedule" WHERE "entrants"=453; |
## 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 "results" FROM "event_schedule" WHERE "runner_up"='michael demichele'; |
## 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 "entrants"<'1,236' AND "prize"='$817,781'; |
## 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 MIN("entrants") FROM "event_schedule" WHERE "winner"='grant hinkle'; |
## 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 AVG("entrants") FROM "event_schedule" WHERE "winner"='frank gary'; |
## 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 "medal" FROM "list_of_medalists" WHERE "games"='1996 atlanta' AND "sport"='wrestling'; |
## 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 "name" FROM "list_of_medalists" WHERE "games"='2008 beijing'; |
## 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 "event" FROM "list_of_medalists" WHERE "name"='cristina iovu'; |
## 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 "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:
`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 "sport" FROM "list_of_medalists" WHERE "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 "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 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 "surname" FROM "player_roster" WHERE "first"='donovan'; |
## 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 "throws" FROM "player_roster" WHERE "first"='james'; |
## 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 "d_o_b" FROM "player_roster" WHERE "surname"='biddle'; |
## 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 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:
`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 "team" FROM "attendances" WHERE "highest">'2,169' AND "average">'3,502'; |
## 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 AVG("capacity") FROM "attendances" WHERE "highest"<'3,378' AND "stadium"='cappielow'; |
## 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 "opponent" FROM "game_log" WHERE "attendance"='33,628'; |
## 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 "loss" FROM "game_log" WHERE "attendance"='38,062'; |
## 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 "score" FROM "game_log" WHERE "attendance"='33,531'; |
## 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 "date" FROM "game_log" WHERE "attendance"='38,062'; |
## 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 "college_junior_club_team_league" FROM "draft_picks" WHERE "player"='brendan locke'; |
## 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 "position"='right wing' AND "round"='sup'; |
## 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 "round" FROM "draft_picks" WHERE "position"='goaltender'; |
## 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 "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 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"='right wing' AND "round"='6'; |
## 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 "round" FROM "draft_picks" WHERE "position"='center' AND "player"='john parco'; |
## 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 "team" FROM "county_cricket" WHERE "draws"='15'; |
## 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 "season" FROM "county_cricket" WHERE "losses"='16' AND "team"='hampshire'; |
## 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 "wins"='0' AND "losses"='5' AND "team"='surrey'; |
## 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 "draws"='10'; |
## 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 "draws" FROM "county_cricket" WHERE "team"='durham'; |
## 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 "wins" FROM "county_cricket" WHERE "draws"='8'; |
## 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 "grid" FROM "race" WHERE "driver"='jenson button'; |
## 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 "constructor" FROM "race" WHERE "laps"='56' AND "grid"='15'; |
## 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 "grid"='20'; |
## 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 "time_retired" FROM "race" WHERE "constructor"='renault' AND "laps"='40'; |
## 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 "constructor" FROM "race" WHERE "grid"='6'; |
## 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 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 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("f_lap") FROM "by_season" WHERE "pole">0 AND "podiums"=6; |
## 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 "home" FROM "february" WHERE "record"='33-18-9'; |
## 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 "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 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 "visitor"='toronto' AND "record"='29-17-8'; |
## 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 "home" FROM "february" WHERE "visitor"='detroit' AND "date"='february 29'; |
## 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 "music" FROM "discography" WHERE "record_label"='moviebox/ speed records / music waves'; |
## 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 MAX("year") FROM "discography" WHERE "record_label"='supertone melodies'; |
## 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 "record_label" FROM "discography" WHERE "album"='tera roop'; |
## Task
Generate a SQL query to answer the following question:
`Which Record label has an Album of tera roop?`
### 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 Record label has an Album of tera roop?`:
```sql
|
SELECT "record_label" FROM "discography" WHERE "album"='rambo'; |
## Task
Generate a SQL query to answer the following question:
`Which Record label has an Album of rambo?`
### 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 Record label has an Album of rambo?`:
```sql
|
SELECT "info" FROM "discography" WHERE "album"='romeo'; |
## Task
Generate a SQL query to answer the following question:
`Which Info has an Album of romeo?`
### 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 Info has an Album of romeo?`:
```sql
|
SELECT AVG("attendance") FROM "game_log" WHERE "record"='58–49'; |
## Task
Generate a SQL query to answer the following question:
`What was the average attendance when the record was 58–49?`
### 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 average attendance when the record was 58–49?`:
```sql
|
SELECT SUM("attendance") FROM "game_log" WHERE "score"='8–7'; |
## Task
Generate a SQL query to answer the following question:
`What was the attendance when the score was 8–7?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the attendance when the score was 8–7?`:
```sql
|
SELECT COUNT("attendance") FROM "game_log" WHERE "date"='july 18'; |
## Task
Generate a SQL query to answer the following question:
`What was the attendance for july 18?`
### 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 attendance for july 18?`:
```sql
|
SELECT "to_par" FROM "major_tournaments_hosted" WHERE "score"='1 up'; |
## Task
Generate a SQL query to answer the following question:
`How many strokes to par when the score is 1 up?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "major_tournaments_hosted" (
"year" real,
"tournament" text,
"winner" text,
"country" text,
"score" text,
"to_par" text,
"margin_of_victory" text,
"winner_s_share" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many strokes to par when the score is 1 up?`:
```sql
|
SELECT "series" FROM "nba_finals" WHERE "game"='game 5'; |
## Task
Generate a SQL query to answer the following question:
`Name the series for game 5`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "nba_finals" (
"game" text,
"date" text,
"result" text,
"site" text,
"series" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the series for game 5`:
```sql
|
SELECT "site" FROM "nba_finals" WHERE "game"='game 2'; |
## Task
Generate a SQL query to answer the following question:
`Name the site for game of game 2`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "nba_finals" (
"game" text,
"date" text,
"result" text,
"site" text,
"series" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the site for game of game 2`:
```sql
|
SELECT "site" FROM "nba_finals" WHERE "game"='game 6'; |
## Task
Generate a SQL query to answer the following question:
`Name the site with game of game 6`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "nba_finals" (
"game" text,
"date" text,
"result" text,
"site" text,
"series" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the site with game of game 6`:
```sql
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.