output stringlengths 27 479 | instruction stringlengths 407 1.39k |
|---|---|
SELECT COUNT("silver") FROM "medal_table" WHERE "gold">0 AND "rank"='14' AND "bronze">4; |
## Task
Generate a SQL query to answer the following question:
`What is number of silver for the country with more than 0 gold, rank of 14, and more than 4 bronze?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table" (
"rank" text,
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is number of silver for the country with more than 0 gold, rank of 14, and more than 4 bronze?`:
```sql
|
SELECT SUM("gold") FROM "medal_table" WHERE "rank"='19'; |
## Task
Generate a SQL query to answer the following question:
`What is the number of gold for the country ranked 19?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table" (
"rank" text,
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the number of gold for the country ranked 19?`:
```sql
|
SELECT MIN("silver") FROM "medal_table" WHERE "bronze"<0; |
## Task
Generate a SQL query to answer the following question:
`What is the least amount of silver when there is less than 0 bronze?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table" (
"rank" text,
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the least amount of silver when there is less than 0 bronze?`:
```sql
|
SELECT MAX("bronze") FROM "medal_table" WHERE "total"=14 AND "gold">6; |
## Task
Generate a SQL query to answer the following question:
`What is the most bronze when the total is 14, and there are more than 6 gold?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table" (
"rank" text,
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the most bronze when the total is 14, and there are more than 6 gold?`:
```sql
|
SELECT "world_record" FROM "records" WHERE "187kg"='392kg'; |
## Task
Generate a SQL query to answer the following question:
`Which world record has a 187kg of 392kg?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "records" (
"world_record" text,
"snatch" text,
"andrei_rybakou_blr" text,
"187kg" text,
"chiang_mai_thailand" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which world record has a 187kg of 392kg?`:
```sql
|
SELECT "187kg" FROM "records" WHERE "snatch"='clean & jerk'; |
## Task
Generate a SQL query to answer the following question:
`Who has 187kg and a Snatch of Clean & Jerk?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "records" (
"world_record" text,
"snatch" text,
"andrei_rybakou_blr" text,
"187kg" text,
"chiang_mai_thailand" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who has 187kg and a Snatch of Clean & Jerk?`:
```sql
|
SELECT "world_record" FROM "records" WHERE "187kg"='392kg'; |
## Task
Generate a SQL query to answer the following question:
`What is the world record for a 187kg of 392kg?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "records" (
"world_record" text,
"snatch" text,
"andrei_rybakou_blr" text,
"187kg" text,
"chiang_mai_thailand" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the world record for a 187kg of 392kg?`:
```sql
|
SELECT "reserved_for_sc_st_none" FROM "assembly_segments" WHERE "constituency_number"='203'; |
## Task
Generate a SQL query to answer the following question:
`What is the Reserved for (SC / ST /None) when the constituency number is 203?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "assembly_segments" (
"constituency_number" text,
"name" text,
"reserved_for_sc_st_none" text,
"district" text,
"number_of_electorates_2009" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Reserved for (SC / ST /None) when the constituency number is 203?`:
```sql
|
SELECT SUM("number_of_electorates_2009") FROM "assembly_segments" WHERE "district"='indore' AND "reserved_for_sc_st_none"='none' AND "constituency_number"='208'; |
## Task
Generate a SQL query to answer the following question:
`What is the number of electorates (2009) for the Indore district, when reserved for (SC / ST /None) is none, and constituency number is 208?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "assembly_segments" (
"constituency_number" text,
"name" text,
"reserved_for_sc_st_none" text,
"district" text,
"number_of_electorates_2009" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the number of electorates (2009) for the Indore district, when reserved for (SC / ST /None) is none, and constituency number is 208?`:
```sql
|
SELECT "district" FROM "assembly_segments" WHERE "reserved_for_sc_st_none"='none' AND "number_of_electorates_2009">'190,441' AND "name"='indore-2'; |
## Task
Generate a SQL query to answer the following question:
`What is the district when the reserved for (SC / ST /None) is none, number of electorates (2009) is larger than 190,441, and name is Indore-2?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "assembly_segments" (
"constituency_number" text,
"name" text,
"reserved_for_sc_st_none" text,
"district" text,
"number_of_electorates_2009" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the district when the reserved for (SC / ST /None) is none, number of electorates (2009) is larger than 190,441, and name is Indore-2?`:
```sql
|
SELECT "other" FROM "usage_share_of_desktop_browsers_for_june" WHERE "firefox"='21.22%'; |
## Task
Generate a SQL query to answer the following question:
`What percentage of users were using other browsers according to the source that reported 21.22% were using Firefox?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "usage_share_of_desktop_browsers_for_june" (
"source" text,
"chrome" text,
"internet_explorer" text,
"firefox" text,
"safari" text,
"opera" text,
"other" text
);
### SQL
Given the database schema, here is the SQL query that answers `What percentage of users were using other browsers according to the source that reported 21.22% were using Firefox?`:
```sql
|
SELECT "firefox" FROM "usage_share_of_desktop_browsers_for_june" WHERE "source"='w3counter'; |
## Task
Generate a SQL query to answer the following question:
`According to W3Counter, what percentage of browsers used Firefox?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "usage_share_of_desktop_browsers_for_june" (
"source" text,
"chrome" text,
"internet_explorer" text,
"firefox" text,
"safari" text,
"opera" text,
"other" text
);
### SQL
Given the database schema, here is the SQL query that answers `According to W3Counter, what percentage of browsers used Firefox?`:
```sql
|
SELECT "firefox" FROM "usage_share_of_desktop_browsers_for_june" WHERE "internet_explorer"='21.70%'; |
## Task
Generate a SQL query to answer the following question:
`What percentage of users were using Firefox according to the source that reported 21.70% used Internet Explorer?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "usage_share_of_desktop_browsers_for_june" (
"source" text,
"chrome" text,
"internet_explorer" text,
"firefox" text,
"safari" text,
"opera" text,
"other" text
);
### SQL
Given the database schema, here is the SQL query that answers `What percentage of users were using Firefox according to the source that reported 21.70% used Internet Explorer?`:
```sql
|
SELECT "source" FROM "usage_share_of_desktop_browsers_for_june" WHERE "chrome"='32.60%'; |
## Task
Generate a SQL query to answer the following question:
`Which source reported 32.60% of browsers used Chrome?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "usage_share_of_desktop_browsers_for_june" (
"source" text,
"chrome" text,
"internet_explorer" text,
"firefox" text,
"safari" text,
"opera" text,
"other" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which source reported 32.60% of browsers used Chrome?`:
```sql
|
SELECT "firefox" FROM "usage_share_of_desktop_browsers_for_june" WHERE "safari"='15.40%'; |
## Task
Generate a SQL query to answer the following question:
`What percentage of users were using Firefox according to the source that reported 15.40% used Safari?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "usage_share_of_desktop_browsers_for_june" (
"source" text,
"chrome" text,
"internet_explorer" text,
"firefox" text,
"safari" text,
"opera" text,
"other" text
);
### SQL
Given the database schema, here is the SQL query that answers `What percentage of users were using Firefox according to the source that reported 15.40% used Safari?`:
```sql
|
SELECT "internet_explorer" FROM "usage_share_of_desktop_browsers_for_june" WHERE "firefox"='20.01%'; |
## Task
Generate a SQL query to answer the following question:
`What percentage of users were using Internet Explorer according to the source that reported 20.01% used Firefox?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "usage_share_of_desktop_browsers_for_june" (
"source" text,
"chrome" text,
"internet_explorer" text,
"firefox" text,
"safari" text,
"opera" text,
"other" text
);
### SQL
Given the database schema, here is the SQL query that answers `What percentage of users were using Internet Explorer according to the source that reported 20.01% used Firefox?`:
```sql
|
SELECT MIN("points") FROM "grand_prix_career_statistics" WHERE "team"='rothmans honda' AND "year"=1992; |
## Task
Generate a SQL query to answer the following question:
`How many points did team Rothmans Honda have in 1992?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "grand_prix_career_statistics" (
"year" real,
"class" text,
"team" text,
"machine" text,
"points" real,
"wins" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many points did team Rothmans Honda have in 1992?`:
```sql
|
SELECT "class" FROM "grand_prix_career_statistics" WHERE "year"<1990 AND "points"=33; |
## Task
Generate a SQL query to answer the following question:
`What class before 1990 has points of 33?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "grand_prix_career_statistics" (
"year" real,
"class" text,
"team" text,
"machine" text,
"points" real,
"wins" real
);
### SQL
Given the database schema, here is the SQL query that answers `What class before 1990 has points of 33?`:
```sql
|
SELECT COUNT("points") FROM "grand_prix_career_statistics" WHERE "year"=1992; |
## Task
Generate a SQL query to answer the following question:
`How many total points were in 1992?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "grand_prix_career_statistics" (
"year" real,
"class" text,
"team" text,
"machine" text,
"points" real,
"wins" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many total points were in 1992?`:
```sql
|
SELECT "class" FROM "grand_prix_career_statistics" WHERE "wins">0 AND "year"=1992; |
## Task
Generate a SQL query to answer the following question:
`In 1992, what class has higher wins than 0?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "grand_prix_career_statistics" (
"year" real,
"class" text,
"team" text,
"machine" text,
"points" real,
"wins" real
);
### SQL
Given the database schema, here is the SQL query that answers `In 1992, what class has higher wins than 0?`:
```sql
|
SELECT "class" FROM "grand_prix_career_statistics" WHERE "team"='honda britain' AND "points">0; |
## Task
Generate a SQL query to answer the following question:
`What was the class that team Honda Britain was in with points higher than 0?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "grand_prix_career_statistics" (
"year" real,
"class" text,
"team" text,
"machine" text,
"points" real,
"wins" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the class that team Honda Britain was in with points higher than 0?`:
```sql
|
SELECT MAX("fa_cup_goals") FROM "appearances_and_goals" WHERE "league_cup_apps">0 AND "name"='trevor cherry'; |
## Task
Generate a SQL query to answer the following question:
`Which FA Cup Goals have League Cup Apps larger than 0, and a Name of trevor cherry?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "appearances_and_goals" (
"name" text,
"position" text,
"league_apps" text,
"league_goals" real,
"fa_cup_apps" text,
"fa_cup_goals" real,
"league_cup_apps" real,
"league_cup_goals" real,
"total_apps" text,
"total_goals" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which FA Cup Goals have League Cup Apps larger than 0, and a Name of trevor cherry?`:
```sql
|
SELECT SUM("league_goals") FROM "appearances_and_goals" WHERE "league_cup_goals"<0; |
## Task
Generate a SQL query to answer the following question:
`How many League Goals have League Cup Goals smaller than 0?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "appearances_and_goals" (
"name" text,
"position" text,
"league_apps" text,
"league_goals" real,
"fa_cup_apps" text,
"fa_cup_goals" real,
"league_cup_apps" real,
"league_cup_goals" real,
"total_apps" text,
"total_goals" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many League Goals have League Cup Goals smaller than 0?`:
```sql
|
SELECT "2009" FROM "grand_slam_women_s_singles_performance_t" WHERE "2011"='1r' AND "tournament"='australian open'; |
## Task
Generate a SQL query to answer the following question:
`What's the 2009 of the Australian Open having a 1R in 2011?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "grand_slam_women_s_singles_performance_t" (
"tournament" text,
"2008" text,
"2009" text,
"2010" text,
"2011" text,
"2012" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the 2009 of the Australian Open having a 1R in 2011?`:
```sql
|
SELECT "2008" FROM "grand_slam_women_s_singles_performance_t" WHERE "2011"='1r' AND "tournament"='australian open'; |
## Task
Generate a SQL query to answer the following question:
`What's the 2008 of the Australian Open when the 2011 was 1R?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "grand_slam_women_s_singles_performance_t" (
"tournament" text,
"2008" text,
"2009" text,
"2010" text,
"2011" text,
"2012" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the 2008 of the Australian Open when the 2011 was 1R?`:
```sql
|
SELECT "2008" FROM "grand_slam_women_s_singles_performance_t" WHERE "2011"='1r' AND "2010"='2r' AND "tournament"='us open'; |
## Task
Generate a SQL query to answer the following question:
`What's the 2008 of the US Open when 2010 was 2R and 2011 was 1R?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "grand_slam_women_s_singles_performance_t" (
"tournament" text,
"2008" text,
"2009" text,
"2010" text,
"2011" text,
"2012" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the 2008 of the US Open when 2010 was 2R and 2011 was 1R?`:
```sql
|
SELECT MIN("number_of_episodes") FROM "first_line_series" WHERE "airing_date"='12 jan- 6 feb'; |
## Task
Generate a SQL query to answer the following question:
`What is the lowest number of episodes in a series with an airing date of 12 jan- 6 feb?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "first_line_series" (
"airing_date" text,
"english_title_chinese_title" text,
"number_of_episodes" real,
"genre" text,
"official_website" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest number of episodes in a series with an airing date of 12 jan- 6 feb?`:
```sql
|
SELECT "tournament" FROM "doubles" WHERE "opponent_in_the_final"='petra mandula patricia wartusch'; |
## Task
Generate a SQL query to answer the following question:
`What tournament has petra mandula patricia wartusch as the opponent in the final?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles" (
"date" text,
"tournament" text,
"surface" text,
"partner" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What tournament has petra mandula patricia wartusch as the opponent in the final?`:
```sql
|
SELECT "date" FROM "doubles" WHERE "opponent_in_the_final"='kimberly po nathalie tauziat'; |
## Task
Generate a SQL query to answer the following question:
`What date has kimberly po nathalie tauziat as the opponent in the final?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles" (
"date" text,
"tournament" text,
"surface" text,
"partner" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date has kimberly po nathalie tauziat as the opponent in the final?`:
```sql
|
SELECT "score" FROM "doubles" WHERE "date"='february 12, 2006'; |
## Task
Generate a SQL query to answer the following question:
`What score has February 12, 2006 as the date?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles" (
"date" text,
"tournament" text,
"surface" text,
"partner" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What score has February 12, 2006 as the date?`:
```sql
|
SELECT "opponent_in_the_final" FROM "doubles" WHERE "date"='october 9, 2005'; |
## Task
Generate a SQL query to answer the following question:
`What opponent in the final has October 9, 2005 as the date?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles" (
"date" text,
"tournament" text,
"surface" text,
"partner" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What opponent in the final has October 9, 2005 as the date?`:
```sql
|
SELECT "to_par" FROM "second_round" WHERE "player"='bo bae song'; |
## Task
Generate a SQL query to answer the following question:
`What is the to par for Bo Bae Song?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "second_round" (
"place" text,
"player" text,
"country" text,
"score" text,
"to_par" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the to par for Bo Bae Song?`:
```sql
|
SELECT "to_par" FROM "second_round" WHERE "place"='t1' AND "player"='jiyai shin'; |
## Task
Generate a SQL query to answer the following question:
`What is the to par for Jiyai Shin when the place is t1?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "second_round" (
"place" text,
"player" text,
"country" text,
"score" text,
"to_par" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the to par for Jiyai Shin when the place is t1?`:
```sql
|
SELECT "to_par" FROM "second_round" WHERE "place"='t1' AND "player"='jiyai shin'; |
## Task
Generate a SQL query to answer the following question:
`What is the to par for Jiyai Shin in place t1?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "second_round" (
"place" text,
"player" text,
"country" text,
"score" text,
"to_par" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the to par for Jiyai Shin in place t1?`:
```sql
|
SELECT "score" FROM "second_round" WHERE "place"='t9' AND "player"='laura diaz'; |
## Task
Generate a SQL query to answer the following question:
`What was Laura Diaz's score for place t9?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "second_round" (
"place" text,
"player" text,
"country" text,
"score" text,
"to_par" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was Laura Diaz's score for place t9?`:
```sql
|
SELECT "country" FROM "second_round" WHERE "player"='bo bae song'; |
## Task
Generate a SQL query to answer the following question:
`What country does Bo Bae Song play for?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "second_round" (
"place" text,
"player" text,
"country" text,
"score" text,
"to_par" text
);
### SQL
Given the database schema, here is the SQL query that answers `What country does Bo Bae Song play for?`:
```sql
|
SELECT AVG("gold") FROM "medal_table_by_country" WHERE "nation"='brazil' AND "total">55; |
## Task
Generate a SQL query to answer the following question:
`How many gold medals did Brazil win with a total of more than 55 medals?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table_by_country" (
"rank" real,
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many gold medals did Brazil win with a total of more than 55 medals?`:
```sql
|
SELECT COUNT("rank") FROM "medal_table_by_country" WHERE "silver">2 AND "bronze"<2; |
## Task
Generate a SQL query to answer the following question:
`How many teams won more than 2 silver medals and fewer than 2 Bronze medals?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table_by_country" (
"rank" real,
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many teams won more than 2 silver medals and fewer than 2 Bronze medals?`:
```sql
|
SELECT MIN("gold") FROM "medal_table_by_country" WHERE "nation"='greece'; |
## Task
Generate a SQL query to answer the following question:
`What is the fewest gold medals won by Greece?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table_by_country" (
"rank" real,
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the fewest gold medals won by Greece?`:
```sql
|
SELECT MIN("rank") FROM "medal_table_by_country" WHERE "nation"='united states' AND "bronze"<4; |
## Task
Generate a SQL query to answer the following question:
`What is the lowest rank of the United States, with fewer than 4 bronze medals?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table_by_country" (
"rank" real,
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest rank of the United States, with fewer than 4 bronze medals?`:
```sql
|
SELECT MAX("gold") FROM "medal_table_by_country" WHERE "silver"<2 AND "bronze"<4; |
## Task
Generate a SQL query to answer the following question:
`What is the highest number of gold medals won by a team that won fewer than 2 silver and fewer than 4 bronze medals?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table_by_country" (
"rank" real,
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest number of gold medals won by a team that won fewer than 2 silver and fewer than 4 bronze medals?`:
```sql
|
SELECT AVG("react") FROM "semifinal_2" WHERE "lane"<4 AND "rank">4 AND "time">23.22; |
## Task
Generate a SQL query to answer the following question:
`Which React has a Lane smaller than 4, and a Rank larger than 4, and a Time larger than 23.22?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "semifinal_2" (
"rank" real,
"lane" real,
"athlete" text,
"country" text,
"time" real,
"react" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which React has a Lane smaller than 4, and a Rank larger than 4, and a Time larger than 23.22?`:
```sql
|
SELECT AVG("against") FROM "2010_ladder" WHERE "draws"=0 AND "losses"=16; |
## Task
Generate a SQL query to answer the following question:
`What shows for against when draws are 0, and losses are 16?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2010_ladder" (
"hampden_fl" text,
"wins" real,
"byes" real,
"losses" real,
"draws" real,
"against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What shows for against when draws are 0, and losses are 16?`:
```sql
|
SELECT MAX("wins") FROM "2010_ladder" WHERE "draws">1 AND "byes">0; |
## Task
Generate a SQL query to answer the following question:
`What is the highest number of wins when draws are larger than 1, and byes are larger than 0?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2010_ladder" (
"hampden_fl" text,
"wins" real,
"byes" real,
"losses" real,
"draws" real,
"against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest number of wins when draws are larger than 1, and byes are larger than 0?`:
```sql
|
SELECT "team" FROM "performance_in_uefa_super_cup_by_club" WHERE "winners"=1 AND "years_runners_up"='2007'; |
## Task
Generate a SQL query to answer the following question:
`Which team were runners-up in 2007 and had 1 under winners?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "performance_in_uefa_super_cup_by_club" (
"team" text,
"winners" real,
"runners_up" real,
"years_won" text,
"years_runners_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which team were runners-up in 2007 and had 1 under winners?`:
```sql
|
SELECT COUNT("winners") FROM "performance_in_uefa_super_cup_by_club" WHERE "years_won"='1983'; |
## Task
Generate a SQL query to answer the following question:
`What is the sum of winners when 1983 is the years won?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "performance_in_uefa_super_cup_by_club" (
"team" text,
"winners" real,
"runners_up" real,
"years_won" text,
"years_runners_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the sum of winners when 1983 is the years won?`:
```sql
|
SELECT AVG("rank") FROM "single_game" WHERE "total"=12; |
## Task
Generate a SQL query to answer the following question:
`Which Rank has a Total of 12?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "single_game" (
"rank" real,
"player" text,
"county" text,
"tally" text,
"total" real,
"opposition" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Rank has a Total of 12?`:
```sql
|
SELECT "rank" FROM "single_game" WHERE "opposition"='limerick'; |
## Task
Generate a SQL query to answer the following question:
`Which Rank has an Opposition of limerick?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "single_game" (
"rank" real,
"player" text,
"county" text,
"tally" text,
"total" real,
"opposition" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Rank has an Opposition of limerick?`:
```sql
|
SELECT COUNT("rank") FROM "single_game" WHERE "tally"='0-10' AND "opposition"='cork'; |
## Task
Generate a SQL query to answer the following question:
`How much Rank has a Tally of 0-10, and an Opposition of cork?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "single_game" (
"rank" real,
"player" text,
"county" text,
"tally" text,
"total" real,
"opposition" text
);
### SQL
Given the database schema, here is the SQL query that answers `How much Rank has a Tally of 0-10, and an Opposition of cork?`:
```sql
|
SELECT MIN("total") FROM "single_game" WHERE "rank"<3 AND "county"='cork'; |
## Task
Generate a SQL query to answer the following question:
`Which Total has a Rank smaller than 3, and a County of cork?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "single_game" (
"rank" real,
"player" text,
"county" text,
"tally" text,
"total" real,
"opposition" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Total has a Rank smaller than 3, and a County of cork?`:
```sql
|
SELECT AVG("rank") FROM "single_game" WHERE "tally"='4-0'; |
## Task
Generate a SQL query to answer the following question:
`Which Rank has a Tally of 4-0?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "single_game" (
"rank" real,
"player" text,
"county" text,
"tally" text,
"total" real,
"opposition" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Rank has a Tally of 4-0?`:
```sql
|
SELECT MAX("lane") FROM "heat_5" WHERE "rank">3 AND "time">45.63 AND "react"<0.28800000000000003 AND "athlete"='geiner mosquera'; |
## Task
Generate a SQL query to answer the following question:
`Which Lane has a Rank larger than 3, and a Time larger than 45.63, and a Reaction smaller than 0.28800000000000003, and an Athlete of geiner mosquera?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heat_5" (
"rank" real,
"lane" real,
"athlete" text,
"nationality" text,
"time" real,
"react" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Lane has a Rank larger than 3, and a Time larger than 45.63, and a Reaction smaller than 0.28800000000000003, and an Athlete of geiner mosquera?`:
```sql
|
SELECT COUNT("react") FROM "heat_5" WHERE "athlete"='alleyne francique' AND "lane">9; |
## Task
Generate a SQL query to answer the following question:
`How many reactions have an Athlete of alleyne francique, and a Lane larger than 9?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heat_5" (
"rank" real,
"lane" real,
"athlete" text,
"nationality" text,
"time" real,
"react" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many reactions have an Athlete of alleyne francique, and a Lane larger than 9?`:
```sql
|
SELECT "year" FROM "previous_championship_encounters" WHERE "waterford_score"='6-08 (24)'; |
## Task
Generate a SQL query to answer the following question:
`What yeae has 6-08 (24) as a waterford score?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "previous_championship_encounters" (
"year" real,
"venue" text,
"competition" text,
"kilkenny_score" text,
"waterford_score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What yeae has 6-08 (24) as a waterford score?`:
```sql
|
SELECT MIN("year") FROM "previous_championship_encounters" WHERE "competition"='all-ireland hurling final' AND "waterford_score"='6-08 (24)'; |
## Task
Generate a SQL query to answer the following question:
`What is the lowest year that has all-ireland hurling final as the competition, and 6-08 (24) as the waterford score?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "previous_championship_encounters" (
"year" real,
"venue" text,
"competition" text,
"kilkenny_score" text,
"waterford_score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest year that has all-ireland hurling final as the competition, and 6-08 (24) as the waterford score?`:
```sql
|
SELECT "waterford_score" FROM "previous_championship_encounters" WHERE "year"<1963 AND "competition"='all-ireland hurling final replay'; |
## Task
Generate a SQL query to answer the following question:
`What is the waterford score that has a year prior to 1963, with all-ireland hurling final replay as the competition?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "previous_championship_encounters" (
"year" real,
"venue" text,
"competition" text,
"kilkenny_score" text,
"waterford_score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the waterford score that has a year prior to 1963, with all-ireland hurling final replay as the competition?`:
```sql
|
SELECT "rounds" FROM "entry_list" WHERE "team"='rml racing silverline' AND "drivers"='james nash'; |
## Task
Generate a SQL query to answer the following question:
`What rounds did RML Racing Silverline and James Nash compete?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "entry_list" (
"team" text,
"car_spec" text,
"drivers" text,
"class" text,
"rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What rounds did RML Racing Silverline and James Nash compete?`:
```sql
|
SELECT "class" FROM "entry_list" WHERE "drivers"='rob collard'; |
## Task
Generate a SQL query to answer the following question:
`What class is Rob Collard in?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "entry_list" (
"team" text,
"car_spec" text,
"drivers" text,
"class" text,
"rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What class is Rob Collard in?`:
```sql
|
SELECT "car_spec" FROM "entry_list" WHERE "team"='airwaves bmw' AND "drivers"='rob collard'; |
## Task
Generate a SQL query to answer the following question:
`What is the car specs for team Airwaves BMW's driver Rob Collard?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "entry_list" (
"team" text,
"car_spec" text,
"drivers" text,
"class" text,
"rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the car specs for team Airwaves BMW's driver Rob Collard?`:
```sql
|
SELECT "language" FROM "channel_listing" WHERE "name"='tv3'; |
## Task
Generate a SQL query to answer the following question:
`What is the language of TV3?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "channel_listing" (
"name" text,
"language" text,
"owner" text,
"group" text,
"type" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the language of TV3?`:
```sql
|
SELECT "group" FROM "channel_listing" WHERE "name"='espn international sports'; |
## Task
Generate a SQL query to answer the following question:
`What is the group of ESPN International Sports?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "channel_listing" (
"name" text,
"language" text,
"owner" text,
"group" text,
"type" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the group of ESPN International Sports?`:
```sql
|
SELECT "type" FROM "channel_listing" WHERE "name"='espn international sports'; |
## Task
Generate a SQL query to answer the following question:
`What is the type of station for ESPN International Sports?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "channel_listing" (
"name" text,
"language" text,
"owner" text,
"group" text,
"type" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the type of station for ESPN International Sports?`:
```sql
|
SELECT "type" FROM "channel_listing" WHERE "group"='movies'; |
## Task
Generate a SQL query to answer the following question:
`What is the type of station that is in the movies group?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "channel_listing" (
"name" text,
"language" text,
"owner" text,
"group" text,
"type" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the type of station that is in the movies group?`:
```sql
|
SELECT SUM("total") FROM "heat_2" WHERE "rank"<5 AND "3rd_run"='37.076 (2)'; |
## Task
Generate a SQL query to answer the following question:
`What is the total sum ranked less than 5 with a 37.076 (2) 3rd run?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heat_2" (
"rank" real,
"name" text,
"1st_run" text,
"2nd_run" text,
"3rd_run" text,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total sum ranked less than 5 with a 37.076 (2) 3rd run?`:
```sql
|
SELECT "name" FROM "heat_2" WHERE "total"=22; |
## Task
Generate a SQL query to answer the following question:
`What is the name of the person with a total of 22?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heat_2" (
"rank" real,
"name" text,
"1st_run" text,
"2nd_run" text,
"3rd_run" text,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the name of the person with a total of 22?`:
```sql
|
SELECT "total" FROM "heat_2" WHERE "rank"<8 AND "2nd_run"='40.143 (4)'; |
## Task
Generate a SQL query to answer the following question:
`What is the total with a rank less than 8 and a 40.143 (4) 2nd run?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heat_2" (
"rank" real,
"name" text,
"1st_run" text,
"2nd_run" text,
"3rd_run" text,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total with a rank less than 8 and a 40.143 (4) 2nd run?`:
```sql
|
SELECT "nationality" FROM "records_1951_1976" WHERE "athlete"='henry carr' AND "time"='20.3y'; |
## Task
Generate a SQL query to answer the following question:
`What's the nationality of Henry Carr having a time of 20.3y?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "records_1951_1976" (
"time" text,
"athlete" text,
"nationality" text,
"location_of_race" text,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the nationality of Henry Carr having a time of 20.3y?`:
```sql
|
SELECT "nationality" FROM "records_1951_1976" WHERE "athlete"='livio berruti'; |
## Task
Generate a SQL query to answer the following question:
`What's the nationality of Livio Berruti?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "records_1951_1976" (
"time" text,
"athlete" text,
"nationality" text,
"location_of_race" text,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the nationality of Livio Berruti?`:
```sql
|
SELECT "nationality" FROM "records_1951_1976" WHERE "time"='20.6' AND "athlete"='ray norton'; |
## Task
Generate a SQL query to answer the following question:
`What's the nationality of Ray norton with a time of 20.6?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "records_1951_1976" (
"time" text,
"athlete" text,
"nationality" text,
"location_of_race" text,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the nationality of Ray norton with a time of 20.6?`:
```sql
|
SELECT SUM("prominence_m") FROM "list_of_european_ultra_prominent_peaks" WHERE "country"='slovakia'; |
## Task
Generate a SQL query to answer the following question:
`What is the sum of the prominence in m of slovakia?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_european_ultra_prominent_peaks" (
"peak" text,
"country" text,
"elevation_m" real,
"prominence_m" real,
"col_m" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the sum of the prominence in m of slovakia?`:
```sql
|
SELECT "prominence_m" FROM "list_of_european_ultra_prominent_peaks" WHERE "col_m">738; |
## Task
Generate a SQL query to answer the following question:
`What is the prominence in m of a col in m greater than 738?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_european_ultra_prominent_peaks" (
"peak" text,
"country" text,
"elevation_m" real,
"prominence_m" real,
"col_m" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the prominence in m of a col in m greater than 738?`:
```sql
|
SELECT MIN("col_m") FROM "list_of_european_ultra_prominent_peaks" WHERE "peak"='gerlachovský štít' AND "elevation_m">'2,655'; |
## Task
Generate a SQL query to answer the following question:
`Whta is the lowest col in m of gerlachovský štít peak, which has an elevation greater than 2,655 m?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_european_ultra_prominent_peaks" (
"peak" text,
"country" text,
"elevation_m" real,
"prominence_m" real,
"col_m" real
);
### SQL
Given the database schema, here is the SQL query that answers `Whta is the lowest col in m of gerlachovský štít peak, which has an elevation greater than 2,655 m?`:
```sql
|
SELECT MIN("elevation_m") FROM "list_of_european_ultra_prominent_peaks" WHERE "prominence_m"<'2,103' AND "peak"='moldoveanu peak' AND "col_m"<498; |
## Task
Generate a SQL query to answer the following question:
`What is the lowest elevation in m of moldoveanu peak, which has a prominence in m less than 2,103 and a col in m less than 498?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_european_ultra_prominent_peaks" (
"peak" text,
"country" text,
"elevation_m" real,
"prominence_m" real,
"col_m" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest elevation in m of moldoveanu peak, which has a prominence in m less than 2,103 and a col in m less than 498?`:
```sql
|
SELECT AVG("prominence_m") FROM "list_of_european_ultra_prominent_peaks" WHERE "peak"='pietrosul rodnei' AND "elevation_m"<'2,303'; |
## Task
Generate a SQL query to answer the following question:
`What is the average prominence in m of pietrosul rodnei peak, which has an elevation less than 2,303?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_european_ultra_prominent_peaks" (
"peak" text,
"country" text,
"elevation_m" real,
"prominence_m" real,
"col_m" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average prominence in m of pietrosul rodnei peak, which has an elevation less than 2,303?`:
```sql
|
SELECT "score" FROM "world_record_progression" WHERE "comp"='og'; |
## Task
Generate a SQL query to answer the following question:
`What is the Score of the Shooter with a Comp of OG?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "world_record_progression" (
"score" text,
"shooter" text,
"date" text,
"comp" text,
"place" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Score of the Shooter with a Comp of OG?`:
```sql
|
SELECT SUM("b_score") FROM "qualified_competitors" WHERE "total">16.125 AND "position"='3rd'; |
## Task
Generate a SQL query to answer the following question:
`What is the B Score when the total is more than 16.125, and position is 3rd?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "qualified_competitors" (
"position" text,
"gymnast" text,
"a_score" real,
"b_score" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the B Score when the total is more than 16.125, and position is 3rd?`:
```sql
|
SELECT MIN("a_score") FROM "qualified_competitors" WHERE "b_score"=9.15 AND "total"=16.05; |
## Task
Generate a SQL query to answer the following question:
`What is the lowest A Score when the B Score is 9.15, and total is 16.05?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "qualified_competitors" (
"position" text,
"gymnast" text,
"a_score" real,
"b_score" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest A Score when the B Score is 9.15, and total is 16.05?`:
```sql
|
SELECT "athlete" FROM "heat_3" WHERE "time"='7:14.64'; |
## Task
Generate a SQL query to answer the following question:
`Who had a time of 7:14.64?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heat_3" (
"rank" real,
"athlete" text,
"country" text,
"time" text,
"notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who had a time of 7:14.64?`:
```sql
|
SELECT COUNT("rank") FROM "heat_3" WHERE "athlete"='lassi karonen'; |
## Task
Generate a SQL query to answer the following question:
`What rank was Lassi Karonen?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heat_3" (
"rank" real,
"athlete" text,
"country" text,
"time" text,
"notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What rank was Lassi Karonen?`:
```sql
|
SELECT MIN("rank") FROM "heat_3" WHERE "time"='7:52.53'; |
## Task
Generate a SQL query to answer the following question:
`What was the rank when then time was 7:52.53?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heat_3" (
"rank" real,
"athlete" text,
"country" text,
"time" text,
"notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the rank when then time was 7:52.53?`:
```sql
|
SELECT "athlete" FROM "heat_3" WHERE "notes"='q' AND "country"='germany'; |
## Task
Generate a SQL query to answer the following question:
`Who was the athlete from Germany with notes of Q?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heat_3" (
"rank" real,
"athlete" text,
"country" text,
"time" text,
"notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the athlete from Germany with notes of Q?`:
```sql
|
SELECT "rank" FROM "heat_3" WHERE "country"='germany'; |
## Task
Generate a SQL query to answer the following question:
`What rank is Germany?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heat_3" (
"rank" real,
"athlete" text,
"country" text,
"time" text,
"notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What rank is Germany?`:
```sql
|
SELECT "athlete" FROM "heat_3" WHERE "country"='hong kong'; |
## Task
Generate a SQL query to answer the following question:
`Who was the athlete from Hong Kong?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heat_3" (
"rank" real,
"athlete" text,
"country" text,
"time" text,
"notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the athlete from Hong Kong?`:
```sql
|
SELECT "school" FROM "former_members" WHERE "conference_joined"='northeast corner' AND "mascot"='blazers'; |
## Task
Generate a SQL query to answer the following question:
`Which school has a mascot of the Blazers and in the Northeast Corner conference?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "former_members" (
"school" text,
"location" text,
"mascot" text,
"enrollment_08_09" real,
"ihsaa_class_football_class" text,
"county" text,
"year_joined" real,
"previous_conference" text,
"year_left" real,
"conference_joined" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which school has a mascot of the Blazers and in the Northeast Corner conference?`:
```sql
|
SELECT "mascot" FROM "former_members" WHERE "ihsaa_class_football_class"='2a/2a'; |
## Task
Generate a SQL query to answer the following question:
`Which mascot has an IHSAA Class and Football class of 2A/2A?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "former_members" (
"school" text,
"location" text,
"mascot" text,
"enrollment_08_09" real,
"ihsaa_class_football_class" text,
"county" text,
"year_joined" real,
"previous_conference" text,
"year_left" real,
"conference_joined" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which mascot has an IHSAA Class and Football class of 2A/2A?`:
```sql
|
SELECT "player" FROM "amateur_draft" WHERE "round"<3; |
## Task
Generate a SQL query to answer the following question:
`Which player was selected in rounds under 3?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "amateur_draft" (
"round" real,
"pick" real,
"player" text,
"nationality" text,
"college_junior_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which player was selected in rounds under 3?`:
```sql
|
SELECT MAX("water_sqmi") FROM "f" WHERE "pop_2010"=359 AND "longitude"<-97.176811; |
## Task
Generate a SQL query to answer the following question:
`Which Water (sqmi) has a Pop (2010) of 359, and a Longitude smaller than -97.176811?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "f" (
"township" text,
"county" text,
"pop_2010" real,
"land_sqmi" real,
"water_sqmi" real,
"latitude" real,
"longitude" real,
"geo_id" real,
"ansi_code" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Water (sqmi) has a Pop (2010) of 359, and a Longitude smaller than -97.176811?`:
```sql
|
SELECT MIN("land_sqmi") FROM "f" WHERE "water_sqmi"<0.04 AND "longitude"=-96.794706; |
## Task
Generate a SQL query to answer the following question:
`Which Land (sqmi) has a Water (sqmi) smaller than 0.04, and a Longitude of -96.794706?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "f" (
"township" text,
"county" text,
"pop_2010" real,
"land_sqmi" real,
"water_sqmi" real,
"latitude" real,
"longitude" real,
"geo_id" real,
"ansi_code" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Land (sqmi) has a Water (sqmi) smaller than 0.04, and a Longitude of -96.794706?`:
```sql
|
SELECT SUM("latitude") FROM "f" WHERE "water_sqmi"=0.267 AND "ansi_code">1759605; |
## Task
Generate a SQL query to answer the following question:
`How much Latitude has a Water (sqmi) of 0.267, and an ANSI code larger than 1759605?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "f" (
"township" text,
"county" text,
"pop_2010" real,
"land_sqmi" real,
"water_sqmi" real,
"latitude" real,
"longitude" real,
"geo_id" real,
"ansi_code" real
);
### SQL
Given the database schema, here is the SQL query that answers `How much Latitude has a Water (sqmi) of 0.267, and an ANSI code larger than 1759605?`:
```sql
|
SELECT MIN("ansi_code") FROM "f" WHERE "geo_id">3809927140 AND "water_sqmi"<0.492 AND "pop_2010"=37 AND "latitude">48.245979; |
## Task
Generate a SQL query to answer the following question:
`Which ANSI code has a GEO ID larger than 3809927140, and a Water (sqmi) smaller than 0.492, and a Pop (2010) of 37, and a Latitude larger than 48.245979?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "f" (
"township" text,
"county" text,
"pop_2010" real,
"land_sqmi" real,
"water_sqmi" real,
"latitude" real,
"longitude" real,
"geo_id" real,
"ansi_code" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which ANSI code has a GEO ID larger than 3809927140, and a Water (sqmi) smaller than 0.492, and a Pop (2010) of 37, and a Latitude larger than 48.245979?`:
```sql
|
SELECT "owner" FROM "radio" WHERE "frequency"='00 99.3'; |
## Task
Generate a SQL query to answer the following question:
`What is the Owner of Frequency 00 99.3?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "radio" (
"frequency" text,
"call_sign" text,
"branding" text,
"format" text,
"owner" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Owner of Frequency 00 99.3?`:
```sql
|
SELECT "branding" FROM "radio" WHERE "frequency"='00 94.5'; |
## Task
Generate a SQL query to answer the following question:
`What is the Branding of Frequency 00 94.5?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "radio" (
"frequency" text,
"call_sign" text,
"branding" text,
"format" text,
"owner" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Branding of Frequency 00 94.5?`:
```sql
|
SELECT "call_sign" FROM "radio" WHERE "owner"='ckua radio foundation'; |
## Task
Generate a SQL query to answer the following question:
`What is the Call Sign of the Frequency by Owner CKUA Radio Foundation?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "radio" (
"frequency" text,
"call_sign" text,
"branding" text,
"format" text,
"owner" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Call Sign of the Frequency by Owner CKUA Radio Foundation?`:
```sql
|
SELECT "owner" FROM "radio" WHERE "format"='first nations community radio'; |
## Task
Generate a SQL query to answer the following question:
`What is the Owner of the Frequency with a Format of First Nations Community Radio?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "radio" (
"frequency" text,
"call_sign" text,
"branding" text,
"format" text,
"owner" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Owner of the Frequency with a Format of First Nations Community Radio?`:
```sql
|
SELECT "school" FROM "membership" WHERE "previous_conference"='none (new school)' AND "year_joined">1960 AND "location"='versailles'; |
## Task
Generate a SQL query to answer the following question:
`Which School has a Previous Conference of none (new school), and a Year Joined larger than 1960, and a Location of versailles?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "membership" (
"school" text,
"location" text,
"mascot" text,
"size" real,
"ihsaa_class" text,
"county" text,
"year_joined" real,
"previous_conference" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which School has a Previous Conference of none (new school), and a Year Joined larger than 1960, and a Location of versailles?`:
```sql
|
SELECT "location" FROM "membership" WHERE "previous_conference"='independents' AND "mascot"='hilltoppers'; |
## Task
Generate a SQL query to answer the following question:
`Which Location has a Previous Conference of independents, and a Mascot of hilltoppers?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "membership" (
"school" text,
"location" text,
"mascot" text,
"size" real,
"ihsaa_class" text,
"county" text,
"year_joined" real,
"previous_conference" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Location has a Previous Conference of independents, and a Mascot of hilltoppers?`:
```sql
|
SELECT AVG("year_joined") FROM "membership" WHERE "size">93 AND "previous_conference"='none (new school)' AND "mascot"='rebels'; |
## Task
Generate a SQL query to answer the following question:
`Which Year Joined has a Size larger than 93, and a Previous Conference of none (new school), and a Mascot of rebels?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "membership" (
"school" text,
"location" text,
"mascot" text,
"size" real,
"ihsaa_class" text,
"county" text,
"year_joined" real,
"previous_conference" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Year Joined has a Size larger than 93, and a Previous Conference of none (new school), and a Mascot of rebels?`:
```sql
|
SELECT COUNT("year_joined") FROM "membership" WHERE "size"<417 AND "ihsaa_class"='a' AND "school"='jac-cen-del'; |
## Task
Generate a SQL query to answer the following question:
`How many years Joined have a Size smaller than 417, and an IHSAA Class of A, and a School of jac-cen-del?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "membership" (
"school" text,
"location" text,
"mascot" text,
"size" real,
"ihsaa_class" text,
"county" text,
"year_joined" real,
"previous_conference" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many years Joined have a Size smaller than 417, and an IHSAA Class of A, and a School of jac-cen-del?`:
```sql
|
SELECT COUNT("1957") FROM "1950s" WHERE "1955"<0.63 AND "1952">0.22; |
## Task
Generate a SQL query to answer the following question:
`What is the 1957 number when the 1955 is smaller than 0.63, and 1952 is larger than 0.22?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1950s" (
"country" text,
"1951" real,
"1952" real,
"1953" real,
"1954" real,
"1955" real,
"1956" real,
"1957" real,
"1958" real,
"1959" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the 1957 number when the 1955 is smaller than 0.63, and 1952 is larger than 0.22?`:
```sql
|
SELECT SUM("1952") FROM "1950s" WHERE "1954">4.2; |
## Task
Generate a SQL query to answer the following question:
`What is the 1952 rate when the 1954 is more than 4.2?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1950s" (
"country" text,
"1951" real,
"1952" real,
"1953" real,
"1954" real,
"1955" real,
"1956" real,
"1957" real,
"1958" real,
"1959" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the 1952 rate when the 1954 is more than 4.2?`:
```sql
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.