cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`What is the low point total for teams with 81 places?`

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

CREATE TABLE "ice_dancing" (
  "rank" real,
  "name" text,
  "nation" text,
  "points" real,
  "places" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the low point total for teams with 81 places?`:
```sql
                SELECT MIN("points") FROM "ice_dancing" WHERE "places"='81';
```
## Task
Generate a SQL query to answer the following question:
`What is the station number of the station at Dogsthorpe?`

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

CREATE TABLE "stations" (
  "station_number" text,
  "district" text,
  "location" text,
  "type" text,
  "appliances" text,
  "registrations" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the station number of the station at Dogsthorpe?`:
```sql
                SELECT "station_number" FROM "stations" WHERE "location"='dogsthorpe';
```
## Task
Generate a SQL query to answer the following question:
`What is the type of the station with a 1 wrl appliance in Linton?`

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

CREATE TABLE "stations" (
  "station_number" text,
  "district" text,
  "location" text,
  "type" text,
  "appliances" text,
  "registrations" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the type of the station with a 1 wrl appliance in Linton?`:
```sql
                SELECT "type" FROM "stations" WHERE "appliances"='1 wrl' AND "location"='linton';
```
## Task
Generate a SQL query to answer the following question:
`What is the appliance at the station in St Neots?`

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

CREATE TABLE "stations" (
  "station_number" text,
  "district" text,
  "location" text,
  "type" text,
  "appliances" text,
  "registrations" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the appliance at the station in St Neots?`:
```sql
                SELECT "appliances" FROM "stations" WHERE "location"='st neots';
```
## Task
Generate a SQL query to answer the following question:
`What is the registration of the station at Cambridge?`

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

CREATE TABLE "stations" (
  "station_number" text,
  "district" text,
  "location" text,
  "type" text,
  "appliances" text,
  "registrations" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the registration of the station at Cambridge?`:
```sql
                SELECT "registrations" FROM "stations" WHERE "district"='cambridge';
```
## Task
Generate a SQL query to answer the following question:
`What is the location of the station at Huntingdonshire with a station number of c17?`

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

CREATE TABLE "stations" (
  "station_number" text,
  "district" text,
  "location" text,
  "type" text,
  "appliances" text,
  "registrations" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the location of the station at Huntingdonshire with a station number of c17?`:
```sql
                SELECT "location" FROM "stations" WHERE "district"='huntingdonshire' AND "station_number"='c17';
```
## Task
Generate a SQL query to answer the following question:
`What is the registration of the station with a retained type and a station number of c03?`

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

CREATE TABLE "stations" (
  "station_number" text,
  "district" text,
  "location" text,
  "type" text,
  "appliances" text,
  "registrations" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the registration of the station with a retained type and a station number of c03?`:
```sql
                SELECT "registrations" FROM "stations" WHERE "type"='retained' AND "station_number"='c03';
```
## Task
Generate a SQL query to answer the following question:
`Name the nationality of the player with round more than 4`

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

CREATE TABLE "draft_picks" (
  "round" real,
  "player" text,
  "nationality" text,
  "nhl_team" text,
  "college_junior_club_team_league" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the nationality of the player with round more than 4`:
```sql
                SELECT "nationality" FROM "draft_picks" WHERE "round">4;
```
## Task
Generate a SQL query to answer the following question:
`In what Year was the Rank 14.0 14?`

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

CREATE TABLE "tallest_buildings" (
  "rank" text,
  "name" text,
  "height_ft_m" text,
  "floors" real,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `In what Year was the Rank 14.0 14?`:
```sql
                SELECT SUM("year") FROM "tallest_buildings" WHERE "rank"='14.0 14';
```
## Task
Generate a SQL query to answer the following question:
`After 1971, what is the Rank with a Height ft (m) of 19.0 477 (145) and less than 35 Floors?`

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

CREATE TABLE "tallest_buildings" (
  "rank" text,
  "name" text,
  "height_ft_m" text,
  "floors" real,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `After 1971, what is the Rank with a Height ft (m) of 19.0 477 (145) and less than 35 Floors?`:
```sql
                SELECT "rank" FROM "tallest_buildings" WHERE "year">1971 AND "floors"<35 AND "height_ft_m"='19.0 477 (145)';
```
## Task
Generate a SQL query to answer the following question:
`What Year has a Rank of 12.0 12?`

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

CREATE TABLE "tallest_buildings" (
  "rank" text,
  "name" text,
  "height_ft_m" text,
  "floors" real,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `What Year has a Rank of 12.0 12?`:
```sql
                SELECT AVG("year") FROM "tallest_buildings" WHERE "rank"='12.0 12';
```
## Task
Generate a SQL query to answer the following question:
`Which crowd  has an Away team score of 8.10 (58)?`

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

CREATE TABLE "round_5" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which crowd  has an Away team score of 8.10 (58)?`:
```sql
                SELECT "crowd" FROM "round_5" WHERE "away_team_score"='8.10 (58)';
```
## Task
Generate a SQL query to answer the following question:
`Which away team had a score of 17.13 (115)?`

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

CREATE TABLE "round_17" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which away team had a score of 17.13 (115)?`:
```sql
                SELECT "away_team" FROM "round_17" WHERE "away_team_score"='17.13 (115)';
```
## Task
Generate a SQL query to answer the following question:
`What did the away team score at VFL Park?`

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

CREATE TABLE "round_17" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What did the away team score at VFL Park?`:
```sql
                SELECT "away_team_score" FROM "round_17" WHERE "venue"='vfl park';
```
## Task
Generate a SQL query to answer the following question:
`How many people watched the game at Lake Oval?`

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

CREATE TABLE "round_17" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many people watched the game at Lake Oval?`:
```sql
                SELECT SUM("crowd") FROM "round_17" WHERE "venue"='lake oval';
```
## Task
Generate a SQL query to answer the following question:
`Where did the home team score 15.21 (111)?`

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

CREATE TABLE "round_17" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where did the home team score 15.21 (111)?`:
```sql
                SELECT "venue" FROM "round_17" WHERE "home_team_score"='15.21 (111)';
```
## Task
Generate a SQL query to answer the following question:
`What was the Comp average, having Gino Guidugli as a player and a rating of more than 92.2?`

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

CREATE TABLE "passing" (
  "player" text,
  "att" real,
  "comp" real,
  "yards" real,
  "rating" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the Comp average, having Gino Guidugli as a player and a rating of more than 92.2?`:
```sql
                SELECT AVG("comp") FROM "passing" WHERE "player"='gino guidugli' AND "rating">92.2;
```
## Task
Generate a SQL query to answer the following question:
`For the player with yards less than 138, and Comp more than 0, what was the highest Att.?`

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

CREATE TABLE "passing" (
  "player" text,
  "att" real,
  "comp" real,
  "yards" real,
  "rating" real
);
### SQL
Given the database schema, here is the SQL query that answers `For the player with yards less than 138, and Comp more than 0, what was the highest Att.?`:
```sql
                SELECT MAX("att") FROM "passing" WHERE "yards"<138 AND "comp">0;
```
## Task
Generate a SQL query to answer the following question:
`How many laps for grid of 9?`

### 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 for grid of 9?`:
```sql
                SELECT "laps" FROM "race" WHERE "grid"=9;
```
## Task
Generate a SQL query to answer the following question:
`What is the high lap total for a grid less than 6, and a Time/Retired of halfshaft?`

### 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 high lap total for a grid less than 6, and a Time/Retired of halfshaft?`:
```sql
                SELECT MAX("laps") FROM "race" WHERE "grid"<6 AND "time_retired"='halfshaft';
```
## Task
Generate a SQL query to answer the following question:
`What is the Set 1 with a Score with 3–2?`

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

CREATE TABLE "pool_b" (
  "date" text,
  "score" text,
  "set_1" text,
  "set_2" text,
  "set_3" text,
  "total" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Set 1 with a Score with 3–2?`:
```sql
                SELECT "set_1" FROM "pool_b" WHERE "score"='3–2';
```
## Task
Generate a SQL query to answer the following question:
`What is the Set 1 with a Set 2 of 15–5, and a Set 3 with 15–3?`

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

CREATE TABLE "pool_b" (
  "date" text,
  "score" text,
  "set_1" text,
  "set_2" text,
  "set_3" text,
  "total" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Set 1 with a Set 2 of 15–5, and a Set 3 with 15–3?`:
```sql
                SELECT "set_1" FROM "pool_b" WHERE "set_2"='15–5' AND "set_3"='15–3';
```
## Task
Generate a SQL query to answer the following question:
`What is the Date with a Set 1 with 15–1?`

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

CREATE TABLE "pool_b" (
  "date" text,
  "score" text,
  "set_1" text,
  "set_2" text,
  "set_3" text,
  "total" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Date with a Set 1 with 15–1?`:
```sql
                SELECT "date" FROM "pool_b" WHERE "set_1"='15–1';
```
## Task
Generate a SQL query to answer the following question:
`What is the Set 3 with a Date of 04 oct, and a Set 2 with 15–5?`

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

CREATE TABLE "pool_b" (
  "date" text,
  "score" text,
  "set_1" text,
  "set_2" text,
  "set_3" text,
  "total" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Set 3 with a Date of 04 oct, and a Set 2 with 15–5?`:
```sql
                SELECT "set_3" FROM "pool_b" WHERE "date"='04 oct' AND "set_2"='15–5';
```
## Task
Generate a SQL query to answer the following question:
`What is the Set 3 with a Set 2 with 15–6?`

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

CREATE TABLE "pool_b" (
  "date" text,
  "score" text,
  "set_1" text,
  "set_2" text,
  "set_3" text,
  "total" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Set 3 with a Set 2 with 15–6?`:
```sql
                SELECT "set_3" FROM "pool_b" WHERE "set_2"='15–6';
```
## Task
Generate a SQL query to answer the following question:
`What is the Set 2 with a Total of 45–12, and a Set 3 with 15–2?`

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

CREATE TABLE "pool_b" (
  "date" text,
  "score" text,
  "set_1" text,
  "set_2" text,
  "set_3" text,
  "total" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Set 2 with a Total of 45–12, and a Set 3 with 15–2?`:
```sql
                SELECT "set_2" FROM "pool_b" WHERE "total"='45–12' AND "set_3"='15–2';
```
## Task
Generate a SQL query to answer the following question:
`What was the grid associated with under 26 laps and a Time/Retired of +6.077?`

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

CREATE TABLE "moto_gp_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 was the grid associated with under 26 laps and a Time/Retired of +6.077?`:
```sql
                SELECT AVG("grid") FROM "moto_gp_classification" WHERE "time_retired"='+6.077' AND "laps"<26;
```
## Task
Generate a SQL query to answer the following question:
`On 5 May 2011, what was the lead percentage?`

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

CREATE TABLE "regional_vote" (
  "date_s_conducted" text,
  "cons" text,
  "plaid_cymru" text,
  "lib_dem" text,
  "ukip" text,
  "green" text,
  "others" text,
  "lead" text
);
### SQL
Given the database schema, here is the SQL query that answers `On 5 May 2011, what was the lead percentage?`:
```sql
                SELECT "lead" FROM "regional_vote" WHERE "date_s_conducted"='5 may 2011';
```
## Task
Generate a SQL query to answer the following question:
`On what date was the lead 8.6%?`

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

CREATE TABLE "regional_vote" (
  "date_s_conducted" text,
  "cons" text,
  "plaid_cymru" text,
  "lib_dem" text,
  "ukip" text,
  "green" text,
  "others" text,
  "lead" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date was the lead 8.6%?`:
```sql
                SELECT "date_s_conducted" FROM "regional_vote" WHERE "lead"='8.6%';
```
## Task
Generate a SQL query to answer the following question:
`what is the lifespan when the imperial height is 7ft 8 in and the nationality is fiji?`

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

CREATE TABLE "men" (
  "nationality" text,
  "metric" text,
  "imperial" text,
  "name" text,
  "lifespan" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the lifespan when the imperial height is 7ft 8 in and the nationality is fiji?`:
```sql
                SELECT "lifespan" FROM "men" WHERE "imperial"='7ft 8 in' AND "nationality"='fiji';
```
## Task
Generate a SQL query to answer the following question:
`what is the nationality with the metric height of 2.36m named sun ming-ming?`

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

CREATE TABLE "men" (
  "nationality" text,
  "metric" text,
  "imperial" text,
  "name" text,
  "lifespan" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the nationality with the metric height of 2.36m named sun ming-ming?`:
```sql
                SELECT "nationality" FROM "men" WHERE "metric"='2.36m' AND "name"='sun ming-ming';
```
## Task
Generate a SQL query to answer the following question:
`What is the grid total that had a retired for engine, teo fabi driving, and under 39 laps?`

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

CREATE TABLE "classification" (
  "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 grid total that had a retired for engine, teo fabi driving, and under 39 laps?`:
```sql
                SELECT SUM("grid") FROM "classification" WHERE "time_retired"='engine' AND "driver"='teo fabi' AND "laps"<39;
```
## Task
Generate a SQL query to answer the following question:
`What is the average grid for johnny dumfries with less than 8 laps?`

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

CREATE TABLE "classification" (
  "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 average grid for johnny dumfries with less than 8 laps?`:
```sql
                SELECT AVG("grid") FROM "classification" WHERE "driver"='johnny dumfries' AND "laps"<8;
```
## Task
Generate a SQL query to answer the following question:
`What is the low lap total for minardi - motori moderni, and a Grid smaller than 18?`

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

CREATE TABLE "classification" (
  "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 low lap total for minardi - motori moderni, and a Grid smaller than 18?`:
```sql
                SELECT MIN("laps") FROM "classification" WHERE "constructor"='minardi - motori moderni' AND "grid"<18;
```
## Task
Generate a SQL query to answer the following question:
`What constructor has a 12 grid?`

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

CREATE TABLE "classification" (
  "driver" text,
  "constructor" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What constructor has a 12 grid?`:
```sql
                SELECT "constructor" FROM "classification" WHERE "grid"=12;
```
## Task
Generate a SQL query to answer the following question:
`What is the average where the swimsuit is larger than 9.437?`

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

CREATE TABLE "scores" (
  "country" text,
  "preliminaries" real,
  "interview" real,
  "swimsuit" real,
  "evening_gown" real,
  "average" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average where the swimsuit is larger than 9.437?`:
```sql
                SELECT MAX("average") FROM "scores" WHERE "swimsuit">9.437;
```
## Task
Generate a SQL query to answer the following question:
`What is the evening gown score where the interview score is 9.22 and the preliminaries are larger than 9.057?`

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

CREATE TABLE "scores" (
  "country" text,
  "preliminaries" real,
  "interview" real,
  "swimsuit" real,
  "evening_gown" real,
  "average" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the evening gown score where the interview score is 9.22 and the preliminaries are larger than 9.057?`:
```sql
                SELECT SUM("evening_gown") FROM "scores" WHERE "interview"=9.22 AND "preliminaries">9.057;
```
## Task
Generate a SQL query to answer the following question:
`What is Pennsylvania's average where the swimsuit is smaller than 9.109 and the evening gown is smaller than 9.163?`

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

CREATE TABLE "scores" (
  "country" text,
  "preliminaries" real,
  "interview" real,
  "swimsuit" real,
  "evening_gown" real,
  "average" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is Pennsylvania's average where the swimsuit is smaller than 9.109 and the evening gown is smaller than 9.163?`:
```sql
                SELECT AVG("average") FROM "scores" WHERE "swimsuit"<9.109 AND "country"='pennsylvania' AND "evening_gown"<9.163;
```
## Task
Generate a SQL query to answer the following question:
`What is the preliminaries score where the swimsuit is smaller than 9.297, the evening gown is 9.617, and the interview is larger than 9.143?`

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

CREATE TABLE "scores" (
  "country" text,
  "preliminaries" real,
  "interview" real,
  "swimsuit" real,
  "evening_gown" real,
  "average" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the preliminaries score where the swimsuit is smaller than 9.297, the evening gown is 9.617, and the interview is larger than 9.143?`:
```sql
                SELECT AVG("preliminaries") FROM "scores" WHERE "swimsuit"<9.297 AND "evening_gown"=9.617 AND "interview">9.143;
```
## Task
Generate a SQL query to answer the following question:
`For Amazon.com's device with a weight of 221g (7.8oz) how many screen pixels does the device have?`

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

CREATE TABLE "electronic_paper_displays" (
  "maker" text,
  "model" text,
  "intro_year" text,
  "screen_size_inch" text,
  "self_lit" text,
  "screen_type" text,
  "weight" text,
  "screen_pixels" text,
  "touch_screen" text,
  "micro_sdhc" text
);
### SQL
Given the database schema, here is the SQL query that answers `For Amazon.com's device with a weight of 221g (7.8oz) how many screen pixels does the device have?`:
```sql
                SELECT "screen_pixels" FROM "electronic_paper_displays" WHERE "maker"='amazon.com' AND "weight"='221g (7.8oz)';
```
## Task
Generate a SQL query to answer the following question:
`How many 5K wins did Lynn Jennings, who had more than 0 10K wins, have?`

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

CREATE TABLE "multiple_winners" (
  "runner" text,
  "country" text,
  "5_k_wins" real,
  "10_k_wins" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many 5K wins did Lynn Jennings, who had more than 0 10K wins, have?`:
```sql
                SELECT SUM("5_k_wins") FROM "multiple_winners" WHERE "10_k_wins">0 AND "runner"='lynn jennings';
```
## Task
Generate a SQL query to answer the following question:
`What is the average 10K wins the United States, which had 0 5K wins, have?`

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

CREATE TABLE "multiple_winners" (
  "runner" text,
  "country" text,
  "5_k_wins" real,
  "10_k_wins" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average 10K wins the United States, which had 0 5K wins, have?`:
```sql
                SELECT AVG("10_k_wins") FROM "multiple_winners" WHERE "country"='united states' AND "5_k_wins"=0;
```
## Task
Generate a SQL query to answer the following question:
`How many 5K wins did Emily Chebet, who had more than 2 total, have?`

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

CREATE TABLE "multiple_winners" (
  "runner" text,
  "country" text,
  "5_k_wins" real,
  "10_k_wins" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many 5K wins did Emily Chebet, who had more than 2 total, have?`:
```sql
                SELECT SUM("5_k_wins") FROM "multiple_winners" WHERE "runner"='emily chebet' AND "total">2;
```
## Task
Generate a SQL query to answer the following question:
`How many 5K wins did Emily Chebet, who had more than 2 total, have?`

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

CREATE TABLE "multiple_winners" (
  "runner" text,
  "country" text,
  "5_k_wins" real,
  "10_k_wins" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many 5K wins did Emily Chebet, who had more than 2 total, have?`:
```sql
                SELECT COUNT("5_k_wins") FROM "multiple_winners" WHERE "runner"='emily chebet' AND "total">2;
```
## Task
Generate a SQL query to answer the following question:
`What is the largest number of Peak lessons taught when the Evaluation average (Before April 2009) was 4.4?`

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

CREATE TABLE "belt_requirements" (
  "evaluation_average_from_february_2011" real,
  "evaluation_average_from_april_2009" text,
  "evaluation_average_before_april_2009" text,
  "pct_of_negative_evaluations" text,
  "submitting_schedule_on_time" text,
  "punctuality_attendance_issues" text,
  "peak_lessons_taught" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the largest number of Peak lessons taught when the Evaluation average (Before April 2009) was 4.4?`:
```sql
                SELECT MAX("peak_lessons_taught") FROM "belt_requirements" WHERE "evaluation_average_before_april_2009"='4.4';
```
## Task
Generate a SQL query to answer the following question:
`What is the mean Evaluation number (before April 2009) when the Peak lessons taught was less than 80 and the negative percentage of evaluations was 0.8%?`

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

CREATE TABLE "belt_requirements" (
  "evaluation_average_from_february_2011" real,
  "evaluation_average_from_april_2009" text,
  "evaluation_average_before_april_2009" text,
  "pct_of_negative_evaluations" text,
  "submitting_schedule_on_time" text,
  "punctuality_attendance_issues" text,
  "peak_lessons_taught" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the mean Evaluation number (before April 2009) when the Peak lessons taught was less than 80 and the negative percentage of evaluations was 0.8%?`:
```sql
                SELECT "evaluation_average_before_april_2009" FROM "belt_requirements" WHERE "peak_lessons_taught"<80 AND "pct_of_negative_evaluations"='0.8%';
```
## Task
Generate a SQL query to answer the following question:
`What is the mean Evaluation number (Before April 2009) when the percentage of negative evaluations was 0.8% and the mean Evaluation number of April 2009 was 4.2?`

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

CREATE TABLE "belt_requirements" (
  "evaluation_average_from_february_2011" real,
  "evaluation_average_from_april_2009" text,
  "evaluation_average_before_april_2009" text,
  "pct_of_negative_evaluations" text,
  "submitting_schedule_on_time" text,
  "punctuality_attendance_issues" text,
  "peak_lessons_taught" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the mean Evaluation number (Before April 2009) when the percentage of negative evaluations was 0.8% and the mean Evaluation number of April 2009 was 4.2?`:
```sql
                SELECT "evaluation_average_before_april_2009" FROM "belt_requirements" WHERE "pct_of_negative_evaluations"='0.8%' AND "evaluation_average_from_april_2009"='4.2';
```
## Task
Generate a SQL query to answer the following question:
`Which venue has an Away team score of 18.9 (117)?`

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

CREATE TABLE "round_18" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which venue has an Away team score of 18.9 (117)?`:
```sql
                SELECT "venue" FROM "round_18" WHERE "away_team_score"='18.9 (117)';
```
## Task
Generate a SQL query to answer the following question:
`What date has a Home team score of 7.11 (53)?`

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

CREATE TABLE "round_18" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date has a Home team score of 7.11 (53)?`:
```sql
                SELECT "date" FROM "round_18" WHERE "home_team_score"='7.11 (53)';
```
## Task
Generate a SQL query to answer the following question:
`What is moorabbin oval's away team?`

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

CREATE TABLE "round_18" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is moorabbin oval's away team?`:
```sql
                SELECT "away_team" FROM "round_18" WHERE "venue"='moorabbin oval';
```
## Task
Generate a SQL query to answer the following question:
`What is the home score with an Away team score of 10.14 (74)?`

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

CREATE TABLE "round_18" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the home score with an Away team score of 10.14 (74)?`:
```sql
                SELECT "home_team_score" FROM "round_18" WHERE "away_team_score"='10.14 (74)';
```
## Task
Generate a SQL query to answer the following question:
`What is Karl Wendlinger's total grid #?`

### 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 Karl Wendlinger's total grid #?`:
```sql
                SELECT COUNT("grid") FROM "race" WHERE "driver"='karl wendlinger';
```
## Task
Generate a SQL query to answer the following question:
`Which away team score also had a home team score of 20.20 (140)?`

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

CREATE TABLE "round_19" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which away team score also had a home team score of 20.20 (140)?`:
```sql
                SELECT "away_team_score" FROM "round_19" WHERE "home_team_score"='20.20 (140)';
```
## Task
Generate a SQL query to answer the following question:
`Which Home team score had a Home team of Fitzroy?`

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

CREATE TABLE "round_19" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Home team score had a Home team of Fitzroy?`:
```sql
                SELECT "home_team_score" FROM "round_19" WHERE "home_team"='fitzroy';
```
## Task
Generate a SQL query to answer the following question:
`Who was replaced by Lieve Wierinck?`

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

CREATE TABLE "list_of_representatives_who_resigned" (
  "name" text,
  "party" text,
  "date_of_resignation" text,
  "replacement" text,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was replaced by Lieve Wierinck?`:
```sql
                SELECT "name" FROM "list_of_representatives_who_resigned" WHERE "replacement"='lieve wierinck';
```
## Task
Generate a SQL query to answer the following question:
`Name the sum of gross tonnage for wood on date more tahn 1846 for comissioned and ship of esk`

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

CREATE TABLE "list_of_rmsp_company_vessels" (
  "ship" text,
  "date_commissioned" real,
  "gross_tonnage" real,
  "propulsion" text,
  "material" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the sum of gross tonnage for wood on date more tahn 1846 for comissioned and ship of esk`:
```sql
                SELECT SUM("gross_tonnage") FROM "list_of_rmsp_company_vessels" WHERE "material"='wood' AND "date_commissioned">1846 AND "ship"='esk';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the sum of Gross Tonnage for isis ship on date commisioned less than 1842`

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

CREATE TABLE "list_of_rmsp_company_vessels" (
  "ship" text,
  "date_commissioned" real,
  "gross_tonnage" real,
  "propulsion" text,
  "material" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the sum of Gross Tonnage for isis ship on date commisioned less than 1842`:
```sql
                SELECT SUM("gross_tonnage") FROM "list_of_rmsp_company_vessels" WHERE "ship"='isis' AND "date_commissioned"<1842;
```
## Task
Generate a SQL query to answer the following question:
`Tell me the lowest date commissioned for iron rmsrhone and gross tonnage less than 2,738`

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

CREATE TABLE "list_of_rmsp_company_vessels" (
  "ship" text,
  "date_commissioned" real,
  "gross_tonnage" real,
  "propulsion" text,
  "material" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the lowest date commissioned for iron rmsrhone and gross tonnage less than 2,738`:
```sql
                SELECT MIN("date_commissioned") FROM "list_of_rmsp_company_vessels" WHERE "material"='iron' AND "ship"='rmsrhone' AND "gross_tonnage"<'2,738';
```
## Task
Generate a SQL query to answer the following question:
`Name the height for 2008 club of trentino volley`

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

CREATE TABLE "men_s_tournament" (
  "name" text,
  "height" text,
  "weight" text,
  "spike" text,
  "2008_club" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the height for 2008 club of trentino volley`:
```sql
                SELECT "height" FROM "men_s_tournament" WHERE "2008_club"='trentino volley';
```
## Task
Generate a SQL query to answer the following question:
`Who was in the 2008 club of gabeca montichiari?`

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

CREATE TABLE "men_s_tournament" (
  "name" text,
  "height" text,
  "weight" text,
  "spike" text,
  "2008_club" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was in the 2008 club of gabeca montichiari?`:
```sql
                SELECT "name" FROM "men_s_tournament" WHERE "2008_club"='gabeca montichiari';
```
## Task
Generate a SQL query to answer the following question:
`What Constructor has a +1.027 Time/Retired?`

### 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 Constructor has a +1.027 Time/Retired?`:
```sql
                SELECT "constructor" FROM "race" WHERE "time_retired"='+1.027';
```
## Task
Generate a SQL query to answer the following question:
`What Constructor has 56 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 Constructor has 56 Laps?`:
```sql
                SELECT "constructor" FROM "race" WHERE "laps"=56;
```
## Task
Generate a SQL query to answer the following question:
`What Driver has 28 Laps and a Grid greater than 5?`

### 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 Driver has 28 Laps and a Grid greater than 5?`:
```sql
                SELECT "driver" FROM "race" WHERE "grid">5 AND "laps"=28;
```
## Task
Generate a SQL query to answer the following question:
`What is the highest Laps with a Time/Retired Wheel?`

### 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 highest Laps with a Time/Retired Wheel?`:
```sql
                SELECT MAX("laps") FROM "race" WHERE "time_retired"='wheel';
```
## Task
Generate a SQL query to answer the following question:
`What Driver has a +1.027 Time/Retired?`

### 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 Driver has a +1.027 Time/Retired?`:
```sql
                SELECT "driver" FROM "race" WHERE "time_retired"='+1.027';
```
## Task
Generate a SQL query to answer the following question:
`What game has a score of 44-20?`

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

CREATE TABLE "challenge_cup" (
  "date" text,
  "competition" text,
  "venue" text,
  "result" text,
  "score" text,
  "goals" text
);
### SQL
Given the database schema, here is the SQL query that answers `What game has a score of 44-20?`:
```sql
                SELECT "result" FROM "challenge_cup" WHERE "score"='44-20';
```
## Task
Generate a SQL query to answer the following question:
`What date was a game played at Headingley Stadium?`

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

CREATE TABLE "challenge_cup" (
  "date" text,
  "competition" text,
  "venue" text,
  "result" text,
  "score" text,
  "goals" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date was a game played at Headingley Stadium?`:
```sql
                SELECT "date" FROM "challenge_cup" WHERE "venue"='headingley stadium';
```
## Task
Generate a SQL query to answer the following question:
`What competition was played at Shay Stadium?`

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

CREATE TABLE "challenge_cup" (
  "date" text,
  "competition" text,
  "venue" text,
  "result" text,
  "score" text,
  "goals" text
);
### SQL
Given the database schema, here is the SQL query that answers `What competition was played at Shay Stadium?`:
```sql
                SELECT "competition" FROM "challenge_cup" WHERE "venue"='shay stadium';
```
## Task
Generate a SQL query to answer the following question:
`Which show had a part 3 before 2011?`

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

CREATE TABLE "filmography" (
  "year" real,
  "show" text,
  "season" real,
  "episode_title" text,
  "episode" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which show had a part 3 before 2011?`:
```sql
                SELECT "show" FROM "filmography" WHERE "year"<2011 AND "episode_title"='part 3';
```
## Task
Generate a SQL query to answer the following question:
`What are the male Bounder books?`

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

CREATE TABLE "residents_of_white_deer_park" (
  "animal_name" text,
  "species" text,
  "books" text,
  "tv_series" text,
  "gender" text,
  "tv_seasons" text,
  "mate" text,
  "first_appearance" text,
  "last_appearance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What are the male Bounder books?`:
```sql
                SELECT "books" FROM "residents_of_white_deer_park" WHERE "gender"='male' AND "animal_name"='bounder';
```
## Task
Generate a SQL query to answer the following question:
`How many people attended on April 12?`

### 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 `How many people attended on April 12?`:
```sql
                SELECT COUNT("attendance") FROM "game_log" WHERE "date"='april 12';
```
## Task
Generate a SQL query to answer the following question:
`On what date were 5 built with 4-4-2t wheels?`

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

CREATE TABLE "1905_1911" (
  "class" text,
  "wheels" text,
  "date" text,
  "no_built" real,
  "loco_nos" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date were 5 built with 4-4-2t wheels?`:
```sql
                SELECT "date" FROM "1905_1911" WHERE "no_built"=5 AND "wheels"='4-4-2t';
```
## Task
Generate a SQL query to answer the following question:
`On what date was the number of locomotives 421-6?`

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

CREATE TABLE "1905_1911" (
  "class" text,
  "wheels" text,
  "date" text,
  "no_built" real,
  "loco_nos" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date was the number of locomotives 421-6?`:
```sql
                SELECT "date" FROM "1905_1911" WHERE "loco_nos"='421-6';
```
## Task
Generate a SQL query to answer the following question:
`How many were built with a locomotive number of 11-20?`

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

CREATE TABLE "1905_1911" (
  "class" text,
  "wheels" text,
  "date" text,
  "no_built" real,
  "loco_nos" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many were built with a locomotive number of 11-20?`:
```sql
                SELECT "no_built" FROM "1905_1911" WHERE "loco_nos"='11-20';
```
## Task
Generate a SQL query to answer the following question:
`On what date were more than 5 built with 4-4-2 wheels?`

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

CREATE TABLE "1905_1911" (
  "class" text,
  "wheels" text,
  "date" text,
  "no_built" real,
  "loco_nos" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date were more than 5 built with 4-4-2 wheels?`:
```sql
                SELECT "date" FROM "1905_1911" WHERE "wheels"='4-4-2' AND "no_built">5;
```
## Task
Generate a SQL query to answer the following question:
`On what date were less than 10 built with a locomotive number of 31-35?`

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

CREATE TABLE "1905_1911" (
  "class" text,
  "wheels" text,
  "date" text,
  "no_built" real,
  "loco_nos" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date were less than 10 built with a locomotive number of 31-35?`:
```sql
                SELECT "date" FROM "1905_1911" WHERE "no_built"<10 AND "loco_nos"='31-35';
```
## Task
Generate a SQL query to answer the following question:
`How many spectators watched when the away team was Collingwood?`

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

CREATE TABLE "round_10" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many spectators watched when the away team was Collingwood?`:
```sql
                SELECT "crowd" FROM "round_10" WHERE "away_team"='collingwood';
```
## Task
Generate a SQL query to answer the following question:
`What did Essendon score when they were the away team?`

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

CREATE TABLE "round_10" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What did Essendon score when they were the away team?`:
```sql
                SELECT "away_team_score" FROM "round_10" WHERE "away_team"='essendon';
```
## Task
Generate a SQL query to answer the following question:
`When did the home team score 19.17 (131)?`

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

CREATE TABLE "round_10" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `When did the home team score 19.17 (131)?`:
```sql
                SELECT "date" FROM "round_10" WHERE "home_team_score"='19.17 (131)';
```