cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`College of san diego state, and a Pick # smaller than 30 is what lowest overall?`

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

CREATE TABLE "indianapolis_colts_draft_history" (
  "round" real,
  "pick_num" real,
  "overall" real,
  "name" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `College of san diego state, and a Pick # smaller than 30 is what lowest overall?`:
```sql
                SELECT MIN("overall") FROM "indianapolis_colts_draft_history" WHERE "college"='san diego state' AND "pick_num"<30;
```
## Task
Generate a SQL query to answer the following question:
`College of san diego state, and a Pick # smaller than 30 has what lowest overall?`

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

CREATE TABLE "indianapolis_colts_draft_history" (
  "round" real,
  "pick_num" real,
  "overall" real,
  "name" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `College of san diego state, and a Pick # smaller than 30 has what lowest overall?`:
```sql
                SELECT MIN("overall") FROM "indianapolis_colts_draft_history" WHERE "college"='san diego state' AND "pick_num"<30;
```
## Task
Generate a SQL query to answer the following question:
`Which city of license has an independent network affiliation, a variety format and is station KKUP?`

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

CREATE TABLE "fm" (
  "station" text,
  "frequency" real,
  "network_affiliation" text,
  "format" text,
  "city_of_license" text,
  "status" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which city of license has an independent network affiliation, a variety format and is station KKUP?`:
```sql
                SELECT "city_of_license" FROM "fm" WHERE "network_affiliation"='independent' AND "format"='variety' AND "station"='kkup';
```
## Task
Generate a SQL query to answer the following question:
`What is the status of the independent station KPFB?`

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

CREATE TABLE "fm" (
  "station" text,
  "frequency" real,
  "network_affiliation" text,
  "format" text,
  "city_of_license" text,
  "status" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the status of the independent station KPFB?`:
```sql
                SELECT "status" FROM "fm" WHERE "network_affiliation"='independent' AND "station"='kpfb';
```
## Task
Generate a SQL query to answer the following question:
`Which city station is owned by Coyote Communications?`

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

CREATE TABLE "fm" (
  "station" text,
  "frequency" real,
  "network_affiliation" text,
  "format" text,
  "city_of_license" text,
  "status" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which city station is owned by Coyote Communications?`:
```sql
                SELECT "city_of_license" FROM "fm" WHERE "status"='owned by coyote communications';
```
## Task
Generate a SQL query to answer the following question:
`What year were the Olympic Games?`

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

CREATE TABLE "achievements" (
  "year" real,
  "competition" text,
  "venue" text,
  "position" text,
  "event" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year were the Olympic Games?`:
```sql
                SELECT SUM("year") FROM "achievements" WHERE "competition"='olympic games';
```
## Task
Generate a SQL query to answer the following question:
`What's the year in 5th position that happened in Osaka, Japan?`

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

CREATE TABLE "achievements" (
  "year" real,
  "competition" text,
  "venue" text,
  "position" text,
  "event" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the year in 5th position that happened in Osaka, Japan?`:
```sql
                SELECT MIN("year") FROM "achievements" WHERE "position"='5th' AND "venue"='osaka, japan';
```
## Task
Generate a SQL query to answer the following question:
`What year was the venue in Barcelona, Spain?`

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

CREATE TABLE "achievements" (
  "year" real,
  "competition" text,
  "venue" text,
  "position" text,
  "event" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year was the venue in Barcelona, Spain?`:
```sql
                SELECT MIN("year") FROM "achievements" WHERE "venue"='barcelona, spain';
```
## Task
Generate a SQL query to answer the following question:
`For a school with authority of state and a roll of 798, what is the decile?`

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

CREATE TABLE "whakatane_district" (
  "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 a school with authority of state and a roll of 798, what is the decile?`:
```sql
                SELECT "decile" FROM "whakatane_district" WHERE "authority"='state' AND "roll"=798;
```
## Task
Generate a SQL query to answer the following question:
`Murupara has a roll greater than 296 for what years?`

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

CREATE TABLE "whakatane_district" (
  "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 `Murupara has a roll greater than 296 for what years?`:
```sql
                SELECT "years" FROM "whakatane_district" WHERE "roll">296 AND "area"='murupara';
```
## Task
Generate a SQL query to answer the following question:
`When a school has authority of state and a decile greater than 1, what is the roll number?`

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

CREATE TABLE "whakatane_district" (
  "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 `When a school has authority of state and a decile greater than 1, what is the roll number?`:
```sql
                SELECT "roll" FROM "whakatane_district" WHERE "authority"='state' AND "decile">1;
```
## Task
Generate a SQL query to answer the following question:
`Who did the Jays play on August 30?`

### 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,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who did the Jays play on August 30?`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "date"='august 30';
```
## Task
Generate a SQL query to answer the following question:
`Which opponent has a record of 5-0-1?`

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

CREATE TABLE "mixed_martial_arts_record" (
  "res" text,
  "record" text,
  "opponent" text,
  "method" text,
  "event" text,
  "round" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which opponent has a record of 5-0-1?`:
```sql
                SELECT "opponent" FROM "mixed_martial_arts_record" WHERE "record"='5-0-1';
```
## Task
Generate a SQL query to answer the following question:
`What method does the opponent of Dan New use?`

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

CREATE TABLE "mixed_martial_arts_record" (
  "res" text,
  "record" text,
  "opponent" text,
  "method" text,
  "event" text,
  "round" text
);
### SQL
Given the database schema, here is the SQL query that answers `What method does the opponent of Dan New use?`:
```sql
                SELECT "method" FROM "mixed_martial_arts_record" WHERE "opponent"='dan new';
```
## Task
Generate a SQL query to answer the following question:
`Which method has a record of 3-0?`

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

CREATE TABLE "mixed_martial_arts_record" (
  "res" text,
  "record" text,
  "opponent" text,
  "method" text,
  "event" text,
  "round" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which method has a record of 3-0?`:
```sql
                SELECT "method" FROM "mixed_martial_arts_record" WHERE "record"='3-0';
```
## Task
Generate a SQL query to answer the following question:
`Which event is a win by an opponent of Nicolas Smith, with the round marked n/a?`

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

CREATE TABLE "mixed_martial_arts_record" (
  "res" text,
  "record" text,
  "opponent" text,
  "method" text,
  "event" text,
  "round" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which event is a win by an opponent of Nicolas Smith, with the round marked n/a?`:
```sql
                SELECT "event" FROM "mixed_martial_arts_record" WHERE "res"='win' AND "round"='n/a' AND "opponent"='nicolas smith';
```
## Task
Generate a SQL query to answer the following question:
`Which event lasted 1 round and included an opponent of Dan Spychalski?`

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

CREATE TABLE "mixed_martial_arts_record" (
  "res" text,
  "record" text,
  "opponent" text,
  "method" text,
  "event" text,
  "round" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which event lasted 1 round and included an opponent of Dan Spychalski?`:
```sql
                SELECT "event" FROM "mixed_martial_arts_record" WHERE "round"='1' AND "opponent"='dan spychalski';
```
## Task
Generate a SQL query to answer the following question:
`What is Jimmy Smith's opponent's record?`

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

CREATE TABLE "mixed_martial_arts_record" (
  "res" text,
  "record" text,
  "opponent" text,
  "method" text,
  "event" text,
  "round" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is Jimmy Smith's opponent's record?`:
```sql
                SELECT "record" FROM "mixed_martial_arts_record" WHERE "opponent"='jimmy smith';
```
## Task
Generate a SQL query to answer the following question:
`Name the sum of frequecy with brand of exa fm`

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

CREATE TABLE "fm_radio" (
  "frequency" real,
  "callsign" text,
  "brand" text,
  "format" text,
  "city_of_license" text,
  "website" text,
  "webcast" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the sum of frequecy with brand of exa fm`:
```sql
                SELECT SUM("frequency") FROM "fm_radio" WHERE "brand"='exa fm';
```
## Task
Generate a SQL query to answer the following question:
`Name the webcast for website of • and frequency of 103.3`

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

CREATE TABLE "fm_radio" (
  "frequency" real,
  "callsign" text,
  "brand" text,
  "format" text,
  "city_of_license" text,
  "website" text,
  "webcast" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the webcast for website of • and frequency of 103.3`:
```sql
                SELECT "webcast" FROM "fm_radio" WHERE "website"='•' AND "frequency"=103.3;
```
## Task
Generate a SQL query to answer the following question:
`Name the lowest frequency for brand of radio manantial`

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

CREATE TABLE "fm_radio" (
  "frequency" real,
  "callsign" text,
  "brand" text,
  "format" text,
  "city_of_license" text,
  "website" text,
  "webcast" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the lowest frequency for brand of radio manantial`:
```sql
                SELECT MIN("frequency") FROM "fm_radio" WHERE "brand"='radio manantial';
```
## Task
Generate a SQL query to answer the following question:
`Score of new york yankees – 2, brooklyn dodgers – 3 involves how many number of games?`

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

CREATE TABLE "summary" (
  "game" real,
  "date" text,
  "score" text,
  "location" text,
  "time" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Score of new york yankees – 2, brooklyn dodgers – 3 involves how many number of games?`:
```sql
                SELECT COUNT("game") FROM "summary" WHERE "score"='new york yankees – 2, brooklyn dodgers – 3';
```
## Task
Generate a SQL query to answer the following question:
`Date of october 5 had what score?`

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

CREATE TABLE "summary" (
  "game" real,
  "date" text,
  "score" text,
  "location" text,
  "time" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Date of october 5 had what score?`:
```sql
                SELECT "score" FROM "summary" WHERE "date"='october 5';
```
## Task
Generate a SQL query to answer the following question:
`brooklyn dodgers – 3, new york yankees – 5, and a Game larger than 1 had what attendance figure?`

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

CREATE TABLE "summary" (
  "game" real,
  "date" text,
  "score" text,
  "location" text,
  "time" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `brooklyn dodgers – 3, new york yankees – 5, and a Game larger than 1 had what attendance figure?`:
```sql
                SELECT SUM("attendance") FROM "summary" WHERE "score"='brooklyn dodgers – 3, new york yankees – 5' AND "game">1;
```
## Task
Generate a SQL query to answer the following question:
`Who won mixed doubles in the 2002 season?`

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

CREATE TABLE "21st_century" (
  "season" real,
  "men_s_singles" text,
  "women_s_singles" text,
  "men_s_doubles" text,
  "women_s_doubles" text,
  "mixed_doubles" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who won mixed doubles in the 2002 season?`:
```sql
                SELECT "mixed_doubles" FROM "21st_century" WHERE "season"=2002;
```
## Task
Generate a SQL query to answer the following question:
`Name the lowest Quay cranes for Berths of 1 and operator of mtl with terminal of terminal 5 (ct5)`

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

CREATE TABLE "container_terminals" (
  "terminal" text,
  "operator" text,
  "depth_m" text,
  "berths" real,
  "quay_cranes" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the lowest Quay cranes for Berths of 1 and operator of mtl with terminal of terminal 5 (ct5)`:
```sql
                SELECT MIN("quay_cranes") FROM "container_terminals" WHERE "berths"=1 AND "operator"='mtl' AND "terminal"='terminal 5 (ct5)';
```
## Task
Generate a SQL query to answer the following question:
`Name the operator with berths more than 1 and depth of 12.5-15.5`

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

CREATE TABLE "container_terminals" (
  "terminal" text,
  "operator" text,
  "depth_m" text,
  "berths" real,
  "quay_cranes" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the operator with berths more than 1 and depth of 12.5-15.5`:
```sql
                SELECT "operator" FROM "container_terminals" WHERE "berths">1 AND "depth_m"='12.5-15.5';
```
## Task
Generate a SQL query to answer the following question:
`What is the average points that Centro Asegurador earned with the McLaren M23 chassis?`

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

CREATE TABLE "complete_formula_one_world_championship_" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average points that Centro Asegurador earned with the McLaren M23 chassis?`:
```sql
                SELECT AVG("points") FROM "complete_formula_one_world_championship_" WHERE "chassis"='mclaren m23' AND "entrant"='centro asegurador';
```
## Task
Generate a SQL query to answer the following question:
`What was the chassis of Emilio de Villota in 1981?`

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

CREATE TABLE "complete_formula_one_world_championship_" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the chassis of Emilio de Villota in 1981?`:
```sql
                SELECT "chassis" FROM "complete_formula_one_world_championship_" WHERE "year">1981;
```
## Task
Generate a SQL query to answer the following question:
`What directors won an award on 14/6/6?`

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

CREATE TABLE "2006" (
  "film" text,
  "director_s" text,
  "recipient" text,
  "date" text,
  "award" text
);
### SQL
Given the database schema, here is the SQL query that answers `What directors won an award on 14/6/6?`:
```sql
                SELECT "director_s" FROM "2006" WHERE "date"='14/6/6';
```
## Task
Generate a SQL query to answer the following question:
`What date did Passion Pictures receive an award?`

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

CREATE TABLE "2006" (
  "film" text,
  "director_s" text,
  "recipient" text,
  "date" text,
  "award" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date did Passion Pictures receive an award?`:
```sql
                SELECT "date" FROM "2006" WHERE "recipient"='passion pictures';
```
## Task
Generate a SQL query to answer the following question:
`What award did Charlie Productions Ltd receive?`

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

CREATE TABLE "2006" (
  "film" text,
  "director_s" text,
  "recipient" text,
  "date" text,
  "award" text
);
### SQL
Given the database schema, here is the SQL query that answers `What award did Charlie Productions Ltd receive?`:
```sql
                SELECT "award" FROM "2006" WHERE "recipient"='charlie productions ltd';
```
## Task
Generate a SQL query to answer the following question:
`What film had Bub Ltd as the recipient?`

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

CREATE TABLE "2006" (
  "film" text,
  "director_s" text,
  "recipient" text,
  "date" text,
  "award" text
);
### SQL
Given the database schema, here is the SQL query that answers `What film had Bub Ltd as the recipient?`:
```sql
                SELECT "film" FROM "2006" WHERE "recipient"='bub ltd';
```
## Task
Generate a SQL query to answer the following question:
`What film was awarded on 22/3/06?`

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

CREATE TABLE "2006" (
  "film" text,
  "director_s" text,
  "recipient" text,
  "date" text,
  "award" text
);
### SQL
Given the database schema, here is the SQL query that answers `What film was awarded on 22/3/06?`:
```sql
                SELECT "film" FROM "2006" WHERE "date"='22/3/06';
```
## Task
Generate a SQL query to answer the following question:
`What score resulted in a winner after 2008?`

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

CREATE TABLE "finals_6_3_titles_3_runners_up" (
  "outcome" text,
  "year" real,
  "tournament" text,
  "partner" text,
  "opponent" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What score resulted in a winner after 2008?`:
```sql
                SELECT "score" FROM "finals_6_3_titles_3_runners_up" WHERE "outcome"='winner' AND "year">2008;
```
## Task
Generate a SQL query to answer the following question:
`What score has an opponent gan teik chai lin woon fui?`

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

CREATE TABLE "finals_6_3_titles_3_runners_up" (
  "outcome" text,
  "year" real,
  "tournament" text,
  "partner" text,
  "opponent" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What score has an opponent gan teik chai lin woon fui?`:
```sql
                SELECT "score" FROM "finals_6_3_titles_3_runners_up" WHERE "opponent"='gan teik chai lin woon fui';
```
## Task
Generate a SQL query to answer the following question:
`What tournament has an opponent gan teik chai lin woon fui?`

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

CREATE TABLE "finals_6_3_titles_3_runners_up" (
  "outcome" text,
  "year" real,
  "tournament" text,
  "partner" text,
  "opponent" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What tournament has an opponent gan teik chai lin woon fui?`:
```sql
                SELECT "tournament" FROM "finals_6_3_titles_3_runners_up" WHERE "opponent"='gan teik chai lin woon fui';
```
## Task
Generate a SQL query to answer the following question:
`What tournament has an opponent jung jae-sung lee yong-dae?`

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

CREATE TABLE "finals_6_3_titles_3_runners_up" (
  "outcome" text,
  "year" real,
  "tournament" text,
  "partner" text,
  "opponent" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What tournament has an opponent jung jae-sung lee yong-dae?`:
```sql
                SELECT "tournament" FROM "finals_6_3_titles_3_runners_up" WHERE "opponent"='jung jae-sung lee yong-dae';
```
## Task
Generate a SQL query to answer the following question:
`What is the record of the team that lost to Alexander (5-2)?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the record of the team that lost to Alexander (5-2)?`:
```sql
                SELECT "record" FROM "game_log" WHERE "loss"='alexander (5-2)';
```
## Task
Generate a SQL query to answer the following question:
`Which opponent has a record of 17-11?`

### 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" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which opponent has a record of 17-11?`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "record"='17-11';
```
## Task
Generate a SQL query to answer the following question:
`What is the score of the game that resulted in a 15-9 record?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the score of the game that resulted in a 15-9 record?`:
```sql
                SELECT "score" FROM "game_log" WHERE "record"='15-9';
```
## Task
Generate a SQL query to answer the following question:
`What was the attendance on May 26?`

### 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" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the attendance on May 26?`:
```sql
                SELECT "attendance" FROM "game_log" WHERE "date"='may 26';
```
## Task
Generate a SQL query to answer the following question:
`What is the score of the game that was a loss to Dotson (2-3)?`

### 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" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the score of the game that was a loss to Dotson (2-3)?`:
```sql
                SELECT "score" FROM "game_log" WHERE "loss"='dotson (2-3)';
```
## Task
Generate a SQL query to answer the following question:
`On what date was the record 19-11?`

### 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" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `On what date was the record 19-11?`:
```sql
                SELECT "date" FROM "game_log" WHERE "record"='19-11';
```
## Task
Generate a SQL query to answer the following question:
`What were the highest points before the year 1974?`

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

CREATE TABLE "complete_formula_one_world_championship_" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What were the highest points before the year 1974?`:
```sql
                SELECT MAX("points") FROM "complete_formula_one_world_championship_" WHERE "year"<1974;
```
## Task
Generate a SQL query to answer the following question:
`What was the chassis when the entrant was Lavazza March, and the points were 0.5?`

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

CREATE TABLE "complete_formula_one_world_championship_" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the chassis when the entrant was Lavazza March, and the points were 0.5?`:
```sql
                SELECT "chassis" FROM "complete_formula_one_world_championship_" WHERE "entrant"='lavazza march' AND "points"=0.5;
```
## Task
Generate a SQL query to answer the following question:
`What was the chassis when the entrant was Lavazza March, and the year was 1975?`

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

CREATE TABLE "complete_formula_one_world_championship_" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the chassis when the entrant was Lavazza March, and the year was 1975?`:
```sql
                SELECT "chassis" FROM "complete_formula_one_world_championship_" WHERE "entrant"='lavazza march' AND "year"=1975;
```
## Task
Generate a SQL query to answer the following question:
`What was the chassis when the points were greater than 0 and the entrant was March Engineering?`

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

CREATE TABLE "complete_formula_one_world_championship_" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the chassis when the points were greater than 0 and the entrant was March Engineering?`:
```sql
                SELECT "chassis" FROM "complete_formula_one_world_championship_" WHERE "points">0 AND "entrant"='march engineering';
```
## Task
Generate a SQL query to answer the following question:
`Who had a time of 56.07?`

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

CREATE TABLE "semifinal_1" (
  "rank" real,
  "lane" real,
  "name" text,
  "nationality" text,
  "time" real
);
### SQL
Given the database schema, here is the SQL query that answers `Who had a time of 56.07?`:
```sql
                SELECT "name" FROM "semifinal_1" WHERE "time"=56.07;
```
## Task
Generate a SQL query to answer the following question:
`What is the original title of Madame Rosa?`

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

CREATE TABLE "1970s" (
  "year" text,
  "english_title" text,
  "original_title" text,
  "country" text,
  "director" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the original title of Madame Rosa?`:
```sql
                SELECT "original_title" FROM "1970s" WHERE "english_title"='madame rosa';
```
## Task
Generate a SQL query to answer the following question:
`What is the original title where Paul Verhoeven is the director?`

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

CREATE TABLE "1970s" (
  "year" text,
  "english_title" text,
  "original_title" text,
  "country" text,
  "director" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the original title where Paul Verhoeven is the director?`:
```sql
                SELECT "original_title" FROM "1970s" WHERE "director"='paul verhoeven';
```
## Task
Generate a SQL query to answer the following question:
`What original title has a year of 1978?`

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

CREATE TABLE "1970s" (
  "year" text,
  "english_title" text,
  "original_title" text,
  "country" text,
  "director" text
);
### SQL
Given the database schema, here is the SQL query that answers `What original title has a year of 1978?`:
```sql
                SELECT "original_title" FROM "1970s" WHERE "year"='1978';
```
## Task
Generate a SQL query to answer the following question:
`Who is the director of the best foreign film?`

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

CREATE TABLE "1970s" (
  "year" text,
  "english_title" text,
  "original_title" text,
  "country" text,
  "director" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the director of the best foreign film?`:
```sql
                SELECT "director" FROM "1970s" WHERE "original_title"='best foreign film';
```
## Task
Generate a SQL query to answer the following question:
`What is the English title for Ansikte Mot Ansikte?`

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

CREATE TABLE "1970s" (
  "year" text,
  "english_title" text,
  "original_title" text,
  "country" text,
  "director" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the English title for Ansikte Mot Ansikte?`:
```sql
                SELECT "english_title" FROM "1970s" WHERE "original_title"='ansikte mot ansikte';
```
## Task
Generate a SQL query to answer the following question:
`What happened on 2009-09-05?`

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

CREATE TABLE "2009" (
  "date" text,
  "location" text,
  "nature_of_incident" text,
  "circumstances" text,
  "casualties" text
);
### SQL
Given the database schema, here is the SQL query that answers `What happened on 2009-09-05?`:
```sql
                SELECT "circumstances" FROM "2009" WHERE "date"='2009-09-05';
```
## Task
Generate a SQL query to answer the following question:
`Where was the combat of 2009-09-16?`

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

CREATE TABLE "2009" (
  "date" text,
  "location" text,
  "nature_of_incident" text,
  "circumstances" text,
  "casualties" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where was the combat of 2009-09-16?`:
```sql
                SELECT "location" FROM "2009" WHERE "circumstances"='combat' AND "date"='2009-09-16';
```
## Task
Generate a SQL query to answer the following question:
`What happened on 2009-03-14?`

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

CREATE TABLE "2009" (
  "date" text,
  "location" text,
  "nature_of_incident" text,
  "circumstances" text,
  "casualties" text
);
### SQL
Given the database schema, here is the SQL query that answers `What happened on 2009-03-14?`:
```sql
                SELECT "circumstances" FROM "2009" WHERE "date"='2009-03-14';
```
## Task
Generate a SQL query to answer the following question:
`How many casualties from the combat in the Fayzabad area?`

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

CREATE TABLE "2009" (
  "date" text,
  "location" text,
  "nature_of_incident" text,
  "circumstances" text,
  "casualties" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many casualties from the combat in the Fayzabad area?`:
```sql
                SELECT "casualties" FROM "2009" WHERE "circumstances"='combat' AND "location"='fayzabad area';
```
## Task
Generate a SQL query to answer the following question:
`Where was the incident of 2009-09-05?`

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

CREATE TABLE "2009" (
  "date" text,
  "location" text,
  "nature_of_incident" text,
  "circumstances" text,
  "casualties" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where was the incident of 2009-09-05?`:
```sql
                SELECT "location" FROM "2009" WHERE "date"='2009-09-05';
```
## Task
Generate a SQL query to answer the following question:
`What is the home team of the game on January 22?`

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

CREATE TABLE "regular_season" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the home team of the game on January 22?`:
```sql
                SELECT "home" FROM "regular_season" WHERE "date"='january 22';
```
## Task
Generate a SQL query to answer the following question:
`What is the score of the game on February 26 with the Chicago black hawks as the home team and the New York Rangers as the visitor team?`

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

CREATE TABLE "regular_season" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the score of the game on February 26 with the Chicago black hawks as the home team and the New York Rangers as the visitor team?`:
```sql
                SELECT "score" FROM "regular_season" WHERE "home"='chicago black hawks' AND "visitor"='new york rangers' AND "date"='february 26';
```
## Task
Generate a SQL query to answer the following question:
`What is the home team of the game on February 4?`

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

CREATE TABLE "regular_season" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the home team of the game on February 4?`:
```sql
                SELECT "home" FROM "regular_season" WHERE "date"='february 4';
```
## Task
Generate a SQL query to answer the following question:
`What Team had less than 1 point with a Zakspeed 871 chassis?`

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

CREATE TABLE "formula_one_results" (
  "year" real,
  "team" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What Team had less than 1 point with a Zakspeed 871 chassis?`:
```sql
                SELECT "team" FROM "formula_one_results" WHERE "points"<1 AND "chassis"='zakspeed 871';
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest amount of points for a Ford Cosworth DFR (Mader) 3.5 V8 engine?`

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

CREATE TABLE "formula_one_results" (
  "year" real,
  "team" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest amount of points for a Ford Cosworth DFR (Mader) 3.5 V8 engine?`:
```sql
                SELECT MIN("points") FROM "formula_one_results" WHERE "engine"='ford cosworth dfr (mader) 3.5 v8';
```
## Task
Generate a SQL query to answer the following question:
`What year was a Rial Arc2 chassis used?`

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

CREATE TABLE "formula_one_results" (
  "year" real,
  "team" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What year was a Rial Arc2 chassis used?`:
```sql
                SELECT SUM("year") FROM "formula_one_results" WHERE "chassis"='rial arc2';
```
## Task
Generate a SQL query to answer the following question:
`Name the bronze when silver is 1`

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

CREATE TABLE "medal_table" (
  "nation" text,
  "gold" real,
  "silver" real,
  "bronze" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the bronze when silver is 1`:
```sql
                SELECT "bronze" FROM "medal_table" WHERE "silver"=1;
```
## Task
Generate a SQL query to answer the following question:
`Name the least silver when gold is less than 0`

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

CREATE TABLE "medal_table" (
  "nation" text,
  "gold" real,
  "silver" real,
  "bronze" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the least silver when gold is less than 0`:
```sql
                SELECT MIN("silver") FROM "medal_table" WHERE "gold"<0;
```
## Task
Generate a SQL query to answer the following question:
`Name the least silver for nation of total when bronze is more than 24`

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

CREATE TABLE "medal_table" (
  "nation" text,
  "gold" real,
  "silver" real,
  "bronze" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `Name the least silver for nation of total when bronze is more than 24`:
```sql
                SELECT MIN("silver") FROM "medal_table" WHERE "nation"='total' AND "bronze">24;
```
## Task
Generate a SQL query to answer the following question:
`Name the year with finish of 12th and record of 23-36`

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

CREATE TABLE "season_by_season" (
  "year" text,
  "record" text,
  "finish" text,
  "manager" text,
  "playoffs" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the year with finish of 12th and record of 23-36`:
```sql
                SELECT "year" FROM "season_by_season" WHERE "finish"='12th' AND "record"='23-36';
```
## Task
Generate a SQL query to answer the following question:
`Name the record for 1997`

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

CREATE TABLE "season_by_season" (
  "year" text,
  "record" text,
  "finish" text,
  "manager" text,
  "playoffs" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the record for 1997`:
```sql
                SELECT "record" FROM "season_by_season" WHERE "year"='1997';
```
## Task
Generate a SQL query to answer the following question:
`Name the year for jesus alfaro and finish of 6th`

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

CREATE TABLE "season_by_season" (
  "year" text,
  "record" text,
  "finish" text,
  "manager" text,
  "playoffs" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the year for jesus alfaro and finish of 6th`:
```sql
                SELECT "year" FROM "season_by_season" WHERE "manager"='jesus alfaro' AND "finish"='6th';
```
## Task
Generate a SQL query to answer the following question:
`Name the manager for playoffs of missed for 1999`

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

CREATE TABLE "season_by_season" (
  "year" text,
  "record" text,
  "finish" text,
  "manager" text,
  "playoffs" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the manager for playoffs of missed for 1999`:
```sql
                SELECT "manager" FROM "season_by_season" WHERE "playoffs"='missed' AND "year"='1999';
```
## Task
Generate a SQL query to answer the following question:
`What was the average attendance when the record was 17-18?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the average attendance when the record was 17-18?`:
```sql
                SELECT AVG("attendance") FROM "game_log" WHERE "record"='17-18';
```
## Task
Generate a SQL query to answer the following question:
`What was marlboro brm's lowest points by using brm p160b?`

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

CREATE TABLE "complete_formula_one_world_championship_" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was marlboro brm's lowest points by using brm p160b?`:
```sql
                SELECT MIN("points") FROM "complete_formula_one_world_championship_" WHERE "entrant"='marlboro brm' AND "chassis"='brm p160b';
```
## Task
Generate a SQL query to answer the following question:
`What is the total points in 1974?`

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

CREATE TABLE "complete_formula_one_world_championship_" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total points in 1974?`:
```sql
                SELECT COUNT("points") FROM "complete_formula_one_world_championship_" WHERE "year"=1974;
```
## Task
Generate a SQL query to answer the following question:
`Who has 0 points in 1974?`

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

CREATE TABLE "complete_formula_one_world_championship_" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Who has 0 points in 1974?`:
```sql
                SELECT "entrant" FROM "complete_formula_one_world_championship_" WHERE "points"=0 AND "year"=1974;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest points of using mclaren m14a as chassis?`

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

CREATE TABLE "complete_formula_one_world_championship_" (
  "year" real,
  "entrant" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest points of using mclaren m14a as chassis?`:
```sql
                SELECT MIN("points") FROM "complete_formula_one_world_championship_" WHERE "chassis"='mclaren m14a';
```
## Task
Generate a SQL query to answer the following question:
`Location of saint paul, and a Final-Score larger than 14.35, and a Event of all around is what sum of year?`

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

CREATE TABLE "2006_season_junior_career" (
  "year" real,
  "competition" text,
  "location" text,
  "event" text,
  "final_rank" real,
  "final_score" real
);
### SQL
Given the database schema, here is the SQL query that answers `Location of saint paul, and a Final-Score larger than 14.35, and a Event of all around is what sum of year?`:
```sql
                SELECT SUM("year") FROM "2006_season_junior_career" WHERE "location"='saint paul' AND "final_score">14.35 AND "event"='all around';
```
## Task
Generate a SQL query to answer the following question:
`Competition of u.s championships, and a Event of all around has what average year?`

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

CREATE TABLE "2006_season_junior_career" (
  "year" real,
  "competition" text,
  "location" text,
  "event" text,
  "final_rank" real,
  "final_score" real
);
### SQL
Given the database schema, here is the SQL query that answers `Competition of u.s championships, and a Event of all around has what average year?`:
```sql
                SELECT AVG("year") FROM "2006_season_junior_career" WHERE "competition"='u.s championships' AND "event"='all around';
```
## Task
Generate a SQL query to answer the following question:
`What film was in 1970?`

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

CREATE TABLE "nominated" (
  "year" real,
  "song" text,
  "film" text,
  "music_director_s" text,
  "lyricist" text
);
### SQL
Given the database schema, here is the SQL query that answers `What film was in 1970?`:
```sql
                SELECT "film" FROM "nominated" WHERE "year"=1970;
```
## Task
Generate a SQL query to answer the following question:
`Who wrote the lyrics for Mukti?`

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

CREATE TABLE "nominated" (
  "year" real,
  "song" text,
  "film" text,
  "music_director_s" text,
  "lyricist" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who wrote the lyrics for Mukti?`:
```sql
                SELECT "lyricist" FROM "nominated" WHERE "film"='mukti';
```
## Task
Generate a SQL query to answer the following question:
`What song was directed by Shankar Jaikishan?`

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

CREATE TABLE "nominated" (
  "year" real,
  "song" text,
  "film" text,
  "music_director_s" text,
  "lyricist" text
);
### SQL
Given the database schema, here is the SQL query that answers `What song was directed by Shankar Jaikishan?`:
```sql
                SELECT "song" FROM "nominated" WHERE "music_director_s"='shankar jaikishan';
```