output stringlengths 27 479 | instruction stringlengths 407 1.39k |
|---|---|
SELECT "release_price_usd" FROM "sandy_bridge_quad_core_32_nm" WHERE "gpu_frequency"='standard power, embedded'; |
## Task
Generate a SQL query to answer the following question:
`What is the release price for the GPU frequency of standard power, embedded?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "sandy_bridge_quad_core_32_nm" (
"model_number" text,
"s_spec_number" text,
"cores" text,
"frequency" text,
"turbo" text,
"l2_cache" text,
"l3_cache" text,
"gpu_model" text,
"gpu_frequency" text,
"socket" text,
"i_o_bus" text,
"release_date" text,
"part_number_s" text,
"release_price_usd" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the release price for the GPU frequency of standard power, embedded?`:
```sql
|
SELECT "socket" FROM "sandy_bridge_quad_core_32_nm" WHERE "turbo"='8/8/10/11'; |
## Task
Generate a SQL query to answer the following question:
`What is the socked when the turbo is 8/8/10/11?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "sandy_bridge_quad_core_32_nm" (
"model_number" text,
"s_spec_number" text,
"cores" text,
"frequency" text,
"turbo" text,
"l2_cache" text,
"l3_cache" text,
"gpu_model" text,
"gpu_frequency" text,
"socket" text,
"i_o_bus" text,
"release_date" text,
"part_number_s" text,
"release_price_usd" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the socked when the turbo is 8/8/10/11?`:
```sql
|
SELECT "round" FROM "mixed_martial_arts_record" WHERE "record"='1-0'; |
## Task
Generate a SQL query to answer the following question:
`Which round did the bout that led to a 1-0 record end in?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "mixed_martial_arts_record" (
"res" text,
"record" text,
"opponent" text,
"method" text,
"event" text,
"round" real,
"time" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which round did the bout that led to a 1-0 record end in?`:
```sql
|
SELECT "time" FROM "heats" WHERE "lane"<2 AND "nationality"='spain'; |
## Task
Generate a SQL query to answer the following question:
`Which Time has a Lane smaller than 2, and a Nationality of spain?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heats" (
"heat" real,
"lane" real,
"name" text,
"nationality" text,
"time" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Time has a Lane smaller than 2, and a Nationality of spain?`:
```sql
|
SELECT COUNT("heat") FROM "heats" WHERE "name"='miguel molina'; |
## Task
Generate a SQL query to answer the following question:
`How many Heats have a Name of miguel molina?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heats" (
"heat" real,
"lane" real,
"name" text,
"nationality" text,
"time" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many Heats have a Name of miguel molina?`:
```sql
|
SELECT "league" FROM "league_standings" WHERE "fa_cup"='qr4' AND "fa_trophy"='qf'; |
## Task
Generate a SQL query to answer the following question:
`what is the league when the fa cup is qr4 and the fa trophy is qf?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "league_standings" (
"year" text,
"league" text,
"position" text,
"leading_scorer" text,
"fa_cup" text,
"fa_trophy" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the league when the fa cup is qr4 and the fa trophy is qf?`:
```sql
|
SELECT "fa_trophy" FROM "league_standings" WHERE "leading_scorer"='lee gregory (8)'; |
## Task
Generate a SQL query to answer the following question:
`what is the fa trophy when the leading scorer is lee gregory (8)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "league_standings" (
"year" text,
"league" text,
"position" text,
"leading_scorer" text,
"fa_cup" text,
"fa_trophy" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the fa trophy when the leading scorer is lee gregory (8)?`:
```sql
|
SELECT "year" FROM "league_standings" WHERE "position"='1/22 promoted' AND "leading_scorer"='james dean (27)'; |
## Task
Generate a SQL query to answer the following question:
`what is the year when the position is 1/22 promoted and the leading scorer is james dean (27)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "league_standings" (
"year" text,
"league" text,
"position" text,
"leading_scorer" text,
"fa_cup" text,
"fa_trophy" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the year when the position is 1/22 promoted and the leading scorer is james dean (27)?`:
```sql
|
SELECT "tie_no" FROM "third_round" WHERE "home_team"='altrincham'; |
## Task
Generate a SQL query to answer the following question:
`When the Altrincham was the home team what was the tie no?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "third_round" (
"tie_no" text,
"home_team" text,
"score" text,
"away_team" text,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `When the Altrincham was the home team what was the tie no?`:
```sql
|
SELECT "tie_no" FROM "third_round" WHERE "home_team"='crawley town'; |
## Task
Generate a SQL query to answer the following question:
`Crawley Town as the home team has what as the tie no?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "third_round" (
"tie_no" text,
"home_team" text,
"score" text,
"away_team" text,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `Crawley Town as the home team has what as the tie no?`:
```sql
|
SELECT "nationality" FROM "heats" WHERE "rank">2 AND "time"='55.77'; |
## Task
Generate a SQL query to answer the following question:
`What is the nationality of the swimmer with a rank over 2 with a time of 55.77?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heats" (
"rank" real,
"heat" real,
"lane" real,
"name" text,
"nationality" text,
"time" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the nationality of the swimmer with a rank over 2 with a time of 55.77?`:
```sql
|
SELECT MIN("heat") FROM "heats" WHERE "nationality"='czech republic' AND "rank">41; |
## Task
Generate a SQL query to answer the following question:
`What is the earliest heat with a finisher from the Czech Republic and a rank over 41?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heats" (
"rank" real,
"heat" real,
"lane" real,
"name" text,
"nationality" text,
"time" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the earliest heat with a finisher from the Czech Republic and a rank over 41?`:
```sql
|
SELECT COUNT("heat") FROM "heats" WHERE "name"='gregor tait' AND "lane">6; |
## Task
Generate a SQL query to answer the following question:
`What is the total number of heats with a finisher named Gregor Tait in lanes over 6?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heats" (
"rank" real,
"heat" real,
"lane" real,
"name" text,
"nationality" text,
"time" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of heats with a finisher named Gregor Tait in lanes over 6?`:
```sql
|
SELECT "time" FROM "heats" WHERE "rank"=40; |
## Task
Generate a SQL query to answer the following question:
`What is the time of the swimmer in rank 40?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heats" (
"rank" real,
"heat" real,
"lane" real,
"name" text,
"nationality" text,
"time" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the time of the swimmer in rank 40?`:
```sql
|
SELECT "series" FROM "1943" WHERE "director"='norm mccabe' AND "title"='tokio jokio'; |
## Task
Generate a SQL query to answer the following question:
`From what series was Tokio Jokio, directed by Norm McCabe?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1943" (
"title" text,
"series" text,
"director" text,
"release_date" text,
"reissue" text
);
### SQL
Given the database schema, here is the SQL query that answers `From what series was Tokio Jokio, directed by Norm McCabe?`:
```sql
|
SELECT "release_date" FROM "1943" WHERE "title"='inki and the minah bird'; |
## Task
Generate a SQL query to answer the following question:
`When was Inki and the Minah Bird released?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1943" (
"title" text,
"series" text,
"director" text,
"release_date" text,
"reissue" text
);
### SQL
Given the database schema, here is the SQL query that answers `When was Inki and the Minah Bird released?`:
```sql
|
SELECT "series" FROM "1945" WHERE "title"='peck up your troubles'; |
## Task
Generate a SQL query to answer the following question:
`From what series is Peck Up Your Troubles?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1945" (
"title" text,
"series" text,
"director" text,
"production_number" text,
"release_date" text,
"reissue" text
);
### SQL
Given the database schema, here is the SQL query that answers `From what series is Peck Up Your Troubles?`:
```sql
|
SELECT SUM("civil_liberties") FROM "historical_rankings" WHERE "political_rights"=6 AND "president"='yoweri museveni' AND "year"=1993; |
## Task
Generate a SQL query to answer the following question:
`When the president was Yoweri Museveni, and the year was 1993, with rank of 6 under political rights, what was the total of civil liberties?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "historical_rankings" (
"year" real,
"political_rights" real,
"civil_liberties" real,
"status" text,
"president" text
);
### SQL
Given the database schema, here is the SQL query that answers `When the president was Yoweri Museveni, and the year was 1993, with rank of 6 under political rights, what was the total of civil liberties?`:
```sql
|
SELECT AVG("year") FROM "historical_rankings" WHERE "status"='not free' AND "civil_liberties"<7 AND "political_rights"<6; |
## Task
Generate a SQL query to answer the following question:
`What is the year average when not free was the status, and less than 7 was the civil liberties, and less than 6 political rights?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "historical_rankings" (
"year" real,
"political_rights" real,
"civil_liberties" real,
"status" text,
"president" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the year average when not free was the status, and less than 7 was the civil liberties, and less than 6 political rights?`:
```sql
|
SELECT MIN("political_rights") FROM "historical_rankings" WHERE "year"=1976; |
## Task
Generate a SQL query to answer the following question:
`What is the least political rights rank in 1976?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "historical_rankings" (
"year" real,
"political_rights" real,
"civil_liberties" real,
"status" text,
"president" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the least political rights rank in 1976?`:
```sql
|
SELECT "average_ratings" FROM "2007_summer_season" WHERE "episodes">9 AND "japanese_title"='ホタルノヒカリ'; |
## Task
Generate a SQL query to answer the following question:
`What is average ratings for Japanese title of ホタルノヒカリ, with episodes larger than 9?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2007_summer_season" (
"japanese_title" text,
"romaji_title" text,
"tv_station" text,
"episodes" real,
"average_ratings" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is average ratings for Japanese title of ホタルノヒカリ, with episodes larger than 9?`:
```sql
|
SELECT MIN("episodes") FROM "2007_summer_season" WHERE "average_ratings"='8.7%'; |
## Task
Generate a SQL query to answer the following question:
`Which episodes has the lowest average ratings of 8.7%?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2007_summer_season" (
"japanese_title" text,
"romaji_title" text,
"tv_station" text,
"episodes" real,
"average_ratings" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which episodes has the lowest average ratings of 8.7%?`:
```sql
|
SELECT "romaji_title" FROM "2007_summer_season" WHERE "japanese_title"='菊次郎とさき 3'; |
## Task
Generate a SQL query to answer the following question:
`Which romaji title, has Japanese title of 菊次郎とさき 3?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2007_summer_season" (
"japanese_title" text,
"romaji_title" text,
"tv_station" text,
"episodes" real,
"average_ratings" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which romaji title, has Japanese title of 菊次郎とさき 3?`:
```sql
|
SELECT "tv_station" FROM "2007_summer_season" WHERE "episodes">10 AND "romaji_title"='tantei gakuen q'; |
## Task
Generate a SQL query to answer the following question:
`Which TV station, has romaji title of tantei gakuen q and episodes larger than 10?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2007_summer_season" (
"japanese_title" text,
"romaji_title" text,
"tv_station" text,
"episodes" real,
"average_ratings" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which TV station, has romaji title of tantei gakuen q and episodes larger than 10?`:
```sql
|
SELECT "snatch" FROM "records" WHERE "world_record"='olympic record' AND "173kg"='172kg'; |
## Task
Generate a SQL query to answer the following question:
`What is the snatch for the person holding the Olympic record, and 173kg of 172kg?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "records" (
"world_record" text,
"snatch" text,
"sergey_filimonov_kaz" text,
"173kg" text,
"almaty_kazakhstan" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the snatch for the person holding the Olympic record, and 173kg of 172kg?`:
```sql
|
SELECT "almaty_kazakhstan" FROM "records" WHERE "sergey_filimonov_kaz"='210kg'; |
## Task
Generate a SQL query to answer the following question:
`What is the Almaty, Kazakhstan when Sergey Filimonov ( KAZ ) is 210kg?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "records" (
"world_record" text,
"snatch" text,
"sergey_filimonov_kaz" text,
"173kg" text,
"almaty_kazakhstan" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Almaty, Kazakhstan when Sergey Filimonov ( KAZ ) is 210kg?`:
```sql
|
SELECT "sergey_filimonov_kaz" FROM "records" WHERE "snatch"='snatch'; |
## Task
Generate a SQL query to answer the following question:
`What shows for Sergey Filimonov (KAZ) when the Snatch shows snatch?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "records" (
"world_record" text,
"snatch" text,
"sergey_filimonov_kaz" text,
"173kg" text,
"almaty_kazakhstan" text
);
### SQL
Given the database schema, here is the SQL query that answers `What shows for Sergey Filimonov (KAZ) when the Snatch shows snatch?`:
```sql
|
SELECT "almaty_kazakhstan" FROM "records" WHERE "sergey_filimonov_kaz"='210kg'; |
## Task
Generate a SQL query to answer the following question:
`What is the Almaty, Kazakhstan when the Sergey Filimonov (KAZ) is 210kg?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "records" (
"world_record" text,
"snatch" text,
"sergey_filimonov_kaz" text,
"173kg" text,
"almaty_kazakhstan" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Almaty, Kazakhstan when the Sergey Filimonov (KAZ) is 210kg?`:
```sql
|
SELECT SUM("week") FROM "schedule" WHERE "attendance">'56,134' AND "opponent"='minnesota vikings'; |
## Task
Generate a SQL query to answer the following question:
`What is the total weeks with more 56,134 attendees against the minnesota vikings?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "schedule" (
"week" real,
"date" text,
"opponent" text,
"result" text,
"attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total weeks with more 56,134 attendees against the minnesota vikings?`:
```sql
|
SELECT MIN("year") FROM "television_series" WHERE "role"='main' AND "character"='guan yu (關羽)'; |
## Task
Generate a SQL query to answer the following question:
`What year was the main role a character named Guan Yu (關羽)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "television_series" (
"year" real,
"chinese_title" text,
"english" text,
"role" text,
"character" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year was the main role a character named Guan Yu (關羽)?`:
```sql
|
SELECT "english" FROM "television_series" WHERE "character"='lin ming kuan (林明寬)'; |
## Task
Generate a SQL query to answer the following question:
`What is the English character for Lin Ming Kuan (林明寬)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "television_series" (
"year" real,
"chinese_title" text,
"english" text,
"role" text,
"character" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the English character for Lin Ming Kuan (林明寬)?`:
```sql
|
SELECT "character" FROM "television_series" WHERE "year">2010 AND "role"='lead role' AND "chinese_title"='戀夏38℃'; |
## Task
Generate a SQL query to answer the following question:
`What character has a Year larger than 2010 with a lead role, and Chinese Title of 戀夏38℃?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "television_series" (
"year" real,
"chinese_title" text,
"english" text,
"role" text,
"character" text
);
### SQL
Given the database schema, here is the SQL query that answers `What character has a Year larger than 2010 with a lead role, and Chinese Title of 戀夏38℃?`:
```sql
|
SELECT AVG("year") FROM "television_series" WHERE "character"='wu ji wei (無極威)'; |
## Task
Generate a SQL query to answer the following question:
`What is the year that has a character named Wu Ji Wei (無極威)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "television_series" (
"year" real,
"chinese_title" text,
"english" text,
"role" text,
"character" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the year that has a character named Wu Ji Wei (無極威)?`:
```sql
|
SELECT MIN("round") FROM "kickboxing_record" WHERE "opponent"='aleksandr pitchkounov'; |
## Task
Generate a SQL query to answer the following question:
`Which Round has an Opponent of aleksandr pitchkounov?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "kickboxing_record" (
"result" text,
"opponent" text,
"method" text,
"event" text,
"round" real,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Round has an Opponent of aleksandr pitchkounov?`:
```sql
|
SELECT "result" FROM "kickboxing_record" WHERE "round"=5 AND "event"='mt one'; |
## Task
Generate a SQL query to answer the following question:
`Which Result has a Round of 5, and an Event of mt one?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "kickboxing_record" (
"result" text,
"opponent" text,
"method" text,
"event" text,
"round" real,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Result has a Round of 5, and an Event of mt one?`:
```sql
|
SELECT COUNT("draws") FROM "1948_ladder" WHERE "against">924 AND "club"='mortlake' AND "losses"<14; |
## Task
Generate a SQL query to answer the following question:
`Mortlake club has more than 924 against, less than 14 losses, and how many total draws?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1948_ladder" (
"club" text,
"wins" real,
"losses" real,
"draws" real,
"against" real
);
### SQL
Given the database schema, here is the SQL query that answers `Mortlake club has more than 924 against, less than 14 losses, and how many total draws?`:
```sql
|
SELECT SUM("wins") FROM "1948_ladder" WHERE "club"='cobden' AND "draws">2; |
## Task
Generate a SQL query to answer the following question:
`What is the total number of wins for Cobden club when there are more than 2 draws?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1948_ladder" (
"club" text,
"wins" real,
"losses" real,
"draws" real,
"against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of wins for Cobden club when there are more than 2 draws?`:
```sql
|
SELECT COUNT("draws") FROM "1948_ladder" WHERE "against"=797 AND "wins">10; |
## Task
Generate a SQL query to answer the following question:
`When against is 797 and wins is more than 10, what is the sum of draws?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1948_ladder" (
"club" text,
"wins" real,
"losses" real,
"draws" real,
"against" real
);
### SQL
Given the database schema, here is the SQL query that answers `When against is 797 and wins is more than 10, what is the sum of draws?`:
```sql
|
SELECT AVG("draws") FROM "1948_ladder" WHERE "wins"<9 AND "club"='warrnambool'; |
## Task
Generate a SQL query to answer the following question:
`Club warrnambool has less than 9 wins and what average of draws?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1948_ladder" (
"club" text,
"wins" real,
"losses" real,
"draws" real,
"against" real
);
### SQL
Given the database schema, here is the SQL query that answers `Club warrnambool has less than 9 wins and what average of draws?`:
```sql
|
SELECT AVG("draws") FROM "1948_ladder" WHERE "club"='mortlake' AND "wins"<0; |
## Task
Generate a SQL query to answer the following question:
`What is the average number of draws for Mortlake club when they have less than 0 wins?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1948_ladder" (
"club" text,
"wins" real,
"losses" real,
"draws" real,
"against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average number of draws for Mortlake club when they have less than 0 wins?`:
```sql
|
SELECT AVG("foreign_population") FROM "subdivisions" WHERE "population_2004">234733; |
## Task
Generate a SQL query to answer the following question:
`Which Foreign population has a Population (2004) larger than 234733?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "subdivisions" (
"name" text,
"geographic_code" text,
"type" text,
"households" real,
"population_2004" real,
"foreign_population" real,
"moroccan_population" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Foreign population has a Population (2004) larger than 234733?`:
```sql
|
SELECT AVG("population_2004") FROM "subdivisions" WHERE "moroccan_population">234506; |
## Task
Generate a SQL query to answer the following question:
`Which Population (2004) has a Moroccan population larger than 234506?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "subdivisions" (
"name" text,
"geographic_code" text,
"type" text,
"households" real,
"population_2004" real,
"foreign_population" real,
"moroccan_population" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Population (2004) has a Moroccan population larger than 234506?`:
```sql
|
SELECT "date" FROM "cup" WHERE "opponent"='vfl sindelfingen'; |
## Task
Generate a SQL query to answer the following question:
`What date was the opponent VFL Sindelfingen?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "cup" (
"round" text,
"date" text,
"opponent" text,
"venue" text,
"result" text,
"attendance" text,
"report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date was the opponent VFL Sindelfingen?`:
```sql
|
SELECT "date" FROM "cup" WHERE "attendance"='1,804'; |
## Task
Generate a SQL query to answer the following question:
`What date was the attendance 1,804?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "cup" (
"round" text,
"date" text,
"opponent" text,
"venue" text,
"result" text,
"attendance" text,
"report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date was the attendance 1,804?`:
```sql
|
SELECT "opponent" FROM "cup" WHERE "attendance"='628'; |
## Task
Generate a SQL query to answer the following question:
`Who was the opponent with an attendance of 628?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "cup" (
"round" text,
"date" text,
"opponent" text,
"venue" text,
"result" text,
"attendance" text,
"report" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the opponent with an attendance of 628?`:
```sql
|
SELECT "bike" FROM "superbike_race_1_classification" WHERE "grid">17 AND "laps"<8 AND "rider"='milos cihak'; |
## Task
Generate a SQL query to answer the following question:
`What bike has a grid greater than 17, laps less than 8, with milos cihak as the rider?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "superbike_race_1_classification" (
"rider" text,
"bike" text,
"laps" real,
"time" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What bike has a grid greater than 17, laps less than 8, with milos cihak as the rider?`:
```sql
|
SELECT MAX("grid") FROM "superbike_race_1_classification" WHERE "rider"='gregorio lavilla'; |
## Task
Generate a SQL query to answer the following question:
`What is the highest grid that has gregorio lavilla as the rider?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "superbike_race_1_classification" (
"rider" text,
"bike" text,
"laps" real,
"time" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest grid that has gregorio lavilla as the rider?`:
```sql
|
SELECT "rider" FROM "superbike_race_1_classification" WHERE "laps"<20 AND "bike"='ducati 1098 rs 08' AND "time"='accident' AND "grid"<14; |
## Task
Generate a SQL query to answer the following question:
`What rider has laps less than 20, a ducati 1098 rs 08 as the bike, with accident as the time, and a grid less than 14?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "superbike_race_1_classification" (
"rider" text,
"bike" text,
"laps" real,
"time" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What rider has laps less than 20, a ducati 1098 rs 08 as the bike, with accident as the time, and a grid less than 14?`:
```sql
|
SELECT SUM("overs") FROM "references" WHERE "runs"=5231 AND "matches"<37; |
## Task
Generate a SQL query to answer the following question:
`How many overs when there are 5231 runs and fewer than 37 matches?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "references" (
"name" text,
"career" text,
"matches" real,
"overs" real,
"maidens" real,
"runs" real,
"wickets" real,
"average" real,
"best" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many overs when there are 5231 runs and fewer than 37 matches?`:
```sql
|
SELECT MIN("wickets") FROM "references" WHERE "career"='1946-1960' AND "maidens">419; |
## Task
Generate a SQL query to answer the following question:
`What are the fewest wickets when player's career spanned 1946-1960 and maidens were more than 419?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "references" (
"name" text,
"career" text,
"matches" real,
"overs" real,
"maidens" real,
"runs" real,
"wickets" real,
"average" real,
"best" text
);
### SQL
Given the database schema, here is the SQL query that answers `What are the fewest wickets when player's career spanned 1946-1960 and maidens were more than 419?`:
```sql
|
SELECT MAX("wickets") FROM "references" WHERE "maidens">630 AND "best"='7/72'; |
## Task
Generate a SQL query to answer the following question:
`What is the largest number of wickets when there are more than 630 maidens and a best of 7/72?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "references" (
"name" text,
"career" text,
"matches" real,
"overs" real,
"maidens" real,
"runs" real,
"wickets" real,
"average" real,
"best" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the largest number of wickets when there are more than 630 maidens and a best of 7/72?`:
```sql
|
SELECT "name" FROM "references" WHERE "overs"<2047.3 AND "wickets">200 AND "average">29.02; |
## Task
Generate a SQL query to answer the following question:
`Who has fewer than 2047.3 overs, more than 200 wickets and an average of 29.02?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "references" (
"name" text,
"career" text,
"matches" real,
"overs" real,
"maidens" real,
"runs" real,
"wickets" real,
"average" real,
"best" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who has fewer than 2047.3 overs, more than 200 wickets and an average of 29.02?`:
```sql
|
SELECT "attendance" FROM "matches_played" WHERE "competition"='scottish cup' AND "date"='29.02.2000'; |
## Task
Generate a SQL query to answer the following question:
`How many people attended the Scottish Cup on 29.02.2000?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "matches_played" (
"season" text,
"date" text,
"venue" text,
"competition" text,
"score" text,
"attendance" real,
"report" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many people attended the Scottish Cup on 29.02.2000?`:
```sql
|
SELECT "score" FROM "matches_played" WHERE "competition"='league cup' AND "season"='2007-08'; |
## Task
Generate a SQL query to answer the following question:
`What was the score of the league cup in the 2007-08 season?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "matches_played" (
"season" text,
"date" text,
"venue" text,
"competition" text,
"score" text,
"attendance" real,
"report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score of the league cup in the 2007-08 season?`:
```sql
|
SELECT MIN("attendance") FROM "matches_played" WHERE "season"='2010-11' AND "score"='2–0'; |
## Task
Generate a SQL query to answer the following question:
`What is the attendance in the game in the 2010-11 season, when the score was 2–0?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "matches_played" (
"season" text,
"date" text,
"venue" text,
"competition" text,
"score" text,
"attendance" real,
"report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the attendance in the game in the 2010-11 season, when the score was 2–0?`:
```sql
|
SELECT "1st_place_team" FROM "international_softball_league_1951_to_19" WHERE "year">1956; |
## Task
Generate a SQL query to answer the following question:
`What team was in 1st plate in a year later than 1956?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "international_softball_league_1951_to_19" (
"year" real,
"1st_place_team" text,
"2nd_place_team" text,
"3rd_place_team" text,
"4th_place_team" text,
"host_location" text
);
### SQL
Given the database schema, here is the SQL query that answers `What team was in 1st plate in a year later than 1956?`:
```sql
|
SELECT "host_location" FROM "international_softball_league_1951_to_19" WHERE "4th_place_team"='national cash register, dayton, oh' AND "year"=1957; |
## Task
Generate a SQL query to answer the following question:
`What location hosted when the National Cash Register, Dayton, Oh was in 4th place in 1957?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "international_softball_league_1951_to_19" (
"year" real,
"1st_place_team" text,
"2nd_place_team" text,
"3rd_place_team" text,
"4th_place_team" text,
"host_location" text
);
### SQL
Given the database schema, here is the SQL query that answers `What location hosted when the National Cash Register, Dayton, Oh was in 4th place in 1957?`:
```sql
|
SELECT MIN("year") FROM "international_softball_league_1951_to_19" WHERE "4th_place_team"='hoak packers, fresno, ca'; |
## Task
Generate a SQL query to answer the following question:
`What year were the Hoak Packers, Fresno, CA the 4th Place Team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "international_softball_league_1951_to_19" (
"year" real,
"1st_place_team" text,
"2nd_place_team" text,
"3rd_place_team" text,
"4th_place_team" text,
"host_location" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year were the Hoak Packers, Fresno, CA the 4th Place Team?`:
```sql
|
SELECT "host_location" FROM "international_softball_league_1951_to_19" WHERE "4th_place_team"='wells motors, greeley, co'; |
## Task
Generate a SQL query to answer the following question:
`What location hosted when Wells Motors, Greeley, Co was the 4th place team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "international_softball_league_1951_to_19" (
"year" real,
"1st_place_team" text,
"2nd_place_team" text,
"3rd_place_team" text,
"4th_place_team" text,
"host_location" text
);
### SQL
Given the database schema, here is the SQL query that answers `What location hosted when Wells Motors, Greeley, Co was the 4th place team?`:
```sql
|
SELECT MAX("year") FROM "international_softball_league_1951_to_19" WHERE "1st_place_team"='hoak packers, fresno, ca' AND "4th_place_team"='wells motors, greeley, co'; |
## Task
Generate a SQL query to answer the following question:
`What year was the 1st Place Team the Hoak Packers, Fresno, CA, and 4th Place was Wells Motors, Greeley, Co?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "international_softball_league_1951_to_19" (
"year" real,
"1st_place_team" text,
"2nd_place_team" text,
"3rd_place_team" text,
"4th_place_team" text,
"host_location" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year was the 1st Place Team the Hoak Packers, Fresno, CA, and 4th Place was Wells Motors, Greeley, Co?`:
```sql
|
SELECT COUNT("year") FROM "international_softball_league_1951_to_19" WHERE "4th_place_team"='wyoming angus, johnstown, co'; |
## Task
Generate a SQL query to answer the following question:
`What year was the 4th Place Team of the Wyoming Angus, Johnstown, Co?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "international_softball_league_1951_to_19" (
"year" real,
"1st_place_team" text,
"2nd_place_team" text,
"3rd_place_team" text,
"4th_place_team" text,
"host_location" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year was the 4th Place Team of the Wyoming Angus, Johnstown, Co?`:
```sql
|
SELECT "base" FROM "references" WHERE "company"='theatro technis karolos koun'; |
## Task
Generate a SQL query to answer the following question:
`Which base has a company of Theatro Technis Karolos Koun?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "references" (
"play" text,
"author" text,
"company" text,
"base" text,
"country" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which base has a company of Theatro Technis Karolos Koun?`:
```sql
|
SELECT "company" FROM "references" WHERE "author"='aristophanes' AND "play"='plutus'; |
## Task
Generate a SQL query to answer the following question:
`Which company has an author of Aristophanes and play of Plutus?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "references" (
"play" text,
"author" text,
"company" text,
"base" text,
"country" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which company has an author of Aristophanes and play of Plutus?`:
```sql
|
SELECT "author" FROM "references" WHERE "company"='semeio theatre'; |
## Task
Generate a SQL query to answer the following question:
`Which author has a company of the Semeio Theatre?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "references" (
"play" text,
"author" text,
"company" text,
"base" text,
"country" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which author has a company of the Semeio Theatre?`:
```sql
|
SELECT "play" FROM "references" WHERE "company"='radu stanca national theatre'; |
## Task
Generate a SQL query to answer the following question:
`Which play was done by the Radu Stanca National Theatre company?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "references" (
"play" text,
"author" text,
"company" text,
"base" text,
"country" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which play was done by the Radu Stanca National Theatre company?`:
```sql
|
SELECT "play" FROM "references" WHERE "base"='aosta'; |
## Task
Generate a SQL query to answer the following question:
`Which play had a base of Aosta?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "references" (
"play" text,
"author" text,
"company" text,
"base" text,
"country" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which play had a base of Aosta?`:
```sql
|
SELECT "country" FROM "references" WHERE "base"='athens' AND "company"='attis theatre'; |
## Task
Generate a SQL query to answer the following question:
`What is the country of the play based in Athens at the Attis Theatre company?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "references" (
"play" text,
"author" text,
"company" text,
"base" text,
"country" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the country of the play based in Athens at the Attis Theatre company?`:
```sql
|
SELECT "class" FROM "tank_locomotives" WHERE "quantity">96; |
## Task
Generate a SQL query to answer the following question:
`Which Class has a Quantity larger than 96?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "tank_locomotives" (
"class" text,
"railway_number_s" text,
"quantity" real,
"year_s_of_manufacture" text,
"type" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Class has a Quantity larger than 96?`:
```sql
|
SELECT COUNT("quantity") FROM "tank_locomotives" WHERE "type"='1′c1′ h2t'; |
## Task
Generate a SQL query to answer the following question:
`How much Quantity has a Type of 1′c1′ h2t?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "tank_locomotives" (
"class" text,
"railway_number_s" text,
"quantity" real,
"year_s_of_manufacture" text,
"type" text
);
### SQL
Given the database schema, here is the SQL query that answers `How much Quantity has a Type of 1′c1′ h2t?`:
```sql
|
SELECT "class" FROM "tank_locomotives" WHERE "type"='1′c n2t'; |
## Task
Generate a SQL query to answer the following question:
`Which Class has a Type of 1′c n2t?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "tank_locomotives" (
"class" text,
"railway_number_s" text,
"quantity" real,
"year_s_of_manufacture" text,
"type" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Class has a Type of 1′c n2t?`:
```sql
|
SELECT "year_s_of_manufacture" FROM "tank_locomotives" WHERE "quantity">39 AND "type"='1′c1′ h2t'; |
## Task
Generate a SQL query to answer the following question:
`Which Year(s) of manufacture has a Quantity larger than 39, and a Type of 1′c1′ h2t?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "tank_locomotives" (
"class" text,
"railway_number_s" text,
"quantity" real,
"year_s_of_manufacture" text,
"type" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Year(s) of manufacture has a Quantity larger than 39, and a Type of 1′c1′ h2t?`:
```sql
|
SELECT "year_s_of_manufacture" FROM "tank_locomotives" WHERE "quantity"=2 AND "type"='b n2t'; |
## Task
Generate a SQL query to answer the following question:
`Which Year(s) of manufacture has a Quantity of 2, and a Type of b n2t?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "tank_locomotives" (
"class" text,
"railway_number_s" text,
"quantity" real,
"year_s_of_manufacture" text,
"type" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Year(s) of manufacture has a Quantity of 2, and a Type of b n2t?`:
```sql
|
SELECT MAX("place") FROM "standings" WHERE "lost">4 AND "points"<18 AND "team"='atlético veragüense'; |
## Task
Generate a SQL query to answer the following question:
`what is the highest place when lost is more than 4, points is less than 18 and team is Team of atlético veragüense?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "standings" (
"place" real,
"team" text,
"played" real,
"draw" real,
"lost" real,
"goals_scored" real,
"goals_conceded" real,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `what is the highest place when lost is more than 4, points is less than 18 and team is Team of atlético veragüense?`:
```sql
|
SELECT MIN("lost") FROM "standings" WHERE "place">4 AND "goals_scored"=12 AND "points">4; |
## Task
Generate a SQL query to answer the following question:
`what is the least lost when the place is higher than 4, goals scored is 12 and points is more than 4?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "standings" (
"place" real,
"team" text,
"played" real,
"draw" real,
"lost" real,
"goals_scored" real,
"goals_conceded" real,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `what is the least lost when the place is higher than 4, goals scored is 12 and points is more than 4?`:
```sql
|
SELECT COUNT("place") FROM "standings" WHERE "team"='tauro' AND "played"<18; |
## Task
Generate a SQL query to answer the following question:
`how many times is the team tauro and played less than 18?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "standings" (
"place" real,
"team" text,
"played" real,
"draw" real,
"lost" real,
"goals_scored" real,
"goals_conceded" real,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `how many times is the team tauro and played less than 18?`:
```sql
|
SELECT MIN("played") FROM "standings" WHERE "points"=36 AND "place">2; |
## Task
Generate a SQL query to answer the following question:
`what is the least played when points is 36 and place is more than 2?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "standings" (
"place" real,
"team" text,
"played" real,
"draw" real,
"lost" real,
"goals_scored" real,
"goals_conceded" real,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `what is the least played when points is 36 and place is more than 2?`:
```sql
|
SELECT AVG("points") FROM "standings" WHERE "goals_conceded"=14 AND "goals_scored"<32; |
## Task
Generate a SQL query to answer the following question:
`what is the average points when goals conceded is 14 and goals scored is less than 32?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "standings" (
"place" real,
"team" text,
"played" real,
"draw" real,
"lost" real,
"goals_scored" real,
"goals_conceded" real,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `what is the average points when goals conceded is 14 and goals scored is less than 32?`:
```sql
|
SELECT "result" FROM "schedule" WHERE "week">1 AND "attendance"='69,149' AND "opponent"='seattle seahawks'; |
## Task
Generate a SQL query to answer the following question:
`Playing against the Seattle Seahawks in a week after week 1 before 69,149 people what was the result of the game?`
### 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 `Playing against the Seattle Seahawks in a week after week 1 before 69,149 people what was the result of the game?`:
```sql
|
SELECT COUNT("week") FROM "schedule" WHERE "date"='bye'; |
## Task
Generate a SQL query to answer the following question:
`How many weeks in total has bye 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,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many weeks in total has bye as the date?`:
```sql
|
SELECT "country" FROM "final_round" WHERE "player"='tiger woods'; |
## Task
Generate a SQL query to answer the following question:
`What country does Tiger Woods come from?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "final_round" (
"place" text,
"player" text,
"country" text,
"score" text,
"to_par" text,
"money" real
);
### SQL
Given the database schema, here is the SQL query that answers `What country does Tiger Woods come from?`:
```sql
|
SELECT "ri_song_hui_prk" FROM "records" WHERE "world_record"='olympic record' AND "snatch"='snatch'; |
## Task
Generate a SQL query to answer the following question:
`What's the Ri Song-Hui when the olympic record is the world record and snatch was snatch?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "records" (
"world_record" text,
"snatch" text,
"ri_song_hui_prk" text,
"102kg" text,
"busan_south_korea" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the Ri Song-Hui when the olympic record is the world record and snatch was snatch?`:
```sql
|
SELECT "102kg" FROM "records" WHERE "ri_song_hui_prk"='226kg'; |
## Task
Generate a SQL query to answer the following question:
`What's the 102kg when the Ri Song-Hui was 226kg?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "records" (
"world_record" text,
"snatch" text,
"ri_song_hui_prk" text,
"102kg" text,
"busan_south_korea" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the 102kg when the Ri Song-Hui was 226kg?`:
```sql
|
SELECT "102kg" FROM "records" WHERE "world_record"='olympic record' AND "snatch"='snatch'; |
## Task
Generate a SQL query to answer the following question:
`What's the 102kg when the snatch was snatch and the olympic record was the world record?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "records" (
"world_record" text,
"snatch" text,
"ri_song_hui_prk" text,
"102kg" text,
"busan_south_korea" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the 102kg when the snatch was snatch and the olympic record was the world record?`:
```sql
|
SELECT AVG("pick") FROM "first_round_selections" WHERE "team"='texas rangers'; |
## Task
Generate a SQL query to answer the following question:
`What was the average pick made by the Texas Rangers?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "first_round_selections" (
"pick" real,
"player" text,
"team" text,
"position" text,
"hometown_school" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the average pick made by the Texas Rangers?`:
```sql
|
SELECT "hometown_school" FROM "first_round_selections" WHERE "team"='san diego padres' AND "player"='bob geren'; |
## Task
Generate a SQL query to answer the following question:
`What was the home town of Bob Geren, picked by the San Diego Padres?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "first_round_selections" (
"pick" real,
"player" text,
"team" text,
"position" text,
"hometown_school" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the home town of Bob Geren, picked by the San Diego Padres?`:
```sql
|
SELECT "position" FROM "first_round_selections" WHERE "player"='jon perlman'; |
## Task
Generate a SQL query to answer the following question:
`What was the position of Jon Perlman?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "first_round_selections" (
"pick" real,
"player" text,
"team" text,
"position" text,
"hometown_school" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the position of Jon Perlman?`:
```sql
|
SELECT "college" FROM "eleventh_round" WHERE "position"='tackle' AND "pick"<87; |
## Task
Generate a SQL query to answer the following question:
`What college has a pick smaller than 87 for the position of tackle?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "eleventh_round" (
"pick" real,
"team" text,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What college has a pick smaller than 87 for the position of tackle?`:
```sql
|
SELECT "college" FROM "eleventh_round" WHERE "pick"=85; |
## Task
Generate a SQL query to answer the following question:
`What college had the pick of 85?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "eleventh_round" (
"pick" real,
"team" text,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What college had the pick of 85?`:
```sql
|
SELECT MIN("losses") FROM "1934_ladder" WHERE "club"='mortlake' AND "against"<970; |
## Task
Generate a SQL query to answer the following question:
`What are the least losses of Mortlake having less than 970 against?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1934_ladder" (
"club" text,
"wins" real,
"losses" real,
"draws" real,
"against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What are the least losses of Mortlake having less than 970 against?`:
```sql
|
SELECT COUNT("against") FROM "1934_ladder" WHERE "draws">0; |
## Task
Generate a SQL query to answer the following question:
`What's the total against when the draws are more than 0?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1934_ladder" (
"club" text,
"wins" real,
"losses" real,
"draws" real,
"against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the total against when the draws are more than 0?`:
```sql
|
SELECT COUNT("wins") FROM "1934_ladder" WHERE "draws"<0; |
## Task
Generate a SQL query to answer the following question:
`What's the total wins when the draws are less than 0?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1934_ladder" (
"club" text,
"wins" real,
"losses" real,
"draws" real,
"against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the total wins when the draws are less than 0?`:
```sql
|
SELECT MIN("against") FROM "1934_ladder" WHERE "club"='cobden' AND "draws">0; |
## Task
Generate a SQL query to answer the following question:
`What's the least against number for Cobden with draws more than 0?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1934_ladder" (
"club" text,
"wins" real,
"losses" real,
"draws" real,
"against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the least against number for Cobden with draws more than 0?`:
```sql
|
SELECT MAX("against") FROM "1934_ladder" WHERE "draws">0; |
## Task
Generate a SQL query to answer the following question:
`What's the most against when the draws are more than 0?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1934_ladder" (
"club" text,
"wins" real,
"losses" real,
"draws" real,
"against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the most against when the draws are more than 0?`:
```sql
|
SELECT SUM("wins") FROM "1934_ladder" WHERE "against"=1261; |
## Task
Generate a SQL query to answer the following question:
`What are the total wins when there are 1261 against?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1934_ladder" (
"club" text,
"wins" real,
"losses" real,
"draws" real,
"against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What are the total wins when there are 1261 against?`:
```sql
|
SELECT "notes" FROM "heat_1" WHERE "time"='1:42.309'; |
## Task
Generate a SQL query to answer the following question:
`What is the notes entry for the row with a Time of 1:42.309?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heat_1" (
"rank" real,
"athletes" text,
"country" text,
"time" text,
"notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the notes entry for the row with a Time of 1:42.309?`:
```sql
|
SELECT SUM("rank") FROM "heat_1" WHERE "country"='china'; |
## Task
Generate a SQL query to answer the following question:
`What is the rank for China?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heat_1" (
"rank" real,
"athletes" text,
"country" text,
"time" text,
"notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the rank for China?`:
```sql
|
SELECT "time" FROM "heat_1" WHERE "notes"='qs' AND "country"='cuba'; |
## Task
Generate a SQL query to answer the following question:
`What is the time for Cuba, with a notes entry of QS?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heat_1" (
"rank" real,
"athletes" text,
"country" text,
"time" text,
"notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the time for Cuba, with a notes entry of QS?`:
```sql
|
SELECT COUNT("week") FROM "schedule" WHERE "date"='october 10, 1976'; |
## Task
Generate a SQL query to answer the following question:
`What is the Week number on October 10, 1976?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "schedule" (
"week" real,
"date" text,
"opponent" text,
"result" text,
"attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Week number on October 10, 1976?`:
```sql
|
SELECT "date" FROM "schedule" WHERE "result"='l 33–14'; |
## Task
Generate a SQL query to answer the following question:
`What is the Date of the game with a Result of L 33–14?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "schedule" (
"week" real,
"date" text,
"opponent" text,
"result" text,
"attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Date of the game with a Result of L 33–14?`:
```sql
|
SELECT "augmented_fifth" FROM "augmented_seventh_chord_table" WHERE "major_third"='d'; |
## Task
Generate a SQL query to answer the following question:
`The Major third of D has what for the Augmented fifth?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "augmented_seventh_chord_table" (
"chord" text,
"root" text,
"major_third" text,
"augmented_fifth" text,
"minor_seventh" text
);
### SQL
Given the database schema, here is the SQL query that answers `The Major third of D has what for the Augmented fifth?`:
```sql
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.