output stringlengths 27 479 | instruction stringlengths 407 1.39k |
|---|---|
SELECT MIN("time") FROM "heats" WHERE "swimmer"='apostolos tsagkarakis' AND "lane"<6; |
## Task
Generate a SQL query to answer the following question:
`Tell me the least time for apostolos tsagkarakis for lane less than 6`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heats" (
"heat_rank" real,
"lane" real,
"swimmer" text,
"country" text,
"time" real,
"overall_rank" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the least time for apostolos tsagkarakis for lane less than 6`:
```sql
|
SELECT "method" FROM "mixed_martial_arts_record" WHERE "event"='pride 33'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the method for pride 33`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "mixed_martial_arts_record" (
"res" text,
"record" text,
"opponent" text,
"method" text,
"event" text,
"round" real,
"time" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the method for pride 33`:
```sql
|
SELECT MIN("round") FROM "mixed_martial_arts_record" WHERE "event"='total combat 15'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the lowest round for total combat 15`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "mixed_martial_arts_record" (
"res" text,
"record" text,
"opponent" text,
"method" text,
"event" text,
"round" real,
"time" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the lowest round for total combat 15`:
```sql
|
SELECT "week" FROM "preseason" WHERE "opponent"='pittsburgh steelers'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the week for pittsburgh steelers opponent`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "preseason" (
"week" text,
"date" text,
"opponent" text,
"time" text,
"game_site" text,
"result_score" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the week for pittsburgh steelers opponent`:
```sql
|
SELECT "week" FROM "preseason" WHERE "record"='0-1'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the week for record of 0-1`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "preseason" (
"week" text,
"date" text,
"opponent" text,
"time" text,
"game_site" text,
"result_score" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the week for record of 0-1`:
```sql
|
SELECT "time" FROM "preseason" WHERE "opponent"='buffalo bills'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the time for buffalo bills`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "preseason" (
"week" text,
"date" text,
"opponent" text,
"time" text,
"game_site" text,
"result_score" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the time for buffalo bills`:
```sql
|
SELECT "record" FROM "preseason" WHERE "week"='hf'; |
## Task
Generate a SQL query to answer the following question:
`Tell me thee record for week of hf`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "preseason" (
"week" text,
"date" text,
"opponent" text,
"time" text,
"game_site" text,
"result_score" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me thee record for week of hf`:
```sql
|
SELECT "game_site" FROM "preseason" WHERE "week"='1'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the game site for week of 1`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "preseason" (
"week" text,
"date" text,
"opponent" text,
"time" text,
"game_site" text,
"result_score" text,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the game site for week of 1`:
```sql
|
SELECT "result" FROM "international_goals" WHERE "competition"='1990 world cup qualifying'; |
## Task
Generate a SQL query to answer the following question:
`What was the result of the 1990 world cup qualifying competition?`
### 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 result of the 1990 world cup qualifying competition?`:
```sql
|
SELECT "score" FROM "international_goals" WHERE "venue"='torrance, california'; |
## Task
Generate a SQL query to answer the following question:
`What was the Score of the match in Torrance, California?`
### 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 Score of the match in Torrance, California?`:
```sql
|
SELECT "score" FROM "results_and_fixtures" WHERE "type"='international friendly' AND "date"='17 august 2013'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the score for international friendly 17 august 2013`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "results_and_fixtures" (
"date" text,
"result" text,
"score" text,
"type" text,
"venue" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the score for international friendly 17 august 2013`:
```sql
|
SELECT "position" FROM "round_four" WHERE "mls_team"='metrostars'; |
## Task
Generate a SQL query to answer the following question:
`What position did the MLS team metrostars pick?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_four" (
"pick_num" real,
"mls_team" text,
"player" text,
"position" text,
"affiliation" text
);
### SQL
Given the database schema, here is the SQL query that answers `What position did the MLS team metrostars pick?`:
```sql
|
SELECT "mls_team" FROM "round_four" WHERE "affiliation"='yale university'; |
## Task
Generate a SQL query to answer the following question:
`What MLS team is affiliated with yale university?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_four" (
"pick_num" real,
"mls_team" text,
"player" text,
"position" text,
"affiliation" text
);
### SQL
Given the database schema, here is the SQL query that answers `What MLS team is affiliated with yale university?`:
```sql
|
SELECT "affiliation" FROM "round_four" WHERE "pick_num"<32; |
## Task
Generate a SQL query to answer the following question:
`What affiliations have Pick #s under 32?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_four" (
"pick_num" real,
"mls_team" text,
"player" text,
"position" text,
"affiliation" text
);
### SQL
Given the database schema, here is the SQL query that answers `What affiliations have Pick #s under 32?`:
```sql
|
SELECT "player" FROM "round_four" WHERE "position"='f'; |
## Task
Generate a SQL query to answer the following question:
`What players have a position of F?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_four" (
"pick_num" real,
"mls_team" text,
"player" text,
"position" text,
"affiliation" text
);
### SQL
Given the database schema, here is the SQL query that answers `What players have a position of F?`:
```sql
|
SELECT "goals" FROM "player_statistics" WHERE "caps"='73'; |
## Task
Generate a SQL query to answer the following question:
`How many goals were scored when there were 73 caps?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "player_statistics" (
"name" text,
"national_team_career" text,
"goals" text,
"caps" text,
"average" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many goals were scored when there were 73 caps?`:
```sql
|
SELECT "build_year" FROM "imported" WHERE "total_production"=150; |
## Task
Generate a SQL query to answer the following question:
`Tell me the build year for total production of 150`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "imported" (
"model" text,
"build_year" text,
"top_speed_in_operation_km_h" real,
"power_output_k_w" text,
"total_production" real
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the build year for total production of 150`:
```sql
|
SELECT "power_output_k_w" FROM "imported" WHERE "total_production"=100; |
## Task
Generate a SQL query to answer the following question:
`Tell me the power output for total production of 100`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "imported" (
"model" text,
"build_year" text,
"top_speed_in_operation_km_h" real,
"power_output_k_w" text,
"total_production" real
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the power output for total production of 100`:
```sql
|
SELECT "total_production" FROM "imported" WHERE "model"='nd5'; |
## Task
Generate a SQL query to answer the following question:
`Name the total production for model nd5`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "imported" (
"model" text,
"build_year" text,
"transmission" text,
"top_speed_in_operation_km_h" real,
"power_output_k_w" real,
"builder_family" text,
"total_production" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the total production for model nd5`:
```sql
|
SELECT "nationality" FROM "list_of_minnesota_timberwolves_players_s" WHERE "position_s"='guard' AND "season_s"='2006'; |
## Task
Generate a SQL query to answer the following question:
`What is the nationality of the player who played guard in 2006?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_minnesota_timberwolves_players_s" (
"name" text,
"nationality" text,
"school_club" text,
"season_s" text,
"position_s" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the nationality of the player who played guard in 2006?`:
```sql
|
SELECT SUM("b_p_2nd_comp_c") FROM "ternary_azeotropes" WHERE "b_p_azeo_c"=57.5; |
## Task
Generate a SQL query to answer the following question:
`Tell me the sum of bp 2nd comp with bp azeo of 57.5`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "ternary_azeotropes" (
"2nd_component" text,
"b_p_2nd_comp_c" real,
"3rd_component" text,
"b_p_3rd_comp_c" real,
"b_p_azeo_c" real
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the sum of bp 2nd comp with bp azeo of 57.5`:
```sql
|
SELECT "rider" FROM "superbike_race_1_classification" WHERE "laps"=18 AND "time"='+25.165'; |
## Task
Generate a SQL query to answer the following question:
`Which rider went 18 laps ending +25.165 behind the leader?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "superbike_race_1_classification" (
"rider" text,
"bike" text,
"laps" real,
"time" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which rider went 18 laps ending +25.165 behind the leader?`:
```sql
|
SELECT "nationality" FROM "final" WHERE "50m_split"=29.51; |
## Task
Generate a SQL query to answer the following question:
`Which nationality has a split in the 50m of 29.51?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "final" (
"place" real,
"lane" real,
"name" text,
"nationality" text,
"50m_split" real,
"100m_split" text,
"150m_split" text,
"time" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which nationality has a split in the 50m of 29.51?`:
```sql
|
SELECT AVG("50m_split") FROM "final" WHERE "150m_split"='1:40.00' AND "place"<2; |
## Task
Generate a SQL query to answer the following question:
`Which average 50m split had a 150m split of 1:40.00, with a placing of less than 2?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "final" (
"place" real,
"lane" real,
"name" text,
"nationality" text,
"50m_split" real,
"100m_split" text,
"150m_split" text,
"time" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which average 50m split had a 150m split of 1:40.00, with a placing of less than 2?`:
```sql
|
SELECT "result" FROM "achievements" WHERE "year">2002; |
## Task
Generate a SQL query to answer the following question:
`What is the result for a year later than 2002?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "achievements" (
"year" real,
"tournament" text,
"venue" text,
"result" text,
"extra" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the result for a year later than 2002?`:
```sql
|
SELECT "result" FROM "achievements" WHERE "year"=1999; |
## Task
Generate a SQL query to answer the following question:
`What is the result for the year 1999?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "achievements" (
"year" real,
"tournament" text,
"venue" text,
"result" text,
"extra" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the result for the year 1999?`:
```sql
|
SELECT "engine" FROM "teams_and_drivers" WHERE "team"='dhg tom''s racing'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the engine for dhg tom's racing`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "teams_and_drivers" (
"team" text,
"driver" text,
"chassis" text,
"engine" text,
"rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the engine for dhg tom's racing`:
```sql
|
SELECT "team" FROM "teams_and_drivers" WHERE "driver"='toshihiro kaneishi'; |
## Task
Generate a SQL query to answer the following question:
`Name the team for toshihiro kaneishi`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "teams_and_drivers" (
"team" text,
"driver" text,
"chassis" text,
"engine" text,
"rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the team for toshihiro kaneishi`:
```sql
|
SELECT AVG("year") FROM "television_series" WHERE "chinese_title"='敗犬女王'; |
## Task
Generate a SQL query to answer the following question:
`I want the average year of 敗犬女王`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "television_series" (
"year" real,
"chinese_title" text,
"english_title" text,
"role" text,
"character" text
);
### SQL
Given the database schema, here is the SQL query that answers `I want the average year of 敗犬女王`:
```sql
|
SELECT "role" FROM "television_series" WHERE "year"=2005; |
## Task
Generate a SQL query to answer the following question:
`Tell me the role for 2005`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "television_series" (
"year" real,
"chinese_title" text,
"english_title" text,
"role" text,
"character" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the role for 2005`:
```sql
|
SELECT AVG("year") FROM "television_series" WHERE "english_title"='my queen'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the average year for my queen`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "television_series" (
"year" real,
"chinese_title" text,
"english_title" text,
"role" text,
"character" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the average year for my queen`:
```sql
|
SELECT "singles_w_l" FROM "all_players" WHERE "years_played">1 AND "highest_singles_ranking"='1346'; |
## Task
Generate a SQL query to answer the following question:
`Tell me singles W-L that has years larger than 1 and highest singles ranking of 1346`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "all_players" (
"player" text,
"highest_singles_ranking" text,
"highest_doubles_ranking" text,
"first_year_played" real,
"years_played" real,
"ties_played" real,
"total_w_l" text,
"singles_w_l" text,
"doubles_w_l" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me singles W-L that has years larger than 1 and highest singles ranking of 1346`:
```sql
|
SELECT "best_finish" FROM "lpga_tour_career_summary" WHERE "top_10s">0 AND "scoring_average"=73.04; |
## Task
Generate a SQL query to answer the following question:
`When the Top 10s is larger than 0 and the scoring average 73.04, what is the best finish?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "lpga_tour_career_summary" (
"year" real,
"tournaments_played" real,
"cuts_made" real,
"wins" real,
"top_10s" real,
"best_finish" text,
"earnings" real,
"money_list_rank" text,
"scoring_average" real,
"scoring_rank" text
);
### SQL
Given the database schema, here is the SQL query that answers `When the Top 10s is larger than 0 and the scoring average 73.04, what is the best finish?`:
```sql
|
SELECT COUNT("scoring_average") FROM "lpga_tour_career_summary" WHERE "earnings">'117,682' AND "best_finish"='t24'; |
## Task
Generate a SQL query to answer the following question:
`What is the total of scoring averages with an earnings larger than $117,682 and a best finish of T24?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "lpga_tour_career_summary" (
"year" real,
"tournaments_played" real,
"cuts_made" real,
"wins" real,
"top_10s" real,
"best_finish" text,
"earnings" real,
"money_list_rank" text,
"scoring_average" real,
"scoring_rank" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total of scoring averages with an earnings larger than $117,682 and a best finish of T24?`:
```sql
|
SELECT SUM("wins") FROM "lpga_tour_career_summary" WHERE "earnings"<'507,292' AND "money_list_rank"='183' AND "tournaments_played">3; |
## Task
Generate a SQL query to answer the following question:
`When the earnings are less than $507,292, the money list rank 183, and more than 3 tournaments are played, what is the sum of wins?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "lpga_tour_career_summary" (
"year" real,
"tournaments_played" real,
"cuts_made" real,
"wins" real,
"top_10s" real,
"best_finish" text,
"earnings" real,
"money_list_rank" text,
"scoring_average" real,
"scoring_rank" text
);
### SQL
Given the database schema, here is the SQL query that answers `When the earnings are less than $507,292, the money list rank 183, and more than 3 tournaments are played, what is the sum of wins?`:
```sql
|
SELECT "result" FROM "international_goals" WHERE "venue"='praterstadion, vienna' AND "competition"='euro 1980 qualifier'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the score of praterstadion, vienna, and competition of euro 1980 qualifier`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "international_goals" (
"date" text,
"venue" text,
"score" text,
"result" text,
"competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the score of praterstadion, vienna, and competition of euro 1980 qualifier`:
```sql
|
SELECT "score" FROM "international_goals" WHERE "date"='28 march 1979'; |
## Task
Generate a SQL query to answer the following question:
`I want the score for 28 march 1979`
### 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 `I want the score for 28 march 1979`:
```sql
|
SELECT "score" FROM "international_goals" WHERE "date"='30 april 1977'; |
## Task
Generate a SQL query to answer the following question:
`I want the score for 30 april 1977`
### 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 `I want the score for 30 april 1977`:
```sql
|
SELECT "event" FROM "achievements" WHERE "competition"='world championships' AND "year"<2011; |
## Task
Generate a SQL query to answer the following question:
`What competition was the World Championships before 2011?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "achievements" (
"year" real,
"competition" text,
"venue" text,
"position" text,
"event" text
);
### SQL
Given the database schema, here is the SQL query that answers `What competition was the World Championships before 2011?`:
```sql
|
SELECT "event" FROM "achievements" WHERE "venue"='erfurt, germany'; |
## Task
Generate a SQL query to answer the following question:
`What event took place in Erfurt, Germany?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "achievements" (
"year" real,
"competition" text,
"venue" text,
"position" text,
"event" text
);
### SQL
Given the database schema, here is the SQL query that answers `What event took place in Erfurt, Germany?`:
```sql
|
SELECT "team_nickname" FROM "current_members" WHERE "enrollment">'42,326'; |
## Task
Generate a SQL query to answer the following question:
`Name the team nickname for enrollment more than 42,326`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "current_members" (
"school" text,
"location" text,
"founded" real,
"affiliation" text,
"enrollment" real,
"team_nickname" text,
"primary_conference" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the team nickname for enrollment more than 42,326`:
```sql
|
SELECT "points_against" FROM "overall" WHERE "lost"='3'; |
## Task
Generate a SQL query to answer the following question:
`With the lost of 3, how many points?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "overall" (
"played_in" text,
"matches" text,
"lost" text,
"drawn" text,
"points_for" text,
"points_against" text
);
### SQL
Given the database schema, here is the SQL query that answers `With the lost of 3, how many points?`:
```sql
|
SELECT "points_against" FROM "overall" WHERE "matches"='16'; |
## Task
Generate a SQL query to answer the following question:
`How many against points for 16 matches?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "overall" (
"played_in" text,
"matches" text,
"lost" text,
"drawn" text,
"points_for" text,
"points_against" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many against points for 16 matches?`:
```sql
|
SELECT "points_for" FROM "overall" WHERE "points_against"='51'; |
## Task
Generate a SQL query to answer the following question:
`The 51 points against, how many are for?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "overall" (
"played_in" text,
"matches" text,
"lost" text,
"drawn" text,
"points_for" text,
"points_against" text
);
### SQL
Given the database schema, here is the SQL query that answers `The 51 points against, how many are for?`:
```sql
|
SELECT "points_for" FROM "overall" WHERE "played_in"='total'; |
## Task
Generate a SQL query to answer the following question:
`For the played in, what are the total points?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "overall" (
"played_in" text,
"matches" text,
"lost" text,
"drawn" text,
"points_for" text,
"points_against" text
);
### SQL
Given the database schema, here is the SQL query that answers `For the played in, what are the total points?`:
```sql
|
SELECT "country" FROM "club_career_stats" WHERE "team"='eurasia astana'; |
## Task
Generate a SQL query to answer the following question:
`What country is the Eurasia Astana team from?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "club_career_stats" (
"season" text,
"team" text,
"country" text,
"league" text,
"level" real,
"apps" real
);
### SQL
Given the database schema, here is the SQL query that answers `What country is the Eurasia Astana team from?`:
```sql
|
SELECT "2008" FROM "singles_performance_timeline" WHERE "2012"='4r' AND "2009"='a'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the 2008 for 2012 of 4r and 2009 of a`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_performance_timeline" (
"tournament" text,
"2008" text,
"2009" text,
"2010" text,
"2011" text,
"2012" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the 2008 for 2012 of 4r and 2009 of a`:
```sql
|
SELECT "2008" FROM "singles_performance_timeline" WHERE "2011"='olympic games'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the 2008 of 2001 olympic games`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_performance_timeline" (
"tournament" text,
"2008" text,
"2009" text,
"2010" text,
"2011" text,
"2012" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the 2008 of 2001 olympic games`:
```sql
|
SELECT "tournament" FROM "singles_performance_timeline" WHERE "2009"='atp masters series'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the tournament of 2009 of atp masters series`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_performance_timeline" (
"tournament" text,
"2008" text,
"2009" text,
"2010" text,
"2011" text,
"2012" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the tournament of 2009 of atp masters series`:
```sql
|
SELECT "2011" FROM "singles_performance_timeline" WHERE "tournament"='monte carlo masters'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the 2011 tournament of monte carlo masters`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_performance_timeline" (
"tournament" text,
"2008" text,
"2009" text,
"2010" text,
"2011" text,
"2012" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the 2011 tournament of monte carlo masters`:
```sql
|
SELECT "2011" FROM "singles_performance_timeline" WHERE "2012"='2r' AND "2010"='2r' AND "2009"='2r'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the 2011 with 2012 of 2r`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_performance_timeline" (
"tournament" text,
"2008" text,
"2009" text,
"2010" text,
"2011" text,
"2012" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the 2011 with 2012 of 2r`:
```sql
|
SELECT MAX("round") FROM "nfl_draft" WHERE "position"='running back' AND "college"='california'; |
## Task
Generate a SQL query to answer the following question:
`What was the latest round with a running back from a California college?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "nfl_draft" (
"round" real,
"pick_num" real,
"player" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the latest round with a running back from a California college?`:
```sql
|
SELECT "result" FROM "schedule" WHERE "date"='november 25, 1973'; |
## Task
Generate a SQL query to answer the following question:
`What were the results for november 25, 1973?`
### 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,
"venue" text,
"attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What were the results for november 25, 1973?`:
```sql
|
SELECT "opponent" FROM "schedule" WHERE "week"=14; |
## Task
Generate a SQL query to answer the following question:
`Which Opponent had a week of 14?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "schedule" (
"week" real,
"date" text,
"opponent" text,
"result" text,
"venue" text,
"attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Opponent had a week of 14?`:
```sql
|
SELECT "date" FROM "schedule" WHERE "opponent"='new orleans saints'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the date for new orleans saints`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "schedule" (
"week" real,
"date" text,
"opponent" text,
"result" text,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the date for new orleans saints`:
```sql
|
SELECT "result" FROM "schedule" WHERE "week"=4; |
## Task
Generate a SQL query to answer the following question:
`Tell me the result for week of 4`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "schedule" (
"week" real,
"date" text,
"opponent" text,
"result" text,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the result for week of 4`:
```sql
|
SELECT MIN("week") FROM "schedule" WHERE "result"='w 10-3'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the lowest week for w 10-3`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "schedule" (
"week" real,
"date" text,
"opponent" text,
"result" text,
"attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the lowest week for w 10-3`:
```sql
|
SELECT AVG("heat_rank") FROM "heats" WHERE "lane"=2 AND "time"<27.66; |
## Task
Generate a SQL query to answer the following question:
`Tell me the average heat rank with a lane of 2 and time less than 27.66`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heats" (
"heat_rank" real,
"lane" real,
"swimmer" text,
"country" text,
"time" real,
"overall_rank" real
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the average heat rank with a lane of 2 and time less than 27.66`:
```sql
|
SELECT MAX("overall_rank") FROM "heats" WHERE "lane"<8 AND "time"<27.16; |
## Task
Generate a SQL query to answer the following question:
`Tell me the highest overall rank for lane less than 8 and time less than 27.16`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heats" (
"heat_rank" real,
"lane" real,
"swimmer" text,
"country" text,
"time" real,
"overall_rank" real
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the highest overall rank for lane less than 8 and time less than 27.16`:
```sql
|
SELECT COUNT("time") FROM "heats" WHERE "swimmer"='luke hall' AND "overall_rank">105; |
## Task
Generate a SQL query to answer the following question:
`Tell me the total number of time for luke hall overall rank being larger than 105`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "heats" (
"heat_rank" real,
"lane" real,
"swimmer" text,
"country" text,
"time" real,
"overall_rank" real
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the total number of time for luke hall overall rank being larger than 105`:
```sql
|
SELECT "left_team" FROM "references" WHERE "name"='josh vanlandingham'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the left team for josh vanlandingham`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "references" (
"name" text,
"nationality" text,
"pos" text,
"college" text,
"season_entered" text,
"manner_of_entry" text,
"left_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the left team for josh vanlandingham`:
```sql
|
SELECT "name" FROM "top_goalscorers" WHERE "goals"<7 AND "rank"<7 AND "appearances">8; |
## Task
Generate a SQL query to answer the following question:
`Who had less than 7 goals, was ranked under 7, and had more than 8 appearances?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "top_goalscorers" (
"rank" real,
"name" text,
"team" text,
"goals" real,
"appearances" real
);
### SQL
Given the database schema, here is the SQL query that answers `Who had less than 7 goals, was ranked under 7, and had more than 8 appearances?`:
```sql
|
SELECT SUM("rank") FROM "top_goalscorers" WHERE "name"='fernando cavenaghi' AND "appearances"<7; |
## Task
Generate a SQL query to answer the following question:
`What was the sum of ranks of those called Fernando Cavenaghi who appeared less than 7.`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "top_goalscorers" (
"rank" real,
"name" text,
"team" text,
"goals" real,
"appearances" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the sum of ranks of those called Fernando Cavenaghi who appeared less than 7.`:
```sql
|
SELECT COUNT("appearances") FROM "top_goalscorers" WHERE "goals"=5 AND "rank"<7; |
## Task
Generate a SQL query to answer the following question:
`How many appearances were made by people that had 5 goals and less than 7 rank?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "top_goalscorers" (
"rank" real,
"name" text,
"team" text,
"goals" real,
"appearances" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many appearances were made by people that had 5 goals and less than 7 rank?`:
```sql
|
SELECT "surface" FROM "doubles_11_5_titles_6_runners_up" WHERE "partner"='vania king'; |
## Task
Generate a SQL query to answer the following question:
`What was the surface for the game that had a partner of vania king?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_11_5_titles_6_runners_up" (
"outcome" text,
"date" text,
"surface" text,
"partner" text,
"opponents" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the surface for the game that had a partner of vania king?`:
```sql
|
SELECT "partner" FROM "doubles_11_5_titles_6_runners_up" WHERE "date"='october 20, 2013'; |
## Task
Generate a SQL query to answer the following question:
`Who was the partner for the game on October 20, 2013?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_11_5_titles_6_runners_up" (
"outcome" text,
"date" text,
"surface" text,
"partner" text,
"opponents" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the partner for the game on October 20, 2013?`:
```sql
|
SELECT "name" FROM "first_mc_intyre_final_six_system" WHERE "round"='e'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the name for round of e`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "first_mc_intyre_final_six_system" (
"round" text,
"match" text,
"name" text,
"team_1" text,
"team_2" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the name for round of e`:
```sql
|
SELECT "team_1" FROM "first_mc_intyre_final_six_system" WHERE "name"='preliminary final'; |
## Task
Generate a SQL query to answer the following question:
`Name the team one for preliminary final`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "first_mc_intyre_final_six_system" (
"round" text,
"match" text,
"name" text,
"team_1" text,
"team_2" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the team one for preliminary final`:
```sql
|
SELECT "team_1" FROM "first_mc_intyre_final_six_system" WHERE "round"='3'; |
## Task
Generate a SQL query to answer the following question:
`Name the team 1 for round 3`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "first_mc_intyre_final_six_system" (
"round" text,
"match" text,
"name" text,
"team_1" text,
"team_2" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the team 1 for round 3`:
```sql
|
SELECT "round" FROM "first_mc_intyre_final_six_system" WHERE "match"='2nd elimination final'; |
## Task
Generate a SQL query to answer the following question:
`Name the round for 2nd elimination final`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "first_mc_intyre_final_six_system" (
"round" text,
"match" text,
"name" text,
"team_1" text,
"team_2" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the round for 2nd elimination final`:
```sql
|
SELECT MAX("grid") FROM "race" WHERE "driver"='alexander wurz' AND "laps"<58; |
## Task
Generate a SQL query to answer the following question:
`In less than 58 laps, what is the highest grid for Alexander Wurz?`
### 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 `In less than 58 laps, what is the highest grid for Alexander Wurz?`:
```sql
|
SELECT COUNT("laps") FROM "race" WHERE "grid"=19; |
## Task
Generate a SQL query to answer the following question:
`What is the total laps for grid 19?`
### 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 total laps for grid 19?`:
```sql
|
SELECT "winning_driver" FROM "race_calendar_and_results" WHERE "winning_team"='mobilecast impul' AND "circuit"='twin ring motegi'; |
## Task
Generate a SQL query to answer the following question:
`Name the winning driver for mobilecast impul and twin ring motegi`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race_calendar_and_results" (
"round" real,
"circuit" text,
"date" text,
"pole_position" text,
"fastest_lap" text,
"winning_driver" text,
"winning_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the winning driver for mobilecast impul and twin ring motegi`:
```sql
|
SELECT "winning_driver" FROM "race_calendar_and_results" WHERE "round"=7; |
## Task
Generate a SQL query to answer the following question:
`Name the winning driver for round 7`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "race_calendar_and_results" (
"round" real,
"circuit" text,
"date" text,
"pole_position" text,
"fastest_lap" text,
"winning_driver" text,
"winning_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the winning driver for round 7`:
```sql
|
SELECT COUNT("total") FROM "medal_table" WHERE "gold"=3 AND "rank"<3; |
## Task
Generate a SQL query to answer the following question:
`Name the number of total for 3 gold and rank less than 3`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "medal_table" (
"rank" real,
"nation" text,
"gold" real,
"silver" real,
"bronze" real,
"total" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the number of total for 3 gold and rank less than 3`:
```sql
|
SELECT "name" FROM "indium_111" WHERE "investigation"='thrombus imaging'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the naame of Investigation of thrombus imaging`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "indium_111" (
"name" text,
"investigation" text,
"route_of_administration" text,
"in_vitro_in_vivo" text,
"imaging_non_imaging" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the naame of Investigation of thrombus imaging`:
```sql
|
SELECT "name" FROM "indium_111" WHERE "route_of_administration"='iv' AND "investigation"='thrombus imaging'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the name for Investigation of thrombus imaging and Route of administration of iv`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "indium_111" (
"name" text,
"investigation" text,
"route_of_administration" text,
"in_vitro_in_vivo" text,
"imaging_non_imaging" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the name for Investigation of thrombus imaging and Route of administration of iv`:
```sql
|
SELECT "in_vitro_in_vivo" FROM "indium_111" WHERE "route_of_administration"='iv' AND "investigation"='somatostatin receptor imaging'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the in-vitro for Route of administration of iv and Investigation of somatostatin receptor imaging`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "indium_111" (
"name" text,
"investigation" text,
"route_of_administration" text,
"in_vitro_in_vivo" text,
"imaging_non_imaging" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the in-vitro for Route of administration of iv and Investigation of somatostatin receptor imaging`:
```sql
|
SELECT SUM("pick_num") FROM "round_two" WHERE "position"='d' AND "player"='tim regan'; |
## Task
Generate a SQL query to answer the following question:
`The player is Tim Regan and the pick # is position of d, what's the sum?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_two" (
"pick_num" real,
"mls_team" text,
"player" text,
"position" text,
"affiliation" text
);
### SQL
Given the database schema, here is the SQL query that answers `The player is Tim Regan and the pick # is position of d, what's the sum?`:
```sql
|
SELECT "position" FROM "round_two" WHERE "pick_num"=16; |
## Task
Generate a SQL query to answer the following question:
`The position that has a pick # of 16 is what?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_two" (
"pick_num" real,
"mls_team" text,
"player" text,
"position" text,
"affiliation" text
);
### SQL
Given the database schema, here is the SQL query that answers `The position that has a pick # of 16 is what?`:
```sql
|
SELECT MIN("pick_num") FROM "round_two" WHERE "player"='damani ralph'; |
## Task
Generate a SQL query to answer the following question:
`Damani Ralph is associated with which lowest pick #?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_two" (
"pick_num" real,
"mls_team" text,
"player" text,
"position" text,
"affiliation" text
);
### SQL
Given the database schema, here is the SQL query that answers `Damani Ralph is associated with which lowest pick #?`:
```sql
|
SELECT COUNT("pick_num") FROM "round_two" WHERE "mls_team"='chicago fire'; |
## Task
Generate a SQL query to answer the following question:
`Chicago fire has a total of a total of how many #s?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "round_two" (
"pick_num" real,
"mls_team" text,
"player" text,
"position" text,
"affiliation" text
);
### SQL
Given the database schema, here is the SQL query that answers `Chicago fire has a total of a total of how many #s?`:
```sql
|
SELECT "score_l_score_in_legs_s_score_in_sets" FROM "pdc_premier_event_finals_5_1_title_4_run" WHERE "year"<2012; |
## Task
Generate a SQL query to answer the following question:
`Tell me the score for score in legs and year less than 2012`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "pdc_premier_event_finals_5_1_title_4_run" (
"outcome" text,
"year" real,
"championship" text,
"opponent_in_the_final" text,
"score_l_score_in_legs_s_score_in_sets" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the score for score in legs and year less than 2012`:
```sql
|
SELECT "championship" FROM "pdc_premier_event_finals_5_1_title_4_run" WHERE "outcome"='runner-up' AND "year"=2010; |
## Task
Generate a SQL query to answer the following question:
`Tell me the championship for runner-up outcome of 2010`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "pdc_premier_event_finals_5_1_title_4_run" (
"outcome" text,
"year" real,
"championship" text,
"opponent_in_the_final" text,
"score_l_score_in_legs_s_score_in_sets" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the championship for runner-up outcome of 2010`:
```sql
|
SELECT "outcome" FROM "pdc_premier_event_finals_5_1_title_4_run" WHERE "championship"='premier league darts'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the outcome for premier league darts`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "pdc_premier_event_finals_5_1_title_4_run" (
"outcome" text,
"year" real,
"championship" text,
"opponent_in_the_final" text,
"score_l_score_in_legs_s_score_in_sets" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the outcome for premier league darts`:
```sql
|
SELECT SUM("year") FROM "pdc_premier_event_finals_5_1_title_4_run" WHERE "outcome"='runner-up' AND "championship"='world darts championship'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the sum of Year for outcome of runner-up for world darts championship`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "pdc_premier_event_finals_5_1_title_4_run" (
"outcome" text,
"year" real,
"championship" text,
"opponent_in_the_final" text,
"score_l_score_in_legs_s_score_in_sets" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the sum of Year for outcome of runner-up for world darts championship`:
```sql
|
SELECT COUNT("points_won") FROM "solheim_cup_record" WHERE "year"='2007' AND "total_matches">5; |
## Task
Generate a SQL query to answer the following question:
`In 2007, how many points were won when more than 5 matches were played?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "solheim_cup_record" (
"year" text,
"total_matches" real,
"total_w_l_h" text,
"singles_w_l_h" text,
"points_won" real,
"points_pct" real
);
### SQL
Given the database schema, here is the SQL query that answers `In 2007, how many points were won when more than 5 matches were played?`:
```sql
|
SELECT AVG("total_matches") FROM "solheim_cup_record" WHERE "points_pct">33.3 AND "year"='2007'; |
## Task
Generate a SQL query to answer the following question:
`In 2007, what is the average total matches with points % larger than 33.3?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "solheim_cup_record" (
"year" text,
"total_matches" real,
"total_w_l_h" text,
"singles_w_l_h" text,
"points_won" real,
"points_pct" real
);
### SQL
Given the database schema, here is the SQL query that answers `In 2007, what is the average total matches with points % larger than 33.3?`:
```sql
|
SELECT "player" FROM "s" WHERE "school_club_team"='georgia tech'; |
## Task
Generate a SQL query to answer the following question:
`Which player attended school at Georgia Tech?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "s" (
"player" text,
"nationality" text,
"position" text,
"years_in_toronto" text,
"school_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which player attended school at Georgia Tech?`:
```sql
|
SELECT "position" FROM "s" WHERE "player"='ed stokes'; |
## Task
Generate a SQL query to answer the following question:
`What position does Ed Stokes hold?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "s" (
"player" text,
"nationality" text,
"position" text,
"years_in_toronto" text,
"school_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `What position does Ed Stokes hold?`:
```sql
|
SELECT "school_club_team" FROM "s" WHERE "player"='michael stewart'; |
## Task
Generate a SQL query to answer the following question:
`What is Michael Stewart's school or club team?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "s" (
"player" text,
"nationality" text,
"position" text,
"years_in_toronto" text,
"school_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is Michael Stewart's school or club team?`:
```sql
|
SELECT "tournament" FROM "doubles_8_10" WHERE "date"='may 29, 2010'; |
## Task
Generate a SQL query to answer the following question:
`What tournament was played on May 29, 2010?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_8_10" (
"outcome" text,
"date" text,
"tournament" text,
"surface" text,
"partner" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What tournament was played on May 29, 2010?`:
```sql
|
SELECT "surface" FROM "doubles_8_10" WHERE "partner"='paula ormaechea'; |
## Task
Generate a SQL query to answer the following question:
`What was the surface made of in the contest where Paula Ormaechea was the partner?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "doubles_8_10" (
"outcome" text,
"date" text,
"tournament" text,
"surface" text,
"partner" text,
"opponent_in_the_final" text,
"score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the surface made of in the contest where Paula Ormaechea was the partner?`:
```sql
|
SELECT COUNT("year") FROM "24_hours_of_le_mans_results" WHERE "class_pos"='3rd' AND "laps">353; |
## Task
Generate a SQL query to answer the following question:
`Tell me the total number of year for class pos of 3rd and laps larger than 353`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "24_hours_of_le_mans_results" (
"year" real,
"team" text,
"co_drivers" text,
"class" text,
"laps" real,
"pos" text,
"class_pos" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the total number of year for class pos of 3rd and laps larger than 353`:
```sql
|
SELECT "method" FROM "mixed_martial_arts_record" WHERE "record"='4-2'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the method with a record of 4-2`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "mixed_martial_arts_record" (
"res" text,
"record" text,
"opponent" text,
"method" text,
"event" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the method with a record of 4-2`:
```sql
|
SELECT "record" FROM "mixed_martial_arts_record" WHERE "opponent"='yukiya naito'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the record for yukiya naito`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "mixed_martial_arts_record" (
"res" text,
"record" text,
"opponent" text,
"method" text,
"event" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the record for yukiya naito`:
```sql
|
SELECT "record" FROM "mixed_martial_arts_record" WHERE "opponent"='kazuhiro nakamura'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the record for kazuhiro nakamura`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "mixed_martial_arts_record" (
"res" text,
"record" text,
"opponent" text,
"method" text,
"event" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the record for kazuhiro nakamura`:
```sql
|
SELECT "method" FROM "mixed_martial_arts_record" WHERE "opponent"='stanislav nuschik'; |
## Task
Generate a SQL query to answer the following question:
`Tell me the method for stanislav nuschik`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "mixed_martial_arts_record" (
"res" text,
"record" text,
"opponent" text,
"method" text,
"event" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the method for stanislav nuschik`:
```sql
|
SELECT "res" FROM "mixed_martial_arts_record" WHERE "event"='ifl: los angeles'; |
## Task
Generate a SQL query to answer the following question:
`What was the Result of IFL: Los Angeles?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "mixed_martial_arts_record" (
"res" text,
"record" text,
"opponent" text,
"method" text,
"event" text,
"round" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the Result of IFL: Los Angeles?`:
```sql
|
SELECT "event" FROM "mixed_martial_arts_record" WHERE "res"='win' AND "opponent"='shane ott'; |
## Task
Generate a SQL query to answer the following question:
`Which Event resulted in a Win for Opponent, Shane Ott?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "mixed_martial_arts_record" (
"res" text,
"record" text,
"opponent" text,
"method" text,
"event" text,
"round" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Event resulted in a Win for Opponent, Shane Ott?`:
```sql
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.