cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`Name the winning driver for monaco grand prix`

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

CREATE TABLE "non_championship_grands_prix" (
  "name" text,
  "circuit" text,
  "date" text,
  "winning_driver" text,
  "winning_constructor" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the winning driver for monaco grand prix`:
```sql
                SELECT "winning_driver" FROM "non_championship_grands_prix" WHERE "name"='monaco grand prix';
```
## Task
Generate a SQL query to answer the following question:
`Name the circuit for marcel lehoux`

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

CREATE TABLE "non_championship_grands_prix" (
  "name" text,
  "circuit" text,
  "date" text,
  "winning_driver" text,
  "winning_constructor" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the circuit for marcel lehoux`:
```sql
                SELECT "circuit" FROM "non_championship_grands_prix" WHERE "winning_driver"='marcel lehoux';
```
## Task
Generate a SQL query to answer the following question:
`Name the report for per-viktor widengren and alfa romeo`

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

CREATE TABLE "non_championship_grands_prix" (
  "name" text,
  "circuit" text,
  "date" text,
  "winning_driver" text,
  "winning_constructor" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the report for per-viktor widengren and alfa romeo`:
```sql
                SELECT "report" FROM "non_championship_grands_prix" WHERE "winning_driver"='per-viktor widengren' AND "winning_constructor"='alfa romeo';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the date for warsaw 1929`

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

CREATE TABLE "1925_1929" (
  "year" real,
  "competition" text,
  "date" text,
  "location" text,
  "score" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the date for warsaw 1929`:
```sql
                SELECT "date" FROM "1925_1929" WHERE "location"='warsaw' AND "year"=1929;
```
## Task
Generate a SQL query to answer the following question:
`Tell me the result for warsaw 1929`

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

CREATE TABLE "1925_1929" (
  "year" real,
  "competition" text,
  "date" text,
  "location" text,
  "score" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the result for warsaw 1929`:
```sql
                SELECT "result" FROM "1925_1929" WHERE "location"='warsaw' AND "year"=1929;
```
## Task
Generate a SQL query to answer the following question:
`Tell me the result for harrogate`

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

CREATE TABLE "1925_1929" (
  "year" real,
  "competition" text,
  "date" text,
  "location" text,
  "score" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the result for harrogate`:
```sql
                SELECT "result" FROM "1925_1929" WHERE "location"='harrogate';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the Stem Meaning of ical`

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

CREATE TABLE "honorifics" (
  "stem_meaning" text,
  "2nd_person_sg" text,
  "2nd_person_sg_honorific" text,
  "3rd_person_sg" text,
  "3rd_person_sg_honorific" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the Stem Meaning of ical`:
```sql
                SELECT "stem_meaning" FROM "honorifics" WHERE "3rd_person_sg"='ical';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the 3rd person sg for tiecal, tiecaltzi`

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

CREATE TABLE "honorifics" (
  "stem_meaning" text,
  "2nd_person_sg" text,
  "2nd_person_sg_honorific" text,
  "3rd_person_sg" text,
  "3rd_person_sg_honorific" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the 3rd person sg for tiecal, tiecaltzi`:
```sql
                SELECT "3rd_person_sg" FROM "honorifics" WHERE "3rd_person_sg_honorific"='tiecal, tiecaltzi';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the overall rank for roland schoeman`

### 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 overall rank for roland schoeman`:
```sql
                SELECT "overall_rank" FROM "heats" WHERE "swimmer"='roland schoeman';
```
## Task
Generate a SQL query to answer the following question:
`How many Silver medals did nation who is ranked greater than 1 and has 4 Gold medals have?`

### 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 `How many Silver medals did nation who is ranked greater than 1 and has 4 Gold medals have?`:
```sql
                SELECT SUM("silver") FROM "medal_table" WHERE "rank">1 AND "gold"=4;
```
## Task
Generate a SQL query to answer the following question:
`Which nation has more than 6 Silver medals and fewer than 8 Gold medals?`

### 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 `Which nation has more than 6 Silver medals and fewer than 8 Gold medals?`:
```sql
                SELECT AVG("total") FROM "medal_table" WHERE "silver">6 AND "gold"<8;
```
## Task
Generate a SQL query to answer the following question:
`What is the rank of the Nation that has fewer than 24 total medals are more than 7 Gold medals?`

### 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 `What is the rank of the Nation that has fewer than 24 total medals are more than 7 Gold medals?`:
```sql
                SELECT AVG("rank") FROM "medal_table" WHERE "total"<24 AND "gold">7;
```
## Task
Generate a SQL query to answer the following question:
`What is the rank of the nation that has more than 1 Bronze medals and fewer than 4 Gold medals?`

### 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 `What is the rank of the nation that has more than 1 Bronze medals and fewer than 4 Gold medals?`:
```sql
                SELECT MIN("rank") FROM "medal_table" WHERE "bronze">1 AND "gold"<4;
```
## Task
Generate a SQL query to answer the following question:
`How many silver medals does Belarus (blr) along with 4 gold and 4 bronze?`

### 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 `How many silver medals does Belarus (blr) along with 4 gold and 4 bronze?`:
```sql
                SELECT SUM("silver") FROM "medal_table" WHERE "gold"=4 AND "nation"='belarus (blr)' AND "bronze">4;
```
## Task
Generate a SQL query to answer the following question:
`What rank is Belarus (BLR), which earned 15 medals total?`

### 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 `What rank is Belarus (BLR), which earned 15 medals total?`:
```sql
                SELECT MAX("rank") FROM "medal_table" WHERE "nation"='belarus (blr)' AND "total"<15;
```
## Task
Generate a SQL query to answer the following question:
`What was the name of the race on 24 September?`

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

CREATE TABLE "grandes_preuves" (
  "name" text,
  "circuit" text,
  "date" text,
  "winning_drivers" text,
  "winning_constructor" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the name of the race on 24 September?`:
```sql
                SELECT "name" FROM "grandes_preuves" WHERE "date"='24 september';
```
## Task
Generate a SQL query to answer the following question:
`What is the name of the race on 9 July?`

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

CREATE TABLE "grandes_preuves" (
  "name" text,
  "circuit" text,
  "date" text,
  "winning_drivers" text,
  "winning_constructor" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the name of the race on 9 July?`:
```sql
                SELECT "name" FROM "grandes_preuves" WHERE "date"='9 july';
```
## Task
Generate a SQL query to answer the following question:
`What was the race that was won by a Maserati being driven by Giuseppe Campari?`

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

CREATE TABLE "grandes_preuves" (
  "name" text,
  "circuit" text,
  "date" text,
  "winning_drivers" text,
  "winning_constructor" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the race that was won by a Maserati being driven by Giuseppe Campari?`:
```sql
                SELECT "circuit" FROM "grandes_preuves" WHERE "winning_constructor"='maserati' AND "winning_drivers"='giuseppe campari';
```
## Task
Generate a SQL query to answer the following question:
`What date was the race won by Louis Chiron?`

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

CREATE TABLE "grandes_preuves" (
  "name" text,
  "circuit" text,
  "date" text,
  "winning_drivers" text,
  "winning_constructor" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date was the race won by Louis Chiron?`:
```sql
                SELECT "date" FROM "grandes_preuves" WHERE "winning_drivers"='louis chiron';
```
## Task
Generate a SQL query to answer the following question:
`What brand of vehicle won a race driven by Tazio Nuvolari?`

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

CREATE TABLE "grandes_preuves" (
  "name" text,
  "circuit" text,
  "date" text,
  "winning_drivers" text,
  "winning_constructor" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What brand of vehicle won a race driven by Tazio Nuvolari?`:
```sql
                SELECT "winning_constructor" FROM "grandes_preuves" WHERE "winning_drivers"='tazio nuvolari';
```
## Task
Generate a SQL query to answer the following question:
`What race was won by Tazio Nuvolari?`

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

CREATE TABLE "grandes_preuves" (
  "name" text,
  "circuit" text,
  "date" text,
  "winning_drivers" text,
  "winning_constructor" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `What race was won by Tazio Nuvolari?`:
```sql
                SELECT "name" FROM "grandes_preuves" WHERE "winning_drivers"='tazio nuvolari';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the result for week less than 4 and september 7, 1986`

### 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" real
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the result for week less than 4 and september 7, 1986`:
```sql
                SELECT "result" FROM "schedule" WHERE "week"<4 AND "date"='september 7, 1986';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the result for week of 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" real
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the result for week of 3`:
```sql
                SELECT "result" FROM "schedule" WHERE "week"=3;
```
## Task
Generate a SQL query to answer the following question:
`Tell me the lowest week for attedance less thaan 32,738`

### 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" real
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the lowest week for attedance less thaan 32,738`:
```sql
                SELECT MIN("week") FROM "schedule" WHERE "attendance"<'32,738';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the ship for lieutenant montagu verling`

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

CREATE TABLE "ships_served_in_by_richard_bolitho" (
  "ship" text,
  "guns" text,
  "class" text,
  "captain" text,
  "rank" text,
  "year" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the ship for lieutenant montagu verling`:
```sql
                SELECT "ship" FROM "ships_served_in_by_richard_bolitho" WHERE "captain"='lieutenant montagu verling';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the class for admiral and hms frobisher`

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

CREATE TABLE "ships_served_in_by_richard_bolitho" (
  "ship" text,
  "guns" text,
  "class" text,
  "captain" text,
  "rank" text,
  "year" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the class for admiral and hms frobisher`:
```sql
                SELECT "class" FROM "ships_served_in_by_richard_bolitho" WHERE "rank"='admiral' AND "ship"='hms frobisher';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the guns for third-rate ship of the line and rank of vice-admiral with year of 1802`

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

CREATE TABLE "ships_served_in_by_richard_bolitho" (
  "ship" text,
  "guns" text,
  "class" text,
  "captain" text,
  "rank" text,
  "year" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the guns for third-rate ship of the line and rank of vice-admiral with year of 1802`:
```sql
                SELECT "guns" FROM "ships_served_in_by_richard_bolitho" WHERE "class"='third-rate ship of the line' AND "rank"='vice-admiral' AND "year"='1802';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the captain for 1774 and guns of 14`

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

CREATE TABLE "ships_served_in_by_richard_bolitho" (
  "ship" text,
  "guns" text,
  "class" text,
  "captain" text,
  "rank" text,
  "year" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the captain for 1774 and guns of 14`:
```sql
                SELECT "captain" FROM "ships_served_in_by_richard_bolitho" WHERE "year"='1774' AND "guns"='14';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the captain for guns of 28`

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

CREATE TABLE "ships_served_in_by_richard_bolitho" (
  "ship" text,
  "guns" text,
  "class" text,
  "captain" text,
  "rank" text,
  "year" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the captain for guns of 28`:
```sql
                SELECT "captain" FROM "ships_served_in_by_richard_bolitho" WHERE "guns"='28';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the status of eliminated of anton dela paz`

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

CREATE TABLE "star_struck_standing" (
  "week_num" real,
  "finalists" text,
  "status" text,
  "eliminated" text,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the status of eliminated of anton dela paz`:
```sql
                SELECT "status" FROM "star_struck_standing" WHERE "eliminated"='anton dela paz';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the finalists for week # less than 2`

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

CREATE TABLE "star_struck_standing" (
  "week_num" real,
  "finalists" text,
  "status" text,
  "eliminated" text,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the finalists for week # less than 2`:
```sql
                SELECT "finalists" FROM "star_struck_standing" WHERE "week_num"<2;
```
## Task
Generate a SQL query to answer the following question:
`Tell me the eliminated for week # larger than 4`

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

CREATE TABLE "star_struck_standing" (
  "week_num" real,
  "finalists" text,
  "status" text,
  "eliminated" text,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the eliminated for week # larger than 4`:
```sql
                SELECT "eliminated" FROM "star_struck_standing" WHERE "week_num">4;
```
## Task
Generate a SQL query to answer the following question:
`At the UFC 78, what is the average round when the time is 5:00?`

### 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 `At the UFC 78, what is the average round when the time is 5:00?`:
```sql
                SELECT AVG("round") FROM "mixed_martial_arts_record" WHERE "time"='5:00' AND "event"='ufc 78';
```
## Task
Generate a SQL query to answer the following question:
`When there was a draw, what was the time?`

### 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 `When there was a draw, what was the time?`:
```sql
                SELECT "time" FROM "mixed_martial_arts_record" WHERE "res"='draw';
```
## Task
Generate a SQL query to answer the following question:
`What is the sum of points in 2010 when the driver had more than 14 races and an F.L. of less than 0?`

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

CREATE TABLE "gp2_series" (
  "year" real,
  "drivers" text,
  "races" real,
  "wins" real,
  "poles" real,
  "f_l" real,
  "points" real,
  "d_c" text,
  "t_c" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the sum of points in 2010 when the driver had more than 14 races and an F.L. of less than 0?`:
```sql
                SELECT SUM("points") FROM "gp2_series" WHERE "year"=2010 AND "races">14 AND "f_l"<0;
```
## Task
Generate a SQL query to answer the following question:
`What day was the game that had an attendance of more than 46,551 people and had a week number of less than 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" real
);
### SQL
Given the database schema, here is the SQL query that answers `What day was the game that had an attendance of more than 46,551 people and had a week number of less than 4?`:
```sql
                SELECT "date" FROM "schedule" WHERE "attendance">'46,551' AND "week"<4;
```
## Task
Generate a SQL query to answer the following question:
`What was the outcome of the game that had a week number of less than 2?`

### 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" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the outcome of the game that had a week number of less than 2?`:
```sql
                SELECT "result" FROM "schedule" WHERE "week"<2;
```
## Task
Generate a SQL query to answer the following question:
`What heat and what lane is thi hue pham in?`

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

CREATE TABLE "heats" (
  "rank" real,
  "heat_lane" text,
  "name" text,
  "nationality" text,
  "time" text
);
### SQL
Given the database schema, here is the SQL query that answers `What heat and what lane is thi hue pham in?`:
```sql
                SELECT "heat_lane" FROM "heats" WHERE "name"='thi hue pham';
```
## Task
Generate a SQL query to answer the following question:
`What Heat & Lane is the person who has a time of 1:01.12?`

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

CREATE TABLE "heats" (
  "rank" real,
  "heat_lane" text,
  "name" text,
  "nationality" text,
  "time" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Heat & Lane is the person who has a time of 1:01.12?`:
```sql
                SELECT "heat_lane" FROM "heats" WHERE "time"='1:01.12';
```
## Task
Generate a SQL query to answer the following question:
`How many laps did Fernando Alonso do?`

### 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 `How many laps did Fernando Alonso do?`:
```sql
                SELECT "laps" FROM "race" WHERE "driver"='fernando alonso';
```
## Task
Generate a SQL query to answer the following question:
`What was Jenson Button's constructor?`

### 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 was Jenson Button's constructor?`:
```sql
                SELECT "constructor" FROM "race" WHERE "driver"='jenson button';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the package for EEPROM less than 128`

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

CREATE TABLE "supported_microcontrollers_according_to_" (
  "chip" text,
  "flash_size" text,
  "eeprom" real,
  "sram" real,
  "frequency_m_hz" real,
  "package" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the package for EEPROM less than 128`:
```sql
                SELECT "package" FROM "supported_microcontrollers_according_to_" WHERE "eeprom"<128;
```
## Task
Generate a SQL query to answer the following question:
`Tell me the chip with frequency larger than 10`

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

CREATE TABLE "supported_microcontrollers_according_to_" (
  "chip" text,
  "flash_size" text,
  "eeprom" real,
  "sram" real,
  "frequency_m_hz" real,
  "package" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the chip with frequency larger than 10`:
```sql
                SELECT "chip" FROM "supported_microcontrollers_according_to_" WHERE "frequency_m_hz">10;
```
## Task
Generate a SQL query to answer the following question:
`I want the highest Grid for Toyota and jarno trulli`

### 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 `I want the highest Grid for Toyota and jarno trulli`:
```sql
                SELECT MAX("grid") FROM "race" WHERE "constructor"='toyota' AND "driver"='jarno trulli';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the average Laps for grid larger than 22`

### 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 `Tell me the average Laps for grid larger than 22`:
```sql
                SELECT AVG("laps") FROM "race" WHERE "grid">22;
```
## Task
Generate a SQL query to answer the following question:
`Tell me the constructor for grid of 17`

### 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 `Tell me the constructor for grid of 17`:
```sql
                SELECT "constructor" FROM "race" WHERE "grid"=17;
```
## Task
Generate a SQL query to answer the following question:
`What years had a manager who lost more than 1 and drawn more than 11?`

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

CREATE TABLE "ukraine_managers" (
  "manager" text,
  "ukraine_career" text,
  "played" real,
  "drawn" real,
  "lost" real,
  "win_pct" real
);
### SQL
Given the database schema, here is the SQL query that answers `What years had a manager who lost more than 1 and drawn more than 11?`:
```sql
                SELECT "ukraine_career" FROM "ukraine_managers" WHERE "lost">1 AND "drawn">11;
```
## Task
Generate a SQL query to answer the following question:
`what is the total win % of manager viktor prokopenko, when he lost fewer than 2?`

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

CREATE TABLE "ukraine_managers" (
  "manager" text,
  "ukraine_career" text,
  "played" real,
  "drawn" real,
  "lost" real,
  "win_pct" real
);
### SQL
Given the database schema, here is the SQL query that answers `what is the total win % of manager viktor prokopenko, when he lost fewer than 2?`:
```sql
                SELECT COUNT("win_pct") FROM "ukraine_managers" WHERE "manager"='viktor prokopenko' AND "lost"<2;
```
## Task
Generate a SQL query to answer the following question:
`When 4 clubs are involved, what is the average number of fixtures?`

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

CREATE TABLE "format_and_schedule" (
  "round" text,
  "date_s" text,
  "clubs_from_the_previous_round" text,
  "clubs_involved" real,
  "fixtures" real
);
### SQL
Given the database schema, here is the SQL query that answers `When 4 clubs are involved, what is the average number of fixtures?`:
```sql
                SELECT AVG("fixtures") FROM "format_and_schedule" WHERE "clubs_involved"=4;
```
## Task
Generate a SQL query to answer the following question:
`In the sixth round, what is the sum of fixtures when there were more than 15 clubs involved?`

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

CREATE TABLE "format_and_schedule" (
  "round" text,
  "date_s" text,
  "clubs_from_the_previous_round" text,
  "clubs_involved" real,
  "fixtures" real
);
### SQL
Given the database schema, here is the SQL query that answers `In the sixth round, what is the sum of fixtures when there were more than 15 clubs involved?`:
```sql
                SELECT SUM("fixtures") FROM "format_and_schedule" WHERE "round"='sixth round' AND "clubs_involved">15;
```
## Task
Generate a SQL query to answer the following question:
`Tell me the league for year of 1915/16`

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

CREATE TABLE "year_by_year" (
  "year" text,
  "division" text,
  "league" text,
  "reg_season" text,
  "playoffs" text,
  "challenge_cup" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the league for year of 1915/16`:
```sql
                SELECT "league" FROM "year_by_year" WHERE "year"='1915/16';
```
## Task
Generate a SQL query to answer the following question:
`What is the make of the car that drove 54 laps?`

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

CREATE TABLE "race" (
  "driver" text,
  "constructor" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the make of the car that drove 54 laps?`:
```sql
                SELECT "constructor" FROM "race" WHERE "laps"=54;
```
## Task
Generate a SQL query to answer the following question:
`Who has a 59 cap?`

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

CREATE TABLE "highest_capped" (
  "name" text,
  "career" text,
  "caps" real,
  "goals" real,
  "first_cap" text,
  "recent_cap" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who has a 59 cap?`:
```sql
                SELECT "name" FROM "highest_capped" WHERE "caps"=59;
```
## Task
Generate a SQL query to answer the following question:
`Tell me the sum of frequency for ERP W less than 1`

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

CREATE TABLE "translators" (
  "call_sign" text,
  "frequency_m_hz" real,
  "city_of_license" text,
  "erp_w" real,
  "class" text,
  "fcc_info" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the sum of frequency for ERP W less than 1`:
```sql
                SELECT SUM("frequency_m_hz") FROM "translators" WHERE "erp_w"<1;
```
## Task
Generate a SQL query to answer the following question:
`Tell me the lowest ties played with a debut of 1936`

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

CREATE TABLE "players" (
  "player" text,
  "total_w_l" text,
  "singles_w_l" text,
  "doubles_w_l" text,
  "ties_played" real,
  "debut" real,
  "years_played" real
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the lowest ties played with a debut of 1936`:
```sql
                SELECT MIN("ties_played") FROM "players" WHERE "debut"=1936;
```
## Task
Generate a SQL query to answer the following question:
`Where did the Paris Marathon occur?`

### 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 `Where did the Paris Marathon occur?`:
```sql
                SELECT "venue" FROM "achievements" WHERE "competition"='paris marathon';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the capacity for city park stadium`

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

CREATE TABLE "current_usl_soccer_specific_stadiums" (
  "stadium" text,
  "club_s" text,
  "division" text,
  "city" text,
  "capacity" real,
  "opened" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the capacity for city park stadium`:
```sql
                SELECT "capacity" FROM "current_usl_soccer_specific_stadiums" WHERE "stadium"='city park stadium';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the tournament for opponents of andrei pavel rogier wassen`

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

CREATE TABLE "titles_6" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponents_in_the_final" text,
  "score_in_the_final" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the tournament for opponents of andrei pavel rogier wassen`:
```sql
                SELECT "tournament" FROM "titles_6" WHERE "opponents_in_the_final"='andrei pavel rogier wassen';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the tournament for score in the final of 1–6, 3–6`

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

CREATE TABLE "titles_6" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponents_in_the_final" text,
  "score_in_the_final" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the tournament for score in the final of 1–6, 3–6`:
```sql
                SELECT "tournament" FROM "titles_6" WHERE "score_in_the_final"='1–6, 3–6';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the opponents for score in the final of 1–6, 2–6`

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

CREATE TABLE "titles_6" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponents_in_the_final" text,
  "score_in_the_final" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the opponents for score in the final of 1–6, 2–6`:
```sql
                SELECT "opponents_in_the_final" FROM "titles_6" WHERE "score_in_the_final"='1–6, 2–6';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the surface for 16 april 2007`

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

CREATE TABLE "titles_6" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "partner" text,
  "opponents_in_the_final" text,
  "score_in_the_final" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the surface for 16 april 2007`:
```sql
                SELECT "surface" FROM "titles_6" WHERE "date"='16 april 2007';
```
## Task
Generate a SQL query to answer the following question:
`I want the average pages for  ISBN of 978-0-9766580-5-4`

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

CREATE TABLE "publications" (
  "title" text,
  "year" real,
  "isbn" text,
  "volume" text,
  "strips" text,
  "pages" real,
  "colors" text
);
### SQL
Given the database schema, here is the SQL query that answers `I want the average pages for  ISBN of 978-0-9766580-5-4`:
```sql
                SELECT AVG("pages") FROM "publications" WHERE "isbn"='978-0-9766580-5-4';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the sum of year for 244 pages`

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

CREATE TABLE "publications" (
  "title" text,
  "year" real,
  "isbn" text,
  "volume" text,
  "strips" text,
  "pages" real,
  "colors" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the sum of year for 244 pages`:
```sql
                SELECT SUM("year") FROM "publications" WHERE "pages"=244;
```
## Task
Generate a SQL query to answer the following question:
`Tell me the title for pages of 96`

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

CREATE TABLE "publications" (
  "title" text,
  "year" real,
  "isbn" text,
  "volume" text,
  "strips" text,
  "pages" real,
  "colors" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the title for pages of 96`:
```sql
                SELECT "title" FROM "publications" WHERE "pages"=96;
```
## Task
Generate a SQL query to answer the following question:
`What was the date of birth of a republican member of the United States House of Representatives who held the term of 1863-1865?`

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

CREATE TABLE "historical" (
  "begin_date" text,
  "representative" text,
  "date_of_birth" text,
  "house_term" text,
  "state_served" text,
  "party" text,
  "age_years_days" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the date of birth of a republican member of the United States House of Representatives who held the term of 1863-1865?`:
```sql
                SELECT "date_of_birth" FROM "historical" WHERE "party"='republican' AND "house_term"='1863-1865';
```
## Task
Generate a SQL query to answer the following question:
`What was the age of the member of the United States House of Representatives that began their term on May 7, 1886?`

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

CREATE TABLE "historical" (
  "begin_date" text,
  "representative" text,
  "date_of_birth" text,
  "house_term" text,
  "state_served" text,
  "party" text,
  "age_years_days" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the age of the member of the United States House of Representatives that began their term on May 7, 1886?`:
```sql
                SELECT "age_years_days" FROM "historical" WHERE "begin_date"='may 7, 1886';
```
## Task
Generate a SQL query to answer the following question:
`What was the date of birth of the member of the United States House of Representatives that began their term on April 24, 1902?`

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

CREATE TABLE "historical" (
  "begin_date" text,
  "representative" text,
  "date_of_birth" text,
  "house_term" text,
  "state_served" text,
  "party" text,
  "age_years_days" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the date of birth of the member of the United States House of Representatives that began their term on April 24, 1902?`:
```sql
                SELECT "date_of_birth" FROM "historical" WHERE "begin_date"='april 24, 1902';
```
## Task
Generate a SQL query to answer the following question:
`Which member of the United States House of Representatives began their term on January 4, 1997?`

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

CREATE TABLE "historical" (
  "begin_date" text,
  "representative" text,
  "date_of_birth" text,
  "house_term" text,
  "state_served" text,
  "party" text,
  "age_years_days" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which member of the United States House of Representatives began their term on January 4, 1997?`:
```sql
                SELECT "representative" FROM "historical" WHERE "begin_date"='january 4, 1997';
```
## Task
Generate a SQL query to answer the following question:
`Which state did Samuel Thatcher of the Federalist party represent?`

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

CREATE TABLE "historical" (
  "begin_date" text,
  "representative" text,
  "date_of_birth" text,
  "house_term" text,
  "state_served" text,
  "party" text,
  "age_years_days" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which state did Samuel Thatcher of the Federalist party represent?`:
```sql
                SELECT "state_served" FROM "historical" WHERE "party"='federalist' AND "representative"='samuel thatcher';
```
## Task
Generate a SQL query to answer the following question:
`What position does Hedo Türkoğlu play?`

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

CREATE TABLE "t" (
  "player" text,
  "nationality" text,
  "position" text,
  "years_in_toronto" text,
  "school_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `What position does Hedo Türkoğlu play?`:
```sql
                SELECT "position" FROM "t" WHERE "player"='hedo türkoğlu';
```
## Task
Generate a SQL query to answer the following question:
`How long has Sebastian Telfair played for Toronto?`

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

CREATE TABLE "t" (
  "player" text,
  "nationality" text,
  "position" text,
  "years_in_toronto" text,
  "school_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `How long has Sebastian Telfair played for Toronto?`:
```sql
                SELECT "years_in_toronto" FROM "t" WHERE "player"='sebastian telfair';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the title for japan august 23, 2012`

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

CREATE TABLE "games_developed" (
  "title" text,
  "japan" text,
  "north_america" text,
  "europe" text,
  "australia" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the title for japan august 23, 2012`:
```sql
                SELECT "title" FROM "games_developed" WHERE "japan"='august 23, 2012';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the Australia march 17, 2005`

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

CREATE TABLE "games_developed" (
  "title" text,
  "japan" text,
  "north_america" text,
  "europe" text,
  "australia" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the Australia march 17, 2005`:
```sql
                SELECT "australia" FROM "games_developed" WHERE "japan"='march 17, 2005';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the Europe for z.h.p. unlosing ranger vs darkdeath evilman`

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

CREATE TABLE "games_developed" (
  "title" text,
  "japan" text,
  "north_america" text,
  "europe" text,
  "australia" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the Europe for z.h.p. unlosing ranger vs darkdeath evilman`:
```sql
                SELECT "europe" FROM "games_developed" WHERE "title"='z.h.p. unlosing ranger vs darkdeath evilman';
```
## Task
Generate a SQL query to answer the following question:
`Name the total losses for 4 place and ties less than 0`

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

CREATE TABLE "group_a" (
  "place" real,
  "team" text,
  "wins" real,
  "ties" real,
  "losses" real,
  "points" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the total losses for 4 place and ties less than 0`:
```sql
                SELECT COUNT("losses") FROM "group_a" WHERE "place"=4 AND "ties"<0;
```
## Task
Generate a SQL query to answer the following question:
`Name the average place for ties less than 1 and losess more than 3 with points of 6 qc`

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

CREATE TABLE "group_a" (
  "place" real,
  "team" text,
  "wins" real,
  "ties" real,
  "losses" real,
  "points" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the average place for ties less than 1 and losess more than 3 with points of 6 qc`:
```sql
                SELECT AVG("place") FROM "group_a" WHERE "ties"<1 AND "points"='6 qc' AND "losses">3;
```
## Task
Generate a SQL query to answer the following question:
`Name the most wins for losses more than 2 and points of two with place larger than 7`

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

CREATE TABLE "group_a" (
  "place" real,
  "team" text,
  "wins" real,
  "ties" real,
  "losses" real,
  "points" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the most wins for losses more than 2 and points of two with place larger than 7`:
```sql
                SELECT MAX("wins") FROM "group_a" WHERE "losses">2 AND "points"='2' AND "place">7;
```
## Task
Generate a SQL query to answer the following question:
`Name the sum of place with ties larger than 0 and point sof 7 qc and losses more than 2`

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

CREATE TABLE "group_a" (
  "place" real,
  "team" text,
  "wins" real,
  "ties" real,
  "losses" real,
  "points" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the sum of place with ties larger than 0 and point sof 7 qc and losses more than 2`:
```sql
                SELECT SUM("place") FROM "group_a" WHERE "ties">0 AND "points"='7 qc' AND "losses">2;
```
## Task
Generate a SQL query to answer the following question:
`Tell me the number range for 4vip`

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

CREATE TABLE "fleet_details" (
  "class" text,
  "type" text,
  "no_converted" real,
  "year_converted" text,
  "no_range" text,
  "operator" text,
  "withdrawn" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the number range for 4vip`:
```sql
                SELECT "no_range" FROM "fleet_details" WHERE "type"='4vip';
```
## Task
Generate a SQL query to answer the following question:
`Name the heat rank for senegal`

### 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 `Name the heat rank for senegal`:
```sql
                SELECT "heat_rank" FROM "heats" WHERE "country"='senegal';
```
## Task
Generate a SQL query to answer the following question:
`What is the value for 2010 when the 2012 value is Q2?`

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

CREATE TABLE "singles_performance_timeline" (
  "tournament" text,
  "2006" text,
  "2007" text,
  "2008" text,
  "2009" text,
  "2010" text,
  "2011" text,
  "2012" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the value for 2010 when the 2012 value is Q2?`:
```sql
                SELECT "2010" FROM "singles_performance_timeline" WHERE "2012"='q2';
```