output stringlengths 27 479 | instruction stringlengths 407 1.39k |
|---|---|
SELECT SUM("year") FROM "biggest_wins" WHERE "opponent"='penrith panthers'; |
## Task
Generate a SQL query to answer the following question:
`Name the sum of year for penrith panthers opponent`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "biggest_wins" (
"margin" real,
"score" text,
"opponent" text,
"venue" text,
"year" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the sum of year for penrith panthers opponent`:
```sql
|
SELECT "opponent" FROM "biggest_wins" WHERE "venue"='mt smart stadium' AND "year"=1996; |
## Task
Generate a SQL query to answer the following question:
`Name the opponent for 1996 at the mt smart stadium venue`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "biggest_wins" (
"margin" real,
"score" text,
"opponent" text,
"venue" text,
"year" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the opponent for 1996 at the mt smart stadium venue`:
```sql
|
SELECT AVG("year") FROM "biggest_wins" WHERE "margin"=46; |
## Task
Generate a SQL query to answer the following question:
`Name the average year for 46 margin`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "biggest_wins" (
"margin" real,
"score" text,
"opponent" text,
"venue" text,
"year" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the average year for 46 margin`:
```sql
|
SELECT "margin" FROM "biggest_wins" WHERE "year"=2002; |
## Task
Generate a SQL query to answer the following question:
`Name the margin for 2002`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "biggest_wins" (
"margin" real,
"score" text,
"opponent" text,
"venue" text,
"year" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the margin for 2002`:
```sql
|
SELECT "mixed_doubles" FROM "past_winners" WHERE "women_s_singles"='tracey hallam'; |
## Task
Generate a SQL query to answer the following question:
`Who participated in the Mixed Doubles when Tracey Hallam participated in the Women's Singles?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "past_winners" (
"year" real,
"men_s_singles" text,
"women_s_singles" text,
"women_s_doubles" text,
"mixed_doubles" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who participated in the Mixed Doubles when Tracey Hallam participated in the Women's Singles?`:
```sql
|
SELECT "mixed_doubles" FROM "past_winners" WHERE "men_s_singles"='simon santoso' AND "year">2008; |
## Task
Generate a SQL query to answer the following question:
`Who participated in the Mixed Doubles when Simon Santoso participated in the Men's Singles after 2008?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "past_winners" (
"year" real,
"men_s_singles" text,
"women_s_singles" text,
"women_s_doubles" text,
"mixed_doubles" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who participated in the Mixed Doubles when Simon Santoso participated in the Men's Singles after 2008?`:
```sql
|
SELECT "affiliation" FROM "private_schools" WHERE "enrollment">502; |
## Task
Generate a SQL query to answer the following question:
`Which Affiliation has an Enrollement larger than 502?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "private_schools" (
"school" text,
"grades" text,
"affiliation" text,
"student_body" text,
"enrollment" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Affiliation has an Enrollement larger than 502?`:
```sql
|
SELECT "school" FROM "private_schools" WHERE "enrollment"<301; |
## Task
Generate a SQL query to answer the following question:
`What School has an Enrollement smaller than 301?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "private_schools" (
"school" text,
"grades" text,
"affiliation" text,
"student_body" text,
"enrollment" real
);
### SQL
Given the database schema, here is the SQL query that answers `What School has an Enrollement smaller than 301?`:
```sql
|
SELECT "grades" FROM "private_schools" WHERE "enrollment">443 AND "student_body"='co-ed'; |
## Task
Generate a SQL query to answer the following question:
`Which Grades has an Enrollment larger htan 443 with a Student body of Co-ed?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "private_schools" (
"school" text,
"grades" text,
"affiliation" text,
"student_body" text,
"enrollment" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Grades has an Enrollment larger htan 443 with a Student body of Co-ed?`:
```sql
|
SELECT "student_body" FROM "private_schools" WHERE "affiliation"='roman catholic' AND "enrollment"=502; |
## Task
Generate a SQL query to answer the following question:
`What's the Student Body with an Affiliation of Roman Catholic and has an Enrollment of 502?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "private_schools" (
"school" text,
"grades" text,
"affiliation" text,
"student_body" text,
"enrollment" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the Student Body with an Affiliation of Roman Catholic and has an Enrollment of 502?`:
```sql
|
SELECT AVG("year") FROM "grand_tour_finishers" WHERE "final_position_tour"=54 AND "final_position_vuelta">55; |
## Task
Generate a SQL query to answer the following question:
`What is the average year that has a final Tour position of 54 and a final Vuelta position over 55?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "grand_tour_finishers" (
"rider" text,
"year" real,
"final_position_giro" real,
"final_position_tour" real,
"final_position_vuelta" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average year that has a final Tour position of 54 and a final Vuelta position over 55?`:
```sql
|
SELECT "final_position_vuelta" FROM "grand_tour_finishers" WHERE "final_position_giro">39 AND "final_position_tour"=90; |
## Task
Generate a SQL query to answer the following question:
`What is the final Vuelta position associated with a final Giro position over 39 and a final Tour position of 90?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "grand_tour_finishers" (
"rider" text,
"year" real,
"final_position_giro" real,
"final_position_tour" real,
"final_position_vuelta" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the final Vuelta position associated with a final Giro position over 39 and a final Tour position of 90?`:
```sql
|
SELECT COUNT("final_position_giro") FROM "grand_tour_finishers" WHERE "year"=1971 AND "final_position_tour">50; |
## Task
Generate a SQL query to answer the following question:
`How many Giro positions are associated with the year 1971 and Tour final positions over 50?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "grand_tour_finishers" (
"rider" text,
"year" real,
"final_position_giro" real,
"final_position_tour" real,
"final_position_vuelta" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many Giro positions are associated with the year 1971 and Tour final positions over 50?`:
```sql
|
SELECT SUM("laps") FROM "250cc_classification" WHERE "rider"='alex baldolini'; |
## Task
Generate a SQL query to answer the following question:
`How many laps did the rider Alex Baldolini take?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "250cc_classification" (
"rider" text,
"manufacturer" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many laps did the rider Alex Baldolini take?`:
```sql
|
SELECT COUNT("laps") FROM "250cc_classification" WHERE "time_retired"='+7.213' AND "grid">7; |
## Task
Generate a SQL query to answer the following question:
`How many laps were completed in the time of +7.213 with a grid number larger than 7?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "250cc_classification" (
"rider" text,
"manufacturer" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many laps were completed in the time of +7.213 with a grid number larger than 7?`:
```sql
|
SELECT COUNT("laps") FROM "250cc_classification" WHERE "manufacturer"='ktm' AND "time_retired"='+3.578' AND "grid">4; |
## Task
Generate a SQL query to answer the following question:
`What is total number of laps for bikes manufactured by KTM with a time of +3.578 and a grid number larger than 4?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "250cc_classification" (
"rider" text,
"manufacturer" text,
"laps" real,
"time_retired" text,
"grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is total number of laps for bikes manufactured by KTM with a time of +3.578 and a grid number larger than 4?`:
```sql
|
SELECT "surface" FROM "atp_challenger_tour_and_itf_futures_doub" WHERE "date"='may 10, 2009'; |
## Task
Generate a SQL query to answer the following question:
`What was the surface for the May 10, 2009 tournament?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "atp_challenger_tour_and_itf_futures_doub" (
"date" text,
"tournament" 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 May 10, 2009 tournament?`:
```sql
|
SELECT "co_drivers" FROM "24_hours_of_le_mans_results" WHERE "laps"<282 AND "tyres"='p'; |
## Task
Generate a SQL query to answer the following question:
`Which co-driver has fewer than 282 laps and type P tyres?`
### 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,
"class" text,
"tyres" text,
"team" text,
"co_drivers" text,
"laps" real,
"pos" text,
"class_pos" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which co-driver has fewer than 282 laps and type P tyres?`:
```sql
|
SELECT "class" FROM "24_hours_of_le_mans_results" WHERE "tyres"='g' AND "year">1988; |
## Task
Generate a SQL query to answer the following question:
`Which class more recent than 1988 has G tyres?`
### 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,
"class" text,
"tyres" text,
"team" text,
"co_drivers" text,
"laps" real,
"pos" text,
"class_pos" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which class more recent than 1988 has G tyres?`:
```sql
|
SELECT MAX("caps") FROM "internationally_capped_players" WHERE "player"='bruce djite'; |
## Task
Generate a SQL query to answer the following question:
`What is the greatest number of caps for Bruce Djite?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "internationally_capped_players" (
"player" text,
"country" text,
"caps" real,
"goals" text,
"years_active" text,
"years_at_club" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the greatest number of caps for Bruce Djite?`:
```sql
|
SELECT "goals" FROM "internationally_capped_players" WHERE "player"='eugene galeković'; |
## Task
Generate a SQL query to answer the following question:
`How many goals were scored by Eugene Galeković?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "internationally_capped_players" (
"player" text,
"country" text,
"caps" real,
"goals" text,
"years_active" text,
"years_at_club" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many goals were scored by Eugene Galeković?`:
```sql
|
SELECT "goals" FROM "internationally_capped_players" WHERE "caps">16; |
## Task
Generate a SQL query to answer the following question:
`How many goals were scored by players with more than 16 caps?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "internationally_capped_players" (
"player" text,
"country" text,
"caps" real,
"goals" text,
"years_active" text,
"years_at_club" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many goals were scored by players with more than 16 caps?`:
```sql
|
SELECT MAX("rank") FROM "semifinal_2" WHERE "nationality"='netherlands'; |
## Task
Generate a SQL query to answer the following question:
`What is the highest place of a swimmer from the Netherlands?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "semifinal_2" (
"rank" real,
"lane" real,
"name" text,
"nationality" text,
"time" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest place of a swimmer from the Netherlands?`:
```sql
|
SELECT "authority" FROM "waikato_district" WHERE "roll"<254 AND "decile"='8' AND "area"='te akau'; |
## Task
Generate a SQL query to answer the following question:
`Name the authority for te akau with roll less than 254 and decile of 8`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "waikato_district" (
"name" text,
"years" text,
"gender" text,
"area" text,
"authority" text,
"decile" text,
"roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the authority for te akau with roll less than 254 and decile of 8`:
```sql
|
SELECT "name" FROM "waikato_district" WHERE "decile"='6' AND "roll"=93; |
## Task
Generate a SQL query to answer the following question:
`Tell me the name with decile of 6 and roll of 93`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "waikato_district" (
"name" text,
"years" text,
"gender" text,
"area" text,
"authority" text,
"decile" text,
"roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the name with decile of 6 and roll of 93`:
```sql
|
SELECT "result" FROM "international_goals" WHERE "date"='january 26, 2006'; |
## Task
Generate a SQL query to answer the following question:
`What is the result of the match on January 26, 2006?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "international_goals" (
"goal" real,
"date" text,
"venue" text,
"score" text,
"result" text,
"competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the result of the match on January 26, 2006?`:
```sql
|
SELECT "bluetooth" FROM "specifications" WHERE "launch_year">2004 AND "rom_mi_b"=128 AND "wi_fi"='802.11b'; |
## Task
Generate a SQL query to answer the following question:
`What was the status of Bluetooth for the model that launched after 2004 with a ROM (MiB) of 128 and a Wifi of 802.11b?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "specifications" (
"model" text,
"launch_year" real,
"ram_mi_b" real,
"rom_mi_b" real,
"slots" text,
"wi_fi" text,
"bluetooth" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the status of Bluetooth for the model that launched after 2004 with a ROM (MiB) of 128 and a Wifi of 802.11b?`:
```sql
|
SELECT "ram_mi_b" FROM "specifications" WHERE "model"='x30 mid-range'; |
## Task
Generate a SQL query to answer the following question:
`What is the RAM (MiB) value for the X30 Mid-Range model?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "specifications" (
"model" text,
"launch_year" real,
"ram_mi_b" real,
"rom_mi_b" real,
"slots" text,
"wi_fi" text,
"bluetooth" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the RAM (MiB) value for the X30 Mid-Range model?`:
```sql
|
SELECT SUM("points") FROM "regular_season" WHERE "games">68 AND "tied"='4' AND "goals_against">272; |
## Task
Generate a SQL query to answer the following question:
`How many points did the team with more than 68 games, 4 ties, and more than 272 goals against have?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "regular_season" (
"season" text,
"games" real,
"lost" real,
"tied" text,
"points" real,
"goals_for" real,
"goals_against" real,
"standing" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many points did the team with more than 68 games, 4 ties, and more than 272 goals against have?`:
```sql
|
SELECT "event" FROM "short_course_25_meter_pool" WHERE "time"='45.74'; |
## Task
Generate a SQL query to answer the following question:
`Which event had the time 45.74?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "short_course_25_meter_pool" (
"event" text,
"time" text,
"venue" text,
"date" text,
"notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which event had the time 45.74?`:
```sql
|
SELECT "time" FROM "short_course_25_meter_pool" WHERE "date"='december 15, 2010'; |
## Task
Generate a SQL query to answer the following question:
`What was the time of December 15, 2010?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "short_course_25_meter_pool" (
"event" text,
"time" text,
"venue" text,
"date" text,
"notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the time of December 15, 2010?`:
```sql
|
SELECT "notes" FROM "short_course_25_meter_pool" WHERE "time"='45.74'; |
## Task
Generate a SQL query to answer the following question:
`What were the notes for the time 45.74?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "short_course_25_meter_pool" (
"event" text,
"time" text,
"venue" text,
"date" text,
"notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What were the notes for the time 45.74?`:
```sql
|
SELECT "player" FROM "2008_squad_statistics" WHERE "tries"=23; |
## Task
Generate a SQL query to answer the following question:
`What Player has 23 Tries?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2008_squad_statistics" (
"player" text,
"position" text,
"previous_club" text,
"apps" real,
"tries" real,
"goals" text,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What Player has 23 Tries?`:
```sql
|
SELECT "goals" FROM "2008_squad_statistics" WHERE "player"='matt cook'; |
## Task
Generate a SQL query to answer the following question:
`How many Goals did Matt Cook have?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2008_squad_statistics" (
"player" text,
"position" text,
"previous_club" text,
"apps" real,
"tries" real,
"goals" text,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many Goals did Matt Cook have?`:
```sql
|
SELECT "player" FROM "2008_squad_statistics" WHERE "position"='full back' AND "apps"=0; |
## Task
Generate a SQL query to answer the following question:
`What Full Back Player has 0 Apps?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2008_squad_statistics" (
"player" text,
"position" text,
"previous_club" text,
"apps" real,
"tries" real,
"goals" text,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What Full Back Player has 0 Apps?`:
```sql
|
SELECT "position" FROM "2008_squad_statistics" WHERE "goals"='0' AND "tries"<1 AND "player"='matt james'; |
## Task
Generate a SQL query to answer the following question:
`With 0 Goals and less than 1 Tries, what is Matt James position?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2008_squad_statistics" (
"player" text,
"position" text,
"previous_club" text,
"apps" real,
"tries" real,
"goals" text,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `With 0 Goals and less than 1 Tries, what is Matt James position?`:
```sql
|
SELECT MIN("round") FROM "january_secondary_phase" WHERE "school"='university of southern california'; |
## Task
Generate a SQL query to answer the following question:
`What is the earliest round drafted for a University of Southern California player?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "january_secondary_phase" (
"round" real,
"name" text,
"position" text,
"school" text,
"signed" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the earliest round drafted for a University of Southern California player?`:
```sql
|
SELECT COUNT("round") FROM "january_secondary_phase" WHERE "position"='1b' AND "signed"='no cardinals - 1969 june'; |
## Task
Generate a SQL query to answer the following question:
`What round drafted was the 1b and a Signed of no cardinals - 1969 june?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "january_secondary_phase" (
"round" real,
"name" text,
"position" text,
"school" text,
"signed" text
);
### SQL
Given the database schema, here is the SQL query that answers `What round drafted was the 1b and a Signed of no cardinals - 1969 june?`:
```sql
|
SELECT "event" FROM "mixed_martial_arts_record" WHERE "opponent"='akihiro gono' AND "method"='decision'; |
## Task
Generate a SQL query to answer the following question:
`Which event has an Opponent of akihiro gono, and a Method of decision?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "mixed_martial_arts_record" (
"res" text,
"record" text,
"opponent" text,
"method" text,
"event" text,
"round" real,
"time" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which event has an Opponent of akihiro gono, and a Method of decision?`:
```sql
|
SELECT "location" FROM "mixed_martial_arts_record" WHERE "opponent"='masanori suda'; |
## Task
Generate a SQL query to answer the following question:
`Which location has an Opponent of masanori suda?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "mixed_martial_arts_record" (
"res" text,
"record" text,
"opponent" text,
"method" text,
"event" text,
"round" real,
"time" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which location has an Opponent of masanori suda?`:
```sql
|
SELECT "opponent" FROM "mixed_martial_arts_record" WHERE "time"='1:34'; |
## Task
Generate a SQL query to answer the following question:
`Which opponent has a Time of 1:34?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "mixed_martial_arts_record" (
"res" text,
"record" text,
"opponent" text,
"method" text,
"event" text,
"round" real,
"time" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which opponent has a Time of 1:34?`:
```sql
|
SELECT "event" FROM "mixed_martial_arts_record" WHERE "res"='loss' AND "opponent"='maurice smith'; |
## Task
Generate a SQL query to answer the following question:
`Which event resulted in loss with an Opponent of maurice smith?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "mixed_martial_arts_record" (
"res" text,
"record" text,
"opponent" text,
"method" text,
"event" text,
"round" real,
"time" text,
"location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which event resulted in loss with an Opponent of maurice smith?`:
```sql
|
SELECT "gold" FROM "changes_in_medal_standings" WHERE "bronze"='↓ 1' AND "sport"='cycling'; |
## Task
Generate a SQL query to answer the following question:
`What is the winner of gold that also has ↓ 1 in the sport of cycling?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "changes_in_medal_standings" (
"sport" text,
"event" text,
"nation" text,
"gold" text,
"silver" text,
"bronze" text,
"total" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the winner of gold that also has ↓ 1 in the sport of cycling?`:
```sql
|
SELECT MAX("year") FROM "complete_24_hours_of_le_mans_results" WHERE "team"='gulf racing middle east'; |
## Task
Generate a SQL query to answer the following question:
`What is the most recent year that Gulf Racing Middle East won?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "complete_24_hours_of_le_mans_results" (
"year" real,
"team" text,
"co_drivers" text,
"class" text,
"pos" text,
"class_pos" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the most recent year that Gulf Racing Middle East won?`:
```sql
|
SELECT "class" FROM "complete_24_hours_of_le_mans_results" WHERE "co_drivers"='emanuele pirro jj lehto'; |
## Task
Generate a SQL query to answer the following question:
`What is the class of the co-driver emanuele pirro jj lehto?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "complete_24_hours_of_le_mans_results" (
"year" real,
"team" text,
"co_drivers" text,
"class" text,
"pos" text,
"class_pos" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the class of the co-driver emanuele pirro jj lehto?`:
```sql
|
SELECT "pos" FROM "complete_24_hours_of_le_mans_results" WHERE "team"='arena motorsports international'; |
## Task
Generate a SQL query to answer the following question:
`What was the final position of Arena Motorsports International?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "complete_24_hours_of_le_mans_results" (
"year" real,
"team" text,
"co_drivers" text,
"class" text,
"pos" text,
"class_pos" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the final position of Arena Motorsports International?`:
```sql
|
SELECT "co_drivers" FROM "complete_24_hours_of_le_mans_results" WHERE "year"=1992; |
## Task
Generate a SQL query to answer the following question:
`Who was the Co-Driver of the winner of 1992's race?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "complete_24_hours_of_le_mans_results" (
"year" real,
"team" text,
"co_drivers" text,
"class" text,
"pos" text,
"class_pos" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the Co-Driver of the winner of 1992's race?`:
```sql
|
SELECT "score_in_the_final" FROM "singles_5_3_titles_2_runner_ups" WHERE "outcome"='runner-up' AND "surface"='hard (i)'; |
## Task
Generate a SQL query to answer the following question:
`What is the score in the final with runner-up as the outcome and hard (i) as the surface?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "singles_5_3_titles_2_runner_ups" (
"outcome" text,
"date" text,
"surface" text,
"opponent_in_the_final" text,
"score_in_the_final" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the score in the final with runner-up as the outcome and hard (i) as the surface?`:
```sql
|
SELECT "team_1" FROM "second_round" WHERE "2nd_leg"='1-3' AND "team_2"='asec mimosas'; |
## Task
Generate a SQL query to answer the following question:
`Who is team 1 when 2nd leg score is 1-3 and Asec Mimosas is Team 2?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "second_round" (
"team_1" text,
"agg" text,
"team_2" text,
"1st_leg" text,
"2nd_leg" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is team 1 when 2nd leg score is 1-3 and Asec Mimosas is Team 2?`:
```sql
|
SELECT "1st_leg" FROM "second_round" WHERE "2nd_leg"='3-3'; |
## Task
Generate a SQL query to answer the following question:
`What is the 1st leg score when 2nd leg score is 3-3?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "second_round" (
"team_1" text,
"agg" text,
"team_2" text,
"1st_leg" text,
"2nd_leg" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the 1st leg score when 2nd leg score is 3-3?`:
```sql
|
SELECT "1st_leg" FROM "second_round" WHERE "team_1"='us mbila nzambi'; |
## Task
Generate a SQL query to answer the following question:
`What is the 1st leg score when US Mbila Nzambi is team 1?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "second_round" (
"team_1" text,
"agg" text,
"team_2" text,
"1st_leg" text,
"2nd_leg" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the 1st leg score when US Mbila Nzambi is team 1?`:
```sql
|
SELECT "opponent" FROM "game_log" WHERE "date"='may 20'; |
## Task
Generate a SQL query to answer the following question:
`Who was the opponent on May 20?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the opponent on May 20?`:
```sql
|
SELECT "loss" FROM "game_log" WHERE "date"='may 25'; |
## Task
Generate a SQL query to answer the following question:
`Who took the loss on May 25?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who took the loss on May 25?`:
```sql
|
SELECT "record" FROM "game_log" WHERE "score"='2-3'; |
## Task
Generate a SQL query to answer the following question:
`What was the record after the game that ended in a 2-3 loss?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the record after the game that ended in a 2-3 loss?`:
```sql
|
SELECT "date" FROM "game_log" WHERE "loss"='politte (0-2)'; |
## Task
Generate a SQL query to answer the following question:
`What was the date of the game that had a loss of Politte (0-2)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the date of the game that had a loss of Politte (0-2)?`:
```sql
|
SELECT "opponent" FROM "game_log" WHERE "loss"='hendrickson (0-1)'; |
## Task
Generate a SQL query to answer the following question:
`Who was the opponent at the game that had a loss of Hendrickson (0-1)?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the opponent at the game that had a loss of Hendrickson (0-1)?`:
```sql
|
SELECT MIN("attendance") FROM "game_log" WHERE "record"='7-15'; |
## Task
Generate a SQL query to answer the following question:
`What was the smallest attendance at a game when the record was 7-15?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the smallest attendance at a game when the record was 7-15?`:
```sql
|
SELECT AVG("attendance") FROM "game_log" WHERE "record"='6-13'; |
## Task
Generate a SQL query to answer the following question:
`What was the average attendance at a game when the record was 6-13?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the average attendance at a game when the record was 6-13?`:
```sql
|
SELECT SUM("yield_neutrons_per_fission") FROM "principle" WHERE "decay_constant_s_1"<0.301 AND "half_life_s"=22.72 AND "group">2; |
## Task
Generate a SQL query to answer the following question:
`What is the yield, neutrons per fission of the group with decay constants less than 0.301, a half-life of 22.72, and a group number larger than 2?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "principle" (
"group" real,
"half_life_s" real,
"decay_constant_s_1" real,
"yield_neutrons_per_fission" real,
"fraction" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the yield, neutrons per fission of the group with decay constants less than 0.301, a half-life of 22.72, and a group number larger than 2?`:
```sql
|
SELECT COUNT("decay_constant_s_1") FROM "principle" WHERE "half_life_s"<22.72 AND "yield_neutrons_per_fission"=0.0031000000000000003 AND "group"<3; |
## Task
Generate a SQL query to answer the following question:
`What is the decay constant with a half-life less than 22.72, a yield, neutrons per fission of 0.0031000000000000003, and a group number less than 3?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "principle" (
"group" real,
"half_life_s" real,
"decay_constant_s_1" real,
"yield_neutrons_per_fission" real,
"fraction" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the decay constant with a half-life less than 22.72, a yield, neutrons per fission of 0.0031000000000000003, and a group number less than 3?`:
```sql
|
SELECT MIN("half_life_s") FROM "principle" WHERE "yield_neutrons_per_fission">0.0031000000000000003 AND "decay_constant_s_1"<0.030500000000000003; |
## Task
Generate a SQL query to answer the following question:
`What is the lowest half-life with a yield, neutrons per fission bigger than 0.0031000000000000003 and a decay constant less than 0.030500000000000003?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "principle" (
"group" real,
"half_life_s" real,
"decay_constant_s_1" real,
"yield_neutrons_per_fission" real,
"fraction" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest half-life with a yield, neutrons per fission bigger than 0.0031000000000000003 and a decay constant less than 0.030500000000000003?`:
```sql
|
SELECT MAX("overall") FROM "indianapolis_colts_draft_history" WHERE "round"=3 AND "pick_num">10; |
## Task
Generate a SQL query to answer the following question:
`With Round 3 and Pick # over 10, what is the higher Overall number?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "indianapolis_colts_draft_history" (
"round" real,
"pick_num" real,
"overall" real,
"name" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `With Round 3 and Pick # over 10, what is the higher Overall number?`:
```sql
|
SELECT MAX("round") FROM "indianapolis_colts_draft_history" WHERE "college"='nebraska' AND "overall"<190; |
## Task
Generate a SQL query to answer the following question:
`What is the highest round for College of Nebraska if the Overall is under 190?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "indianapolis_colts_draft_history" (
"round" real,
"pick_num" real,
"overall" real,
"name" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest round for College of Nebraska if the Overall is under 190?`:
```sql
|
SELECT "college" FROM "indianapolis_colts_draft_history" WHERE "pick_num"=1 AND "overall">1 AND "round"=7; |
## Task
Generate a SQL query to answer the following question:
`Which college has a Pick # 1, Overall more than one, and Round is 7?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "indianapolis_colts_draft_history" (
"round" real,
"pick_num" real,
"overall" real,
"name" text,
"position" text,
"college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which college has a Pick # 1, Overall more than one, and Round is 7?`:
```sql
|
SELECT SUM("attendance") FROM "fa_premier_league" WHERE "date"='21 august 2004'; |
## Task
Generate a SQL query to answer the following question:
`What was the attendance on 21 August 2004?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "fa_premier_league" (
"date" text,
"opponents" text,
"result_f_a" text,
"attendance" real,
"league_position" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the attendance on 21 August 2004?`:
```sql
|
SELECT AVG("rank") FROM "semifinal_2" WHERE "time">53.38; |
## Task
Generate a SQL query to answer the following question:
`What is the average rank of an athlete that holds a time higher than 53.38?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "semifinal_2" (
"rank" real,
"lane" real,
"name" text,
"nationality" text,
"time" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average rank of an athlete that holds a time higher than 53.38?`:
```sql
|
SELECT MAX("lane") FROM "semifinal_2" WHERE "time"=52.84; |
## Task
Generate a SQL query to answer the following question:
`What lane did the swimmer with a time of 52.84 have?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "semifinal_2" (
"rank" real,
"lane" real,
"name" text,
"nationality" text,
"time" real
);
### SQL
Given the database schema, here is the SQL query that answers `What lane did the swimmer with a time of 52.84 have?`:
```sql
|
SELECT MAX("lane") FROM "semifinal_2" WHERE "rank"=3; |
## Task
Generate a SQL query to answer the following question:
`What lane did the rank 3 swimmer use?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "semifinal_2" (
"rank" real,
"lane" real,
"name" text,
"nationality" text,
"time" real
);
### SQL
Given the database schema, here is the SQL query that answers `What lane did the rank 3 swimmer use?`:
```sql
|
SELECT "opponent" FROM "game_log" WHERE "date"='july 15'; |
## Task
Generate a SQL query to answer the following question:
`Which opponent played on July 15?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which opponent played on July 15?`:
```sql
|
SELECT "record" FROM "game_log" WHERE "attendance">'32,162' AND "date"='july 16'; |
## Task
Generate a SQL query to answer the following question:
`What is the record for a game played on July 16 with attendance of more than 32,162?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the record for a game played on July 16 with attendance of more than 32,162?`:
```sql
|
SELECT "place" FROM "final_leaderboard" WHERE "player"='jimmy demaret'; |
## Task
Generate a SQL query to answer the following question:
`Where has Jimmy Demaret as a player?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "final_leaderboard" (
"place" text,
"player" text,
"country" text,
"score" text,
"to_par" text,
"money" real
);
### SQL
Given the database schema, here is the SQL query that answers `Where has Jimmy Demaret as a player?`:
```sql
|
SELECT COUNT("money") FROM "final_leaderboard" WHERE "country"='united states' AND "player"='byron nelson'; |
## Task
Generate a SQL query to answer the following question:
`How much does it cost for United States and Byron nelson?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "final_leaderboard" (
"place" text,
"player" text,
"country" text,
"score" text,
"to_par" text,
"money" real
);
### SQL
Given the database schema, here is the SQL query that answers `How much does it cost for United States and Byron nelson?`:
```sql
|
SELECT "country" FROM "final_leaderboard" WHERE "place"='t8' AND "player"='byron nelson'; |
## Task
Generate a SQL query to answer the following question:
`Which Country has a Place of t8 and byron nelson?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "final_leaderboard" (
"place" text,
"player" text,
"country" text,
"score" text,
"to_par" text,
"money" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Country has a Place of t8 and byron nelson?`:
```sql
|
SELECT AVG("pop") FROM "list_of_japanese_prefectural_capitals" WHERE "region"='chūgoku' AND "prefecture"='okayama'; |
## Task
Generate a SQL query to answer the following question:
`Name the average pop for chūgoku and prefecture of okayama`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_japanese_prefectural_capitals" (
"capital" text,
"prefecture" text,
"region" text,
"island" text,
"pop" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the average pop for chūgoku and prefecture of okayama`:
```sql
|
SELECT MAX("pop") FROM "list_of_japanese_prefectural_capitals" WHERE "prefecture"='tottori'; |
## Task
Generate a SQL query to answer the following question:
`Name the highest pop for tottori`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_japanese_prefectural_capitals" (
"capital" text,
"prefecture" text,
"region" text,
"island" text,
"pop" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the highest pop for tottori`:
```sql
|
SELECT SUM("pop") FROM "list_of_japanese_prefectural_capitals" WHERE "prefecture"='shizuoka'; |
## Task
Generate a SQL query to answer the following question:
`Name the sum of pop for shizuoka`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_japanese_prefectural_capitals" (
"capital" text,
"prefecture" text,
"region" text,
"island" text,
"pop" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the sum of pop for shizuoka`:
```sql
|
SELECT COUNT("pop") FROM "list_of_japanese_prefectural_capitals" WHERE "prefecture"='ibaraki'; |
## Task
Generate a SQL query to answer the following question:
`Name the total number of pop for ibaraki`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_japanese_prefectural_capitals" (
"capital" text,
"prefecture" text,
"region" text,
"island" text,
"pop" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the total number of pop for ibaraki`:
```sql
|
SELECT "mascot" FROM "current_members" WHERE "location"='mishawaka'; |
## Task
Generate a SQL query to answer the following question:
`Who is the mascot for Mishawaka?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "current_members" (
"school" text,
"location" text,
"mascot" text,
"county" text,
"enrollment_ihsaa_class" text,
"joined" real,
"previous_conference" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the mascot for Mishawaka?`:
```sql
|
SELECT "previous_conference" FROM "current_members" WHERE "school"='penn'; |
## Task
Generate a SQL query to answer the following question:
`Which previous conference is associated with Penn school?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "current_members" (
"school" text,
"location" text,
"mascot" text,
"county" text,
"enrollment_ihsaa_class" text,
"joined" real,
"previous_conference" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which previous conference is associated with Penn school?`:
```sql
|
SELECT "location" FROM "current_members" WHERE "county"='71 st. joseph' AND "school"='south bend washington'; |
## Task
Generate a SQL query to answer the following question:
`Which location is in 71 St. Joseph county with South Bend Washington school?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "current_members" (
"school" text,
"location" text,
"mascot" text,
"county" text,
"enrollment_ihsaa_class" text,
"joined" real,
"previous_conference" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which location is in 71 St. Joseph county with South Bend Washington school?`:
```sql
|
SELECT "mascot" FROM "current_members" WHERE "school"='south bend clay'; |
## Task
Generate a SQL query to answer the following question:
`What is the mascot for South Bend Clay?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "current_members" (
"school" text,
"location" text,
"mascot" text,
"county" text,
"enrollment_ihsaa_class" text,
"joined" real,
"previous_conference" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the mascot for South Bend Clay?`:
```sql
|
SELECT "street_address" FROM "timeline_of_tallest_buildings" WHERE "architect"='edmund woolley and andrew hamilton'; |
## Task
Generate a SQL query to answer the following question:
`What was the address of the building with architects Edmund Woolley and Andrew Hamilton?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "timeline_of_tallest_buildings" (
"name" text,
"street_address" text,
"years_as_tallest" text,
"height_ft_m" text,
"floors" text,
"architect" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the address of the building with architects Edmund Woolley and Andrew Hamilton?`:
```sql
|
SELECT "years_as_tallest" FROM "timeline_of_tallest_buildings" WHERE "name"='tenth presbyterian church'; |
## Task
Generate a SQL query to answer the following question:
`How many years as tallest building was the Tenth Presbyterian Church?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "timeline_of_tallest_buildings" (
"name" text,
"street_address" text,
"years_as_tallest" text,
"height_ft_m" text,
"floors" text,
"architect" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many years as tallest building was the Tenth Presbyterian Church?`:
```sql
|
SELECT "years_as_tallest" FROM "timeline_of_tallest_buildings" WHERE "name"='independence hall'; |
## Task
Generate a SQL query to answer the following question:
`How many years as tallest building was Independence Hall?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "timeline_of_tallest_buildings" (
"name" text,
"street_address" text,
"years_as_tallest" text,
"height_ft_m" text,
"floors" text,
"architect" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many years as tallest building was Independence Hall?`:
```sql
|
SELECT "height_ft_m" FROM "timeline_of_tallest_buildings" WHERE "name"='tenth presbyterian church'; |
## Task
Generate a SQL query to answer the following question:
`What is the height of the Tenth Presbyterian Church?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "timeline_of_tallest_buildings" (
"name" text,
"street_address" text,
"years_as_tallest" text,
"height_ft_m" text,
"floors" text,
"architect" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the height of the Tenth Presbyterian Church?`:
```sql
|
SELECT "record" FROM "game_log" WHERE "loss"='plesac (1-5)'; |
## Task
Generate a SQL query to answer the following question:
`For the Loss of Plesac (1-5), what is the Record?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `For the Loss of Plesac (1-5), what is the Record?`:
```sql
|
SELECT "record" FROM "game_log" WHERE "loss"='plesac (1-5)'; |
## Task
Generate a SQL query to answer the following question:
`For the Loss of Plesac (1-5), what is the Record?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "game_log" (
"date" text,
"opponent" text,
"score" text,
"loss" text,
"attendance" real,
"record" text
);
### SQL
Given the database schema, here is the SQL query that answers `For the Loss of Plesac (1-5), what is the Record?`:
```sql
|
SELECT "entrant" FROM "complete_formula_one_world_championship_" WHERE "year"<1990 AND "chassis"='eurobrun er189'; |
## Task
Generate a SQL query to answer the following question:
`Name the entrant for year less than 1990 and chassis of eurobrun er189`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "complete_formula_one_world_championship_" (
"year" real,
"entrant" text,
"chassis" text,
"engine" text,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the entrant for year less than 1990 and chassis of eurobrun er189`:
```sql
|
SELECT "engine" FROM "complete_formula_one_world_championship_" WHERE "year"<1990 AND "chassis"='eurobrun er189'; |
## Task
Generate a SQL query to answer the following question:
`Name the engine for years before 1990 and chassis of eurobrun er189`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "complete_formula_one_world_championship_" (
"year" real,
"entrant" text,
"chassis" text,
"engine" text,
"points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the engine for years before 1990 and chassis of eurobrun er189`:
```sql
|
SELECT MIN("touchdowns") FROM "statistics" WHERE "receptions"=51 AND "games_started"<16; |
## Task
Generate a SQL query to answer the following question:
`With games started smaller than 16 plus receptions of 51, what is the smallest amount of touchdowns listed?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "statistics" (
"year" text,
"games_played" real,
"games_started" real,
"attempts" real,
"yards" real,
"touchdowns" real,
"receptions" real,
"rec_yards" real,
"rec_touchdowns" real,
"fumbles" real
);
### SQL
Given the database schema, here is the SQL query that answers `With games started smaller than 16 plus receptions of 51, what is the smallest amount of touchdowns listed?`:
```sql
|
SELECT MAX("games_played") FROM "statistics" WHERE "receptions"=6 AND "games_started"=10 AND "fumbles"<3; |
## Task
Generate a SQL query to answer the following question:
`What are the highest number of games played that had game starts of 10, receptions of 6 and fumbles smaller than 3?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "statistics" (
"year" text,
"games_played" real,
"games_started" real,
"attempts" real,
"yards" real,
"touchdowns" real,
"receptions" real,
"rec_yards" real,
"rec_touchdowns" real,
"fumbles" real
);
### SQL
Given the database schema, here is the SQL query that answers `What are the highest number of games played that had game starts of 10, receptions of 6 and fumbles smaller than 3?`:
```sql
|
SELECT "date" FROM "2011" WHERE "casualties"='1 wia' AND "circumstances"='ied' AND "location"='15km nw of pol-e khomri'; |
## Task
Generate a SQL query to answer the following question:
`When was the location 15km NW of Pol-E Khomri, the circumstaances IED and the casualties of 1 WIA?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2011" (
"date" text,
"location" text,
"nature_of_incident" text,
"circumstances" text,
"casualties" text
);
### SQL
Given the database schema, here is the SQL query that answers `When was the location 15km NW of Pol-E Khomri, the circumstaances IED and the casualties of 1 WIA?`:
```sql
|
SELECT "date" FROM "2011" WHERE "location"='pol-e khomri'; |
## Task
Generate a SQL query to answer the following question:
`When was the incident in Pol-E Khomri?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2011" (
"date" text,
"location" text,
"nature_of_incident" text,
"circumstances" text,
"casualties" text
);
### SQL
Given the database schema, here is the SQL query that answers `When was the incident in Pol-E Khomri?`:
```sql
|
SELECT "nature_of_incident" FROM "2011" WHERE "location"='imam sahib area, kunduz province'; |
## Task
Generate a SQL query to answer the following question:
`What was the incident in imam sahib area, kunduz province?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "2011" (
"date" text,
"location" text,
"nature_of_incident" text,
"circumstances" text,
"casualties" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the incident in imam sahib area, kunduz province?`:
```sql
|
SELECT "gender" FROM "list_of_hostages" WHERE "romanized_name"='kim yoon-yeong'; |
## Task
Generate a SQL query to answer the following question:
`What gender has Romanized name and kim yoon-yeong?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "list_of_hostages" (
"romanized_name" text,
"name_in_hangul" text,
"name_in_hanja" text,
"gender" text,
"birth_year" real
);
### SQL
Given the database schema, here is the SQL query that answers `What gender has Romanized name and kim yoon-yeong?`:
```sql
|
SELECT MIN("year") FROM "career_statistics" WHERE "team"='baltimore ravens' AND "games"<15; |
## Task
Generate a SQL query to answer the following question:
`What year did Willis McGahee play fewer than 15 games with the Baltimore Ravens?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "career_statistics" (
"year" real,
"team" text,
"games" real,
"attempts" real,
"yards" real
);
### SQL
Given the database schema, here is the SQL query that answers `What year did Willis McGahee play fewer than 15 games with the Baltimore Ravens?`:
```sql
|
SELECT MIN("games") FROM "career_statistics" WHERE "year">2013; |
## Task
Generate a SQL query to answer the following question:
`After the 2013 season, what was the fewest number of games that Willis McGahee played in a single season?`
### Database Schema
This query will run on a database whose schema is represented in this string:
CREATE TABLE "career_statistics" (
"year" real,
"team" text,
"games" real,
"attempts" real,
"yards" real
);
### SQL
Given the database schema, here is the SQL query that answers `After the 2013 season, what was the fewest number of games that Willis McGahee played in a single season?`:
```sql
|
SELECT "result" FROM "international_goals" WHERE "competition"='2006 fifa world cup qualifier' AND "venue"='warner park sporting complex, bassaterre'; |
## Task
Generate a SQL query to answer the following question:
`What is the result when the competition was the 2006 fifa world cup qualifier, and a Venue of warner park sporting complex, bassaterre?`
### 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 is the result when the competition was the 2006 fifa world cup qualifier, and a Venue of warner park sporting complex, bassaterre?`:
```sql
|
SELECT "venue" FROM "international_goals" WHERE "competition"='friendly' AND "result"='2–3'; |
## Task
Generate a SQL query to answer the following question:
`What is the name of the venue when the competition was friendly, with a Result of 2–3?`
### 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 is the name of the venue when the competition was friendly, with a Result of 2–3?`:
```sql
|
SELECT "venue" FROM "international_goals" WHERE "score"='5–0' AND "competition"='2007 caribbean cup qualifier'; |
## Task
Generate a SQL query to answer the following question:
`What is the name of the venue when the score was 5–0, and a Competition of 2007 caribbean cup 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 `What is the name of the venue when the score was 5–0, and a Competition of 2007 caribbean cup qualifier?`:
```sql
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.