output stringlengths 27 479 | instruction stringlengths 407 1.39k |
|---|---|
SELECT "date" FROM "round_16" WHERE "home_team_score"='11.18 (84)'; |
## Task
Generate a SQL query to answer the following question:
`What date has a Home team score of 11.18 (84)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_16" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date has a Home team score of 11.18 (84)?`:
```sql
|
SELECT "home_team_score" FROM "round_16" WHERE "away_team"='melbourne'; |
## Task
Generate a SQL query to answer the following question:
`What home team score has a Away team of melbourne?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_16" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What home team score has a Away team of melbourne?`:
```sql
|
SELECT "away_team" FROM "round_16" WHERE "home_team"='richmond'; |
## Task
Generate a SQL query to answer the following question:
`What away team is the home team richmond?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_16" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What away team is the home team richmond?`:
```sql
|
SELECT MAX("grid") FROM "classification" WHERE "driver"='giancarlo fisichella' AND "laps"<52; |
## Task
Generate a SQL query to answer the following question:
`When Giancarlo Fisichella was the Driver and there were less than 52 Laps, what was the highest Grid?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "classification" (
"driver" text,
"constructor" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `When Giancarlo Fisichella was the Driver and there were less than 52 Laps, what was the highest Grid?`:
```sql
|
SELECT "constructor" FROM "classification" WHERE "grid"<17 AND "laps"<52 AND "driver"='olivier panis'; |
## Task
Generate a SQL query to answer the following question:
`Which Constructor has a Grid less than 17, Laps under 52, and Olivier Panis as the Driver?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "classification" (
"driver" text,
"constructor" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Constructor has a Grid less than 17, Laps under 52, and Olivier Panis as the Driver?`:
```sql
|
SELECT "pick_num" FROM "round_six" WHERE "college"='idaho state'; |
## Task
Generate a SQL query to answer the following question:
`Which 2006 cfl draft pick played college ball at Idaho state?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_six" (
"pick_num" text,
"cfl_team" text,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which 2006 cfl draft pick played college ball at Idaho state?`:
```sql
|
SELECT "position" FROM "round_six" WHERE "college"='toronto'; |
## Task
Generate a SQL query to answer the following question:
`What position did the CFL player drafted out of college of toronto in 2007 play?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_six" (
"pick_num" text,
"cfl_team" text,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What position did the CFL player drafted out of college of toronto in 2007 play?`:
```sql
|
SELECT "date_of_death" FROM "house_of_valois_burgundy_1405_1482" WHERE "date_of_birth"='28 may 1371'; |
## Task
Generate a SQL query to answer the following question:
`What was the Date of Death of the person whose Date of Birth was 28 May 1371?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "house_of_valois_burgundy_1405_1482" (
"name" text,
"date_of_birth" text,
"date_of_death" text,
"reign" text,
"relationship_with_predecessor" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the Date of Death of the person whose Date of Birth was 28 May 1371?`:
```sql
|
SELECT "reign" FROM "house_of_valois_burgundy_1405_1482" WHERE "date_of_birth"='22 march 1459'; |
## Task
Generate a SQL query to answer the following question:
`What was the Reign of the person whose Date of Birth was 22 March 1459?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "house_of_valois_burgundy_1405_1482" (
"name" text,
"date_of_birth" text,
"date_of_death" text,
"reign" text,
"relationship_with_predecessor" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the Reign of the person whose Date of Birth was 22 March 1459?`:
```sql
|
SELECT AVG("year") FROM "year_by_year_record" WHERE "record"='33-33'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the average year with a record of 33-33`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "year_by_year_record" (
"year" real,
"record" text,
"finish" text,
"manager" text,
"playoffs" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the average year with a record of 33-33`:
```sql
|
SELECT COUNT("year") FROM "year_by_year_record" WHERE "record"='39-31'; |
## Task
Generate a SQL query to answer the following question:
`Name the total number of years for a 39-31 record`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "year_by_year_record" (
"year" real,
"record" text,
"finish" text,
"manager" text,
"playoffs" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the total number of years for a 39-31 record`:
```sql
|
SELECT MIN("year") FROM "year_by_year_record" WHERE "manager"='gene hassell' AND "finish"='6th'; |
## Task
Generate a SQL query to answer the following question:
`Name the least year for gene hassell manager and 6th finish`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "year_by_year_record" (
"year" real,
"record" text,
"finish" text,
"manager" text,
"playoffs" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the least year for gene hassell manager and 6th finish`:
```sql
|
SELECT "finish" FROM "year_by_year_record" WHERE "record"='39-31'; |
## Task
Generate a SQL query to answer the following question:
`Name the finish for a 39-31 record`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "year_by_year_record" (
"year" real,
"record" text,
"finish" text,
"manager" text,
"playoffs" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the finish for a 39-31 record`:
```sql
|
SELECT MIN("goal_difference") FROM "final_table" WHERE "club"='ud alzira' AND "played">38; |
## Task
Generate a SQL query to answer the following question:
`What is the lowest goal difference for the club ud alzira, with a played larger than 38?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "final_table" (
"position" real,
"club" text,
"played" real,
"points" text,
"wins" real,
"draws" real,
"losses" real,
"goals_for" real,
"goals_against" real,
"goal_difference" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest goal difference for the club ud alzira, with a played larger than 38?`:
```sql
|
SELECT SUM("goal_difference") FROM "final_table" WHERE "goals_against"<33 AND "draws">13; |
## Task
Generate a SQL query to answer the following question:
`What is the goal difference sum that has goals against smaller than 33, draws larger than 13?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "final_table" (
"position" real,
"club" text,
"played" real,
"points" text,
"wins" real,
"draws" real,
"losses" real,
"goals_for" real,
"goals_against" real,
"goal_difference" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the goal difference sum that has goals against smaller than 33, draws larger than 13?`:
```sql
|
SELECT "transfer_fee" FROM "out" WHERE "name"='damia'; |
## Task
Generate a SQL query to answer the following question:
`Name the transfer fee for damia`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "out" (
"name" text,
"country" text,
"status" text,
"moving_to" text,
"transfer_window" text,
"transfer_fee" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the transfer fee for damia`:
```sql
|
SELECT "moving_to" FROM "out" WHERE "transfer_fee"='free' AND "status"='transfer' AND "name"='rodri'; |
## Task
Generate a SQL query to answer the following question:
`Name the moving to with a transfer fee of free with a transfer status for rodri`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "out" (
"name" text,
"country" text,
"status" text,
"moving_to" text,
"transfer_window" text,
"transfer_fee" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the moving to with a transfer fee of free with a transfer status for rodri`:
```sql
|
SELECT "date" FROM "round_3" WHERE "venue"='western oval'; |
## Task
Generate a SQL query to answer the following question:
`When was the game played at the Western Oval venue?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_3" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `When was the game played at the Western Oval venue?`:
```sql
|
SELECT "home_team_score" FROM "round_3" WHERE "away_team"='north melbourne'; |
## Task
Generate a SQL query to answer the following question:
`What is the home team score for the team that played an away game at North Melbourne?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_3" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the home team score for the team that played an away game at North Melbourne?`:
```sql
|
SELECT "livery" FROM "locomotives" WHERE "serial_no"='83-1010'; |
## Task
Generate a SQL query to answer the following question:
`What is the livery of the locomotive with a serial number 83-1010?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "locomotives" (
"locomotive" text,
"serial_no" text,
"entered_service" text,
"gauge" text,
"livery" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the livery of the locomotive with a serial number 83-1010?`:
```sql
|
SELECT "livery" FROM "locomotives" WHERE "serial_no"='83-1011'; |
## Task
Generate a SQL query to answer the following question:
`What is the livery on the locomotive with a serial number 83-1011?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "locomotives" (
"locomotive" text,
"serial_no" text,
"entered_service" text,
"gauge" text,
"livery" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the livery on the locomotive with a serial number 83-1011?`:
```sql
|
SELECT "locomotive" FROM "locomotives" WHERE "gauge"='standard' AND "serial_no"='83-1015'; |
## Task
Generate a SQL query to answer the following question:
`What is the locomotive with a standard gauge and a serial number of 83-1015?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "locomotives" (
"locomotive" text,
"serial_no" text,
"entered_service" text,
"gauge" text,
"livery" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the locomotive with a standard gauge and a serial number of 83-1015?`:
```sql
|
SELECT "entered_service" FROM "locomotives" WHERE "gauge"='broad' AND "serial_no"='83-1018'; |
## Task
Generate a SQL query to answer the following question:
`What is the date of entered service for the locomotive with a broad gauge and a serial no of 83-1018?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "locomotives" (
"locomotive" text,
"serial_no" text,
"entered_service" text,
"gauge" text,
"livery" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the date of entered service for the locomotive with a broad gauge and a serial no of 83-1018?`:
```sql
|
SELECT "venue" FROM "international_goals" WHERE "date"='october 16, 1996'; |
## Task
Generate a SQL query to answer the following question:
`What was the venue on October 16, 1996?`
### 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 `What was the venue on October 16, 1996?`:
```sql
|
SELECT "score" FROM "international_goals" WHERE "result"='win' AND "competition"='1998 fifa world cup qualification' AND "date"='october 30, 1996'; |
## Task
Generate a SQL query to answer the following question:
`What's the score at the October 30, 1996 1998 fifa world cup qualification with a result of win?`
### 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 `What's the score at the October 30, 1996 1998 fifa world cup qualification with a result of win?`:
```sql
|
SELECT "date" FROM "international_goals" WHERE "competition"='friendship cup'; |
## Task
Generate a SQL query to answer the following question:
`When was the friendship cup?`
### 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 `When was the friendship cup?`:
```sql
|
SELECT MIN("cars_per_set") FROM "class_253_and_254" WHERE "year_built"='1977-1979' AND "number">32; |
## Task
Generate a SQL query to answer the following question:
`What is the smallest number for Cars per Set built in 1977-1979 larger than 32?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "class_253_and_254" (
"class" text,
"operator" text,
"number" real,
"year_built" text,
"cars_per_set" real,
"unit_numbers" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the smallest number for Cars per Set built in 1977-1979 larger than 32?`:
```sql
|
SELECT "unit_numbers" FROM "class_253_and_254" WHERE "cars_per_set">9 AND "year_built"='1982'; |
## Task
Generate a SQL query to answer the following question:
`What unit has cars per set larger than 9 built in 1982?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "class_253_and_254" (
"class" text,
"operator" text,
"number" real,
"year_built" text,
"cars_per_set" real,
"unit_numbers" text
);
### SQL
Given the database schema, here is the SQL query that answers `What unit has cars per set larger than 9 built in 1982?`:
```sql
|
SELECT MAX("number") FROM "class_253_and_254" WHERE "cars_per_set"<9; |
## Task
Generate a SQL query to answer the following question:
`What is the largest number of cars per set that is less than 9?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "class_253_and_254" (
"class" text,
"operator" text,
"number" real,
"year_built" text,
"cars_per_set" real,
"unit_numbers" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the largest number of cars per set that is less than 9?`:
```sql
|
SELECT "year_built" FROM "class_253_and_254" WHERE "class"='class 253' AND "number">18; |
## Task
Generate a SQL query to answer the following question:
`What year was the class 253 larger than 18 built?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "class_253_and_254" (
"class" text,
"operator" text,
"number" real,
"year_built" text,
"cars_per_set" real,
"unit_numbers" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year was the class 253 larger than 18 built?`:
```sql
|
SELECT "margin" FROM "wins_14" WHERE "championship"='masters tournament (2)'; |
## Task
Generate a SQL query to answer the following question:
`What is the margin for the Masters Tournament (2) championship?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "wins_14" (
"year" real,
"championship" text,
"54_holes" text,
"winning_score" text,
"margin" text,
"runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the margin for the Masters Tournament (2) championship?`:
```sql
|
SELECT COUNT("year") FROM "wins_14" WHERE "54_holes"='2 shot lead'; |
## Task
Generate a SQL query to answer the following question:
`How many years had 54 holes and a 2 shot lead?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "wins_14" (
"year" real,
"championship" text,
"54_holes" text,
"winning_score" text,
"margin" text,
"runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many years had 54 holes and a 2 shot lead?`:
```sql
|
SELECT "54_holes" FROM "wins_14" WHERE "runner_s_up"='phil mickelson'; |
## Task
Generate a SQL query to answer the following question:
`What is the round of 54 holes in which Phil Mickelson was the runner-up?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "wins_14" (
"year" real,
"championship" text,
"54_holes" text,
"winning_score" text,
"margin" text,
"runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the round of 54 holes in which Phil Mickelson was the runner-up?`:
```sql
|
SELECT "championship" FROM "wins_14" WHERE "margin"='2 strokes' AND "54_holes"='1 shot lead' AND "runner_s_up"='david duval'; |
## Task
Generate a SQL query to answer the following question:
`What is the championship when the margin was 2 strokes, there were 54 holes with a 1 shot lead, and the runner-up was David Duval?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "wins_14" (
"year" real,
"championship" text,
"54_holes" text,
"winning_score" text,
"margin" text,
"runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the championship when the margin was 2 strokes, there were 54 holes with a 1 shot lead, and the runner-up was David Duval?`:
```sql
|
SELECT "home" FROM "quarter_finals_1_vs_nashville_predators_" WHERE "date"='april 14'; |
## Task
Generate a SQL query to answer the following question:
`What is the home team of the April 14 game?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "quarter_finals_1_vs_nashville_predators_" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"decision" text,
"attendance" real,
"series" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the home team of the April 14 game?`:
```sql
|
SELECT "date" FROM "quarter_finals_1_vs_nashville_predators_" WHERE "visitor"='detroit'; |
## Task
Generate a SQL query to answer the following question:
`What is the date of the game with Detroit as the visitor team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "quarter_finals_1_vs_nashville_predators_" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"decision" text,
"attendance" real,
"series" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the date of the game with Detroit as the visitor team?`:
```sql
|
SELECT "viewers_m" FROM "u_s_nielsen_ratings" WHERE "share"=1 AND "rating">0.7000000000000001 AND "rank_num"='100/102'; |
## Task
Generate a SQL query to answer the following question:
`How many vieweres for the episode with a share of 1, a Rating larger than 0.7000000000000001, and a Rank (#) of 100/102?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "u_s_nielsen_ratings" (
"episode" text,
"airdate" text,
"rating" real,
"share" real,
"18_49_rating_share" text,
"viewers_m" real,
"rank_num" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many vieweres for the episode with a share of 1, a Rating larger than 0.7000000000000001, and a Rank (#) of 100/102?`:
```sql
|
SELECT "lead_tpt" FROM "history_of_ggb_members" WHERE "bass"='kevin tomanka' AND "alto_1"='alan moffett'; |
## Task
Generate a SQL query to answer the following question:
`Name the lead tpt for bass of kevin tomanka and alto 1 of alan moffett`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "history_of_ggb_members" (
"alto_1" text,
"alto_2" text,
"tenor" text,
"lead_tpt" text,
"tpt_2" text,
"tpt_3" text,
"mello" text,
"lead_bone" text,
"bass_bone" text,
"bass" text,
"drums" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the lead tpt for bass of kevin tomanka and alto 1 of alan moffett`:
```sql
|
SELECT COUNT("crowd") FROM "round_13" WHERE "venue"='moorabbin oval'; |
## Task
Generate a SQL query to answer the following question:
`What was the crowd size at the moorabbin oval venue?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_13" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the crowd size at the moorabbin oval venue?`:
```sql
|
SELECT "home_team_score" FROM "round_13" WHERE "away_team_score"='11.8 (74)'; |
## Task
Generate a SQL query to answer the following question:
`What was the home team score in the game where the away team scored 11.8 (74)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_13" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the home team score in the game where the away team scored 11.8 (74)?`:
```sql
|
SELECT "home_team_score" FROM "round_13" WHERE "away_team"='collingwood'; |
## Task
Generate a SQL query to answer the following question:
`What did the home team score against the away team collingwood?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_13" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What did the home team score against the away team collingwood?`:
```sql
|
SELECT "1_letter" FROM "table_of_standard_amino_acid_abbreviatio" WHERE "amino_acid"='asparagine'; |
## Task
Generate a SQL query to answer the following question:
`what is the 1-letter for the amino acid asparagine?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "table_of_standard_amino_acid_abbreviatio" (
"amino_acid" text,
"3_letter" text,
"1_letter" text,
"side_chain_polarity" text,
"side_chain_charge_p_h_7_4" text,
"hydropathy_index" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the 1-letter for the amino acid asparagine?`:
```sql
|
SELECT "side_chain_polarity" FROM "table_of_standard_amino_acid_abbreviatio" WHERE "1_letter"='v'; |
## Task
Generate a SQL query to answer the following question:
`what is the side-chain polarity for the amino acid with the 1-letter v?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "table_of_standard_amino_acid_abbreviatio" (
"amino_acid" text,
"3_letter" text,
"1_letter" text,
"side_chain_polarity" text,
"side_chain_charge_p_h_7_4" text,
"hydropathy_index" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the side-chain polarity for the amino acid with the 1-letter v?`:
```sql
|
SELECT "side_chain_charge_p_h_7_4" FROM "table_of_standard_amino_acid_abbreviatio" WHERE "1_letter"='p'; |
## Task
Generate a SQL query to answer the following question:
`What is the side-chain charge (ph 7.4) for the amino acid with the 1-letter p?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "table_of_standard_amino_acid_abbreviatio" (
"amino_acid" text,
"3_letter" text,
"1_letter" text,
"side_chain_polarity" text,
"side_chain_charge_p_h_7_4" text,
"hydropathy_index" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the side-chain charge (ph 7.4) for the amino acid with the 1-letter p?`:
```sql
|
SELECT "away_team_score" FROM "round_9" WHERE "home_team"='north melbourne'; |
## Task
Generate a SQL query to answer the following question:
`What was home team North Melbourne's opponents score?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_9" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was home team North Melbourne's opponents score?`:
```sql
|
SELECT "home_team_score" FROM "round_9" WHERE "home_team"='melbourne'; |
## Task
Generate a SQL query to answer the following question:
`What was Melbourne's score as the home team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_9" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was Melbourne's score as the home team?`:
```sql
|
SELECT "away_team" FROM "round_9" WHERE "venue"='junction oval'; |
## Task
Generate a SQL query to answer the following question:
`Who was the away team at Junction Oval?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_9" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the away team at Junction Oval?`:
```sql
|
SELECT "usca" FROM "major_awards" WHERE "total"<14 AND "joint_music_award"='1' AND "mrhma"='2' AND "rthk"='3'; |
## Task
Generate a SQL query to answer the following question:
`What is the USCA that's Total is smaller than 14, with 1 Joint Music Award, MRHMA of 2, and RTHK of 3?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "major_awards" (
"year" real,
"mrhma" text,
"usca" text,
"rthk" text,
"joint_music_award" text,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the USCA that's Total is smaller than 14, with 1 Joint Music Award, MRHMA of 2, and RTHK of 3?`:
```sql
|
SELECT "total" FROM "major_awards" WHERE "joint_music_award"='1' AND "rthk"='4' AND "usca"='4'; |
## Task
Generate a SQL query to answer the following question:
`What is the Total with a Joint Music Award of 1, RTHK of 4, and USCA of 4?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "major_awards" (
"year" real,
"mrhma" text,
"usca" text,
"rthk" text,
"joint_music_award" text,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Total with a Joint Music Award of 1, RTHK of 4, and USCA of 4?`:
```sql
|
SELECT "joint_music_award" FROM "major_awards" WHERE "year"<2006 AND "rthk"='1'; |
## Task
Generate a SQL query to answer the following question:
`How many Joint Music Awards were there with a RTHK of 1, in a Year before 2006?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "major_awards" (
"year" real,
"mrhma" text,
"usca" text,
"rthk" text,
"joint_music_award" text,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many Joint Music Awards were there with a RTHK of 1, in a Year before 2006?`:
```sql
|
SELECT "joint_music_award" FROM "major_awards" WHERE "total">18 AND "year">2007; |
## Task
Generate a SQL query to answer the following question:
`How many Joint Music Awards are there when the Total is larger than 18, in a Year after 2007?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "major_awards" (
"year" real,
"mrhma" text,
"usca" text,
"rthk" text,
"joint_music_award" text,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many Joint Music Awards are there when the Total is larger than 18, in a Year after 2007?`:
```sql
|
SELECT MIN("lane") FROM "final_classification" WHERE "semi"=49.19; |
## Task
Generate a SQL query to answer the following question:
`Which lane did the athlete swim in who had a semi-final time of 49.19?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "final_classification" (
"athlete" text,
"final" real,
"lane" real,
"semi" real,
"quart" real,
"heat" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which lane did the athlete swim in who had a semi-final time of 49.19?`:
```sql
|
SELECT "species" FROM "original_farthing_wood_animals" WHERE "gender"='male'; |
## Task
Generate a SQL query to answer the following question:
`Which species is male?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "original_farthing_wood_animals" (
"animal_name" text,
"species" text,
"books" text,
"tv_series" text,
"gender" text,
"tv_seasons" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which species is male?`:
```sql
|
SELECT "home_team_score" FROM "round_1" WHERE "venue"='junction oval'; |
## Task
Generate a SQL query to answer the following question:
`What was the home teams score at Junction Oval?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_1" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the home teams score at Junction Oval?`:
```sql
|
SELECT "president" FROM "list_of_presidents" WHERE "presidency">7; |
## Task
Generate a SQL query to answer the following question:
`What President has a Presidency greater than 7?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_presidents" (
"presidency" real,
"president" text,
"date_of_birth" text,
"took_office" real,
"left_office" text
);
### SQL
Given the database schema, here is the SQL query that answers `What President has a Presidency greater than 7?`:
```sql
|
SELECT MAX("presidency") FROM "list_of_presidents" WHERE "left_office"='1998' AND "took_office">1974; |
## Task
Generate a SQL query to answer the following question:
`What is the highest Presidency that Took Office after 1974 and Left Office in 1998?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_presidents" (
"presidency" real,
"president" text,
"date_of_birth" text,
"took_office" real,
"left_office" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest Presidency that Took Office after 1974 and Left Office in 1998?`:
```sql
|
SELECT SUM("took_office") FROM "list_of_presidents" WHERE "left_office"='incumbent'; |
## Task
Generate a SQL query to answer the following question:
`What is the Took Office Date of the Presidency that Left Office Incumbent?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_presidents" (
"presidency" real,
"president" text,
"date_of_birth" text,
"took_office" real,
"left_office" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Took Office Date of the Presidency that Left Office Incumbent?`:
```sql
|
SELECT MAX("took_office") FROM "list_of_presidents" WHERE "left_office"='1998'; |
## Task
Generate a SQL query to answer the following question:
`What was the greatest Took Office dates that Left Office in 1998?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_presidents" (
"presidency" real,
"president" text,
"date_of_birth" text,
"took_office" real,
"left_office" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the greatest Took Office dates that Left Office in 1998?`:
```sql
|
SELECT AVG("laps") FROM "race" WHERE "driver"='andrea de cesaris'; |
## Task
Generate a SQL query to answer the following question:
`What is the average Laps for andrea de cesaris?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race" (
"driver" text,
"constructor" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average Laps for andrea de cesaris?`:
```sql
|
SELECT MIN("grid") FROM "race" WHERE "laps">51 AND "driver"='jj lehto'; |
## Task
Generate a SQL query to answer the following question:
`What is the lowest Grid for jj lehto with over 51 laps?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race" (
"driver" text,
"constructor" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest Grid for jj lehto with over 51 laps?`:
```sql
|
SELECT AVG("grid") FROM "race" WHERE "time_retired"='+2 laps' AND "laps"<51; |
## Task
Generate a SQL query to answer the following question:
`What is the average Grid that has a Time/Retired of +2 laps, and under 51 laps?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race" (
"driver" text,
"constructor" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average Grid that has a Time/Retired of +2 laps, and under 51 laps?`:
```sql
|
SELECT "home_team" FROM "round_18" WHERE "venue"='victoria park'; |
## Task
Generate a SQL query to answer the following question:
`What's the Home teams Venue near Victoria Park?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_18" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the Home teams Venue near Victoria Park?`:
```sql
|
SELECT "crowd" FROM "round_18" WHERE "home_team"='footscray'; |
## Task
Generate a SQL query to answer the following question:
`What is the Home team with a crowd relevant to footscray?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_18" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Home team with a crowd relevant to footscray?`:
```sql
|
SELECT "record" FROM "december" WHERE "home"='nashville'; |
## Task
Generate a SQL query to answer the following question:
`What is the team's record when they play nashville at home?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "december" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"decision" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the team's record when they play nashville at home?`:
```sql
|
SELECT "decision" FROM "december" WHERE "visitor"='phoenix'; |
## Task
Generate a SQL query to answer the following question:
`What is the decision when they're at phoenix?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "december" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"decision" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the decision when they're at phoenix?`:
```sql
|
SELECT "score" FROM "2006" WHERE "tournament"='frankfurt'; |
## Task
Generate a SQL query to answer the following question:
`What was the score in the Tournament of Frankfurt?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2006" (
"tournament" text,
"winner" text,
"runner_up" text,
"score" text,
"third_place" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score in the Tournament of Frankfurt?`:
```sql
|
SELECT "winner" FROM "2006" WHERE "tournament"='graz-seiersberg'; |
## Task
Generate a SQL query to answer the following question:
`Who was the winner in the Tournament of Graz-Seiersberg?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2006" (
"tournament" text,
"winner" text,
"runner_up" text,
"score" text,
"third_place" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the winner in the Tournament of Graz-Seiersberg?`:
```sql
|
SELECT "third_place" FROM "2006" WHERE "winner"='paul haarhuis'; |
## Task
Generate a SQL query to answer the following question:
`Who earned third place when the winner was Paul Haarhuis?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2006" (
"tournament" text,
"winner" text,
"runner_up" text,
"score" text,
"third_place" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who earned third place when the winner was Paul Haarhuis?`:
```sql
|
SELECT MAX("laps") FROM "classification" WHERE "time_retired"='differential' AND "grid">2; |
## Task
Generate a SQL query to answer the following question:
`what is the most laps with the time/retired is differential and the grid is more than 2?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "classification" (
"driver" text,
"constructor" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `what is the most laps with the time/retired is differential and the grid is more than 2?`:
```sql
|
SELECT MIN("laps") FROM "classification" WHERE "grid"=5; |
## Task
Generate a SQL query to answer the following question:
`what is the least laps when the grid is 5?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "classification" (
"driver" text,
"constructor" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `what is the least laps when the grid is 5?`:
```sql
|
SELECT "deleted" FROM "superfund_sites" WHERE "name"='anniston army depot (se industrial area)'; |
## Task
Generate a SQL query to answer the following question:
`On what date was Anniston Army Depot (SE Industrial Area) deleted?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "superfund_sites" (
"cerclis_id" text,
"name" text,
"county" text,
"proposed" text,
"listed" text,
"construction_completed" text,
"partially_deleted" text,
"deleted" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date was Anniston Army Depot (SE Industrial Area) deleted?`:
```sql
|
SELECT "county" FROM "superfund_sites" WHERE "listed"='09/21/1984' AND "construction_completed"='07/19/2000'; |
## Task
Generate a SQL query to answer the following question:
`In what county is the entry that has a Construction Completed date of 07/19/2000 and a Listed date of 09/21/1984 located?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "superfund_sites" (
"cerclis_id" text,
"name" text,
"county" text,
"proposed" text,
"listed" text,
"construction_completed" text,
"partially_deleted" text,
"deleted" text
);
### SQL
Given the database schema, here is the SQL query that answers `In what county is the entry that has a Construction Completed date of 07/19/2000 and a Listed date of 09/21/1984 located?`:
```sql
|
SELECT "deleted" FROM "superfund_sites" WHERE "listed"='09/21/1984' AND "name"='stauffer chemical company (lemoyne plant)'; |
## Task
Generate a SQL query to answer the following question:
`On what date was Stauffer Chemical Company (Lemoyne Plant), which was listed on 09/21/1984, deleted?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "superfund_sites" (
"cerclis_id" text,
"name" text,
"county" text,
"proposed" text,
"listed" text,
"construction_completed" text,
"partially_deleted" text,
"deleted" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date was Stauffer Chemical Company (Lemoyne Plant), which was listed on 09/21/1984, deleted?`:
```sql
|
SELECT "proposed" FROM "superfund_sites" WHERE "cerclis_id"='al0001058056'; |
## Task
Generate a SQL query to answer the following question:
`What was the Proposed date of the entry that has a CERCLIS ID of al0001058056?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "superfund_sites" (
"cerclis_id" text,
"name" text,
"county" text,
"proposed" text,
"listed" text,
"construction_completed" text,
"partially_deleted" text,
"deleted" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the Proposed date of the entry that has a CERCLIS ID of al0001058056?`:
```sql
|
SELECT "first_appearance" FROM "x" WHERE "year"=1966 AND "name"='x-2-y'; |
## Task
Generate a SQL query to answer the following question:
`What first appeared in 1966 in the comic X-2-Y?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "x" (
"name" text,
"original_publisher" text,
"first_appearance" text,
"year" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What first appeared in 1966 in the comic X-2-Y?`:
```sql
|
SELECT "team" FROM "former_current_professional_teams" WHERE "sport"='baseball' AND "class"='aaa'; |
## Task
Generate a SQL query to answer the following question:
`Which baseball team is class AAA?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "former_current_professional_teams" (
"team" text,
"sport" text,
"league" text,
"played" text,
"class" text,
"championships" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which baseball team is class AAA?`:
```sql
|
SELECT "venue" FROM "round_3" WHERE "away_team"='collingwood'; |
## Task
Generate a SQL query to answer the following question:
`Where does Collingwood play their games?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_3" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where does Collingwood play their games?`:
```sql
|
SELECT "position" FROM "2012_team" WHERE "player"='robert nkemdiche'; |
## Task
Generate a SQL query to answer the following question:
`Which position does Robert Nkemdiche play?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2012_team" (
"player" text,
"position" text,
"school" text,
"hometown" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which position does Robert Nkemdiche play?`:
```sql
|
SELECT "college" FROM "2012_team" WHERE "player"='reuben foster'; |
## Task
Generate a SQL query to answer the following question:
`What is Reuben Foster's college?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2012_team" (
"player" text,
"position" text,
"school" text,
"hometown" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is Reuben Foster's college?`:
```sql
|
SELECT "position" FROM "2012_team" WHERE "hometown"='muscle shoals, alabama'; |
## Task
Generate a SQL query to answer the following question:
`Which position does the player from Muscle Shoals, Alabama play?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2012_team" (
"player" text,
"position" text,
"school" text,
"hometown" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which position does the player from Muscle Shoals, Alabama play?`:
```sql
|
SELECT "player" FROM "2012_team" WHERE "college"='virginia'; |
## Task
Generate a SQL query to answer the following question:
`Which player is attending college at Virginia?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2012_team" (
"player" text,
"position" text,
"school" text,
"hometown" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which player is attending college at Virginia?`:
```sql
|
SELECT "player" FROM "2012_team" WHERE "school"='hoover high school'; |
## Task
Generate a SQL query to answer the following question:
`Which player attended Hoover High School?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2012_team" (
"player" text,
"position" text,
"school" text,
"hometown" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which player attended Hoover High School?`:
```sql
|
SELECT "record" FROM "game_log" WHERE "opponent"='giants' AND "date"='may 12'; |
## Task
Generate a SQL query to answer the following question:
`What is the team's record on may 12 when they play the giants?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the team's record on may 12 when they play the giants?`:
```sql
|
SELECT "attendance" FROM "western_conference_semi_finals" WHERE "visitor"='san jose' AND "date"='may 4'; |
## Task
Generate a SQL query to answer the following question:
`What is the attendance at the game where San Jose was the visitor on May 4?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "western_conference_semi_finals" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"decision" text,
"attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the attendance at the game where San Jose was the visitor on May 4?`:
```sql
|
SELECT "home" FROM "western_conference_semi_finals" WHERE "date"='may 2'; |
## Task
Generate a SQL query to answer the following question:
`Who was the home team on the May 2 game?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "western_conference_semi_finals" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"decision" text,
"attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the home team on the May 2 game?`:
```sql
|
SELECT "decision" FROM "western_conference_semi_finals" WHERE "attendance">'17,496' AND "date"='april 30'; |
## Task
Generate a SQL query to answer the following question:
`What is the decision of the game with more than 17,496 attendance on April 30?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "western_conference_semi_finals" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"decision" text,
"attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the decision of the game with more than 17,496 attendance on April 30?`:
```sql
|
SELECT "date" FROM "round_4" WHERE "crowd">'20,000'; |
## Task
Generate a SQL query to answer the following question:
`What date is the crowd larger than 20,000?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_4" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date is the crowd larger than 20,000?`:
```sql
|
SELECT "away_team" FROM "round_4" WHERE "away_team_score"='11.13 (79)'; |
## Task
Generate a SQL query to answer the following question:
`Which away team has a score of more that 11.13 (79)`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_4" (
"home_team" text,
"home_team_score" text,
"away_team" text,
"away_team_score" text,
"venue" text,
"crowd" real,
"date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which away team has a score of more that 11.13 (79)`:
```sql
|
SELECT "record" FROM "game_log" WHERE "score"='11-10'; |
## Task
Generate a SQL query to answer the following question:
`What was the record when the score was 11-10?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the record when the score was 11-10?`:
```sql
|
SELECT "record" FROM "game_log" WHERE "attendance"='22,713'; |
## Task
Generate a SQL query to answer the following question:
`What was the record when the attendance was 22,713?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the record when the attendance was 22,713?`:
```sql
|
SELECT "attendance" FROM "game_log" WHERE "record"='49-61'; |
## Task
Generate a SQL query to answer the following question:
`What was the attendance at the game when the record was 49-61?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the attendance at the game when the record was 49-61?`:
```sql
|
SELECT "date" FROM "game_log" WHERE "opponent"='detroit tigers' AND "attendance"='38,639'; |
## Task
Generate a SQL query to answer the following question:
`On what date was there a game in which the opponent was the Detroit Tigers, and the attendance was 38,639?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date was there a game in which the opponent was the Detroit Tigers, and the attendance was 38,639?`:
```sql
|
SELECT "software" FROM "general" WHERE "cost_usd"='free' AND "latest_stable_date_version"='1.1'; |
## Task
Generate a SQL query to answer the following question:
`What is the free sotware with the latest stable date version of 1.1?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "general" (
"software" text,
"latest_stable_date_version" text,
"cost_usd" text,
"open_source" text,
"license" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the free sotware with the latest stable date version of 1.1?`:
```sql
|
SELECT "software" FROM "general" WHERE "latest_stable_date_version"='0.6.1'; |
## Task
Generate a SQL query to answer the following question:
`Name the software with the latest stable date of 0.6.1`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "general" (
"software" text,
"latest_stable_date_version" text,
"cost_usd" text,
"open_source" text,
"license" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the software with the latest stable date of 0.6.1`:
```sql
|
SELECT "cost_usd" FROM "general" WHERE "latest_stable_date_version"='online'; |
## Task
Generate a SQL query to answer the following question:
`Name the cost for latest stable date of online`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "general" (
"software" text,
"latest_stable_date_version" text,
"cost_usd" text,
"open_source" text,
"license" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the cost for latest stable date of online`:
```sql
|
SELECT "birth_place" FROM "prime_ministers" WHERE "monarchs_served"='george v' AND "entered_office"='23 october 1922'; |
## Task
Generate a SQL query to answer the following question:
`What is the birth place of the prime minister who served George V and entered office on 23 October 1922?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "prime_ministers" (
"name" text,
"entered_office" text,
"left_office" text,
"political_party" text,
"monarchs_served" text,
"birth_place" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the birth place of the prime minister who served George V and entered office on 23 October 1922?`:
```sql
|
SELECT "political_party" FROM "prime_ministers" WHERE "monarchs_served"='george v' AND "birth_place"='manchester'; |
## Task
Generate a SQL query to answer the following question:
`To which political party did the prime minister who served under George V and was born in Manchester belong?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "prime_ministers" (
"name" text,
"entered_office" text,
"left_office" text,
"political_party" text,
"monarchs_served" text,
"birth_place" text
);
### SQL
Given the database schema, here is the SQL query that answers `To which political party did the prime minister who served under George V and was born in Manchester belong?`:
```sql
|
SELECT "left_office" FROM "prime_ministers" WHERE "entered_office"='7 december 1916'; |
## Task
Generate a SQL query to answer the following question:
`What date did the prime minister who entered office on 7 December 1916 leave office?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "prime_ministers" (
"name" text,
"entered_office" text,
"left_office" text,
"political_party" text,
"monarchs_served" text,
"birth_place" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date did the prime minister who entered office on 7 December 1916 leave office?`:
```sql
|
SELECT "monarchs_served" FROM "prime_ministers" WHERE "name"='stanley baldwin (1st ministry)'; |
## Task
Generate a SQL query to answer the following question:
`What monarch(s) did Stanley Baldwin (1st ministry) serve?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "prime_ministers" (
"name" text,
"entered_office" text,
"left_office" text,
"political_party" text,
"monarchs_served" text,
"birth_place" text
);
### SQL
Given the database schema, here is the SQL query that answers `What monarch(s) did Stanley Baldwin (1st ministry) serve?`:
```sql
|
SELECT "date" FROM "schedule" WHERE "game_site"='rich stadium'; |
## Task
Generate a SQL query to answer the following question:
`What is the date of the game played at rich stadium?`
### 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" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the date of the game played at rich stadium?`:
```sql
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.