output stringlengths 27 479 | instruction stringlengths 407 1.39k |
|---|---|
SELECT SUM("goals_for") FROM "final_table" WHERE "draws">9 AND "played">38; |
## Task
Generate a SQL query to answer the following question:
`How many goals have more than 38 played and more than 9 draws?`
### 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 `How many goals have more than 38 played and more than 9 draws?`:
```sql
|
SELECT MIN("losses") FROM "final_table" WHERE "goals_against">59 AND "position">17; |
## Task
Generate a SQL query to answer the following question:
`How many losses has more than 59 goals against and more than 17 position?`
### 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 `How many losses has more than 59 goals against and more than 17 position?`:
```sql
|
SELECT "date" FROM "women" WHERE "meet"='2007 pan american games' AND "time"='1:07.78'; |
## Task
Generate a SQL query to answer the following question:
`On what Date was the Meet of 2007 Pan American Games with a Time of 1:07.78?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "women" (
"event" text,
"time" text,
"nationality" text,
"date" text,
"meet" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what Date was the Meet of 2007 Pan American Games with a Time of 1:07.78?`:
```sql
|
SELECT "nationality" FROM "women" WHERE "time"='2:07.64'; |
## Task
Generate a SQL query to answer the following question:
`What Nationality's time is 2:07.64?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "women" (
"event" text,
"time" text,
"nationality" text,
"date" text,
"meet" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Nationality's time is 2:07.64?`:
```sql
|
SELECT "event" FROM "women" WHERE "time"='4:01.00'; |
## Task
Generate a SQL query to answer the following question:
`What Event's Time is 4:01.00?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "women" (
"event" text,
"time" text,
"nationality" text,
"date" text,
"meet" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Event's Time is 4:01.00?`:
```sql
|
SELECT "location" FROM "women" WHERE "nationality"='united states' AND "time"='2:25.62'; |
## Task
Generate a SQL query to answer the following question:
`In what Location in the United States the Time 2:25.62?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "women" (
"event" text,
"time" text,
"nationality" text,
"date" text,
"meet" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `In what Location in the United States the Time 2:25.62?`:
```sql
|
SELECT "playoffs" FROM "outdoor" WHERE "year">1975 AND "record"='13–11'; |
## Task
Generate a SQL query to answer the following question:
`Year larger than 1975, and a Record of 13–11 is what playoffs?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "outdoor" (
"year" real,
"record" text,
"regular_season_finish" text,
"playoffs" text,
"avg_attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Year larger than 1975, and a Record of 13–11 is what playoffs?`:
```sql
|
SELECT "9_30" FROM "sunday" WHERE "10_30"='le journal weekend'; |
## Task
Generate a SQL query to answer the following question:
`Which 9:30 has a 10:30 of le journal weekend?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "sunday" (
"7_00" text,
"7_30" text,
"8_00" text,
"8_30" text,
"9_00" text,
"9_30" text,
"10_00" text,
"10_30" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which 9:30 has a 10:30 of le journal weekend?`:
```sql
|
SELECT "9_00" FROM "sunday" WHERE "8_00"='behind the movies'; |
## Task
Generate a SQL query to answer the following question:
`Which 9:00 has an 8:00 behind the movies?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "sunday" (
"7_00" text,
"7_30" text,
"8_00" text,
"8_30" text,
"9_00" text,
"9_30" text,
"10_00" text,
"10_30" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which 9:00 has an 8:00 behind the movies?`:
```sql
|
SELECT "10_00" FROM "sunday" WHERE "7_30"='da kink in my hair'; |
## Task
Generate a SQL query to answer the following question:
`What 10:00 has a 7:30 of da kink in my hair?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "sunday" (
"7_00" text,
"7_30" text,
"8_00" text,
"8_30" text,
"9_00" text,
"9_30" text,
"10_00" text,
"10_30" text
);
### SQL
Given the database schema, here is the SQL query that answers `What 10:00 has a 7:30 of da kink in my hair?`:
```sql
|
SELECT "7_00" FROM "sunday" WHERE "9_30"='tout le monde en parle'; |
## Task
Generate a SQL query to answer the following question:
`What 7:00 has a 9:30 of tout le monde en parle?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "sunday" (
"7_00" text,
"7_30" text,
"8_00" text,
"8_30" text,
"9_00" text,
"9_30" text,
"10_00" text,
"10_30" text
);
### SQL
Given the database schema, here is the SQL query that answers `What 7:00 has a 9:30 of tout le monde en parle?`:
```sql
|
SELECT "7_00" FROM "sunday" WHERE "10_00"='dirty sexy money'; |
## Task
Generate a SQL query to answer the following question:
`What 7:00 has a 10:00 of dirty sexy money?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "sunday" (
"7_00" text,
"7_30" text,
"8_00" text,
"8_30" text,
"9_00" text,
"9_30" text,
"10_00" text,
"10_30" text
);
### SQL
Given the database schema, here is the SQL query that answers `What 7:00 has a 10:00 of dirty sexy money?`:
```sql
|
SELECT "10_00" FROM "sunday" WHERE "8_00"='movies'; |
## Task
Generate a SQL query to answer the following question:
`What 10:00 has a 8:00 of movies?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "sunday" (
"7_00" text,
"7_30" text,
"8_00" text,
"8_30" text,
"9_00" text,
"9_30" text,
"10_00" text,
"10_30" text
);
### SQL
Given the database schema, here is the SQL query that answers `What 10:00 has a 8:00 of movies?`:
```sql
|
SELECT "venue" FROM "major_titles" WHERE "year"<2005 AND "category"='world class' AND "result"='bronze'; |
## Task
Generate a SQL query to answer the following question:
`What are the venues prior to 2005 in the World Class category that resulted in a bronze?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "major_titles" (
"competition" text,
"venue" text,
"year" real,
"category" text,
"result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What are the venues prior to 2005 in the World Class category that resulted in a bronze?`:
```sql
|
SELECT "competition" FROM "major_titles" WHERE "year"<2006 AND "venue"='svk nitra'; |
## Task
Generate a SQL query to answer the following question:
`What are the competitions that occurred before 2006 in SVK Nitra?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "major_titles" (
"competition" text,
"venue" text,
"year" real,
"category" text,
"result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What are the competitions that occurred before 2006 in SVK Nitra?`:
```sql
|
SELECT "category" FROM "major_titles" WHERE "year">2007 AND "competition"='world championships'; |
## Task
Generate a SQL query to answer the following question:
`What are the categories of events that occurred after 2007 that were World Championships?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "major_titles" (
"competition" text,
"venue" text,
"year" real,
"category" text,
"result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What are the categories of events that occurred after 2007 that were World Championships?`:
```sql
|
SELECT "result" FROM "major_titles" WHERE "year"<2010 AND "venue"='nor elverum'; |
## Task
Generate a SQL query to answer the following question:
`What was the result of events held at Nor Elverum, prior to 2010?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "major_titles" (
"competition" text,
"venue" text,
"year" real,
"category" text,
"result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the result of events held at Nor Elverum, prior to 2010?`:
```sql
|
SELECT "competition" FROM "major_titles" WHERE "year"=2003; |
## Task
Generate a SQL query to answer the following question:
`What was the competition held in 2003?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "major_titles" (
"competition" text,
"venue" text,
"year" real,
"category" text,
"result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the competition held in 2003?`:
```sql
|
SELECT "chassis" FROM "complete_formula_one_world_championship_" WHERE "entrant"='scuderia ferrari' AND "points">1; |
## Task
Generate a SQL query to answer the following question:
`What chassis type does a scuderia ferrari with more than 1 point have?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "complete_formula_one_world_championship_" (
"year" real,
"entrant" text,
"chassis" text,
"engine" text,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What chassis type does a scuderia ferrari with more than 1 point have?`:
```sql
|
SELECT "chassis" FROM "complete_formula_one_world_championship_" WHERE "engine"='ferrari flat-12' AND "points">1; |
## Task
Generate a SQL query to answer the following question:
`A ferrari flat-12 engine with more than 1 point has what kind of chassis?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "complete_formula_one_world_championship_" (
"year" real,
"entrant" text,
"chassis" text,
"engine" text,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `A ferrari flat-12 engine with more than 1 point has what kind of chassis?`:
```sql
|
SELECT AVG("year") FROM "complete_formula_one_world_championship_" WHERE "chassis"='merzario a2'; |
## Task
Generate a SQL query to answer the following question:
`What is the average year for a merzario a2 chassis?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "complete_formula_one_world_championship_" (
"year" real,
"entrant" text,
"chassis" text,
"engine" text,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average year for a merzario a2 chassis?`:
```sql
|
SELECT "record" FROM "regular_season" WHERE "visitor"='chicago black hawks' AND "date"='november 24'; |
## Task
Generate a SQL query to answer the following question:
`What was the team's record when they played visitor team Chicago Black Hawks on November 24?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "regular_season" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the team's record when they played visitor team Chicago Black Hawks on November 24?`:
```sql
|
SELECT "visitor" FROM "regular_season" WHERE "home"='chicago black hawks' AND "date"='march 20'; |
## Task
Generate a SQL query to answer the following question:
`What is the name of the visitor team who played home team Chicago Black Hawks on March 20?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "regular_season" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the name of the visitor team who played home team Chicago Black Hawks on March 20?`:
```sql
|
SELECT "record" FROM "regular_season" WHERE "date"='november 12'; |
## Task
Generate a SQL query to answer the following question:
`What was the team's record on November 12?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "regular_season" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the team's record on November 12?`:
```sql
|
SELECT "champion" FROM "past_winners_and_runners_up" WHERE "year"='1981'; |
## Task
Generate a SQL query to answer the following question:
`What champion has 1981 as the year?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "past_winners_and_runners_up" (
"year" text,
"date_final" text,
"venue" text,
"prize_money" text,
"champion" text,
"runner_up" text,
"score_in_final" text,
"commercial_name" text
);
### SQL
Given the database schema, here is the SQL query that answers `What champion has 1981 as the year?`:
```sql
|
SELECT "date_final" FROM "past_winners_and_runners_up" WHERE "year"='1982'; |
## Task
Generate a SQL query to answer the following question:
`What date final has 1982 as the year?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "past_winners_and_runners_up" (
"year" text,
"date_final" text,
"venue" text,
"prize_money" text,
"champion" text,
"runner_up" text,
"score_in_final" text,
"commercial_name" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date final has 1982 as the year?`:
```sql
|
SELECT "prize_money" FROM "past_winners_and_runners_up" WHERE "commercial_name"='michelob light challenge of champions'; |
## Task
Generate a SQL query to answer the following question:
`What prize money has michelob light challenge of champions as the commercial name?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "past_winners_and_runners_up" (
"year" text,
"date_final" text,
"venue" text,
"prize_money" text,
"champion" text,
"runner_up" text,
"score_in_final" text,
"commercial_name" text
);
### SQL
Given the database schema, here is the SQL query that answers `What prize money has michelob light challenge of champions as the commercial name?`:
```sql
|
SELECT "date_final" FROM "past_winners_and_runners_up" WHERE "year"='1989'; |
## Task
Generate a SQL query to answer the following question:
`What date final has 1989 as the year?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "past_winners_and_runners_up" (
"year" text,
"date_final" text,
"venue" text,
"prize_money" text,
"champion" text,
"runner_up" text,
"score_in_final" text,
"commercial_name" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date final has 1989 as the year?`:
```sql
|
SELECT "score_in_final" FROM "past_winners_and_runners_up" WHERE "champion"='boris becker'; |
## Task
Generate a SQL query to answer the following question:
`What score in final has boris becker as the champion?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "past_winners_and_runners_up" (
"year" text,
"date_final" text,
"venue" text,
"prize_money" text,
"champion" text,
"runner_up" text,
"score_in_final" text,
"commercial_name" text
);
### SQL
Given the database schema, here is the SQL query that answers `What score in final has boris becker as the champion?`:
```sql
|
SELECT MAX("points") FROM "complete_world_championship_formula_one_" WHERE "engine"='alta straight-4' AND "entrant"='connaught engineering' AND "year"<1957; |
## Task
Generate a SQL query to answer the following question:
`What is the greatest point of an Entrant of connaught engineering alta straight-4 engine before 1957`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "complete_world_championship_formula_one_" (
"year" real,
"entrant" text,
"chassis" text,
"engine" text,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the greatest point of an Entrant of connaught engineering alta straight-4 engine before 1957`:
```sql
|
SELECT "engine" FROM "complete_world_championship_formula_one_" WHERE "chassis"='connaught type b' AND "year">1957; |
## Task
Generate a SQL query to answer the following question:
`What 1957 engine has a Chassis of connaught type b?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "complete_world_championship_formula_one_" (
"year" real,
"entrant" text,
"chassis" text,
"engine" text,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What 1957 engine has a Chassis of connaught type b?`:
```sql
|
SELECT MIN("year") FROM "winners" WHERE "men_s_singles"='david eddy'; |
## Task
Generate a SQL query to answer the following question:
`Name the least year for david eddy`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "winners" (
"year" real,
"men_s_singles" text,
"women_s_singles" text,
"men_s_doubles" text,
"women_s_doubles" text,
"mixed_doubles" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the least year for david eddy`:
```sql
|
SELECT "mixed_doubles" FROM "winners" WHERE "year"<1991 AND "men_s_doubles"='david jepson buck ryan'; |
## Task
Generate a SQL query to answer the following question:
`Name the mixed doubles for year before 1991 and men's doubles of david jepson buck ryan`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "winners" (
"year" real,
"men_s_singles" text,
"women_s_singles" text,
"men_s_doubles" text,
"women_s_doubles" text,
"mixed_doubles" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the mixed doubles for year before 1991 and men's doubles of david jepson buck ryan`:
```sql
|
SELECT "women_s_doubles" FROM "winners" WHERE "year"<1972; |
## Task
Generate a SQL query to answer the following question:
`Name the women's doubles for year less than 1972`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "winners" (
"year" real,
"men_s_singles" text,
"women_s_singles" text,
"men_s_doubles" text,
"women_s_doubles" text,
"mixed_doubles" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the women's doubles for year less than 1972`:
```sql
|
SELECT "date" FROM "champions_tour_wins_9" WHERE "winning_score"='−9 (72-68-64-67=271)'; |
## Task
Generate a SQL query to answer the following question:
`When was the winning score −9 (72-68-64-67=271)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "champions_tour_wins_9" (
"date" text,
"tournament" text,
"winning_score" text,
"margin_of_victory" text,
"runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `When was the winning score −9 (72-68-64-67=271)?`:
```sql
|
SELECT "margin_of_victory" FROM "champions_tour_wins_9" WHERE "tournament"='mississippi gulf resort classic'; |
## Task
Generate a SQL query to answer the following question:
`What was the margin of victory for the Mississippi Gulf Resort Classic?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "champions_tour_wins_9" (
"date" text,
"tournament" text,
"winning_score" text,
"margin_of_victory" text,
"runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the margin of victory for the Mississippi Gulf Resort Classic?`:
```sql
|
SELECT "margin_of_victory" FROM "champions_tour_wins_9" WHERE "runner_s_up"='mark calcavecchia'; |
## Task
Generate a SQL query to answer the following question:
`What was the margin of victory when Mark Calcavecchia was the runner-up?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "champions_tour_wins_9" (
"date" text,
"tournament" text,
"winning_score" text,
"margin_of_victory" text,
"runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the margin of victory when Mark Calcavecchia was the runner-up?`:
```sql
|
SELECT "date" FROM "champions_tour_wins_9" WHERE "margin_of_victory"='1 stroke' AND "tournament"='the ace group classic'; |
## Task
Generate a SQL query to answer the following question:
`What was the date of the Ace Group Classic tournament with a 1 stroke margin of victory?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "champions_tour_wins_9" (
"date" text,
"tournament" text,
"winning_score" text,
"margin_of_victory" text,
"runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the date of the Ace Group Classic tournament with a 1 stroke margin of victory?`:
```sql
|
SELECT "margin_of_victory" FROM "champions_tour_wins_9" WHERE "winning_score"='−9 (72-68-64-67=271)'; |
## Task
Generate a SQL query to answer the following question:
`What was the margin of victory when the winning score was −9 (72-68-64-67=271)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "champions_tour_wins_9" (
"date" text,
"tournament" text,
"winning_score" text,
"margin_of_victory" text,
"runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the margin of victory when the winning score was −9 (72-68-64-67=271)?`:
```sql
|
SELECT AVG("round") FROM "1981_raiders_draft_selections" WHERE "position"='te'; |
## Task
Generate a SQL query to answer the following question:
`What is the average round for te position?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1981_raiders_draft_selections" (
"round" real,
"overall" real,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average round for te position?`:
```sql
|
SELECT AVG("overall") FROM "1981_raiders_draft_selections" WHERE "player"='james davis'; |
## Task
Generate a SQL query to answer the following question:
`Name the average overall for james davis`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1981_raiders_draft_selections" (
"round" real,
"overall" real,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the average overall for james davis`:
```sql
|
SELECT MAX("overall") FROM "1981_raiders_draft_selections" WHERE "player"='james davis' AND "round">5; |
## Task
Generate a SQL query to answer the following question:
`Name the most overall for james davis and round more than 5`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1981_raiders_draft_selections" (
"round" real,
"overall" real,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the most overall for james davis and round more than 5`:
```sql
|
SELECT COUNT("overall") FROM "1981_raiders_draft_selections" WHERE "college"='villanova' AND "round"<2; |
## Task
Generate a SQL query to answer the following question:
`Name the total number of overall for villanova and round less than 2`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "1981_raiders_draft_selections" (
"round" real,
"overall" real,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the total number of overall for villanova and round less than 2`:
```sql
|
SELECT "state" FROM "the_50_most_topographically_prominent_su" WHERE "mountain_peak"='mount chiginagak'; |
## Task
Generate a SQL query to answer the following question:
`Which state is Mount Chiginagak located in?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "the_50_most_topographically_prominent_su" (
"rank" real,
"mountain_peak" text,
"state" text,
"mountain_range" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which state is Mount Chiginagak located in?`:
```sql
|
SELECT "circumstances" FROM "2008" WHERE "location"='baghlan'; |
## Task
Generate a SQL query to answer the following question:
`What were the circumstances for the Baghlan location?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2008" (
"date" text,
"location" text,
"nature_of_incident" text,
"circumstances" text,
"casualties" text
);
### SQL
Given the database schema, here is the SQL query that answers `What were the circumstances for the Baghlan location?`:
```sql
|
SELECT "casualties" FROM "2008" WHERE "location"='baghlan'; |
## Task
Generate a SQL query to answer the following question:
`What were the casualties in the Baghlan location?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2008" (
"date" text,
"location" text,
"nature_of_incident" text,
"circumstances" text,
"casualties" text
);
### SQL
Given the database schema, here is the SQL query that answers `What were the casualties in the Baghlan location?`:
```sql
|
SELECT "date" FROM "2008" WHERE "circumstances"='natural cause'; |
## Task
Generate a SQL query to answer the following question:
`What was the date of natural cause situation?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2008" (
"date" text,
"location" text,
"nature_of_incident" text,
"circumstances" text,
"casualties" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the date of natural cause situation?`:
```sql
|
SELECT "gold_coast" FROM "2008" WHERE "perth"='no' AND "sydney"='yes' AND "auckland"='yes'; |
## Task
Generate a SQL query to answer the following question:
`Which Gold Coast has a Perth of no, a Sydney of yes, and an Auckland of yes?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2008" (
"sydney" text,
"melbourne" text,
"perth" text,
"adelaide" text,
"gold_coast" text,
"auckland" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Gold Coast has a Perth of no, a Sydney of yes, and an Auckland of yes?`:
```sql
|
SELECT "melbourne" FROM "2008" WHERE "auckland"='no' AND "gold_coast"='no'; |
## Task
Generate a SQL query to answer the following question:
`Which Melbourne has an Auckland of no, and a Gold Coast of no?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2008" (
"sydney" text,
"melbourne" text,
"perth" text,
"adelaide" text,
"gold_coast" text,
"auckland" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Melbourne has an Auckland of no, and a Gold Coast of no?`:
```sql
|
SELECT "adelaide" FROM "2008" WHERE "melbourne"='yes' AND "auckland"='yes' AND "perth"='yes'; |
## Task
Generate a SQL query to answer the following question:
`Which Adelaide has a Melbourne of yes, an Auckland of yes, and a Perth of yes?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2008" (
"sydney" text,
"melbourne" text,
"perth" text,
"adelaide" text,
"gold_coast" text,
"auckland" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Adelaide has a Melbourne of yes, an Auckland of yes, and a Perth of yes?`:
```sql
|
SELECT "sydney" FROM "2008" WHERE "perth"='no' AND "melbourne"='yes' AND "gold_coast"='no'; |
## Task
Generate a SQL query to answer the following question:
`Which Sydney has a Perth of no, a Melbourne of yes, and a Gold Coast of no?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2008" (
"sydney" text,
"melbourne" text,
"perth" text,
"adelaide" text,
"gold_coast" text,
"auckland" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Sydney has a Perth of no, a Melbourne of yes, and a Gold Coast of no?`:
```sql
|
SELECT "auckland" FROM "2008" WHERE "adelaide"='no' AND "melbourne"='yes' AND "sydney"='yes'; |
## Task
Generate a SQL query to answer the following question:
`Which Auckland has an Adelaide of no, a Melbourne of yes, and a Sydney of yes?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2008" (
"sydney" text,
"melbourne" text,
"perth" text,
"adelaide" text,
"gold_coast" text,
"auckland" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Auckland has an Adelaide of no, a Melbourne of yes, and a Sydney of yes?`:
```sql
|
SELECT "adelaide" FROM "2008" WHERE "auckland"='yes' AND "melbourne"='yes' AND "perth"='yes' AND "sydney"='cancelled'; |
## Task
Generate a SQL query to answer the following question:
`Which Adelaide has an Auckland of yes, a Melbourne of yes, a Perth of yes, and a Sydney of cancelled?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2008" (
"sydney" text,
"melbourne" text,
"perth" text,
"adelaide" text,
"gold_coast" text,
"auckland" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Adelaide has an Auckland of yes, a Melbourne of yes, a Perth of yes, and a Sydney of cancelled?`:
```sql
|
SELECT "owner_s" FROM "full_time_teams" WHERE "team"='rss racing' AND "driver_s"='ryan sieg'; |
## Task
Generate a SQL query to answer the following question:
`Who is the owner of RSS Racing that driver Ryan Sieg belongs to?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "full_time_teams" (
"team" text,
"truck_s" text,
"driver_s" text,
"primary_sponsor_s" text,
"owner_s" text,
"crew_chief" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the owner of RSS Racing that driver Ryan Sieg belongs to?`:
```sql
|
SELECT "driver_s" FROM "full_time_teams" WHERE "primary_sponsor_s"='parts plus'; |
## Task
Generate a SQL query to answer the following question:
`Parts Plus sponsors what driver?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "full_time_teams" (
"team" text,
"truck_s" text,
"driver_s" text,
"primary_sponsor_s" text,
"owner_s" text,
"crew_chief" text
);
### SQL
Given the database schema, here is the SQL query that answers `Parts Plus sponsors what driver?`:
```sql
|
SELECT "owner_s" FROM "full_time_teams" WHERE "team"='nts motorsports' AND "primary_sponsor_s"='qore-24'; |
## Task
Generate a SQL query to answer the following question:
`Who is the owner of NTS Motorsports sponsored by Qore-24?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "full_time_teams" (
"team" text,
"truck_s" text,
"driver_s" text,
"primary_sponsor_s" text,
"owner_s" text,
"crew_chief" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the owner of NTS Motorsports sponsored by Qore-24?`:
```sql
|
SELECT "crew_chief" FROM "full_time_teams" WHERE "driver_s"='matt kurzejewski'; |
## Task
Generate a SQL query to answer the following question:
`Who is the crew chief, of driver Matt kurzejewski?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "full_time_teams" (
"team" text,
"truck_s" text,
"driver_s" text,
"primary_sponsor_s" text,
"owner_s" text,
"crew_chief" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the crew chief, of driver Matt kurzejewski?`:
```sql
|
SELECT "driver_s" FROM "full_time_teams" WHERE "crew_chief"='gary ritter'; |
## Task
Generate a SQL query to answer the following question:
`Who is the driver that has a crew chief Gary Ritter?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "full_time_teams" (
"team" text,
"truck_s" text,
"driver_s" text,
"primary_sponsor_s" text,
"owner_s" text,
"crew_chief" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the driver that has a crew chief Gary Ritter?`:
```sql
|
SELECT "award" FROM "others_awards_and_nominations" WHERE "year"=2009 AND "category"='songwriter of the year'; |
## Task
Generate a SQL query to answer the following question:
`what is the award for the 2009 songwriter of the year?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "others_awards_and_nominations" (
"year" real,
"result" text,
"award" text,
"category" text,
"nominated_work" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the award for the 2009 songwriter of the year?`:
```sql
|
SELECT "category" FROM "others_awards_and_nominations" WHERE "award"='people''s choice awards'; |
## Task
Generate a SQL query to answer the following question:
`what is the category that has the people's choice awards?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "others_awards_and_nominations" (
"year" real,
"result" text,
"award" text,
"category" text,
"nominated_work" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the category that has the people's choice awards?`:
```sql
|
SELECT COUNT("year") FROM "others_awards_and_nominations" WHERE "nominated_work"='general' AND "category"='choice breakthrough artist'; |
## Task
Generate a SQL query to answer the following question:
`what year has general nominated in the category or choice breakthrough artist?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "others_awards_and_nominations" (
"year" real,
"result" text,
"award" text,
"category" text,
"nominated_work" text
);
### SQL
Given the database schema, here is the SQL query that answers `what year has general nominated in the category or choice breakthrough artist?`:
```sql
|
SELECT "score" FROM "national_team" WHERE "date"='6 february 2008'; |
## Task
Generate a SQL query to answer the following question:
`What was the score on 6 February 2008?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "national_team" (
"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 score on 6 February 2008?`:
```sql
|
SELECT "competition" FROM "national_team" WHERE "date"='14 november 2012'; |
## Task
Generate a SQL query to answer the following question:
`Which competition was held on 14 November 2012?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "national_team" (
"date" text,
"venue" text,
"score" text,
"result" text,
"competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which competition was held on 14 November 2012?`:
```sql
|
SELECT "competition" FROM "national_team" WHERE "date"='10 august 2011'; |
## Task
Generate a SQL query to answer the following question:
`What competition took place on 10 August 2011?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "national_team" (
"date" text,
"venue" text,
"score" text,
"result" text,
"competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `What competition took place on 10 August 2011?`:
```sql
|
SELECT AVG("year") FROM "complete_formula_one_world_championship_" WHERE "chassis"='cooper t60'; |
## Task
Generate a SQL query to answer the following question:
`What is the average Year with Chassis equalling cooper t60?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "complete_formula_one_world_championship_" (
"year" real,
"entrant" text,
"chassis" text,
"engine" text,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average Year with Chassis equalling cooper t60?`:
```sql
|
SELECT "chassis" FROM "complete_formula_one_world_championship_" WHERE "entrant"='cooper car company' AND "year"=1963; |
## Task
Generate a SQL query to answer the following question:
`Which Chassis has an Entrant of cooper car company, and a Year of 1963?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "complete_formula_one_world_championship_" (
"year" real,
"entrant" text,
"chassis" text,
"engine" text,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Chassis has an Entrant of cooper car company, and a Year of 1963?`:
```sql
|
SELECT "entrant" FROM "complete_formula_one_world_championship_" WHERE "engine"='climax straight-4' AND "points">0; |
## Task
Generate a SQL query to answer the following question:
`Which Entrant has an Engine of climax straight-4, and Points larger than 0?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "complete_formula_one_world_championship_" (
"year" real,
"entrant" text,
"chassis" text,
"engine" text,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Entrant has an Engine of climax straight-4, and Points larger than 0?`:
```sql
|
SELECT "tournament" FROM "singles_18_itf" WHERE "surface"='hard' AND "date"='apr. 12, 1998'; |
## Task
Generate a SQL query to answer the following question:
`Which tournament has hard as the surface and apr. 12, 1998 as the date?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_18_itf" (
"date" text,
"tournament" text,
"surface" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which tournament has hard as the surface and apr. 12, 1998 as the date?`:
```sql
|
SELECT "surface" FROM "singles_18_itf" WHERE "opponent_in_the_final"='wynne prakusya'; |
## Task
Generate a SQL query to answer the following question:
`Which surface has wynne prakusya as the opponent in the final?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_18_itf" (
"date" text,
"tournament" text,
"surface" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which surface has wynne prakusya as the opponent in the final?`:
```sql
|
SELECT "score" FROM "singles_18_itf" WHERE "opponent_in_the_final"='wynne prakusya'; |
## Task
Generate a SQL query to answer the following question:
`What score has wynne prakusya as the opponent in the final?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_18_itf" (
"date" text,
"tournament" text,
"surface" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What score has wynne prakusya as the opponent in the final?`:
```sql
|
SELECT "tournament" FROM "singles_18_itf" WHERE "date"='nov. 21, 1999'; |
## Task
Generate a SQL query to answer the following question:
`What tournament has nov. 21, 1999 as the date?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_18_itf" (
"date" text,
"tournament" text,
"surface" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What tournament has nov. 21, 1999 as the date?`:
```sql
|
SELECT "authority" FROM "masterton_district" WHERE "gender"='coed' AND "name"='chanel college'; |
## Task
Generate a SQL query to answer the following question:
`Name the authority for coed gender and chanel college`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "masterton_district" (
"name" text,
"years" text,
"gender" text,
"area" text,
"authority" text,
"decile" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the authority for coed gender and chanel college`:
```sql
|
SELECT AVG("decile") FROM "masterton_district" WHERE "authority"='state' AND "area"='fernridge'; |
## Task
Generate a SQL query to answer the following question:
`Name the average decile for state authority and area of fernridge`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "masterton_district" (
"name" text,
"years" text,
"gender" text,
"area" text,
"authority" text,
"decile" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the average decile for state authority and area of fernridge`:
```sql
|
SELECT MIN("week") FROM "schedule" WHERE "date"='october 11, 1998'; |
## Task
Generate a SQL query to answer the following question:
`What was the week on October 11, 1998?`
### 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,
"record" text,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the week on October 11, 1998?`:
```sql
|
SELECT "game_site" FROM "schedule" WHERE "attendance"='63,336'; |
## Task
Generate a SQL query to answer the following question:
`What is the location of the game with attendance of 63,336?`
### 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,
"record" text,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the location of the game with attendance of 63,336?`:
```sql
|
SELECT "date" FROM "schedule" WHERE "week"=13; |
## Task
Generate a SQL query to answer the following question:
`What was the date of the week 13 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,
"game_site" text,
"record" text,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the date of the week 13 game?`:
```sql
|
SELECT "division_record" FROM "2007_regular_season_football_standings" WHERE "team"='panthers'; |
## Task
Generate a SQL query to answer the following question:
`What is the Panthers' Division Record?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2007_regular_season_football_standings" (
"school" text,
"team" text,
"division_record" text,
"overall_record" text,
"season_outcome" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Panthers' Division Record?`:
```sql
|
SELECT "division_record" FROM "2007_regular_season_football_standings" WHERE "team"='senators'; |
## Task
Generate a SQL query to answer the following question:
`What is the Senators' division record?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2007_regular_season_football_standings" (
"school" text,
"team" text,
"division_record" text,
"overall_record" text,
"season_outcome" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Senators' division record?`:
```sql
|
SELECT "record" FROM "regular_season" WHERE "date"='january 18'; |
## Task
Generate a SQL query to answer the following question:
`What was the record after the January 18 game?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "regular_season" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the record after the January 18 game?`:
```sql
|
SELECT "record" FROM "regular_season" WHERE "date"='january 6'; |
## Task
Generate a SQL query to answer the following question:
`What was the record after the January 6 game?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "regular_season" (
"date" text,
"visitor" text,
"score" text,
"home" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the record after the January 6 game?`:
```sql
|
SELECT COUNT("rank") FROM "settlements_with_population_below_100" WHERE "municipality"='kujalleq' AND "former_name"='brattahlíð' AND "population"<47; |
## Task
Generate a SQL query to answer the following question:
`Name the total number of ranks for kujalleq with former name of brattahlíð and population less than 47`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "settlements_with_population_below_100" (
"rank" real,
"population" real,
"name" text,
"former_name" text,
"municipality" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the total number of ranks for kujalleq with former name of brattahlíð and population less than 47`:
```sql
|
SELECT "former_name" FROM "settlements_with_population_below_100" WHERE "rank"=49; |
## Task
Generate a SQL query to answer the following question:
`Name the former name for 49 rank`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "settlements_with_population_below_100" (
"rank" real,
"population" real,
"name" text,
"former_name" text,
"municipality" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the former name for 49 rank`:
```sql
|
SELECT "nhl_team" FROM "round_six" WHERE "position"='left wing'; |
## Task
Generate a SQL query to answer the following question:
`Which NHL team has left wing listed as the position?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_six" (
"pick_num" text,
"player" text,
"position" text,
"nationality" text,
"nhl_team" text,
"college_junior_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which NHL team has left wing listed as the position?`:
```sql
|
SELECT "years" FROM "ruapehu_district" WHERE "decile"=3 AND "name"='kakahi school'; |
## Task
Generate a SQL query to answer the following question:
`What years does Kakahi school, with a decile of 3, have?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "ruapehu_district" (
"name" text,
"years" text,
"area" text,
"authority" text,
"decile" real,
"roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `What years does Kakahi school, with a decile of 3, have?`:
```sql
|
SELECT AVG("decile") FROM "ruapehu_district" WHERE "authority"='state' AND "name"='ruapehu college'; |
## Task
Generate a SQL query to answer the following question:
`What is the average decile of Ruapehu college, which has a state authority?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "ruapehu_district" (
"name" text,
"years" text,
"area" text,
"authority" text,
"decile" real,
"roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average decile of Ruapehu college, which has a state authority?`:
```sql
|
SELECT SUM("roll") FROM "ruapehu_district" WHERE "area"='raetihi' AND "name"='orautoha school' AND "decile"<8; |
## Task
Generate a SQL query to answer the following question:
`What is the roll number of Orautoha school in Raetihi, which has a decile smaller than 8?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "ruapehu_district" (
"name" text,
"years" text,
"area" text,
"authority" text,
"decile" real,
"roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the roll number of Orautoha school in Raetihi, which has a decile smaller than 8?`:
```sql
|
SELECT "date" FROM "schedule" WHERE "opponent"='utah blaze'; |
## Task
Generate a SQL query to answer the following question:
`On what day was Utah Blaze the opponent?`
### 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,
"home_away_game" text,
"result" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what day was Utah Blaze the opponent?`:
```sql
|
SELECT "2006" FROM "doubles_performance_timeline" WHERE "2011"='1r'; |
## Task
Generate a SQL query to answer the following question:
`What is the 2006 value with a 1r in 2011?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_performance_timeline" (
"tournament" text,
"1999" text,
"2002" text,
"2004" text,
"2006" text,
"2007" text,
"2010" text,
"2011" text,
"2012" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the 2006 value with a 1r in 2011?`:
```sql
|
SELECT "2010" FROM "doubles_performance_timeline" WHERE "2004"='2r' AND "2011"='3r'; |
## Task
Generate a SQL query to answer the following question:
`What is the 2010 value with a 2r in 200r and a 3r in 2011?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_performance_timeline" (
"tournament" text,
"1999" text,
"2002" text,
"2004" text,
"2006" text,
"2007" text,
"2010" text,
"2011" text,
"2012" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the 2010 value with a 2r in 200r and a 3r in 2011?`:
```sql
|
SELECT "2007" FROM "doubles_performance_timeline" WHERE "2012"='2r' AND "2002"='1r'; |
## Task
Generate a SQL query to answer the following question:
`What is the 2007 value with a 2r in 2012 and 1r in 2002?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_performance_timeline" (
"tournament" text,
"1999" text,
"2002" text,
"2004" text,
"2006" text,
"2007" text,
"2010" text,
"2011" text,
"2012" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the 2007 value with a 2r in 2012 and 1r in 2002?`:
```sql
|
SELECT "2004" FROM "doubles_performance_timeline" WHERE "2011"='grand slam tournaments'; |
## Task
Generate a SQL query to answer the following question:
`What is the 2004 value in the 2011 Grand Slam Tournaments?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_performance_timeline" (
"tournament" text,
"1999" text,
"2002" text,
"2004" text,
"2006" text,
"2007" text,
"2010" text,
"2011" text,
"2012" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the 2004 value in the 2011 Grand Slam Tournaments?`:
```sql
|
SELECT "2004" FROM "doubles_performance_timeline" WHERE "2010"='sf'; |
## Task
Generate a SQL query to answer the following question:
`What is the 2004 value with a sf in 2010?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_performance_timeline" (
"tournament" text,
"1999" text,
"2002" text,
"2004" text,
"2006" text,
"2007" text,
"2010" text,
"2011" text,
"2012" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the 2004 value with a sf in 2010?`:
```sql
|
SELECT "women_s_singles" FROM "canadian_open" WHERE "year"='2002'; |
## Task
Generate a SQL query to answer the following question:
`Who played women's singles in 2002?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "canadian_open" (
"year" text,
"men_s_singles" text,
"women_s_singles" text,
"men_s_doubles" text,
"women_s_doubles" text,
"mixed_doubles" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who played women's singles in 2002?`:
```sql
|
SELECT "men_s_doubles" FROM "canadian_open" WHERE "year"='1963'; |
## Task
Generate a SQL query to answer the following question:
`Who played men's doubles in 1963?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "canadian_open" (
"year" text,
"men_s_singles" text,
"women_s_singles" text,
"men_s_doubles" text,
"women_s_doubles" text,
"mixed_doubles" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who played men's doubles in 1963?`:
```sql
|
SELECT "score" FROM "international_goals" WHERE "date"='30 january 2013'; |
## Task
Generate a SQL query to answer the following question:
`Name the score for 30 january 2013`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "international_goals" (
"goal_num" real,
"date" text,
"venue" text,
"score" text,
"result" text,
"competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the score for 30 january 2013`:
```sql
|
SELECT "result" FROM "international_goals" WHERE "goal_num">4; |
## Task
Generate a SQL query to answer the following question:
`Name the result for goal # more than 4`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "international_goals" (
"goal_num" real,
"date" text,
"venue" text,
"score" text,
"result" text,
"competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the result for goal # more than 4`:
```sql
|
SELECT "to_par" FROM "first_round" WHERE "player"='fred couples'; |
## Task
Generate a SQL query to answer the following question:
`What is Fred Couples to par?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "first_round" (
"place" text,
"player" text,
"country" text,
"score" real,
"to_par" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is Fred Couples to par?`:
```sql
|
SELECT "place" FROM "first_round" WHERE "score"<68; |
## Task
Generate a SQL query to answer the following question:
`What place has a score under 68?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "first_round" (
"place" text,
"player" text,
"country" text,
"score" real,
"to_par" text
);
### SQL
Given the database schema, here is the SQL query that answers `What place has a score under 68?`:
```sql
|
SELECT "winning_driver" FROM "other_grands_prix" WHERE "winning_constructor"='o.m.'; |
## Task
Generate a SQL query to answer the following question:
`Which driver won when o.m. was the winning constructor ?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "other_grands_prix" (
"name" text,
"circuit" text,
"date" text,
"winning_driver" text,
"winning_constructor" text,
"report" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which driver won when o.m. was the winning constructor ?`:
```sql
|
SELECT "winning_driver" FROM "other_grands_prix" WHERE "winning_constructor"='bugatti' AND "name"='boulogne grand prix'; |
## Task
Generate a SQL query to answer the following question:
`Which driver won when the winning constructor was bugatti at the Boulogne Grand Prix ?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "other_grands_prix" (
"name" text,
"circuit" text,
"date" text,
"winning_driver" text,
"winning_constructor" text,
"report" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which driver won when the winning constructor was bugatti at the Boulogne Grand Prix ?`:
```sql
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.