cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`What Chinese Title Ranking #7 has an Average of 32 and Peak less than 38?`

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

CREATE TABLE "highest_rating_drama_series_of_2006" (
  "rank" real,
  "english_title" text,
  "chinese_title" text,
  "average" real,
  "peak" real,
  "premiere" real,
  "finale" real,
  "hk_viewers" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Chinese Title Ranking #7 has an Average of 32 and Peak less than 38?`:
```sql
                SELECT "chinese_title" FROM "highest_rating_drama_series_of_2006" WHERE "average"=32 AND "peak"<38 AND "rank"=7;
```
## Task
Generate a SQL query to answer the following question:
`Which away team has a score of 17.4 (106)?`

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

CREATE TABLE "round_1" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which away team has a score of 17.4 (106)?`:
```sql
                SELECT "away_team" FROM "round_1" WHERE "away_team_score"='17.4 (106)';
```
## Task
Generate a SQL query to answer the following question:
`What is the average crowd size for corio oval?`

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

CREATE TABLE "round_1" (
  "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 size for corio oval?`:
```sql
                SELECT AVG("crowd") FROM "round_1" WHERE "venue"='corio oval';
```
## Task
Generate a SQL query to answer the following question:
`What is the average crowd size for Brunswick street oval?`

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

CREATE TABLE "round_1" (
  "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 size for Brunswick street oval?`:
```sql
                SELECT AVG("crowd") FROM "round_1" WHERE "venue"='brunswick street oval';
```
## Task
Generate a SQL query to answer the following question:
`What day did the team play in murcia with a score of 0-3 after 1992?`

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

CREATE TABLE "1990_1999" (
  "year" real,
  "competition" text,
  "date" text,
  "location" text,
  "score" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What day did the team play in murcia with a score of 0-3 after 1992?`:
```sql
                SELECT "date" FROM "1990_1999" WHERE "year">1992 AND "location"='murcia' AND "score"='0-3';
```
## Task
Generate a SQL query to answer the following question:
`What location did the team win before 1998 in the europe/africa zone, group i, round robin?`

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

CREATE TABLE "1990_1999" (
  "year" real,
  "competition" text,
  "date" text,
  "location" text,
  "score" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What location did the team win before 1998 in the europe/africa zone, group i, round robin?`:
```sql
                SELECT "location" FROM "1990_1999" WHERE "competition"='europe/africa zone, group i, round robin' AND "result"='win' AND "year"<1998;
```
## Task
Generate a SQL query to answer the following question:
`What day did they record a score of 1-2 in 1994?`

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

CREATE TABLE "1990_1999" (
  "year" real,
  "competition" text,
  "date" text,
  "location" text,
  "score" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What day did they record a score of 1-2 in 1994?`:
```sql
                SELECT "date" FROM "1990_1999" WHERE "score"='1-2' AND "year"=1994;
```
## Task
Generate a SQL query to answer the following question:
`Who was the opponent on November 5, 1944 with more than 24,123 people to watch?`

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

CREATE TABLE "schedule" (
  "week" real,
  "date" text,
  "opponent" text,
  "result" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the opponent on November 5, 1944 with more than 24,123 people to watch?`:
```sql
                SELECT "opponent" FROM "schedule" WHERE "attendance">'24,123' AND "date"='november 5, 1944';
```
## Task
Generate a SQL query to answer the following question:
`When the country is austria germany and the rank is kept under 5, what's the average number of matches played?`

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

CREATE TABLE "all_matches" (
  "rank" real,
  "name" text,
  "country" text,
  "years" text,
  "matches" real,
  "goals" real
);
### SQL
Given the database schema, here is the SQL query that answers `When the country is austria germany and the rank is kept under 5, what's the average number of matches played?`:
```sql
                SELECT AVG("matches") FROM "all_matches" WHERE "country"='austria germany' AND "rank"<5;
```
## Task
Generate a SQL query to answer the following question:
`Which country does the player pele belong to?`

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

CREATE TABLE "all_matches" (
  "rank" real,
  "name" text,
  "country" text,
  "years" text,
  "matches" real,
  "goals" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which country does the player pele belong to?`:
```sql
                SELECT "country" FROM "all_matches" WHERE "name"='pele';
```
## Task
Generate a SQL query to answer the following question:
`What is the earliest game that had 42,707 attending?`

### 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 `What is the earliest game that had 42,707 attending?`:
```sql
                SELECT MIN("game") FROM "summary" WHERE "attendance"='42,707';
```
## Task
Generate a SQL query to answer the following question:
`What is the sum of the figure skating scores whose total is less than 117.78?`

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

CREATE TABLE "ladies" (
  "rank" real,
  "name" text,
  "nation" text,
  "placings" text,
  "figures" real,
  "free" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the sum of the figure skating scores whose total is less than 117.78?`:
```sql
                SELECT SUM("figures") FROM "ladies" WHERE "total"<117.78;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest total score among skaters from West Germany with a rank of 20 and a figure skating score less than 74.85?`

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

CREATE TABLE "ladies" (
  "rank" real,
  "name" text,
  "nation" text,
  "placings" text,
  "figures" real,
  "free" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest total score among skaters from West Germany with a rank of 20 and a figure skating score less than 74.85?`:
```sql
                SELECT MIN("total") FROM "ladies" WHERE "nation"='west germany' AND "rank"=20 AND "figures"<74.85;
```
## Task
Generate a SQL query to answer the following question:
`How many placings did Jacqueline du Bief earn where her total score is greater than 131.26?`

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

CREATE TABLE "ladies" (
  "rank" real,
  "name" text,
  "nation" text,
  "placings" text,
  "figures" real,
  "free" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many placings did Jacqueline du Bief earn where her total score is greater than 131.26?`:
```sql
                SELECT "placings" FROM "ladies" WHERE "total">131.26 AND "name"='jacqueline du bief';
```
## Task
Generate a SQL query to answer the following question:
`Can you tell me the Placings that hasthe Free smaller than 524.3, and the Total smaller than 1170.1, and the Name of per cock-clausen?`

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

CREATE TABLE "men" (
  "rank" real,
  "name" text,
  "nation" text,
  "placings" real,
  "figures" real,
  "free" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `Can you tell me the Placings that hasthe Free smaller than 524.3, and the Total smaller than 1170.1, and the Name of per cock-clausen?`:
```sql
                SELECT "placings" FROM "men" WHERE "free"<524.3 AND "total"<1170.1 AND "name"='per cock-clausen';
```
## Task
Generate a SQL query to answer the following question:
`Can you tell me the average Figures that has the Placings of 34, and the Total larger than 1247.51?`

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

CREATE TABLE "men" (
  "rank" real,
  "name" text,
  "nation" text,
  "placings" real,
  "figures" real,
  "free" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `Can you tell me the average Figures that has the Placings of 34, and the Total larger than 1247.51?`:
```sql
                SELECT AVG("figures") FROM "men" WHERE "placings"=34 AND "total">1247.51;
```
## Task
Generate a SQL query to answer the following question:
`What is the result where the opponent is Columbus Destroyers?`

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

CREATE TABLE "regular_season_schedule" (
  "week" real,
  "date" text,
  "opponent" text,
  "home_away_game" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the result where the opponent is Columbus Destroyers?`:
```sql
                SELECT "result" FROM "regular_season_schedule" WHERE "opponent"='columbus destroyers';
```
## Task
Generate a SQL query to answer the following question:
`What is the date of the away game in week 8?`

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

CREATE TABLE "regular_season_schedule" (
  "week" real,
  "date" text,
  "opponent" text,
  "home_away_game" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the date of the away game in week 8?`:
```sql
                SELECT "date" FROM "regular_season_schedule" WHERE "home_away_game"='away' AND "week"=8;
```
## Task
Generate a SQL query to answer the following question:
`Which grand prix had gerhard berger in his fastest lap and a jacques villeneuve pole position?`

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

CREATE TABLE "grands_prix" (
  "round" real,
  "grand_prix" text,
  "pole_position" text,
  "fastest_lap" text,
  "winning_driver" text,
  "winning_constructor" text,
  "report" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which grand prix had gerhard berger in his fastest lap and a jacques villeneuve pole position?`:
```sql
                SELECT "grand_prix" FROM "grands_prix" WHERE "fastest_lap"='gerhard berger' AND "pole_position"='jacques villeneuve';
```
## Task
Generate a SQL query to answer the following question:
`Which council has a notional control of noc and a 2007 result of no overall control (snp + ld)?`

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

CREATE TABLE "councils" (
  "council" text,
  "2003_result" text,
  "notional_control_based_on_2003_results" text,
  "2007_result" text,
  "details" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which council has a notional control of noc and a 2007 result of no overall control (snp + ld)?`:
```sql
                SELECT "council" FROM "councils" WHERE "notional_control_based_on_2003_results"='noc' AND "2007_result"='no overall control (snp + ld)';
```
## Task
Generate a SQL query to answer the following question:
`What's the 2007 result when the notional control is noc?`

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

CREATE TABLE "councils" (
  "council" text,
  "2003_result" text,
  "notional_control_based_on_2003_results" text,
  "2007_result" text,
  "details" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the 2007 result when the notional control is noc?`:
```sql
                SELECT "2007_result" FROM "councils" WHERE "notional_control_based_on_2003_results"='noc';
```
## Task
Generate a SQL query to answer the following question:
`What's the 2003 result for the falkirk council?`

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

CREATE TABLE "councils" (
  "council" text,
  "2003_result" text,
  "notional_control_based_on_2003_results" text,
  "2007_result" text,
  "details" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the 2003 result for the falkirk council?`:
```sql
                SELECT "2003_result" FROM "councils" WHERE "council"='falkirk';
```
## Task
Generate a SQL query to answer the following question:
`What council has a 2007 result of no overall control (ind + snp)?`

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

CREATE TABLE "councils" (
  "council" text,
  "2003_result" text,
  "notional_control_based_on_2003_results" text,
  "2007_result" text,
  "details" text
);
### SQL
Given the database schema, here is the SQL query that answers `What council has a 2007 result of no overall control (ind + snp)?`:
```sql
                SELECT "council" FROM "councils" WHERE "2007_result"='no overall control (ind + snp)';
```
## Task
Generate a SQL query to answer the following question:
`What's the 2007 result when the notional control is noc and the 2003 result is snp?`

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

CREATE TABLE "councils" (
  "council" text,
  "2003_result" text,
  "notional_control_based_on_2003_results" text,
  "2007_result" text,
  "details" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the 2007 result when the notional control is noc and the 2003 result is snp?`:
```sql
                SELECT "2007_result" FROM "councils" WHERE "notional_control_based_on_2003_results"='noc' AND "2003_result"='snp';
```
## Task
Generate a SQL query to answer the following question:
`On which date was the manager fired and replaced by Albert Cartier?`

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

CREATE TABLE "managerial_changes" (
  "team" text,
  "outgoing_manager" text,
  "manner_of_departure" text,
  "date_of_vacancy" text,
  "replaced_by" text,
  "date_of_appointment" text
);
### SQL
Given the database schema, here is the SQL query that answers `On which date was the manager fired and replaced by Albert Cartier?`:
```sql
                SELECT "date_of_vacancy" FROM "managerial_changes" WHERE "manner_of_departure"='fired' AND "replaced_by"='albert cartier';
```
## Task
Generate a SQL query to answer the following question:
`What was the manner of departure for the team Anderlecht?`

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

CREATE TABLE "managerial_changes" (
  "team" text,
  "outgoing_manager" text,
  "manner_of_departure" text,
  "date_of_vacancy" text,
  "replaced_by" text,
  "date_of_appointment" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the manner of departure for the team Anderlecht?`:
```sql
                SELECT "manner_of_departure" FROM "managerial_changes" WHERE "team"='anderlecht';
```
## Task
Generate a SQL query to answer the following question:
`What was the manner of depature when the date of appointment was 27 December 2007?`

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

CREATE TABLE "managerial_changes" (
  "team" text,
  "outgoing_manager" text,
  "manner_of_departure" text,
  "date_of_vacancy" text,
  "replaced_by" text,
  "date_of_appointment" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the manner of depature when the date of appointment was 27 December 2007?`:
```sql
                SELECT "manner_of_departure" FROM "managerial_changes" WHERE "date_of_appointment"='27 december 2007';
```
## Task
Generate a SQL query to answer the following question:
`Who was the replacement for the Brussels team with a date of vacancy of 22 December 2007?`

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

CREATE TABLE "managerial_changes" (
  "team" text,
  "outgoing_manager" text,
  "manner_of_departure" text,
  "date_of_vacancy" text,
  "replaced_by" text,
  "date_of_appointment" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the replacement for the Brussels team with a date of vacancy of 22 December 2007?`:
```sql
                SELECT "replaced_by" FROM "managerial_changes" WHERE "team"='brussels' AND "date_of_vacancy"='22 december 2007';
```
## Task
Generate a SQL query to answer the following question:
`What was the date of vacancy where the replacement was Albert Cartier and the manager was fired?`

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

CREATE TABLE "managerial_changes" (
  "team" text,
  "outgoing_manager" text,
  "manner_of_departure" text,
  "date_of_vacancy" text,
  "replaced_by" text,
  "date_of_appointment" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the date of vacancy where the replacement was Albert Cartier and the manager was fired?`:
```sql
                SELECT "date_of_vacancy" FROM "managerial_changes" WHERE "manner_of_departure"='fired' AND "replaced_by"='albert cartier';
```
## Task
Generate a SQL query to answer the following question:
`What is the Tallangatta DFL losses greater than 2 and an against greater than 1013`

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

CREATE TABLE "2009_ladder" (
  "tallangatta_dfl" text,
  "wins" real,
  "byes" real,
  "losses" real,
  "draws" real,
  "against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Tallangatta DFL losses greater than 2 and an against greater than 1013`:
```sql
                SELECT "tallangatta_dfl" FROM "2009_ladder" WHERE "against">1013 AND "losses">2;
```
## Task
Generate a SQL query to answer the following question:
`What are the average byes that are greater than 1479, wins greater than 5 and 0 draws?`

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

CREATE TABLE "2009_ladder" (
  "tallangatta_dfl" text,
  "wins" real,
  "byes" real,
  "losses" real,
  "draws" real,
  "against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What are the average byes that are greater than 1479, wins greater than 5 and 0 draws?`:
```sql
                SELECT AVG("byes") FROM "2009_ladder" WHERE "against">1479 AND "wins">5 AND "draws"<0;
```
## Task
Generate a SQL query to answer the following question:
`Tell me the average year for rank more than 3 and 28 floors`

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

CREATE TABLE "tallest_buildings" (
  "rank" real,
  "name" text,
  "height_m_ft" text,
  "floors" real,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the average year for rank more than 3 and 28 floors`:
```sql
                SELECT AVG("year") FROM "tallest_buildings" WHERE "rank">3 AND "floors"=28;
```
## Task
Generate a SQL query to answer the following question:
`I want the name for rank less than 6 and year more than 1974`

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

CREATE TABLE "tallest_buildings" (
  "rank" real,
  "name" text,
  "height_m_ft" text,
  "floors" real,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `I want the name for rank less than 6 and year more than 1974`:
```sql
                SELECT "name" FROM "tallest_buildings" WHERE "rank"<6 AND "year">1974;
```
## Task
Generate a SQL query to answer the following question:
`What is the average rank of Great Britain when their total is over 4?`

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

CREATE TABLE "nations" (
  "rank" real,
  "nation" text,
  "gold" real,
  "silver" real,
  "bronze" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average rank of Great Britain when their total is over 4?`:
```sql
                SELECT AVG("rank") FROM "nations" WHERE "total">4 AND "nation"='great britain';
```
## Task
Generate a SQL query to answer the following question:
`What is the total number of Silvers held by France when their rank was over 14?`

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

CREATE TABLE "nations" (
  "rank" real,
  "nation" text,
  "gold" real,
  "silver" real,
  "bronze" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of Silvers held by France when their rank was over 14?`:
```sql
                SELECT COUNT("silver") FROM "nations" WHERE "nation"='france' AND "rank">14;
```
## Task
Generate a SQL query to answer the following question:
`Who was the home team at the game held at Princes Park?`

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

CREATE TABLE "round_20" (
  "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 was the home team at the game held at Princes Park?`:
```sql
                SELECT "home_team" FROM "round_20" WHERE "venue"='princes park';
```
## Task
Generate a SQL query to answer the following question:
`Who was the home team when the away team scored 18.18 (126)?`

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

CREATE TABLE "round_20" (
  "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 was the home team when the away team scored 18.18 (126)?`:
```sql
                SELECT "home_team" FROM "round_20" WHERE "away_team_score"='18.18 (126)';
```
## Task
Generate a SQL query to answer the following question:
`Who was the home team when Hawthorn was the away team?`

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

CREATE TABLE "round_20" (
  "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 was the home team when Hawthorn was the away team?`:
```sql
                SELECT "home_team" FROM "round_20" WHERE "away_team"='hawthorn';
```
## Task
Generate a SQL query to answer the following question:
`What was the Rockies record at their game that had a loss of Hernandez (3–5)?`

### 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 `What was the Rockies record at their game that had a loss of Hernandez (3–5)?`:
```sql
                SELECT "record" FROM "game_log" WHERE "loss"='hernandez (3–5)';
```
## Task
Generate a SQL query to answer the following question:
`What engine has g tyres and is driven by elio de angelis?`

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

CREATE TABLE "drivers_and_constructors" (
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What engine has g tyres and is driven by elio de angelis?`:
```sql
                SELECT "engine" FROM "drivers_and_constructors" WHERE "tyres"='g' AND "driver"='elio de angelis';
```
## Task
Generate a SQL query to answer the following question:
`What rounds does elio de angelis drive?`

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

CREATE TABLE "drivers_and_constructors" (
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What rounds does elio de angelis drive?`:
```sql
                SELECT "rounds" FROM "drivers_and_constructors" WHERE "driver"='elio de angelis';
```
## Task
Generate a SQL query to answer the following question:
`Who is the constructor for driver alan jones using a chassis of fw06 fw07?`

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

CREATE TABLE "drivers_and_constructors" (
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the constructor for driver alan jones using a chassis of fw06 fw07?`:
```sql
                SELECT "constructor" FROM "drivers_and_constructors" WHERE "chassis"='fw06 fw07' AND "driver"='alan jones';
```
## Task
Generate a SQL query to answer the following question:
`What engine does driver james hunt have?`

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

CREATE TABLE "drivers_and_constructors" (
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What engine does driver james hunt have?`:
```sql
                SELECT "engine" FROM "drivers_and_constructors" WHERE "driver"='james hunt';
```
## Task
Generate a SQL query to answer the following question:
`What's the engine used for rounds 5-6?`

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

CREATE TABLE "drivers_and_constructors" (
  "constructor" text,
  "chassis" text,
  "engine" text,
  "tyres" text,
  "driver" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the engine used for rounds 5-6?`:
```sql
                SELECT "engine" FROM "drivers_and_constructors" WHERE "rounds"='5-6';
```
## Task
Generate a SQL query to answer the following question:
`Who was the home team at Princes Park?`

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

CREATE TABLE "round_4" (
  "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 was the home team at Princes Park?`:
```sql
                SELECT "home_team_score" FROM "round_4" WHERE "venue"='princes park';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the city/state for the holden racing team with winner of mark skaife todd kelly`

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

CREATE TABLE "race_calendar" (
  "date" text,
  "series" text,
  "circuit" text,
  "city_state" text,
  "winner" text,
  "team" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the city/state for the holden racing team with winner of mark skaife todd kelly`:
```sql
                SELECT "city_state" FROM "race_calendar" WHERE "team"='holden racing team' AND "winner"='mark skaife todd kelly';
```
## Task
Generate a SQL query to answer the following question:
`What is the engine configuration of the 1.2 mpi engine?`

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

CREATE TABLE "engine_specifications" (
  "engine_name" text,
  "engine_configuration" text,
  "displacement" text,
  "max_power_at_rpm" text,
  "max_torque_at_rpm" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the engine configuration of the 1.2 mpi engine?`:
```sql
                SELECT "engine_configuration" FROM "engine_specifications" WHERE "engine_name"='1.2 mpi';
```
## Task
Generate a SQL query to answer the following question:
`What is the max torque of the 1.2 mpi engine?`

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

CREATE TABLE "engine_specifications" (
  "engine_name" text,
  "engine_configuration" text,
  "displacement" text,
  "max_power_at_rpm" text,
  "max_torque_at_rpm" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the max torque of the 1.2 mpi engine?`:
```sql
                SELECT "max_torque_at_rpm" FROM "engine_specifications" WHERE "engine_name"='1.2 mpi';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the long for TD's of 4`

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

CREATE TABLE "rushing" (
  "player" text,
  "car" real,
  "yards" text,
  "avg" text,
  "td_s" real,
  "long" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the long for TD's of 4`:
```sql
                SELECT "long" FROM "rushing" WHERE "td_s"=4;
```
## Task
Generate a SQL query to answer the following question:
`Tell me the long for charles frederick`

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

CREATE TABLE "rushing" (
  "player" text,
  "car" real,
  "yards" text,
  "avg" text,
  "td_s" real,
  "long" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the long for charles frederick`:
```sql
                SELECT "long" FROM "rushing" WHERE "player"='charles frederick';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the average for 1 yards`

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

CREATE TABLE "rushing" (
  "player" text,
  "car" real,
  "yards" text,
  "avg" text,
  "td_s" real,
  "long" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the average for 1 yards`:
```sql
                SELECT "avg" FROM "rushing" WHERE "yards"='1';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the sum of TD's for 4 avg.`

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

CREATE TABLE "rushing" (
  "player" text,
  "car" real,
  "yards" text,
  "avg" text,
  "td_s" real,
  "long" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the sum of TD's for 4 avg.`:
```sql
                SELECT SUM("td_s") FROM "rushing" WHERE "avg"='4';
```
## Task
Generate a SQL query to answer the following question:
`Which time/retired had 75 laps and Pedro de la Rosa as a driver?`

### 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 `Which time/retired had 75 laps and Pedro de la Rosa as a driver?`:
```sql
                SELECT "time_retired" FROM "race" WHERE "laps"=75 AND "driver"='pedro de la rosa';
```
## Task
Generate a SQL query to answer the following question:
`What is the total number in the season for the #30 Robert Berlinger series?`

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

CREATE TABLE "season_2" (
  "no_in_series" real,
  "no_in_season" real,
  "title" text,
  "directed_by" text,
  "written_by" text,
  "original_air_date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number in the season for the #30 Robert Berlinger series?`:
```sql
                SELECT COUNT("no_in_season") FROM "season_2" WHERE "directed_by"='robert berlinger' AND "no_in_series"=30;
```
## Task
Generate a SQL query to answer the following question:
`When did Julie gets Validated originally air?`

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

CREATE TABLE "season_2" (
  "no_in_series" real,
  "no_in_season" real,
  "title" text,
  "directed_by" text,
  "written_by" text,
  "original_air_date" text
);
### SQL
Given the database schema, here is the SQL query that answers `When did Julie gets Validated originally air?`:
```sql
                SELECT "original_air_date" FROM "season_2" WHERE "title"='julie gets validated';
```
## Task
Generate a SQL query to answer the following question:
`Who was the number 24 series written by?`

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

CREATE TABLE "season_2" (
  "no_in_series" real,
  "no_in_season" real,
  "title" text,
  "directed_by" text,
  "written_by" text,
  "original_air_date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the number 24 series written by?`:
```sql
                SELECT "written_by" FROM "season_2" WHERE "no_in_series"=24;
```
## Task
Generate a SQL query to answer the following question:
`When did Boyd Hale's Julie gets Validated originally air?`

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

CREATE TABLE "season_2" (
  "no_in_series" real,
  "no_in_season" real,
  "title" text,
  "directed_by" text,
  "written_by" text,
  "original_air_date" text
);
### SQL
Given the database schema, here is the SQL query that answers `When did Boyd Hale's Julie gets Validated originally air?`:
```sql
                SELECT "original_air_date" FROM "season_2" WHERE "written_by"='boyd hale' AND "title"='julie gets validated';
```
## Task
Generate a SQL query to answer the following question:
`What was the Queens number when Brooklyn was 201,866?`

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

CREATE TABLE "1973" (
  "1973_democratic_run_off_primary" text,
  "manhattan" text,
  "the_bronx" text,
  "brooklyn" text,
  "queens" text,
  "richmond_staten_is" text,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the Queens number when Brooklyn was 201,866?`:
```sql
                SELECT "queens" FROM "1973" WHERE "brooklyn"='201,866';
```
## Task
Generate a SQL query to answer the following question:
`Which Queens number in the 1973 Democratic run-off primary involved Herman Badillo and where the Bronx's percentage was 47%?`

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

CREATE TABLE "1973" (
  "1973_democratic_run_off_primary" text,
  "manhattan" text,
  "the_bronx" text,
  "brooklyn" text,
  "queens" text,
  "richmond_staten_is" text,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Queens number in the 1973 Democratic run-off primary involved Herman Badillo and where the Bronx's percentage was 47%?`:
```sql
                SELECT "queens" FROM "1973" WHERE "1973_democratic_run_off_primary"='herman badillo' AND "the_bronx"='47%';
```
## Task
Generate a SQL query to answer the following question:
`Which Manhattan number appeared when Richmond (Staten Island) was 78%?`

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

CREATE TABLE "1973" (
  "1973_democratic_run_off_primary" text,
  "manhattan" text,
  "the_bronx" text,
  "brooklyn" text,
  "queens" text,
  "richmond_staten_is" text,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Manhattan number appeared when Richmond (Staten Island) was 78%?`:
```sql
                SELECT "manhattan" FROM "1973" WHERE "richmond_staten_is"='78%';
```
## Task
Generate a SQL query to answer the following question:
`Which Manhattan number was there when the Total was bigger than 354,581 and The Bronx's number was 97,415?`

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

CREATE TABLE "1973" (
  "1973_democratic_run_off_primary" text,
  "manhattan" text,
  "the_bronx" text,
  "brooklyn" text,
  "queens" text,
  "richmond_staten_is" text,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Manhattan number was there when the Total was bigger than 354,581 and The Bronx's number was 97,415?`:
```sql
                SELECT "manhattan" FROM "1973" WHERE "total">'354,581' AND "the_bronx"='97,415';
```
## Task
Generate a SQL query to answer the following question:
`What did the home team score against Fitzroy?`

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

CREATE TABLE "round_5" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What did the home team score against Fitzroy?`:
```sql
                SELECT "home_team_score" FROM "round_5" WHERE "away_team"='fitzroy';
```
## Task
Generate a SQL query to answer the following question:
`Who is the listed opponent in Week 2?`

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

CREATE TABLE "schedule" (
  "week" real,
  "date" text,
  "opponent" text,
  "result" text,
  "attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the listed opponent in Week 2?`:
```sql
                SELECT "opponent" FROM "schedule" WHERE "week"=2;
```
## Task
Generate a SQL query to answer the following question:
`What date has attendance listed as 45,024?`

### 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 date has attendance listed as 45,024?`:
```sql
                SELECT "date" FROM "schedule" WHERE "attendance"='45,024';
```
## Task
Generate a SQL query to answer the following question:
`What numbered pick was mattias ohlund, with over 52 PL GP, and also a round under 11?`

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

CREATE TABLE "list_of_vancouver_canucks_draft_picks" (
  "rd_num" real,
  "pick_num" real,
  "player" text,
  "team_league" text,
  "reg_gp" real,
  "pl_gp" real
);
### SQL
Given the database schema, here is the SQL query that answers `What numbered pick was mattias ohlund, with over 52 PL GP, and also a round under 11?`:
```sql
                SELECT SUM("pick_num") FROM "list_of_vancouver_canucks_draft_picks" WHERE "rd_num"<11 AND "player"='mattias ohlund' AND "pl_gp">52;
```
## Task
Generate a SQL query to answer the following question:
`How many reg GP for mattias ohlund?`

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

CREATE TABLE "list_of_vancouver_canucks_draft_picks" (
  "rd_num" real,
  "pick_num" real,
  "player" text,
  "team_league" text,
  "reg_gp" real,
  "pl_gp" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many reg GP for mattias ohlund?`:
```sql
                SELECT COUNT("reg_gp") FROM "list_of_vancouver_canucks_draft_picks" WHERE "player"='mattias ohlund';
```
## Task
Generate a SQL query to answer the following question:
`What is the average attendance against the expos?`

### 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 average attendance against the expos?`:
```sql
                SELECT AVG("attendance") FROM "game_log" WHERE "opponent"='expos';
```
## Task
Generate a SQL query to answer the following question:
`What is the team's record on april 12?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the team's record on april 12?`:
```sql
                SELECT "record" FROM "game_log" WHERE "date"='april 12';
```
## Task
Generate a SQL query to answer the following question:
`Who did the team play on april 19?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "attendance" real,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who did the team play on april 19?`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "date"='april 19';
```
## Task
Generate a SQL query to answer the following question:
`What is the Aspect of Channel 26.5?`

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

CREATE TABLE "channel_lineup" (
  "channel" real,
  "video" text,
  "aspect" text,
  "psip_short_name" text,
  "programming" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Aspect of Channel 26.5?`:
```sql
                SELECT "aspect" FROM "channel_lineup" WHERE "channel"=26.5;
```
## Task
Generate a SQL query to answer the following question:
`Which Programming is on Channel 26.5?`

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

CREATE TABLE "channel_lineup" (
  "channel" real,
  "video" text,
  "aspect" text,
  "psip_short_name" text,
  "programming" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Programming is on Channel 26.5?`:
```sql
                SELECT "programming" FROM "channel_lineup" WHERE "channel"=26.5;
```
## Task
Generate a SQL query to answer the following question:
`Which Programming is on a channel less than 26.5, has a Video of 480i and a PSIP Short Name of jtv?`

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

CREATE TABLE "channel_lineup" (
  "channel" real,
  "video" text,
  "aspect" text,
  "psip_short_name" text,
  "programming" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Programming is on a channel less than 26.5, has a Video of 480i and a PSIP Short Name of jtv?`:
```sql
                SELECT "programming" FROM "channel_lineup" WHERE "channel"<26.5 AND "video"='480i' AND "psip_short_name"='jtv';
```
## Task
Generate a SQL query to answer the following question:
`What number of laps were done by driver Ronnie Peterson?`

### 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 number of laps were done by driver Ronnie Peterson?`:
```sql
                SELECT "laps" FROM "classification" WHERE "driver"='ronnie peterson';
```
## Task
Generate a SQL query to answer the following question:
`Which driver had a time/retired of fuel system?`

### 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 `Which driver had a time/retired of fuel system?`:
```sql
                SELECT "driver" FROM "classification" WHERE "time_retired"='fuel system';
```
## Task
Generate a SQL query to answer the following question:
`What is the sum of grids with an engine in Time/Retired with less than 45 laps for Giancarlo Baghetti?`

### 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 sum of grids with an engine in Time/Retired with less than 45 laps for Giancarlo Baghetti?`:
```sql
                SELECT SUM("grid") FROM "classification" WHERE "time_retired"='engine' AND "laps"<45 AND "driver"='giancarlo baghetti';
```
## Task
Generate a SQL query to answer the following question:
`I want the Grid for Laps of 35`

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

CREATE TABLE "race" (
  "driver" text,
  "constructor" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `I want the Grid for Laps of 35`:
```sql
                SELECT "grid" FROM "race" WHERE "laps"=35;
```
## Task
Generate a SQL query to answer the following question:
`What is Jonty Rhodes's batting style?`

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

CREATE TABLE "south_africa" (
  "player" text,
  "date_of_birth" text,
  "batting_style" text,
  "bowling_style" text,
  "first_class_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is Jonty Rhodes's batting style?`:
```sql
                SELECT "batting_style" FROM "south_africa" WHERE "player"='jonty rhodes';
```
## Task
Generate a SQL query to answer the following question:
`What bowling style does First Class Team, Griqualand West have?`

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

CREATE TABLE "south_africa" (
  "player" text,
  "date_of_birth" text,
  "batting_style" text,
  "bowling_style" text,
  "first_class_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `What bowling style does First Class Team, Griqualand West have?`:
```sql
                SELECT "bowling_style" FROM "south_africa" WHERE "first_class_team"='griqualand west';
```