output stringlengths 27 479 | instruction stringlengths 407 1.39k |
|---|---|
SELECT "release_date" FROM "energy_efficient_e_series" WHERE "multi_1"='10.5×'; |
## Task
Generate a SQL query to answer the following question:
`When was the release date for technology that has a Multi 1 of 10.5×?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "energy_efficient_e_series" (
"model_number" text,
"stepping" text,
"frequency" text,
"l2_cache" text,
"multi_1" text,
"v_core" text,
"socket" text,
"release_date" text,
"part_number_s" text
);
### SQL
Given the database schema, here is the SQL query that answers `When was the release date for technology that has a Multi 1 of 10.5×?`:
```sql
|
SELECT "stepping" FROM "energy_efficient_e_series" WHERE "part_number_s"='adh4450iaa5do'; |
## Task
Generate a SQL query to answer the following question:
`What's the stepping amount for adh4450iaa5do?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "energy_efficient_e_series" (
"model_number" text,
"stepping" text,
"frequency" text,
"l2_cache" text,
"multi_1" text,
"v_core" text,
"socket" text,
"release_date" text,
"part_number_s" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the stepping amount for adh4450iaa5do?`:
```sql
|
SELECT MAX("wins") FROM "cart_career_results" WHERE "year">1996 AND "championship_finish"='1st' AND "points"<168; |
## Task
Generate a SQL query to answer the following question:
`Which Wins is the highest one that has a Year larger than 1996, and a Championship Finish of 1st, and Points smaller than 168?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "cart_career_results" (
"year" real,
"team" text,
"wins" real,
"points" real,
"championship_finish" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Wins is the highest one that has a Year larger than 1996, and a Championship Finish of 1st, and Points smaller than 168?`:
```sql
|
SELECT MAX("year") FROM "cart_career_results" WHERE "team"='walker racing' AND "wins">1; |
## Task
Generate a SQL query to answer the following question:
`Which Year is the highest that has a Team of walker racing, and Wins larger than 1?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "cart_career_results" (
"year" real,
"team" text,
"wins" real,
"points" real,
"championship_finish" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Year is the highest that has a Team of walker racing, and Wins larger than 1?`:
```sql
|
SELECT AVG("points") FROM "cart_career_results" WHERE "year">1998 AND "wins"=1; |
## Task
Generate a SQL query to answer the following question:
`Which Points have a Year larger than 1998, and Wins of 1?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "cart_career_results" (
"year" real,
"team" text,
"wins" real,
"points" real,
"championship_finish" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Points have a Year larger than 1998, and Wins of 1?`:
```sql
|
SELECT MIN("bronze") FROM "medal_table" WHERE "silver"=2 AND "total"=8; |
## Task
Generate a SQL query to answer the following question:
`What is the lowest bronze number when silver shows 2, and the total is 8?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table" (
"rank" 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 bronze number when silver shows 2, and the total is 8?`:
```sql
|
SELECT AVG("silver") FROM "medal_table" WHERE "gold">4 AND "total"<24; |
## Task
Generate a SQL query to answer the following question:
`What is the silver number when gold is more than 4, and the total is less than 24?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table" (
"rank" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the silver number when gold is more than 4, and the total is less than 24?`:
```sql
|
SELECT AVG("gold") FROM "medal_table" WHERE "total"=8 AND "bronze">4; |
## Task
Generate a SQL query to answer the following question:
`What is the gold number when the total is 8 and bronze is more than 4?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table" (
"rank" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the gold number when the total is 8 and bronze is more than 4?`:
```sql
|
SELECT SUM("total") FROM "medal_table" WHERE "gold"=0 AND "silver"<2 AND "rank"='6'; |
## Task
Generate a SQL query to answer the following question:
`What is the sum of Total for 0 gold and less than 2, silver with a rank of 6?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table" (
"rank" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the sum of Total for 0 gold and less than 2, silver with a rank of 6?`:
```sql
|
SELECT AVG("gold") FROM "medal_table" WHERE "silver">2 AND "bronze">1; |
## Task
Generate a SQL query to answer the following question:
`What is the average Gold when silver is more than 2, and bronze is more than 1`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table" (
"rank" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average Gold when silver is more than 2, and bronze is more than 1`:
```sql
|
SELECT AVG("bronze") FROM "medal_table" WHERE "silver">2 AND "rank"='2' AND "gold">2; |
## Task
Generate a SQL query to answer the following question:
`What is the average Bronze when silver is more than 2, and rank is 2, and gold more than 2`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table" (
"rank" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average Bronze when silver is more than 2, and rank is 2, and gold more than 2`:
```sql
|
SELECT "city" FROM "list_of_cities_by_latitude" WHERE "state"='svalbard' AND "longitude"='15°39′e'; |
## Task
Generate a SQL query to answer the following question:
`What city in Svalbard has a longitude of 15°39′e?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_cities_by_latitude" (
"latitude" text,
"longitude" text,
"city" text,
"state" text,
"country" text
);
### SQL
Given the database schema, here is the SQL query that answers `What city in Svalbard has a longitude of 15°39′e?`:
```sql
|
SELECT "longitude" FROM "list_of_cities_by_latitude" WHERE "latitude"='77°28′n'; |
## Task
Generate a SQL query to answer the following question:
`If the latitude is 77°28′n, what is the longitude?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_cities_by_latitude" (
"latitude" text,
"longitude" text,
"city" text,
"state" text,
"country" text
);
### SQL
Given the database schema, here is the SQL query that answers `If the latitude is 77°28′n, what is the longitude?`:
```sql
|
SELECT "longitude" FROM "list_of_cities_by_latitude" WHERE "latitude"='76°25′n'; |
## Task
Generate a SQL query to answer the following question:
`If the latitude is 76°25′n, what is the longitude?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_cities_by_latitude" (
"latitude" text,
"longitude" text,
"city" text,
"state" text,
"country" text
);
### SQL
Given the database schema, here is the SQL query that answers `If the latitude is 76°25′n, what is the longitude?`:
```sql
|
SELECT "longitude" FROM "list_of_cities_by_latitude" WHERE "latitude"='71°18′n'; |
## Task
Generate a SQL query to answer the following question:
`If the latitude is 71°18′n, what is the longitude?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_cities_by_latitude" (
"latitude" text,
"longitude" text,
"city" text,
"state" text,
"country" text
);
### SQL
Given the database schema, here is the SQL query that answers `If the latitude is 71°18′n, what is the longitude?`:
```sql
|
SELECT "partner" FROM "doubles_titles_5" WHERE "opponents_in_the_final"='florian mayer & alexander waske'; |
## Task
Generate a SQL query to answer the following question:
`Who is the partner facing the opponents florian Mayer & alexander waske in the final?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_titles_5" (
"date" text,
"tournament" text,
"surface" text,
"partner" text,
"opponents_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the partner facing the opponents florian Mayer & alexander waske in the final?`:
```sql
|
SELECT "tournament" FROM "doubles_titles_5" WHERE "surface"='hard' AND "opponents_in_the_final"='rohan bopanna & mustafa ghouse'; |
## Task
Generate a SQL query to answer the following question:
`Which tournament has a hard surface and final opponents rohan bopanna & mustafa ghouse?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_titles_5" (
"date" text,
"tournament" text,
"surface" text,
"partner" text,
"opponents_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which tournament has a hard surface and final opponents rohan bopanna & mustafa ghouse?`:
```sql
|
SELECT "date" FROM "doubles_titles_5" WHERE "surface"='clay'; |
## Task
Generate a SQL query to answer the following question:
`On which date did the tournament final with the clay surface take place?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_titles_5" (
"date" text,
"tournament" text,
"surface" text,
"partner" text,
"opponents_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `On which date did the tournament final with the clay surface take place?`:
```sql
|
SELECT "tournament" FROM "doubles_titles_5" WHERE "partner"='julian knowle'; |
## Task
Generate a SQL query to answer the following question:
`Which tournament features the partner julian knowle?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_titles_5" (
"date" text,
"tournament" text,
"surface" text,
"partner" text,
"opponents_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which tournament features the partner julian knowle?`:
```sql
|
SELECT "date" FROM "doubles_titles_5" WHERE "opponents_in_the_final"='michael berrer & kenneth carlsen'; |
## Task
Generate a SQL query to answer the following question:
`On which date is the tournament final with the opponents michael berrer & kenneth carlsen?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_titles_5" (
"date" text,
"tournament" text,
"surface" text,
"partner" text,
"opponents_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `On which date is the tournament final with the opponents michael berrer & kenneth carlsen?`:
```sql
|
SELECT "score" FROM "schedule_and_results" WHERE "february">4 AND "game"=61; |
## Task
Generate a SQL query to answer the following question:
`What was the score after february 4 in the game 61?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "schedule_and_results" (
"game" real,
"february" real,
"opponent" text,
"score" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score after february 4 in the game 61?`:
```sql
|
SELECT COUNT("pick_num") FROM "atlanta_falcons_draft_history" WHERE "college"='arkansas state' AND "overall"<242; |
## Task
Generate a SQL query to answer the following question:
`What is Arkansas State's total pick number with an overal lower than 242?`
### 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 Arkansas State's total pick number with an overal lower than 242?`:
```sql
|
SELECT "name" FROM "atlanta_falcons_draft_history" WHERE "college"='cincinnati'; |
## Task
Generate a SQL query to answer the following question:
`Who is from the College of Cincinnati?`
### 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 `Who is from the College of Cincinnati?`:
```sql
|
SELECT COUNT("overall") FROM "atlanta_falcons_draft_history" WHERE "position"='kicker' AND "pick_num"<6; |
## Task
Generate a SQL query to answer the following question:
`What is the overall number for a kicker with a pick of less than 6?`
### 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 overall number for a kicker with a pick of less than 6?`:
```sql
|
SELECT "college" FROM "atlanta_falcons_draft_history" WHERE "round">6 AND "position"='defensive end'; |
## Task
Generate a SQL query to answer the following question:
`Which college has a defensive end with a round less than 6?`
### 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 `Which college has a defensive end with a round less than 6?`:
```sql
|
SELECT "record" FROM "game_log" WHERE "score"='111-96'; |
## Task
Generate a SQL query to answer the following question:
`What record has a score of 111-96?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"game" real,
"date" text,
"opponent" text,
"score" text,
"location" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What record has a score of 111-96?`:
```sql
|
SELECT "score" FROM "game_log" WHERE "game">34 AND "record"='31-11'; |
## Task
Generate a SQL query to answer the following question:
`What is the score for a game after 34 with a record of 31-11?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"game" real,
"date" text,
"opponent" text,
"score" text,
"location" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the score for a game after 34 with a record of 31-11?`:
```sql
|
SELECT "date" FROM "game_log" WHERE "score"='130-100'; |
## Task
Generate a SQL query to answer the following question:
`What was the date with a resulted score of 130-100?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"game" real,
"date" text,
"opponent" text,
"score" text,
"location" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the date with a resulted score of 130-100?`:
```sql
|
SELECT "water" FROM "theory_of_the_five_elements" WHERE "metal"='contracting'; |
## Task
Generate a SQL query to answer the following question:
`Which Water has a Metal of contracting?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "theory_of_the_five_elements" (
"element" text,
"wood" text,
"fire" text,
"earth" text,
"metal" text,
"water" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Water has a Metal of contracting?`:
```sql
|
SELECT "metal" FROM "theory_of_the_five_elements" WHERE "element"='heavenly stems'; |
## Task
Generate a SQL query to answer the following question:
`Which Metal has an Element of heavenly stems?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "theory_of_the_five_elements" (
"element" text,
"wood" text,
"fire" text,
"earth" text,
"metal" text,
"water" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Metal has an Element of heavenly stems?`:
```sql
|
SELECT "water" FROM "theory_of_the_five_elements" WHERE "wood"='green'; |
## Task
Generate a SQL query to answer the following question:
`Which water has green wood?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "theory_of_the_five_elements" (
"element" text,
"wood" text,
"fire" text,
"earth" text,
"metal" text,
"water" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which water has green wood?`:
```sql
|
SELECT "earth" FROM "theory_of_the_five_elements" WHERE "metal"='west'; |
## Task
Generate a SQL query to answer the following question:
`Which earth has west metal?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "theory_of_the_five_elements" (
"element" text,
"wood" text,
"fire" text,
"earth" text,
"metal" text,
"water" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which earth has west metal?`:
```sql
|
SELECT "wood" FROM "theory_of_the_five_elements" WHERE "earth"='stabilizing'; |
## Task
Generate a SQL query to answer the following question:
`Which wood has stabilizing earth?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "theory_of_the_five_elements" (
"element" text,
"wood" text,
"fire" text,
"earth" text,
"metal" text,
"water" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which wood has stabilizing earth?`:
```sql
|
SELECT "fire" FROM "theory_of_the_five_elements" WHERE "metal"='dry'; |
## Task
Generate a SQL query to answer the following question:
`Which fire has dry metal?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "theory_of_the_five_elements" (
"element" text,
"wood" text,
"fire" text,
"earth" text,
"metal" text,
"water" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which fire has dry metal?`:
```sql
|
SELECT "name" FROM "commandants_list" WHERE "rank"='lieutenant colonel' AND "begin_date"='1904-02-22 22 february 1904'; |
## Task
Generate a SQL query to answer the following question:
`what name has a Rank of lieutenant colonel, and a Begin Date of 1904-02-22 22 february 1904?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "commandants_list" (
"rank" text,
"name" text,
"begin_date" text,
"end_date" text,
"notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `what name has a Rank of lieutenant colonel, and a Begin Date of 1904-02-22 22 february 1904?`:
```sql
|
SELECT "position" FROM "nfl_draft" WHERE "school_club_team"='oklahoma state'; |
## Task
Generate a SQL query to answer the following question:
`Oklahoma State produced a player in which position in the draft?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "nfl_draft" (
"round" real,
"pick" real,
"player" text,
"position" text,
"school_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `Oklahoma State produced a player in which position in the draft?`:
```sql
|
SELECT MAX("round") FROM "nfl_draft" WHERE "position"='back' AND "player"='ed cody'; |
## Task
Generate a SQL query to answer the following question:
`What is the highest round where a back named Ed Cody can be found?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "nfl_draft" (
"round" real,
"pick" real,
"player" text,
"position" text,
"school_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest round where a back named Ed Cody can be found?`:
```sql
|
SELECT MIN("losses") FROM "australia" WHERE "season"<1920 AND "draws">0; |
## Task
Generate a SQL query to answer the following question:
`Which Losses is the lowest one that has a Season smaller than 1920, and Draws larger than 0?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "australia" (
"season" real,
"team" text,
"wins" real,
"losses" real,
"draws" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Losses is the lowest one that has a Season smaller than 1920, and Draws larger than 0?`:
```sql
|
SELECT SUM("draws") FROM "australia" WHERE "losses">16 AND "season">1966; |
## Task
Generate a SQL query to answer the following question:
`Which Draws have Losses larger than 16, and a Season larger than 1966?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "australia" (
"season" real,
"team" text,
"wins" real,
"losses" real,
"draws" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Draws have Losses larger than 16, and a Season larger than 1966?`:
```sql
|
SELECT SUM("draws") FROM "australia" WHERE "team"='annandale' AND "losses"<13; |
## Task
Generate a SQL query to answer the following question:
`Which Draws have a Team of annandale, and Losses smaller than 13?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "australia" (
"season" real,
"team" text,
"wins" real,
"losses" real,
"draws" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Draws have a Team of annandale, and Losses smaller than 13?`:
```sql
|
SELECT AVG("draws") FROM "australia" WHERE "losses"<16 AND "team"='university' AND "wins">0; |
## Task
Generate a SQL query to answer the following question:
`Which Draws have Losses smaller than 16, and a Team of university, and Wins larger than 0?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "australia" (
"season" real,
"team" text,
"wins" real,
"losses" real,
"draws" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Draws have Losses smaller than 16, and a Team of university, and Wins larger than 0?`:
```sql
|
SELECT MIN("wins") FROM "australia" WHERE "season"<1920 AND "losses"<14; |
## Task
Generate a SQL query to answer the following question:
`Which Wins is the lowest one that has a Season smaller than 1920, and Losses smaller than 14?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "australia" (
"season" real,
"team" text,
"wins" real,
"losses" real,
"draws" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Wins is the lowest one that has a Season smaller than 1920, and Losses smaller than 14?`:
```sql
|
SELECT "date" FROM "2011_2012" WHERE "sport"='academics'; |
## Task
Generate a SQL query to answer the following question:
`Which date had a sport of Academics?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2011_2012" (
"date" text,
"site" text,
"sport" text,
"winning_team" text,
"series" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which date had a sport of Academics?`:
```sql
|
SELECT "date" FROM "2011_2012" WHERE "site"='n/a'; |
## Task
Generate a SQL query to answer the following question:
`Which date had a site of N/A?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2011_2012" (
"date" text,
"site" text,
"sport" text,
"winning_team" text,
"series" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which date had a site of N/A?`:
```sql
|
SELECT "builder" FROM "locomotives_withdrawn_from_service" WHERE "year_built"='1929'; |
## Task
Generate a SQL query to answer the following question:
`what was the builder in 1929`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "locomotives_withdrawn_from_service" (
"name_or_designation" text,
"wheel_arrangement" text,
"builder" text,
"year_built" text,
"year_withdrawn" text
);
### SQL
Given the database schema, here is the SQL query that answers `what was the builder in 1929`:
```sql
|
SELECT "attendance" FROM "game_log" WHERE "points"=53 AND "date"='march 6'; |
## Task
Generate a SQL query to answer the following question:
`What was the attendance for the March 6 game, where one of the teams had 53 points.`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"attendance" real,
"record" text,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the attendance for the March 6 game, where one of the teams had 53 points.`:
```sql
|
SELECT COUNT("points") FROM "game_log" WHERE "attendance"='6,126'; |
## Task
Generate a SQL query to answer the following question:
`For the game with 6,126 in attendance, how many points did both teams have in the standings?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"attendance" real,
"record" text,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `For the game with 6,126 in attendance, how many points did both teams have in the standings?`:
```sql
|
SELECT "record" FROM "game_log" WHERE "home"='st. louis'; |
## Task
Generate a SQL query to answer the following question:
`What is the record of the team with a St. Louis home?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the record of the team with a St. Louis home?`:
```sql
|
SELECT "country" FROM "territorial_and_overseas_regions_recordh" WHERE "territory"='french guiana'; |
## Task
Generate a SQL query to answer the following question:
`What country has a territory of French Guiana?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "territorial_and_overseas_regions_recordh" (
"country" text,
"territory" text,
"name" text,
"birth_date" text,
"death_date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What country has a territory of French Guiana?`:
```sql
|
SELECT "2008_12" FROM "doubles_performance_timeline" WHERE "2013"='a' AND "tournament"='wimbledon'; |
## Task
Generate a SQL query to answer the following question:
`Which 2008-12 has a 2013 of A, and a Tournament of wimbledon?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_performance_timeline" (
"tournament" text,
"2006" text,
"2007" text,
"2008_12" text,
"2013" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which 2008-12 has a 2013 of A, and a Tournament of wimbledon?`:
```sql
|
SELECT "2013" FROM "doubles_performance_timeline" WHERE "2007"='a' AND "tournament"='french open'; |
## Task
Generate a SQL query to answer the following question:
`Which 2013 has a 2007 of A, and a Tournament of french open?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_performance_timeline" (
"tournament" text,
"2006" text,
"2007" text,
"2008_12" text,
"2013" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which 2013 has a 2007 of A, and a Tournament of french open?`:
```sql
|
SELECT "2013" FROM "doubles_performance_timeline" WHERE "2008_12"='a' AND "2007"='a' AND "tournament"='us open'; |
## Task
Generate a SQL query to answer the following question:
`Which 2013 has a 2008-12 of A, and a 2007 of A, and a Tournament of us open?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_performance_timeline" (
"tournament" text,
"2006" text,
"2007" text,
"2008_12" text,
"2013" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which 2013 has a 2008-12 of A, and a 2007 of A, and a Tournament of us open?`:
```sql
|
SELECT "2013" FROM "doubles_performance_timeline" WHERE "2006"='grand slam tournaments'; |
## Task
Generate a SQL query to answer the following question:
`Which 2013 has a 2006 of grand slam tournaments?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_performance_timeline" (
"tournament" text,
"2006" text,
"2007" text,
"2008_12" text,
"2013" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which 2013 has a 2006 of grand slam tournaments?`:
```sql
|
SELECT "2006" FROM "doubles_performance_timeline" WHERE "2007"='a'; |
## Task
Generate a SQL query to answer the following question:
`Which 2006 has a 2007 of A?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_performance_timeline" (
"tournament" text,
"2006" text,
"2007" text,
"2008_12" text,
"2013" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which 2006 has a 2007 of A?`:
```sql
|
SELECT "2008_12" FROM "doubles_performance_timeline" WHERE "2007"='a' AND "tournament"='us open'; |
## Task
Generate a SQL query to answer the following question:
`Which 2008-12 has a 2007 of A, and a Tournament of us open?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_performance_timeline" (
"tournament" text,
"2006" text,
"2007" text,
"2008_12" text,
"2013" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which 2008-12 has a 2007 of A, and a Tournament of us open?`:
```sql
|
SELECT "record" FROM "april" WHERE "date"='april 1'; |
## Task
Generate a SQL query to answer the following question:
`What was the record on April 1?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "april" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the record on April 1?`:
```sql
|
SELECT "score" FROM "april" WHERE "date"='april 9'; |
## Task
Generate a SQL query to answer the following question:
`What's the score on April 9?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "april" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the score on April 9?`:
```sql
|
SELECT "home" FROM "april" WHERE "date"='april 3'; |
## Task
Generate a SQL query to answer the following question:
`Where was home on April 3?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "april" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where was home on April 3?`:
```sql
|
SELECT "score" FROM "april" WHERE "date"='april 9'; |
## Task
Generate a SQL query to answer the following question:
`What's the score on April 9?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "april" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the score on April 9?`:
```sql
|
SELECT AVG("points") FROM "torneo_clausura" WHERE "played">18; |
## Task
Generate a SQL query to answer the following question:
`What is the average number of points of the team with more than 18 played?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "torneo_clausura" (
"position" real,
"team" text,
"played" real,
"wins" real,
"draws" real,
"losses" real,
"scored" real,
"conceded" real,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average number of points of the team with more than 18 played?`:
```sql
|
SELECT MIN("scored") FROM "torneo_clausura" WHERE "points"=19 AND "played"<18; |
## Task
Generate a SQL query to answer the following question:
`What is the lowest score of the team with 19 points and less than 18 played?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "torneo_clausura" (
"position" real,
"team" text,
"played" real,
"wins" real,
"draws" real,
"losses" real,
"scored" real,
"conceded" real,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest score of the team with 19 points and less than 18 played?`:
```sql
|
SELECT AVG("draws") FROM "torneo_clausura" WHERE "points"<17 AND "wins"<4; |
## Task
Generate a SQL query to answer the following question:
`What is the average number of draws of the team with less than 17 points and less than 4 wins?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "torneo_clausura" (
"position" real,
"team" text,
"played" real,
"wins" real,
"draws" real,
"losses" real,
"scored" real,
"conceded" real,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average number of draws of the team with less than 17 points and less than 4 wins?`:
```sql
|
SELECT "title" FROM "catalogue" WHERE "artist"='tangorodrim' AND "cat_num"='fsr006'; |
## Task
Generate a SQL query to answer the following question:
`What is the title of the record with an artist of Tangorodrim, category number FSR006?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "catalogue" (
"artist" text,
"title" text,
"release_date" text,
"format" text,
"cat_num" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the title of the record with an artist of Tangorodrim, category number FSR006?`:
```sql
|
SELECT "format" FROM "catalogue" WHERE "artist"='triumfall'; |
## Task
Generate a SQL query to answer the following question:
`What was the format of the release by Triumfall?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "catalogue" (
"artist" text,
"title" text,
"release_date" text,
"format" text,
"cat_num" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the format of the release by Triumfall?`:
```sql
|
SELECT "cat_num" FROM "catalogue" WHERE "release_date"='november 2007'; |
## Task
Generate a SQL query to answer the following question:
`What is the category number that was released in November 2007?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "catalogue" (
"artist" text,
"title" text,
"release_date" text,
"format" text,
"cat_num" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the category number that was released in November 2007?`:
```sql
|
SELECT MIN("round") FROM "atlanta_falcons_draft_history" WHERE "pick_num"=12 AND "position"='linebacker'; |
## Task
Generate a SQL query to answer the following question:
`Which is the lowest round to have a pick of 12 and position of linebacker?`
### 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 `Which is the lowest round to have a pick of 12 and position of linebacker?`:
```sql
|
SELECT "name" FROM "atlanta_falcons_draft_history" WHERE "pick_num"<13 AND "round"=15; |
## Task
Generate a SQL query to answer the following question:
`Which player was picked in round 15 with a pick smaller than 13?`
### 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 `Which player was picked in round 15 with a pick smaller than 13?`:
```sql
|
SELECT COUNT("pick_num") FROM "atlanta_falcons_draft_history" WHERE "college"='lamar'; |
## Task
Generate a SQL query to answer the following question:
`How many picks were from Lamar College?`
### 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 `How many picks were from Lamar College?`:
```sql
|
SELECT COUNT("overall") FROM "atlanta_falcons_draft_history" WHERE "college"='notre dame' AND "round">2; |
## Task
Generate a SQL query to answer the following question:
`How many overall values have a college of Notre Dame and rounds over 2?`
### 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 `How many overall values have a college of Notre Dame and rounds over 2?`:
```sql
|
SELECT "player" FROM "highest_individual_scores" WHERE "venue"='albion'; |
## Task
Generate a SQL query to answer the following question:
`What player was at Albion?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "highest_individual_scores" (
"rank" text,
"runs" text,
"player" text,
"opponent" text,
"venue" text,
"season" text
);
### SQL
Given the database schema, here is the SQL query that answers `What player was at Albion?`:
```sql
|
SELECT "venue" FROM "highest_individual_scores" WHERE "runs"='274'; |
## Task
Generate a SQL query to answer the following question:
`Where was the venue that had 274 runs?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "highest_individual_scores" (
"rank" text,
"runs" text,
"player" text,
"opponent" text,
"venue" text,
"season" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where was the venue that had 274 runs?`:
```sql
|
SELECT "player" FROM "highest_individual_scores" WHERE "opponent"='queensland'; |
## Task
Generate a SQL query to answer the following question:
`which athlete played against Queensland?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "highest_individual_scores" (
"rank" text,
"runs" text,
"player" text,
"opponent" text,
"venue" text,
"season" text
);
### SQL
Given the database schema, here is the SQL query that answers `which athlete played against Queensland?`:
```sql
|
SELECT "venue" FROM "highest_individual_scores" WHERE "runs"='245'; |
## Task
Generate a SQL query to answer the following question:
`Where is the venue with more than 245 runs?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "highest_individual_scores" (
"rank" text,
"runs" text,
"player" text,
"opponent" text,
"venue" text,
"season" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where is the venue with more than 245 runs?`:
```sql
|
SELECT "venue" FROM "highest_individual_scores" WHERE "player"='jack badcock'; |
## Task
Generate a SQL query to answer the following question:
`Where did Jack Badcock play?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "highest_individual_scores" (
"rank" text,
"runs" text,
"player" text,
"opponent" text,
"venue" text,
"season" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where did Jack Badcock play?`:
```sql
|
SELECT "surface" FROM "doubles_13_6_7" WHERE "date"='16 november 2007'; |
## Task
Generate a SQL query to answer the following question:
`Which Surface has a Date of 16 november 2007?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_13_6_7" (
"outcome" text,
"date" text,
"tournament" text,
"surface" text,
"partner" text,
"opponents_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Surface has a Date of 16 november 2007?`:
```sql
|
SELECT "date" FROM "international_goals" WHERE "competition"='2004 afc asian cup qualifier'; |
## Task
Generate a SQL query to answer the following question:
`Name the date for 2004 afc asian cup qualifier`
### 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 `Name the date for 2004 afc asian cup qualifier`:
```sql
|
SELECT "venue" FROM "international_goals" WHERE "date"='23 january 2009'; |
## Task
Generate a SQL query to answer the following question:
`Name the venue for 23 january 2009`
### 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 `Name the venue for 23 january 2009`:
```sql
|
SELECT "competition" FROM "international_goals" WHERE "venue"='khartoum'; |
## Task
Generate a SQL query to answer the following question:
`Name the competition for khartoum`
### 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 `Name the competition for khartoum`:
```sql
|
SELECT MIN("drawn") FROM "world_championship_group_c_slovenia" WHERE "games"<7; |
## Task
Generate a SQL query to answer the following question:
`What is the fewest ties the team had with fewer than 7 games?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "world_championship_group_c_slovenia" (
"games" real,
"drawn" real,
"lost" real,
"goal_difference" text,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the fewest ties the team had with fewer than 7 games?`:
```sql
|
SELECT "population" FROM "counties" WHERE "median_household_income"='$69,760'; |
## Task
Generate a SQL query to answer the following question:
`What is the population for a county that has a median income of $69,760?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "counties" (
"county" text,
"per_capita_income" text,
"median_household_income" text,
"median_family_income" text,
"population" real,
"number_of_households" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the population for a county that has a median income of $69,760?`:
```sql
|
SELECT "county" FROM "counties" WHERE "per_capita_income"='$51,456'; |
## Task
Generate a SQL query to answer the following question:
`What county has $51,456 income per capita?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "counties" (
"county" text,
"per_capita_income" text,
"median_household_income" text,
"median_family_income" text,
"population" real,
"number_of_households" real
);
### SQL
Given the database schema, here is the SQL query that answers `What county has $51,456 income per capita?`:
```sql
|
SELECT "opponent" FROM "schedule" WHERE "attendance"='60,355'; |
## Task
Generate a SQL query to answer the following question:
`Who was the opponent when attendance was 60,355?`
### 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" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the opponent when attendance was 60,355?`:
```sql
|
SELECT SUM("net_profit_loss_sek") FROM "financial_performance" WHERE "basic_eps_sek"=-6.58 AND "employees_average_year">'31,035'; |
## Task
Generate a SQL query to answer the following question:
`Which Net profit/loss (SEK) has a Basic eps (SEK) of -6.58, and Employees (Average/Year) larger than 31,035?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "financial_performance" (
"year_ended" text,
"passengers_flown" real,
"employees_average_year" real,
"net_profit_loss_sek" real,
"basic_eps_sek" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Net profit/loss (SEK) has a Basic eps (SEK) of -6.58, and Employees (Average/Year) larger than 31,035?`:
```sql
|
SELECT SUM("passengers_flown") FROM "financial_performance" WHERE "net_profit_loss_sek"<'-6,360,000,000' AND "employees_average_year"<'34,544' AND "basic_eps_sek"=-18.2; |
## Task
Generate a SQL query to answer the following question:
`Which Passengers flown has a Net profit/loss (SEK) smaller than -6,360,000,000, and Employees (Average/Year) smaller than 34,544, and a Basic eps (SEK) of -18.2?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "financial_performance" (
"year_ended" text,
"passengers_flown" real,
"employees_average_year" real,
"net_profit_loss_sek" real,
"basic_eps_sek" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Passengers flown has a Net profit/loss (SEK) smaller than -6,360,000,000, and Employees (Average/Year) smaller than 34,544, and a Basic eps (SEK) of -18.2?`:
```sql
|
SELECT AVG("net_profit_loss_sek") FROM "financial_performance" WHERE "employees_average_year">'18,786' AND "year_ended"='2000*' AND "passengers_flown">'23,240,000'; |
## Task
Generate a SQL query to answer the following question:
`Which average Net profit/loss (SEK) has Employees (Average/Year) larger than 18,786, and a Year ended of 2000*, and Passengers flown larger than 23,240,000?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "financial_performance" (
"year_ended" text,
"passengers_flown" real,
"employees_average_year" real,
"net_profit_loss_sek" real,
"basic_eps_sek" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which average Net profit/loss (SEK) has Employees (Average/Year) larger than 18,786, and a Year ended of 2000*, and Passengers flown larger than 23,240,000?`:
```sql
|
SELECT COUNT("employees_average_year") FROM "financial_performance" WHERE "net_profit_loss_sek">'4,936,000,000' AND "basic_eps_sek">1.06; |
## Task
Generate a SQL query to answer the following question:
`How many Employees (Average/Year) have a Net profit/loss (SEK) larger than 4,936,000,000, and a Basic eps (SEK) larger than 1.06?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "financial_performance" (
"year_ended" text,
"passengers_flown" real,
"employees_average_year" real,
"net_profit_loss_sek" real,
"basic_eps_sek" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many Employees (Average/Year) have a Net profit/loss (SEK) larger than 4,936,000,000, and a Basic eps (SEK) larger than 1.06?`:
```sql
|
SELECT "result" FROM "schedule" WHERE "week"=13; |
## Task
Generate a SQL query to answer the following question:
`What is the result when 13 is the week?`
### 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,
"game_site" text,
"attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the result when 13 is the week?`:
```sql
|
SELECT AVG("week") FROM "schedule" WHERE "game_site"='shea stadium' AND "date"='1979-12-09'; |
## Task
Generate a SQL query to answer the following question:
`What average week has shea stadium as the game site, and 1979-12-09 as the date?`
### 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,
"game_site" text,
"attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What average week has shea stadium as the game site, and 1979-12-09 as the date?`:
```sql
|
SELECT MAX("rank") FROM "leaders" WHERE "country"='united states' AND "wins"<1; |
## Task
Generate a SQL query to answer the following question:
`Name the most rank for the United States with wins less than 1`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "leaders" (
"rank" real,
"player" text,
"country" text,
"earnings" real,
"events" real,
"wins" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the most rank for the United States with wins less than 1`:
```sql
|
SELECT MAX("rank") FROM "leaders" WHERE "events"=26 AND "wins">0; |
## Task
Generate a SQL query to answer the following question:
`Name the most rank for wins more than 0 and events of 26`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "leaders" (
"rank" real,
"player" text,
"country" text,
"earnings" real,
"events" real,
"wins" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the most rank for wins more than 0 and events of 26`:
```sql
|
SELECT AVG("earnings") FROM "leaders" WHERE "rank"=3 AND "wins"<3; |
## Task
Generate a SQL query to answer the following question:
`Name the average earnings for rank of 3 and wins less than 3`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "leaders" (
"rank" real,
"player" text,
"country" text,
"earnings" real,
"events" real,
"wins" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the average earnings for rank of 3 and wins less than 3`:
```sql
|
SELECT AVG("area_km_2") FROM "communes" WHERE "density_inhabitants_km_2"<206.2 AND "altitude_mslm"<85; |
## Task
Generate a SQL query to answer the following question:
`What is the average area of the city that has a density less than than 206.2 and an altitude of less than 85?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "communes" (
"rank" text,
"city" text,
"population" real,
"area_km_2" real,
"density_inhabitants_km_2" real,
"altitude_mslm" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average area of the city that has a density less than than 206.2 and an altitude of less than 85?`:
```sql
|
SELECT MIN("density_inhabitants_km_2") FROM "communes" WHERE "area_km_2">16.02 AND "altitude_mslm"<116 AND "city"='alessandria'; |
## Task
Generate a SQL query to answer the following question:
`What is the lowest density of alessandria where the area is bigger than 16.02 and altitude is less than 116?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "communes" (
"rank" text,
"city" text,
"population" real,
"area_km_2" real,
"density_inhabitants_km_2" real,
"altitude_mslm" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest density of alessandria where the area is bigger than 16.02 and altitude is less than 116?`:
```sql
|
SELECT MIN("density_inhabitants_km_2") FROM "communes" WHERE "city"='serravalle scrivia'; |
## Task
Generate a SQL query to answer the following question:
`What is the lowest density of serravalle scrivia?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "communes" (
"rank" text,
"city" text,
"population" real,
"area_km_2" real,
"density_inhabitants_km_2" real,
"altitude_mslm" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest density of serravalle scrivia?`:
```sql
|
SELECT MIN("population") FROM "communes" WHERE "altitude_mslm"<197 AND "city"='alessandria' AND "density_inhabitants_km_2"<461.8; |
## Task
Generate a SQL query to answer the following question:
`What is the lowest population of alessandria where the altitude is less than 197 and density is less than 461.8?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "communes" (
"rank" text,
"city" text,
"population" real,
"area_km_2" real,
"density_inhabitants_km_2" real,
"altitude_mslm" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest population of alessandria where the altitude is less than 197 and density is less than 461.8?`:
```sql
|
SELECT AVG("my_space") FROM "overlap_between_multiple_social_network_" WHERE "site"='linkedin' AND "orkut">3; |
## Task
Generate a SQL query to answer the following question:
`What myspace has linkedin as the site, with an orkit greater than 3?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "overlap_between_multiple_social_network_" (
"site" text,
"bebo" real,
"facebook" real,
"friendster" real,
"linked_in" real,
"my_space" real,
"ning" real,
"orkut" real,
"plaxo" real
);
### SQL
Given the database schema, here is the SQL query that answers `What myspace has linkedin as the site, with an orkit greater than 3?`:
```sql
|
SELECT COUNT("linked_in") FROM "overlap_between_multiple_social_network_" WHERE "site"='facebook' AND "my_space"<64; |
## Task
Generate a SQL query to answer the following question:
`How many linkedin have Facebook as the site, with a myspace less than 64?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "overlap_between_multiple_social_network_" (
"site" text,
"bebo" real,
"facebook" real,
"friendster" real,
"linked_in" real,
"my_space" real,
"ning" real,
"orkut" real,
"plaxo" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many linkedin have Facebook as the site, with a myspace less than 64?`:
```sql
|
SELECT MAX("ning") FROM "overlap_between_multiple_social_network_" WHERE "bebo"<4 AND "orkut"<100 AND "plaxo">0; |
## Task
Generate a SQL query to answer the following question:
`What is the highest Ning that has a bebo less than 4, an orkut less than 100, with a plaxo greater than 0?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "overlap_between_multiple_social_network_" (
"site" text,
"bebo" real,
"facebook" real,
"friendster" real,
"linked_in" real,
"my_space" real,
"ning" real,
"orkut" real,
"plaxo" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest Ning that has a bebo less than 4, an orkut less than 100, with a plaxo greater than 0?`:
```sql
|
SELECT AVG("plaxo") FROM "overlap_between_multiple_social_network_" WHERE "my_space">64 AND "bebo">3 AND "friendster"=4; |
## Task
Generate a SQL query to answer the following question:
`What is the average plaxo that has a myspace greater than 64, a bebo greater than 3, with 4 as the friendster?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "overlap_between_multiple_social_network_" (
"site" text,
"bebo" real,
"facebook" real,
"friendster" real,
"linked_in" real,
"my_space" real,
"ning" real,
"orkut" real,
"plaxo" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average plaxo that has a myspace greater than 64, a bebo greater than 3, with 4 as the friendster?`:
```sql
|
SELECT "album" FROM "singles" WHERE "label"='warp records / paper bag records' AND "title"='i need a life'; |
## Task
Generate a SQL query to answer the following question:
`What album has the title I Need A Life with the label of warp records / paper bag records?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles" (
"year" real,
"title" text,
"label" text,
"format" text,
"album" text
);
### SQL
Given the database schema, here is the SQL query that answers `What album has the title I Need A Life with the label of warp records / paper bag records?`:
```sql
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.