cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`Which Derivative has a Launch Date of july 15, 1970; 15:05 gmt?`

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

CREATE TABLE "spaceflight_by_year" (
  "rocket_launch" text,
  "launch_date" text,
  "mission" text,
  "institutional_authority" text,
  "launch_site" text,
  "outcomes" text,
  "derivatives" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Derivative has a Launch Date of july 15, 1970; 15:05 gmt?`:
```sql
                SELECT "derivatives" FROM "spaceflight_by_year" WHERE "launch_date"='july 15, 1970; 15:05 gmt';
```
## Task
Generate a SQL query to answer the following question:
`Which Outcome has a Launch Date of march 18, 1964; 14:50 gmt?`

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

CREATE TABLE "spaceflight_by_year" (
  "rocket_launch" text,
  "launch_date" text,
  "mission" text,
  "institutional_authority" text,
  "launch_site" text,
  "outcomes" text,
  "derivatives" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Outcome has a Launch Date of march 18, 1964; 14:50 gmt?`:
```sql
                SELECT "outcomes" FROM "spaceflight_by_year" WHERE "launch_date"='march 18, 1964; 14:50 gmt';
```
## Task
Generate a SQL query to answer the following question:
`Which Mission has a Launch Date of december 30, 1970; 14:50 gmt?`

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

CREATE TABLE "spaceflight_by_year" (
  "rocket_launch" text,
  "launch_date" text,
  "mission" text,
  "institutional_authority" text,
  "launch_site" text,
  "outcomes" text,
  "derivatives" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Mission has a Launch Date of december 30, 1970; 14:50 gmt?`:
```sql
                SELECT "mission" FROM "spaceflight_by_year" WHERE "launch_date"='december 30, 1970; 14:50 gmt';
```
## Task
Generate a SQL query to answer the following question:
`What was the score when the Golden State Warriors were the visiting team on 3/7 and there were more than 18,997 people in attendance?`

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

CREATE TABLE "march" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "leading_scorer" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score when the Golden State Warriors were the visiting team on 3/7 and there were more than 18,997 people in attendance?`:
```sql
                SELECT "score" FROM "march" WHERE "visitor"='golden state warriors' AND "attendance">'18,997' AND "date"='3/7';
```
## Task
Generate a SQL query to answer the following question:
`What team was the visitor on 3/2?`

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

CREATE TABLE "march" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "leading_scorer" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What team was the visitor on 3/2?`:
```sql
                SELECT "visitor" FROM "march" WHERE "date"='3/2';
```
## Task
Generate a SQL query to answer the following question:
`What is the home team score for kardinia park?`

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

CREATE TABLE "round_22" (
  "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 team score for kardinia park?`:
```sql
                SELECT "home_team_score" FROM "round_22" WHERE "venue"='kardinia park';
```
## Task
Generate a SQL query to answer the following question:
`When did an away team score 32.16 (208)?`

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

CREATE TABLE "round_22" (
  "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 an away team score 32.16 (208)?`:
```sql
                SELECT "date" FROM "round_22" WHERE "away_team_score"='32.16 (208)';
```
## Task
Generate a SQL query to answer the following question:
`Name the realization for phoneme of /i/ and example of /idːa/`

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

CREATE TABLE "tamazight_vowel_allophony" (
  "phoneme" text,
  "realization" text,
  "environment" text,
  "example" text,
  "gloss" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the realization for phoneme of /i/ and example of /idːa/`:
```sql
                SELECT "realization" FROM "tamazight_vowel_allophony" WHERE "phoneme"='/i/' AND "example"='/idːa/';
```
## Task
Generate a SQL query to answer the following question:
`Name the phoneme for realizaiton of [ɪj]`

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

CREATE TABLE "tamazight_vowel_allophony" (
  "phoneme" text,
  "realization" text,
  "environment" text,
  "example" text,
  "gloss" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the phoneme for realizaiton of [ɪj]`:
```sql
                SELECT "phoneme" FROM "tamazight_vowel_allophony" WHERE "realization"='[ɪj]';
```
## Task
Generate a SQL query to answer the following question:
`Name the example when the environment is #_x`

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

CREATE TABLE "tamazight_vowel_allophony" (
  "phoneme" text,
  "realization" text,
  "environment" text,
  "example" text,
  "gloss" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the example when the environment is #_x`:
```sql
                SELECT "example" FROM "tamazight_vowel_allophony" WHERE "environment"='#_x';
```
## Task
Generate a SQL query to answer the following question:
`Name the example when the realization is [ɐ]`

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

CREATE TABLE "tamazight_vowel_allophony" (
  "phoneme" text,
  "realization" text,
  "environment" text,
  "example" text,
  "gloss" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the example when the realization is [ɐ]`:
```sql
                SELECT "example" FROM "tamazight_vowel_allophony" WHERE "realization"='[ɐ]';
```
## Task
Generate a SQL query to answer the following question:
`Name the phoneme when the example is /umsʁ/`

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

CREATE TABLE "tamazight_vowel_allophony" (
  "phoneme" text,
  "realization" text,
  "environment" text,
  "example" text,
  "gloss" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the phoneme when the example is /umsʁ/`:
```sql
                SELECT "phoneme" FROM "tamazight_vowel_allophony" WHERE "example"='/umsʁ/';
```
## Task
Generate a SQL query to answer the following question:
`Name the phoneme when the realizationis [ɑ]`

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

CREATE TABLE "tamazight_vowel_allophony" (
  "phoneme" text,
  "realization" text,
  "environment" text,
  "example" text,
  "gloss" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the phoneme when the realizationis [ɑ]`:
```sql
                SELECT "phoneme" FROM "tamazight_vowel_allophony" WHERE "realization"='[ɑ]';
```
## Task
Generate a SQL query to answer the following question:
`What is the power of the engine with an engine code m44b19?`

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

CREATE TABLE "engines_and_performance" (
  "name" text,
  "power" text,
  "torque" text,
  "size" text,
  "engine_code" text,
  "0_100km_h_s" real,
  "top_speed" text,
  "years" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the power of the engine with an engine code m44b19?`:
```sql
                SELECT "power" FROM "engines_and_performance" WHERE "engine_code"='m44b19';
```
## Task
Generate a SQL query to answer the following question:
`What is the highest numbered grid for piercarlo ghinzani with over 3 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 highest numbered grid for piercarlo ghinzani with over 3 laps?`:
```sql
                SELECT MAX("grid") FROM "classification" WHERE "driver"='piercarlo ghinzani' AND "laps">3;
```
## Task
Generate a SQL query to answer the following question:
`How many laps for a grid of over 18 and retired due to electrical failure?`

### 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 `How many laps for a grid of over 18 and retired due to electrical failure?`:
```sql
                SELECT SUM("laps") FROM "classification" WHERE "grid">18 AND "time_retired"='electrical';
```
## Task
Generate a SQL query to answer the following question:
`What was the crowd attendance for the game with an away team score of 14.10 (94)?`

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

CREATE TABLE "round_2" (
  "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 was the crowd attendance for the game with an away team score of 14.10 (94)?`:
```sql
                SELECT SUM("crowd") FROM "round_2" WHERE "away_team_score"='14.10 (94)';
```
## Task
Generate a SQL query to answer the following question:
`What was the average crowd attendance for the Junction Oval venue?`

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

CREATE TABLE "round_2" (
  "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 was the average crowd attendance for the Junction Oval venue?`:
```sql
                SELECT AVG("crowd") FROM "round_2" WHERE "venue"='junction oval';
```
## Task
Generate a SQL query to answer the following question:
`What is the home team for the Princes Park venue?`

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

CREATE TABLE "round_2" (
  "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 team for the Princes Park venue?`:
```sql
                SELECT "home_team" FROM "round_2" WHERE "venue"='princes park';
```
## Task
Generate a SQL query to answer the following question:
`What is the average home team score for Footscray?`

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

CREATE TABLE "round_2" (
  "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 average home team score for Footscray?`:
```sql
                SELECT "home_team_score" FROM "round_2" WHERE "home_team"='footscray';
```
## Task
Generate a SQL query to answer the following question:
`Which home teams had Geelong as the away team?`

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

CREATE TABLE "round_2" (
  "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 teams had Geelong as the away team?`:
```sql
                SELECT "home_team" FROM "round_2" WHERE "away_team"='geelong';
```
## Task
Generate a SQL query to answer the following question:
`When did the Rockies play the Giants with an attendance over 24,100?`

### 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 `When did the Rockies play the Giants with an attendance over 24,100?`:
```sql
                SELECT "date" FROM "game_log" WHERE "opponent"='giants' AND "attendance">'24,100';
```
## Task
Generate a SQL query to answer the following question:
`What is the date of the game when the Rockies had a record of 61–66?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the date of the game when the Rockies had a record of 61–66?`:
```sql
                SELECT "date" FROM "game_log" WHERE "record"='61–66';
```
## Task
Generate a SQL query to answer the following question:
`How many seasons has John Mcfadden coached?`

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

CREATE TABLE "data_prior_to_the_2012_ncaa_tournament" (
  "coach" text,
  "years" text,
  "seasons" real,
  "lost" real,
  "pct" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many seasons has John Mcfadden coached?`:
```sql
                SELECT COUNT("seasons") FROM "data_prior_to_the_2012_ncaa_tournament" WHERE "coach"='john mcfadden';
```
## Task
Generate a SQL query to answer the following question:
`What is the station with the most riders that has an annaul ridership of 4,445,100 and line smaller than 1??`

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

CREATE TABLE "see_also" (
  "annual_ridership_2012" real,
  "rider_per_mile" real,
  "opened" real,
  "stations" real,
  "lines" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the station with the most riders that has an annaul ridership of 4,445,100 and line smaller than 1??`:
```sql
                SELECT MAX("stations") FROM "see_also" WHERE "annual_ridership_2012"='4,445,100' AND "lines"<1;
```
## Task
Generate a SQL query to answer the following question:
`What is the number of annual ridership with a station that has more than 13 stations and larger than 4 lines?`

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

CREATE TABLE "see_also" (
  "annual_ridership_2012" real,
  "rider_per_mile" real,
  "opened" real,
  "stations" real,
  "lines" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the number of annual ridership with a station that has more than 13 stations and larger than 4 lines?`:
```sql
                SELECT SUM("annual_ridership_2012") FROM "see_also" WHERE "stations"=13 AND "lines">4;
```
## Task
Generate a SQL query to answer the following question:
`How many lines have fewer than 44 stations and fewer than 881 riders per mile?`

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

CREATE TABLE "see_also" (
  "annual_ridership_2012" real,
  "rider_per_mile" real,
  "opened" real,
  "stations" real,
  "lines" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many lines have fewer than 44 stations and fewer than 881 riders per mile?`:
```sql
                SELECT COUNT("lines") FROM "see_also" WHERE "stations"<44 AND "rider_per_mile"<881;
```
## Task
Generate a SQL query to answer the following question:
`Which station has 3,871 riders per mile, and an annual ridership in 2012 of larger than 15,399,400?`

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

CREATE TABLE "see_also" (
  "annual_ridership_2012" real,
  "rider_per_mile" real,
  "opened" real,
  "stations" real,
  "lines" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which station has 3,871 riders per mile, and an annual ridership in 2012 of larger than 15,399,400?`:
```sql
                SELECT MAX("stations") FROM "see_also" WHERE "rider_per_mile"='3,871' AND "annual_ridership_2012">'15,399,400';
```
## Task
Generate a SQL query to answer the following question:
`What is the highest season for the 7th position?`

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

CREATE TABLE "season_to_season" (
  "season" real,
  "level" text,
  "division" text,
  "administration" text,
  "position" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest season for the 7th position?`:
```sql
                SELECT MAX("season") FROM "season_to_season" WHERE "position"='7th';
```
## Task
Generate a SQL query to answer the following question:
`Who is the opponent in the final of the Tournament of Blenheim?`

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

CREATE TABLE "singles_titles" (
  "date" text,
  "tournament" text,
  "surface" text,
  "opponent_in_the_final" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the opponent in the final of the Tournament of Blenheim?`:
```sql
                SELECT "opponent_in_the_final" FROM "singles_titles" WHERE "tournament"='blenheim';
```
## Task
Generate a SQL query to answer the following question:
`Who is the opponent in the final on August 14, 2006?`

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

CREATE TABLE "singles_titles" (
  "date" text,
  "tournament" text,
  "surface" text,
  "opponent_in_the_final" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the opponent in the final on August 14, 2006?`:
```sql
                SELECT "opponent_in_the_final" FROM "singles_titles" WHERE "date"='august 14, 2006';
```
## Task
Generate a SQL query to answer the following question:
`Who is the opponent in the final with a clay surface at the Tournament of Lyneham?`

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

CREATE TABLE "singles_titles" (
  "date" text,
  "tournament" text,
  "surface" text,
  "opponent_in_the_final" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the opponent in the final with a clay surface at the Tournament of Lyneham?`:
```sql
                SELECT "opponent_in_the_final" FROM "singles_titles" WHERE "surface"='clay' AND "tournament"='lyneham';
```
## Task
Generate a SQL query to answer the following question:
`On what surface was the score 6–2, 6–1?`

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

CREATE TABLE "singles_titles" (
  "date" text,
  "tournament" text,
  "surface" text,
  "opponent_in_the_final" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what surface was the score 6–2, 6–1?`:
```sql
                SELECT "surface" FROM "singles_titles" WHERE "score"='6–2, 6–1';
```
## Task
Generate a SQL query to answer the following question:
`What is the score for the Tournament of Cordenons?`

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

CREATE TABLE "singles_titles" (
  "date" text,
  "tournament" text,
  "surface" text,
  "opponent_in_the_final" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the score for the Tournament of Cordenons?`:
```sql
                SELECT "score" FROM "singles_titles" WHERE "tournament"='cordenons';
```
## Task
Generate a SQL query to answer the following question:
`On what date was the surface clay with Cyril Saulnier as the opponent in the final?`

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

CREATE TABLE "singles_titles" (
  "date" text,
  "tournament" text,
  "surface" text,
  "opponent_in_the_final" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date was the surface clay with Cyril Saulnier as the opponent in the final?`:
```sql
                SELECT "date" FROM "singles_titles" WHERE "surface"='clay' AND "opponent_in_the_final"='cyril saulnier';
```
## Task
Generate a SQL query to answer the following question:
`Which artist has a Mintage of 500?`

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

CREATE TABLE "provincial_coat_of_arms" (
  "year" real,
  "theme" text,
  "artist" text,
  "composition" text,
  "mintage" real,
  "issue_price" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which artist has a Mintage of 500?`:
```sql
                SELECT "artist" FROM "provincial_coat_of_arms" WHERE "mintage"=500;
```
## Task
Generate a SQL query to answer the following question:
`Which Artist has an Issue Price of $1,541.95?`

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

CREATE TABLE "provincial_coat_of_arms" (
  "year" real,
  "theme" text,
  "artist" text,
  "composition" text,
  "mintage" real,
  "issue_price" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Artist has an Issue Price of $1,541.95?`:
```sql
                SELECT "artist" FROM "provincial_coat_of_arms" WHERE "issue_price"='$1,541.95';
```
## Task
Generate a SQL query to answer the following question:
`Who is the opponent in the final on a hard surface with a score of 6–3 7–6(5)?`

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

CREATE TABLE "singles_titles" (
  "date" text,
  "tournament" text,
  "surface" text,
  "opponent_in_the_final" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the opponent in the final on a hard surface with a score of 6–3 7–6(5)?`:
```sql
                SELECT "opponent_in_the_final" FROM "singles_titles" WHERE "surface"='hard' AND "score"='6–3 7–6(5)';
```
## Task
Generate a SQL query to answer the following question:
`Who is the opponent in the Tournament of Lahore final?`

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

CREATE TABLE "singles_titles" (
  "date" text,
  "tournament" text,
  "surface" text,
  "opponent_in_the_final" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the opponent in the Tournament of Lahore final?`:
```sql
                SELECT "opponent_in_the_final" FROM "singles_titles" WHERE "tournament"='lahore';
```
## Task
Generate a SQL query to answer the following question:
`On what date did the opponent in the Toshiaki Sakai final play on a grass surface?`

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

CREATE TABLE "singles_titles" (
  "date" text,
  "tournament" text,
  "surface" text,
  "opponent_in_the_final" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date did the opponent in the Toshiaki Sakai final play on a grass surface?`:
```sql
                SELECT "date" FROM "singles_titles" WHERE "opponent_in_the_final"='toshiaki sakai' AND "surface"='grass';
```
## Task
Generate a SQL query to answer the following question:
`On what surface did a score of 4–6 6–3 6–4 occur at the Tournament of Lahore?`

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

CREATE TABLE "singles_titles" (
  "date" text,
  "tournament" text,
  "surface" text,
  "opponent_in_the_final" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what surface did a score of 4–6 6–3 6–4 occur at the Tournament of Lahore?`:
```sql
                SELECT "surface" FROM "singles_titles" WHERE "tournament"='lahore' AND "score"='4–6 6–3 6–4';
```
## Task
Generate a SQL query to answer the following question:
`Which tournament had Toshiaki Sakai as an opponent in the final on a grass surface?`

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

CREATE TABLE "singles_titles" (
  "date" text,
  "tournament" text,
  "surface" text,
  "opponent_in_the_final" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which tournament had Toshiaki Sakai as an opponent in the final on a grass surface?`:
```sql
                SELECT "tournament" FROM "singles_titles" WHERE "opponent_in_the_final"='toshiaki sakai' AND "surface"='grass';
```
## Task
Generate a SQL query to answer the following question:
`what was the score on the game that happened on May 15?`

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

CREATE TABLE "eastern_conference_semi_finals_vs_4_wash" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `what was the score on the game that happened on May 15?`:
```sql
                SELECT "score" FROM "eastern_conference_semi_finals_vs_4_wash" WHERE "date"='may 15';
```
## Task
Generate a SQL query to answer the following question:
`What is the status of bel with a Transfer window of winter?`

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

CREATE TABLE "loaned_out" (
  "name" text,
  "country" text,
  "status" text,
  "moving_to" text,
  "transfer_window" text,
  "transfer_fee" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the status of bel with a Transfer window of winter?`:
```sql
                SELECT "status" FROM "loaned_out" WHERE "country"='bel' AND "transfer_window"='winter';
```
## Task
Generate a SQL query to answer the following question:
`What is the union moving name and is from cmr?`

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

CREATE TABLE "loaned_out" (
  "name" text,
  "country" text,
  "status" text,
  "moving_to" text,
  "transfer_window" text,
  "transfer_fee" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the union moving name and is from cmr?`:
```sql
                SELECT "name" FROM "loaned_out" WHERE "moving_to"='union' AND "country"='cmr';
```
## Task
Generate a SQL query to answer the following question:
`What is the transfer window for bel?`

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

CREATE TABLE "loaned_out" (
  "name" text,
  "country" text,
  "status" text,
  "moving_to" text,
  "transfer_window" text,
  "transfer_fee" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the transfer window for bel?`:
```sql
                SELECT "transfer_window" FROM "loaned_out" WHERE "country"='bel';
```
## Task
Generate a SQL query to answer the following question:
`What is the transfer period for habarugira?`

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

CREATE TABLE "loaned_out" (
  "name" text,
  "country" text,
  "status" text,
  "moving_to" text,
  "transfer_window" text,
  "transfer_fee" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the transfer period for habarugira?`:
```sql
                SELECT "transfer_window" FROM "loaned_out" WHERE "name"='habarugira';
```
## Task
Generate a SQL query to answer the following question:
`How big was the crowd in game that featured the visiting team of north melbourne?`

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

CREATE TABLE "round_11" (
  "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 big was the crowd in game that featured the visiting team of north melbourne?`:
```sql
                SELECT "crowd" FROM "round_11" WHERE "away_team"='north melbourne';
```
## Task
Generate a SQL query to answer the following question:
`How many bronze medals for the nation with less than 1 total?`

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

CREATE TABLE "medals_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 bronze medals for the nation with less than 1 total?`:
```sql
                SELECT MAX("bronze") FROM "medals_table" WHERE "total"<1;
```
## Task
Generate a SQL query to answer the following question:
`How many bronze medals for the nation ranked above 2, and under 0 golds?`

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

CREATE TABLE "medals_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 bronze medals for the nation ranked above 2, and under 0 golds?`:
```sql
                SELECT COUNT("bronze") FROM "medals_table" WHERE "rank"<2 AND "gold"<0;
```
## Task
Generate a SQL query to answer the following question:
`How many silvers for japan (1 gold)?`

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

CREATE TABLE "medals_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 silvers for japan (1 gold)?`:
```sql
                SELECT SUM("silver") FROM "medals_table" WHERE "nation"='japan' AND "gold">1;
```
## Task
Generate a SQL query to answer the following question:
`Which authority had a role of 651?`

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

CREATE TABLE "papakura_local_board" (
  "name" text,
  "years" text,
  "gender" text,
  "area" text,
  "authority" text,
  "decile" real,
  "roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which authority had a role of 651?`:
```sql
                SELECT "authority" FROM "papakura_local_board" WHERE "roll"=651;
```
## Task
Generate a SQL query to answer the following question:
`For the roll of 651, what was the lowest Decile?`

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

CREATE TABLE "papakura_local_board" (
  "name" text,
  "years" text,
  "gender" text,
  "area" text,
  "authority" text,
  "decile" real,
  "roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `For the roll of 651, what was the lowest Decile?`:
```sql
                SELECT MIN("decile") FROM "papakura_local_board" WHERE "roll"=651;
```
## Task
Generate a SQL query to answer the following question:
`What were the years for Redhill school, authority of state?`

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

CREATE TABLE "papakura_local_board" (
  "name" text,
  "years" text,
  "gender" text,
  "area" text,
  "authority" text,
  "decile" real,
  "roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `What were the years for Redhill school, authority of state?`:
```sql
                SELECT "years" FROM "papakura_local_board" WHERE "authority"='state' AND "name"='redhill school';
```
## Task
Generate a SQL query to answer the following question:
`What was the sum roll of Karaka area?`

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

CREATE TABLE "papakura_local_board" (
  "name" text,
  "years" text,
  "gender" text,
  "area" text,
  "authority" text,
  "decile" real,
  "roll" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the sum roll of Karaka area?`:
```sql
                SELECT SUM("roll") FROM "papakura_local_board" WHERE "area"='karaka';
```
## Task
Generate a SQL query to answer the following question:
`What home team played North Melbourne?`

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

CREATE TABLE "round_16" (
  "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 home team played North Melbourne?`:
```sql
                SELECT "home_team" FROM "round_16" WHERE "away_team"='north melbourne';
```
## Task
Generate a SQL query to answer the following question:
`What is the average crowd where the home team scored 8.15 (63)?`

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

CREATE TABLE "round_9" (
  "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 average crowd where the home team scored 8.15 (63)?`:
```sql
                SELECT AVG("crowd") FROM "round_9" WHERE "home_team_score"='8.15 (63)';
```
## Task
Generate a SQL query to answer the following question:
`What is the nationality of the player with a round after 4 and plays right wing?`

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

CREATE TABLE "draft_picks" (
  "round" real,
  "player" text,
  "position" text,
  "nationality" text,
  "college_junior_club_team_league" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the nationality of the player with a round after 4 and plays right wing?`:
```sql
                SELECT "nationality" FROM "draft_picks" WHERE "round">4 AND "position"='right wing';
```
## Task
Generate a SQL query to answer the following question:
`What is the college/junior/club team (league) of left wing Ondrej Roman?`

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

CREATE TABLE "draft_picks" (
  "round" real,
  "player" text,
  "position" text,
  "nationality" text,
  "college_junior_club_team_league" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the college/junior/club team (league) of left wing Ondrej Roman?`:
```sql
                SELECT "college_junior_club_team_league" FROM "draft_picks" WHERE "position"='left wing' AND "player"='ondrej roman';
```
## Task
Generate a SQL query to answer the following question:
`Who played in lake oval while away?`

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

CREATE TABLE "round_14" (
  "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 `Who played in lake oval while away?`:
```sql
                SELECT "away_team" FROM "round_14" WHERE "venue"='lake oval';
```
## Task
Generate a SQL query to answer the following question:
`What was the home score when the away team scored 16.11 (107)?`

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

CREATE TABLE "round_14" (
  "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 was the home score when the away team scored 16.11 (107)?`:
```sql
                SELECT "home_team" FROM "round_14" WHERE "away_team_score"='16.11 (107)';
```
## Task
Generate a SQL query to answer the following question:
`What was the home score when the away team scored 5.9 (39)?`

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

CREATE TABLE "round_14" (
  "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 was the home score when the away team scored 5.9 (39)?`:
```sql
                SELECT "home_team" FROM "round_14" WHERE "away_team_score"='5.9 (39)';
```
## Task
Generate a SQL query to answer the following question:
`When did the away team score 17.11 (113)?`

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

CREATE TABLE "round_14" (
  "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 away team score 17.11 (113)?`:
```sql
                SELECT "date" FROM "round_14" WHERE "away_team_score"='17.11 (113)';
```
## Task
Generate a SQL query to answer the following question:
`What is the low crowd size when the away team scored 17.11 (113)?`

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

CREATE TABLE "round_14" (
  "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 low crowd size when the away team scored 17.11 (113)?`:
```sql
                SELECT MIN("crowd") FROM "round_14" WHERE "away_team_score"='17.11 (113)';
```
## Task
Generate a SQL query to answer the following question:
`What week number saw a w 31-16 result?`

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

CREATE TABLE "schedule" (
  "week" real,
  "date" text,
  "opponent" text,
  "result" text,
  "attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What week number saw a w 31-16 result?`:
```sql
                SELECT MIN("week") FROM "schedule" WHERE "result"='w 31-16';
```
## Task
Generate a SQL query to answer the following question:
`When was the game before week 8 with a result of bye?`

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

CREATE TABLE "schedule" (
  "week" real,
  "date" text,
  "opponent" text,
  "result" text,
  "attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `When was the game before week 8 with a result of bye?`:
```sql
                SELECT "date" FROM "schedule" WHERE "week"<8 AND "result"='bye';
```
## Task
Generate a SQL query to answer the following question:
`What week number had the New York Giants as opponent?`

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

CREATE TABLE "schedule" (
  "week" real,
  "date" text,
  "opponent" text,
  "result" text,
  "attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What week number had the New York Giants as opponent?`:
```sql
                SELECT COUNT("week") FROM "schedule" WHERE "opponent"='new york giants';
```
## Task
Generate a SQL query to answer the following question:
`Who built the under grid 6 car with under 49 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 `Who built the under grid 6 car with under 49 laps?`:
```sql
                SELECT "constructor" FROM "race" WHERE "grid"<6 AND "laps"<49;
```
## Task
Generate a SQL query to answer the following question:
`Who built the grid 2 car?`

### 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 `Who built the grid 2 car?`:
```sql
                SELECT "constructor" FROM "race" WHERE "grid"=2;
```
## Task
Generate a SQL query to answer the following question:
`Who built the car that retired due to suspension before 65 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 `Who built the car that retired due to suspension before 65 laps?`:
```sql
                SELECT "constructor" FROM "race" WHERE "laps"<65 AND "time_retired"='suspension';
```
## Task
Generate a SQL query to answer the following question:
`What Valley Vista has a Dysart of 1668?`

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

CREATE TABLE "high_schools_in_dysart_usd" (
  "information" text,
  "dysart" text,
  "shadow_ridge" text,
  "valley_vista" text,
  "willow_canyon" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Valley Vista has a Dysart of 1668?`:
```sql
                SELECT "valley_vista" FROM "high_schools_in_dysart_usd" WHERE "dysart"='1668';
```
## Task
Generate a SQL query to answer the following question:
`What Valley Vista has a Willow Canyon of 2169?`

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

CREATE TABLE "high_schools_in_dysart_usd" (
  "information" text,
  "dysart" text,
  "shadow_ridge" text,
  "valley_vista" text,
  "willow_canyon" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Valley Vista has a Willow Canyon of 2169?`:
```sql
                SELECT "valley_vista" FROM "high_schools_in_dysart_usd" WHERE "willow_canyon"='2169';
```
## Task
Generate a SQL query to answer the following question:
`How many people were in the crowd at Lake Oval?`

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

CREATE TABLE "round_14" (
  "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 were in the crowd at Lake Oval?`:
```sql
                SELECT "crowd" FROM "round_14" WHERE "venue"='lake oval';
```
## Task
Generate a SQL query to answer the following question:
`Where was the game played when Geelong was the away team?`

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

CREATE TABLE "round_14" (
  "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 was the game played when Geelong was the away team?`:
```sql
                SELECT "venue" FROM "round_14" WHERE "away_team"='geelong';
```
## Task
Generate a SQL query to answer the following question:
`What team was the home team on 27 june 1981, at vfl park?`

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

CREATE TABLE "round_14" (
  "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 team was the home team on 27 june 1981, at vfl park?`:
```sql
                SELECT "home_team" FROM "round_14" WHERE "date"='27 june 1981' AND "venue"='vfl park';
```
## Task
Generate a SQL query to answer the following question:
`What is the tyre with a 56 chassis?`

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

CREATE TABLE "teams_and_drivers" (
  "entrant" text,
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyre" text,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the tyre with a 56 chassis?`:
```sql
                SELECT "tyre" FROM "teams_and_drivers" WHERE "chassis"='56';
```
## Task
Generate a SQL query to answer the following question:
`Which country has a GDP (nominal) of $29.9 billion?`

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

CREATE TABLE "prospective_members" (
  "country" text,
  "population" text,
  "area_km" text,
  "gdp_nominal" text,
  "gdp_per_capita_nominal" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which country has a GDP (nominal) of $29.9 billion?`:
```sql
                SELECT "country" FROM "prospective_members" WHERE "gdp_nominal"='$29.9 billion';
```
## Task
Generate a SQL query to answer the following question:
`Which GDP (nominal) has a Population of 5,550,239?`

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

CREATE TABLE "prospective_members" (
  "country" text,
  "population" text,
  "area_km" text,
  "gdp_nominal" text,
  "gdp_per_capita_nominal" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which GDP (nominal) has a Population of 5,550,239?`:
```sql
                SELECT "gdp_nominal" FROM "prospective_members" WHERE "population"='5,550,239';
```
## Task
Generate a SQL query to answer the following question:
`Which population has a GDP (nominal) of $6.4 billion?`

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

CREATE TABLE "prospective_members" (
  "country" text,
  "population" text,
  "area_km" text,
  "gdp_nominal" text,
  "gdp_per_capita_nominal" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which population has a GDP (nominal) of $6.4 billion?`:
```sql
                SELECT "population" FROM "prospective_members" WHERE "gdp_nominal"='$6.4 billion';
```
## Task
Generate a SQL query to answer the following question:
`What is the GDP (nominal) with Population of 5,125,693?`

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

CREATE TABLE "prospective_members" (
  "country" text,
  "population" text,
  "area_km" text,
  "gdp_nominal" text,
  "gdp_per_capita_nominal" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the GDP (nominal) with Population of 5,125,693?`:
```sql
                SELECT "gdp_per_capita_nominal" FROM "prospective_members" WHERE "population"='5,125,693';
```