cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`Where did someone run a 61:32`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "men" (
  "time" text,
  "name" text,
  "nationality" text,
  "date" text,
  "event_place" text,
  "source" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where did someone run a 61:32`:
```sql
                SELECT "event_place" FROM "men" WHERE "time"='61:32';
```
## Task
Generate a SQL query to answer the following question:
`What was Derek Graham's time?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "men" (
  "time" text,
  "name" text,
  "nationality" text,
  "date" text,
  "event_place" text,
  "source" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was Derek Graham's time?`:
```sql
                SELECT "time" FROM "men" WHERE "name"='derek graham';
```
## Task
Generate a SQL query to answer the following question:
`Where did someone run a 58:33?`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "men" (
  "time" text,
  "name" text,
  "nationality" text,
  "date" text,
  "event_place" text,
  "source" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where did someone run a 58:33?`:
```sql
                SELECT "event_place" FROM "men" WHERE "time"='58:33';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the player for pick number less than 29 and mls team of chicago fire`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "round_three" (
  "pick_num" real,
  "mls_team" text,
  "player" text,
  "position" text,
  "affiliation" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the player for pick number less than 29 and mls team of chicago fire`:
```sql
                SELECT "player" FROM "round_three" WHERE "pick_num"<29 AND "mls_team"='chicago fire';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the opponents for partner of yvonne meusburger`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "doubles_2_4" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponents" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the opponents for partner of yvonne meusburger`:
```sql
                SELECT "opponents" FROM "doubles_2_4" WHERE "partner"='yvonne meusburger';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the date for opponents of raffaella bindi biljana pawlowa-dimitrova`

### Database Schema
This query will run on a database whose schema is represented in this string:

CREATE TABLE "doubles_2_4" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponents" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the date for opponents of raffaella bindi biljana pawlowa-dimitrova`:
```sql
                SELECT "date" FROM "doubles_2_4" WHERE "opponents"='raffaella bindi biljana pawlowa-dimitrova';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the highest time for heat rank of 8 and lane more than 2`

### 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 highest time for heat rank of 8 and lane more than 2`:
```sql
                SELECT MAX("time") FROM "heats" WHERE "heat_rank"=8 AND "lane">2;
```
## 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 MIN("time") FROM "heats" WHERE "swimmer"='apostolos tsagkarakis' AND "lane"<6;
```
## 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 "method" FROM "mixed_martial_arts_record" WHERE "event"='pride 33';
```
## 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 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 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 "opponent"='pittsburgh steelers';
```
## 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 "week" FROM "preseason" WHERE "record"='0-1';
```
## 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 "time" FROM "preseason" WHERE "opponent"='buffalo bills';
```
## 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 "record" FROM "preseason" WHERE "week"='hf';
```
## 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 "game_site" FROM "preseason" WHERE "week"='1';
```
## 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 "result" FROM "international_goals" WHERE "competition"='1990 world cup qualifying';
```
## 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 "international_goals" WHERE "venue"='torrance, california';
```
## 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 "score" FROM "results_and_fixtures" WHERE "type"='international friendly' AND "date"='17 august 2013';
```
## 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 "position" FROM "round_four" WHERE "mls_team"='metrostars';
```
## 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 "mls_team" FROM "round_four" WHERE "affiliation"='yale university';
```
## 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 "affiliation" FROM "round_four" WHERE "pick_num"<32;
```
## 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 "player" FROM "round_four" WHERE "position"='f';
```
## 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 "goals" FROM "player_statistics" WHERE "caps"='73';
```
## 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 "build_year" FROM "imported" WHERE "total_production"=150;
```
## 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 "power_output_k_w" FROM "imported" WHERE "total_production"=100;
```
## 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 "total_production" FROM "imported" WHERE "model"='nd5';
```
## 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 "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:
`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 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:
`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 "rider" FROM "superbike_race_1_classification" WHERE "laps"=18 AND "time"='+25.165';
```
## 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 "nationality" FROM "final" WHERE "50m_split"=29.51;
```
## 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 AVG("50m_split") FROM "final" WHERE "150m_split"='1:40.00' AND "place"<2;
```
## 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">2002;
```
## 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 "result" FROM "achievements" WHERE "year"=1999;
```
## 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 "engine" FROM "teams_and_drivers" WHERE "team"='dhg tom''s racing';
```
## 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 "team" FROM "teams_and_drivers" WHERE "driver"='toshihiro kaneishi';
```
## 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 AVG("year") FROM "television_series" WHERE "chinese_title"='敗犬女王';
```
## 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 "role" FROM "television_series" WHERE "year"=2005;
```
## 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 AVG("year") FROM "television_series" WHERE "english_title"='my queen';
```
## 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 "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:
`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 "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:
`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 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:
`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 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:
`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 "result" FROM "international_goals" WHERE "venue"='praterstadion, vienna' AND "competition"='euro 1980 qualifier';
```
## 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"='28 march 1979';
```
## 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 "score" FROM "international_goals" WHERE "date"='30 april 1977';
```
## 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 "competition"='world championships' AND "year"<2011;
```
## 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 "event" FROM "achievements" WHERE "venue"='erfurt, germany';
```
## 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 "team_nickname" FROM "current_members" WHERE "enrollment">'42,326';
```
## 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 "lost"='3';
```
## 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_against" FROM "overall" WHERE "matches"='16';
```
## 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 "points_against"='51';
```
## 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 "points_for" FROM "overall" WHERE "played_in"='total';
```
## 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 "country" FROM "club_career_stats" WHERE "team"='eurasia astana';
```
## 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 "2012"='4r' AND "2009"='a';
```
## 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 "2008" FROM "singles_performance_timeline" WHERE "2011"='olympic games';
```
## 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 "tournament" FROM "singles_performance_timeline" WHERE "2009"='atp masters series';
```
## 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 "tournament"='monte carlo masters';
```
## 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 "2011" FROM "singles_performance_timeline" WHERE "2012"='2r' AND "2010"='2r' AND "2009"='2r';
```
## 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 MAX("round") FROM "nfl_draft" WHERE "position"='running back' AND "college"='california';
```
## 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 "result" FROM "schedule" WHERE "date"='november 25, 1973';
```
## 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 "opponent" FROM "schedule" WHERE "week"=14;
```
## 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 "date" FROM "schedule" WHERE "opponent"='new orleans saints';
```
## 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 "result" FROM "schedule" WHERE "week"=4;
```
## 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 MIN("week") FROM "schedule" WHERE "result"='w 10-3';
```
## 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 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 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 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 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 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 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 "left_team" FROM "references" WHERE "name"='josh vanlandingham';
```
## 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 "name" FROM "top_goalscorers" WHERE "goals"<7 AND "rank"<7 AND "appearances">8;
```
## 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 SUM("rank") FROM "top_goalscorers" WHERE "name"='fernando cavenaghi' AND "appearances"<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 COUNT("appearances") FROM "top_goalscorers" WHERE "goals"=5 AND "rank"<7;
```
## 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 "surface" FROM "doubles_11_5_titles_6_runners_up" WHERE "partner"='vania king';
```
## 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 "partner" FROM "doubles_11_5_titles_6_runners_up" WHERE "date"='october 20, 2013';
```
## 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 "name" FROM "first_mc_intyre_final_six_system" WHERE "round"='e';
```
## 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 "name"='preliminary final';
```
## 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 "team_1" FROM "first_mc_intyre_final_six_system" WHERE "round"='3';
```
## 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 "round" FROM "first_mc_intyre_final_six_system" WHERE "match"='2nd elimination final';
```
## 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 MAX("grid") FROM "race" WHERE "driver"='alexander wurz' AND "laps"<58;
```
## 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 COUNT("laps") FROM "race" WHERE "grid"=19;
```
## 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 "winning_team"='mobilecast impul' AND "circuit"='twin ring motegi';
```
## 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 "winning_driver" FROM "race_calendar_and_results" WHERE "round"=7;
```
## 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 COUNT("total") FROM "medal_table" WHERE "gold"=3 AND "rank"<3;
```