cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`Which model has a Fleet Series (Quantity) of 11081-11092 (12)?`

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

CREATE TABLE "current_fleet_roster" (
  "builder" text,
  "model" text,
  "length_ft_m" text,
  "order_year" text,
  "fuel_propulsion" text,
  "fleet_series_quantity" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which model has a Fleet Series (Quantity) of 11081-11092 (12)?`:
```sql
                SELECT "model" FROM "current_fleet_roster" WHERE "fleet_series_quantity"='11081-11092 (12)';
```
## Task
Generate a SQL query to answer the following question:
`Which order year has a Fleet Series (Quantity) of 12081-12090 (10)?`

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

CREATE TABLE "current_fleet_roster" (
  "builder" text,
  "model" text,
  "length_ft_m" text,
  "order_year" text,
  "fuel_propulsion" text,
  "fleet_series_quantity" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which order year has a Fleet Series (Quantity) of 12081-12090 (10)?`:
```sql
                SELECT "order_year" FROM "current_fleet_roster" WHERE "fleet_series_quantity"='12081-12090 (10)';
```
## Task
Generate a SQL query to answer the following question:
`Which Fleet Series (Quantity) that has a Builder of mci, and an Order Year of 2002?`

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

CREATE TABLE "current_fleet_roster" (
  "builder" text,
  "model" text,
  "length_ft_m" text,
  "order_year" text,
  "fuel_propulsion" text,
  "fleet_series_quantity" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Fleet Series (Quantity) that has a Builder of mci, and an Order Year of 2002?`:
```sql
                SELECT "fleet_series_quantity" FROM "current_fleet_roster" WHERE "builder"='mci' AND "order_year"='2002';
```
## Task
Generate a SQL query to answer the following question:
`Which Fleet Series (Quantity) has an Order Year of 2010, and a Model of de40lfr?`

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

CREATE TABLE "current_fleet_roster" (
  "builder" text,
  "model" text,
  "length_ft_m" text,
  "order_year" text,
  "fuel_propulsion" text,
  "fleet_series_quantity" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Fleet Series (Quantity) has an Order Year of 2010, and a Model of de40lfr?`:
```sql
                SELECT "fleet_series_quantity" FROM "current_fleet_roster" WHERE "order_year"='2010' AND "model"='de40lfr';
```
## Task
Generate a SQL query to answer the following question:
`Which Fuel Propulsion has a Fleet Series (Quantity) of 04001-04125 (125)?`

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

CREATE TABLE "current_fleet_roster" (
  "builder" text,
  "model" text,
  "length_ft_m" text,
  "order_year" text,
  "fuel_propulsion" text,
  "fleet_series_quantity" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Fuel Propulsion has a Fleet Series (Quantity) of 04001-04125 (125)?`:
```sql
                SELECT "fuel_propulsion" FROM "current_fleet_roster" WHERE "fleet_series_quantity"='04001-04125 (125)';
```
## Task
Generate a SQL query to answer the following question:
`Name the sum of roll for morrinsville school`

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

CREATE TABLE "matamata_piako_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 `Name the sum of roll for morrinsville school`:
```sql
                SELECT SUM("roll") FROM "matamata_piako_district" WHERE "name"='morrinsville school';
```
## Task
Generate a SQL query to answer the following question:
`Name the authority for morrinsville college`

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

CREATE TABLE "matamata_piako_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 `Name the authority for morrinsville college`:
```sql
                SELECT "authority" FROM "matamata_piako_district" WHERE "name"='morrinsville college';
```
## Task
Generate a SQL query to answer the following question:
`Name the years when decile was less than 7 for waitoa school`

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

CREATE TABLE "matamata_piako_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 `Name the years when decile was less than 7 for waitoa school`:
```sql
                SELECT "years" FROM "matamata_piako_district" WHERE "decile"<7 AND "name"='waitoa school';
```
## Task
Generate a SQL query to answer the following question:
`Name the total number of roll for state authority and stanley avenue school with decile more than 5`

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

CREATE TABLE "matamata_piako_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 `Name the total number of roll for state authority and stanley avenue school with decile more than 5`:
```sql
                SELECT COUNT("roll") FROM "matamata_piako_district" WHERE "authority"='state' AND "name"='stanley avenue school' AND "decile">5;
```
## Task
Generate a SQL query to answer the following question:
`What was the Blue Jays' record when they played the Royals with an attendance larger than 50,522?`

### 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 Blue Jays' record when they played the Royals with an attendance larger than 50,522?`:
```sql
                SELECT "record" FROM "game_log" WHERE "attendance">'50,522' AND "opponent"='royals';
```
## Task
Generate a SQL query to answer the following question:
`What year had a population region total of 63,073 and a population maroochy smaller than 35,266?`

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

CREATE TABLE "population" (
  "year" real,
  "population_region_total" real,
  "population_caloundra" real,
  "population_maroochy" real,
  "population_noosa" real
);
### SQL
Given the database schema, here is the SQL query that answers `What year had a population region total of 63,073 and a population maroochy smaller than 35,266?`:
```sql
                SELECT MAX("year") FROM "population" WHERE "population_region_total"='63,073' AND "population_maroochy"<'35,266';
```
## Task
Generate a SQL query to answer the following question:
`What is the grid total associated with 18 laps?`

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

CREATE TABLE "125cc_classification" (
  "rider" text,
  "manufacturer" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the grid total associated with 18 laps?`:
```sql
                SELECT COUNT("grid") FROM "125cc_classification" WHERE "laps"=18;
```
## Task
Generate a SQL query to answer the following question:
`What rider is on an aprilia that went under 18 laps with a grid total of 17?`

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

CREATE TABLE "125cc_classification" (
  "rider" text,
  "manufacturer" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What rider is on an aprilia that went under 18 laps with a grid total of 17?`:
```sql
                SELECT "rider" FROM "125cc_classification" WHERE "manufacturer"='aprilia' AND "laps"<18 AND "grid"=17;
```
## Task
Generate a SQL query to answer the following question:
`What is the Manufacturer for simone corsi?`

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

CREATE TABLE "125cc_classification" (
  "rider" text,
  "manufacturer" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Manufacturer for simone corsi?`:
```sql
                SELECT "manufacturer" FROM "125cc_classification" WHERE "rider"='simone corsi';
```
## Task
Generate a SQL query to answer the following question:
`What is the grid total associated with a Time/Retired of +33.634, and a Laps smaller than 19?`

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

CREATE TABLE "125cc_classification" (
  "rider" text,
  "manufacturer" text,
  "laps" real,
  "time_retired" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the grid total associated with a Time/Retired of +33.634, and a Laps smaller than 19?`:
```sql
                SELECT MIN("grid") FROM "125cc_classification" WHERE "time_retired"='+33.634' AND "laps"<19;
```
## Task
Generate a SQL query to answer the following question:
`Tell me the power when the torque is n·m (lb·ft)/*n·m (lb·ft) @1750`

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

CREATE TABLE "engines_and_transmissions" (
  "model_engine" text,
  "capacity" text,
  "cylinders_valves" text,
  "power_rpm" text,
  "torque_nm_rpm" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the power when the torque is n·m (lb·ft)/*n·m (lb·ft) @1750`:
```sql
                SELECT "power_rpm" FROM "engines_and_transmissions" WHERE "torque_nm_rpm"='n·m (lb·ft)/*n·m (lb·ft) @1750';
```
## Task
Generate a SQL query to answer the following question:
`Name the capacity for the engine of 2.0 duratorq`

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

CREATE TABLE "engines_and_transmissions" (
  "model_engine" text,
  "capacity" text,
  "cylinders_valves" text,
  "power_rpm" text,
  "torque_nm_rpm" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the capacity for the engine of 2.0 duratorq`:
```sql
                SELECT "capacity" FROM "engines_and_transmissions" WHERE "model_engine"='2.0 duratorq';
```
## Task
Generate a SQL query to answer the following question:
`Name the capacity for the torque of n·m (lb·ft) @4150`

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

CREATE TABLE "engines_and_transmissions" (
  "model_engine" text,
  "capacity" text,
  "cylinders_valves" text,
  "power_rpm" text,
  "torque_nm_rpm" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the capacity for the torque of n·m (lb·ft) @4150`:
```sql
                SELECT "capacity" FROM "engines_and_transmissions" WHERE "torque_nm_rpm"='n·m (lb·ft) @4150';
```
## Task
Generate a SQL query to answer the following question:
`Name the power for 1.8 duratorq`

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

CREATE TABLE "engines_and_transmissions" (
  "model_engine" text,
  "capacity" text,
  "cylinders_valves" text,
  "power_rpm" text,
  "torque_nm_rpm" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the power for 1.8 duratorq`:
```sql
                SELECT "power_rpm" FROM "engines_and_transmissions" WHERE "model_engine"='1.8 duratorq';
```
## Task
Generate a SQL query to answer the following question:
`Name the power for when the torque is n·m (lb·ft)/*n·m (lb·ft) @1750`

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

CREATE TABLE "engines_and_transmissions" (
  "model_engine" text,
  "capacity" text,
  "cylinders_valves" text,
  "power_rpm" text,
  "torque_nm_rpm" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the power for when the torque is n·m (lb·ft)/*n·m (lb·ft) @1750`:
```sql
                SELECT "power_rpm" FROM "engines_and_transmissions" WHERE "torque_nm_rpm"='n·m (lb·ft)/*n·m (lb·ft) @1750';
```
## Task
Generate a SQL query to answer the following question:
`What are the smallest goals with a Goal Ratio of 0.14, and a Debut in Europe smaller than 1995?`

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

CREATE TABLE "top_appearances_in_uefa_club_competition" (
  "rank" real,
  "player" text,
  "games" real,
  "goals" real,
  "goal_ratio" real,
  "debut_in_europe" real
);
### SQL
Given the database schema, here is the SQL query that answers `What are the smallest goals with a Goal Ratio of 0.14, and a Debut in Europe smaller than 1995?`:
```sql
                SELECT MIN("goals") FROM "top_appearances_in_uefa_club_competition" WHERE "goal_ratio"=0.14 AND "debut_in_europe"<1995;
```
## Task
Generate a SQL query to answer the following question:
`What's the average goal ratio with Goals larger than 1, Games larger than 161, and a Debut in Europe smaller than 1985?`

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

CREATE TABLE "top_appearances_in_uefa_club_competition" (
  "rank" real,
  "player" text,
  "games" real,
  "goals" real,
  "goal_ratio" real,
  "debut_in_europe" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the average goal ratio with Goals larger than 1, Games larger than 161, and a Debut in Europe smaller than 1985?`:
```sql
                SELECT AVG("goal_ratio") FROM "top_appearances_in_uefa_club_competition" WHERE "goals">1 AND "games">161 AND "debut_in_europe"<1985;
```
## Task
Generate a SQL query to answer the following question:
`What lowest games have 20 goals and a Goal Ratio smaller than 0.14?`

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

CREATE TABLE "top_appearances_in_uefa_club_competition" (
  "rank" real,
  "player" text,
  "games" real,
  "goals" real,
  "goal_ratio" real,
  "debut_in_europe" real
);
### SQL
Given the database schema, here is the SQL query that answers `What lowest games have 20 goals and a Goal Ratio smaller than 0.14?`:
```sql
                SELECT MIN("games") FROM "top_appearances_in_uefa_club_competition" WHERE "goals"=20 AND "goal_ratio"<0.14;
```
## Task
Generate a SQL query to answer the following question:
`What is the largest goal ratio with Goals smaller than 0?`

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

CREATE TABLE "top_appearances_in_uefa_club_competition" (
  "rank" real,
  "player" text,
  "games" real,
  "goals" real,
  "goal_ratio" real,
  "debut_in_europe" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the largest goal ratio with Goals smaller than 0?`:
```sql
                SELECT MAX("goal_ratio") FROM "top_appearances_in_uefa_club_competition" WHERE "goals"<0;
```
## Task
Generate a SQL query to answer the following question:
`What lowest games have a Goal Ratio of 0, and Goals smaller than 0?`

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

CREATE TABLE "top_appearances_in_uefa_club_competition" (
  "rank" real,
  "player" text,
  "games" real,
  "goals" real,
  "goal_ratio" real,
  "debut_in_europe" real
);
### SQL
Given the database schema, here is the SQL query that answers `What lowest games have a Goal Ratio of 0, and Goals smaller than 0?`:
```sql
                SELECT MIN("games") FROM "top_appearances_in_uefa_club_competition" WHERE "goal_ratio"=0 AND "goals"<0;
```
## Task
Generate a SQL query to answer the following question:
`How many debuts in Europe have less than 76 goals, more than 151 games, and a rank greater than 5?`

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

CREATE TABLE "top_appearances_in_uefa_club_competition" (
  "rank" real,
  "player" text,
  "games" real,
  "goals" real,
  "goal_ratio" real,
  "debut_in_europe" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many debuts in Europe have less than 76 goals, more than 151 games, and a rank greater than 5?`:
```sql
                SELECT COUNT("debut_in_europe") FROM "top_appearances_in_uefa_club_competition" WHERE "goals"<76 AND "games">151 AND "rank">5;
```
## Task
Generate a SQL query to answer the following question:
`What is the average points of the Ferrari 1512 Chassis after 1965?`

### 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,
  "team" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average points of the Ferrari 1512 Chassis after 1965?`:
```sql
                SELECT AVG("points") FROM "complete_formula_one_world_championship_" WHERE "chassis"='ferrari 1512' AND "year">1965;
```
## Task
Generate a SQL query to answer the following question:
`What is the Chassis of the Cooper Car Company after 1965 when the engine was a Maserati v12?`

### 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,
  "team" text,
  "chassis" text,
  "engine" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Chassis of the Cooper Car Company after 1965 when the engine was a Maserati v12?`:
```sql
                SELECT "chassis" FROM "complete_formula_one_world_championship_" WHERE "year">1965 AND "team"='cooper car company' AND "engine"='maserati v12';
```
## Task
Generate a SQL query to answer the following question:
`Which location had a round of 3, and an Opponent of matt horwich?`

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

CREATE TABLE "mixed_martial_arts_record" (
  "res" text,
  "record" text,
  "opponent" text,
  "method" text,
  "event" text,
  "round" real,
  "time" text,
  "location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which location had a round of 3, and an Opponent of matt horwich?`:
```sql
                SELECT "location" FROM "mixed_martial_arts_record" WHERE "round"<3 AND "opponent"='matt horwich';
```
## Task
Generate a SQL query to answer the following question:
`What was the time of sportfight 10?`

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

CREATE TABLE "mixed_martial_arts_record" (
  "res" text,
  "record" text,
  "opponent" text,
  "method" text,
  "event" text,
  "round" real,
  "time" text,
  "location" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the time of sportfight 10?`:
```sql
                SELECT "time" FROM "mixed_martial_arts_record" WHERE "event"='sportfight 10';
```
## Task
Generate a SQL query to answer the following question:
`Which opponent had a time of 0:29?`

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

CREATE TABLE "mixed_martial_arts_record" (
  "res" text,
  "record" text,
  "opponent" text,
  "method" text,
  "event" text,
  "round" real,
  "time" text,
  "location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which opponent had a time of 0:29?`:
```sql
                SELECT "opponent" FROM "mixed_martial_arts_record" WHERE "time"='0:29';
```
## Task
Generate a SQL query to answer the following question:
`What number has the builder ruston hornsby, the date 1961, and the name Topsy?`

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

CREATE TABLE "locomotives" (
  "number" real,
  "name" text,
  "builder" text,
  "type" text,
  "works_number" real,
  "date" real
);
### SQL
Given the database schema, here is the SQL query that answers `What number has the builder ruston hornsby, the date 1961, and the name Topsy?`:
```sql
                SELECT COUNT("number") FROM "locomotives" WHERE "builder"='ruston hornsby' AND "date"=1961 AND "name"='topsy';
```
## Task
Generate a SQL query to answer the following question:
`What is the number with the builder hunslet and a works number greater than 822?`

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

CREATE TABLE "locomotives" (
  "number" real,
  "name" text,
  "builder" text,
  "type" text,
  "works_number" real,
  "date" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the number with the builder hunslet and a works number greater than 822?`:
```sql
                SELECT COUNT("number") FROM "locomotives" WHERE "builder"='hunslet' AND "works_number">822;
```
## Task
Generate a SQL query to answer the following question:
`What was the score of the March 14 game?`

### 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 was the score of the March 14 game?`:
```sql
                SELECT "score" FROM "regular_season" WHERE "date"='march 14';
```
## Task
Generate a SQL query to answer the following question:
`What was the score for the December 11 game against the Ottawa Senators?`

### 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 was the score for the December 11 game against the Ottawa Senators?`:
```sql
                SELECT "score" FROM "regular_season" WHERE "visitor"='ottawa senators' AND "date"='december 11';
```
## Task
Generate a SQL query to answer the following question:
`Name the project with length overall being 25 and name of levante`

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

CREATE TABLE "list_of_yachts" (
  "hull_no" real,
  "year" real,
  "project" text,
  "length_overall_in_meters_without_bowsprit" real,
  "name" text,
  "destination" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the project with length overall being 25 and name of levante`:
```sql
                SELECT "project" FROM "list_of_yachts" WHERE "length_overall_in_meters_without_bowsprit"=25 AND "name"='levante';
```
## Task
Generate a SQL query to answer the following question:
`Name the sum of Hull number with portugal destination`

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

CREATE TABLE "list_of_yachts" (
  "hull_no" real,
  "year" real,
  "project" text,
  "length_overall_in_meters_without_bowsprit" real,
  "name" text,
  "destination" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the sum of Hull number with portugal destination`:
```sql
                SELECT SUM("hull_no") FROM "list_of_yachts" WHERE "destination"='portugal';
```
## Task
Generate a SQL query to answer the following question:
`Name the sum of hull number for italy and year more than 1999`

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

CREATE TABLE "list_of_yachts" (
  "hull_no" real,
  "year" real,
  "project" text,
  "length_overall_in_meters_without_bowsprit" real,
  "name" text,
  "destination" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the sum of hull number for italy and year more than 1999`:
```sql
                SELECT SUM("hull_no") FROM "list_of_yachts" WHERE "destination"='italy' AND "year">1999;
```
## Task
Generate a SQL query to answer the following question:
`Give me the result for a format saying album with 1994 as the year.`

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

CREATE TABLE "recording_industry_association_of_americ" (
  "year" real,
  "date" text,
  "title" text,
  "format_s" text,
  "award_description_s" text,
  "result_s" text
);
### SQL
Given the database schema, here is the SQL query that answers `Give me the result for a format saying album with 1994 as the year.`:
```sql
                SELECT "result_s" FROM "recording_industry_association_of_americ" WHERE "format_s"='album' AND "year"=1994;
```
## Task
Generate a SQL query to answer the following question:
`List the Award Descriptions for the year of 1989.`

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

CREATE TABLE "recording_industry_association_of_americ" (
  "year" real,
  "date" text,
  "title" text,
  "format_s" text,
  "award_description_s" text,
  "result_s" text
);
### SQL
Given the database schema, here is the SQL query that answers `List the Award Descriptions for the year of 1989.`:
```sql
                SELECT "award_description_s" FROM "recording_industry_association_of_americ" WHERE "year"=1989;
```
## Task
Generate a SQL query to answer the following question:
`What is on at 9:30 on the channel of dancing with the stars?`

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

CREATE TABLE "monday" (
  "7_00" text,
  "7_30" text,
  "8_00" text,
  "8_30" text,
  "9_00" text,
  "9_30" text,
  "10_00" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is on at 9:30 on the channel of dancing with the stars?`:
```sql
                SELECT "9_30" FROM "monday" WHERE "8_30"='dancing with the stars';
```
## Task
Generate a SQL query to answer the following question:
`What is on at 7:30 when k-ville is on at 9:00 on that channel?`

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

CREATE TABLE "monday" (
  "7_00" text,
  "7_30" text,
  "8_00" text,
  "8_30" text,
  "9_00" text,
  "9_30" text,
  "10_00" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is on at 7:30 when k-ville is on at 9:00 on that channel?`:
```sql
                SELECT "7_30" FROM "monday" WHERE "9_00"='k-ville';
```
## Task
Generate a SQL query to answer the following question:
`What is on at 8:30 when occupation double is on at 7:00 at that channel?`

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

CREATE TABLE "monday" (
  "7_00" text,
  "7_30" text,
  "8_00" text,
  "8_30" text,
  "9_00" text,
  "9_30" text,
  "10_00" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is on at 8:30 when occupation double is on at 7:00 at that channel?`:
```sql
                SELECT "8_30" FROM "monday" WHERE "7_00"='occupation double';
```
## Task
Generate a SQL query to answer the following question:
`What is on at 8:30 when etalk is on at 7:00 on that channel?`

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

CREATE TABLE "monday" (
  "7_00" text,
  "7_30" text,
  "8_00" text,
  "8_30" text,
  "9_00" text,
  "9_30" text,
  "10_00" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is on at 8:30 when etalk is on at 7:00 on that channel?`:
```sql
                SELECT "8_30" FROM "monday" WHERE "7_00"='etalk';
```
## Task
Generate a SQL query to answer the following question:
`What is on at 8:00 when etalk is on at 7:00?`

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

CREATE TABLE "monday" (
  "7_00" text,
  "7_30" text,
  "8_00" text,
  "8_30" text,
  "9_00" text,
  "9_30" text,
  "10_00" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is on at 8:00 when etalk is on at 7:00?`:
```sql
                SELECT "8_00" FROM "monday" WHERE "7_00"='etalk';
```
## Task
Generate a SQL query to answer the following question:
`What was the score of the game played on August 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 score of the game played on August 5?`:
```sql
                SELECT "score" FROM "game_log" WHERE "date"='august 5';
```
## Task
Generate a SQL query to answer the following question:
`On what date was the Blue Jays record 60-56?`

### 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 `On what date was the Blue Jays record 60-56?`:
```sql
                SELECT "date" FROM "game_log" WHERE "record"='60-56';
```
## Task
Generate a SQL query to answer the following question:
`Tell me the name for first elected more than 1988 and district of mason`

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

CREATE TABLE "county_board_of_supervisors" (
  "position" text,
  "name" text,
  "party" text,
  "first_elected" real,
  "district" text
);
### SQL
Given the database schema, here is the SQL query that answers `Tell me the name for first elected more than 1988 and district of mason`:
```sql
                SELECT "name" FROM "county_board_of_supervisors" WHERE "first_elected">1988 AND "district"='mason';
```
## Task
Generate a SQL query to answer the following question:
`Name the party with first elected more than 1999 and position of supervisor for john foust`

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

CREATE TABLE "county_board_of_supervisors" (
  "position" text,
  "name" text,
  "party" text,
  "first_elected" real,
  "district" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the party with first elected more than 1999 and position of supervisor for john foust`:
```sql
                SELECT "party" FROM "county_board_of_supervisors" WHERE "first_elected">1999 AND "position"='supervisor' AND "name"='john foust';
```
## Task
Generate a SQL query to answer the following question:
`Name the total number of first elected for dranesville`

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

CREATE TABLE "county_board_of_supervisors" (
  "position" text,
  "name" text,
  "party" text,
  "first_elected" real,
  "district" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the total number of first elected for dranesville`:
```sql
                SELECT COUNT("first_elected") FROM "county_board_of_supervisors" WHERE "district"='dranesville';
```
## Task
Generate a SQL query to answer the following question:
`What year was the venue at Sydney Cricket Ground, and the opponent was Parramatta Eels?`

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

CREATE TABLE "premierships_8_62" (
  "year" real,
  "opponent" text,
  "competition" text,
  "score" text,
  "venue" text,
  "attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year was the venue at Sydney Cricket Ground, and the opponent was Parramatta Eels?`:
```sql
                SELECT COUNT("year") FROM "premierships_8_62" WHERE "venue"='sydney cricket ground' AND "opponent"='parramatta eels';
```
## Task
Generate a SQL query to answer the following question:
`What was the competition in 1978?`

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

CREATE TABLE "premierships_8_62" (
  "year" real,
  "opponent" text,
  "competition" text,
  "score" text,
  "venue" text,
  "attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the competition in 1978?`:
```sql
                SELECT "competition" FROM "premierships_8_62" WHERE "year"=1978;
```
## Task
Generate a SQL query to answer the following question:
`What year was the average attendance 80,388?`

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

CREATE TABLE "premierships_8_62" (
  "year" real,
  "opponent" text,
  "competition" text,
  "score" text,
  "venue" text,
  "attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year was the average attendance 80,388?`:
```sql
                SELECT AVG("year") FROM "premierships_8_62" WHERE "attendance"='80,388';
```
## Task
Generate a SQL query to answer the following question:
`What was the score with the opponent being New Zealand Warriors?`

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

CREATE TABLE "premierships_8_62" (
  "year" real,
  "opponent" text,
  "competition" text,
  "score" text,
  "venue" text,
  "attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score with the opponent being New Zealand Warriors?`:
```sql
                SELECT "score" FROM "premierships_8_62" WHERE "opponent"='new zealand warriors';
```
## Task
Generate a SQL query to answer the following question:
`Which 1st Party has an election in 1847?`

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

CREATE TABLE "members_of_parliament" (
  "election" text,
  "1st_member" text,
  "1st_party" text,
  "2nd_member" text,
  "2nd_party" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which 1st Party has an election in 1847?`:
```sql
                SELECT "1st_party" FROM "members_of_parliament" WHERE "election"='1847';
```
## Task
Generate a SQL query to answer the following question:
`Which 1st Party has an election in 1865?`

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

CREATE TABLE "members_of_parliament" (
  "election" text,
  "1st_member" text,
  "1st_party" text,
  "2nd_member" text,
  "2nd_party" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which 1st Party has an election in 1865?`:
```sql
                SELECT "1st_party" FROM "members_of_parliament" WHERE "election"='1865';
```
## Task
Generate a SQL query to answer the following question:
`Which 1st Party has a 2nd Member of constituency abolished?`

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

CREATE TABLE "members_of_parliament" (
  "election" text,
  "1st_member" text,
  "1st_party" text,
  "2nd_member" text,
  "2nd_party" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which 1st Party has a 2nd Member of constituency abolished?`:
```sql
                SELECT "1st_party" FROM "members_of_parliament" WHERE "2nd_member"='constituency abolished';
```
## Task
Generate a SQL query to answer the following question:
`Which 1st Member has an election in 1880 and a liberal 1st Party?`

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

CREATE TABLE "members_of_parliament" (
  "election" text,
  "1st_member" text,
  "1st_party" text,
  "2nd_member" text,
  "2nd_party" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which 1st Member has an election in 1880 and a liberal 1st Party?`:
```sql
                SELECT "1st_member" FROM "members_of_parliament" WHERE "1st_party"='liberal' AND "election"='1880';
```
## Task
Generate a SQL query to answer the following question:
`Which 1st Member has an election in 1859 and a conservative 2nd Party?`

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

CREATE TABLE "members_of_parliament" (
  "election" text,
  "1st_member" text,
  "1st_party" text,
  "2nd_member" text,
  "2nd_party" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which 1st Member has an election in 1859 and a conservative 2nd Party?`:
```sql
                SELECT "1st_member" FROM "members_of_parliament" WHERE "2nd_party"='conservative' AND "election"='1859';
```
## Task
Generate a SQL query to answer the following question:
`What was the average number of points with bonus pts less than 31 with the rider dennis gavros?`

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

CREATE TABLE "1966_season_finished_1st_54pts_out_of_19" (
  "rider" text,
  "matches" real,
  "rides" real,
  "bonus_pts" real,
  "total_points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the average number of points with bonus pts less than 31 with the rider dennis gavros?`:
```sql
                SELECT AVG("total_points") FROM "1966_season_finished_1st_54pts_out_of_19" WHERE "rider"='dennis gavros' AND "bonus_pts"<31;
```
## Task
Generate a SQL query to answer the following question:
`How many total matches involving dennis gavros had total points less than 167?`

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

CREATE TABLE "1966_season_finished_1st_54pts_out_of_19" (
  "rider" text,
  "matches" real,
  "rides" real,
  "bonus_pts" real,
  "total_points" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many total matches involving dennis gavros had total points less than 167?`:
```sql
                SELECT COUNT("matches") FROM "1966_season_finished_1st_54pts_out_of_19" WHERE "rider"='dennis gavros' AND "total_points"<167;
```
## Task
Generate a SQL query to answer the following question:
`What is the smallest number of matches with Bonus Pts of 19 and Total Points greater than 421?`

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

CREATE TABLE "1966_season_finished_1st_54pts_out_of_19" (
  "rider" text,
  "matches" real,
  "rides" real,
  "bonus_pts" real,
  "total_points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the smallest number of matches with Bonus Pts of 19 and Total Points greater than 421?`:
```sql
                SELECT MIN("matches") FROM "1966_season_finished_1st_54pts_out_of_19" WHERE "bonus_pts"=19 AND "total_points">421;
```
## Task
Generate a SQL query to answer the following question:
`Which category earlier than 2006 has Bart Brentjens as rider 2?`

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

CREATE TABLE "winners_from_2004" (
  "date" real,
  "category" text,
  "team" text,
  "rider_1" text,
  "rider_2" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which category earlier than 2006 has Bart Brentjens as rider 2?`:
```sql
                SELECT "category" FROM "winners_from_2004" WHERE "date"<2006 AND "rider_2"='bart brentjens';
```
## Task
Generate a SQL query to answer the following question:
`How many dates does the ladies category correspond to Rothaus-Cube?`

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

CREATE TABLE "winners_from_2004" (
  "date" real,
  "category" text,
  "team" text,
  "rider_1" text,
  "rider_2" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many dates does the ladies category correspond to Rothaus-Cube?`:
```sql
                SELECT COUNT("date") FROM "winners_from_2004" WHERE "category"='ladies' AND "team"='rothaus-cube';
```
## Task
Generate a SQL query to answer the following question:
`Which category has a team of Cannondale Vredestein?`

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

CREATE TABLE "winners_from_2004" (
  "date" real,
  "category" text,
  "team" text,
  "rider_1" text,
  "rider_2" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which category has a team of Cannondale Vredestein?`:
```sql
                SELECT "category" FROM "winners_from_2004" WHERE "team"='cannondale vredestein';
```
## Task
Generate a SQL query to answer the following question:
`What is the qual with a rank 9?`

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

CREATE TABLE "indy_500_results" (
  "year" text,
  "start" text,
  "qual" text,
  "rank" text,
  "finish" text,
  "laps" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the qual with a rank 9?`:
```sql
                SELECT "qual" FROM "indy_500_results" WHERE "rank"='9';
```
## Task
Generate a SQL query to answer the following question:
`What is the finish in 1956?`

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

CREATE TABLE "indy_500_results" (
  "year" text,
  "start" text,
  "qual" text,
  "rank" text,
  "finish" text,
  "laps" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the finish in 1956?`:
```sql
                SELECT "finish" FROM "indy_500_results" WHERE "year"='1956';
```
## Task
Generate a SQL query to answer the following question:
`What is the finish with 200 laps and a start of 3?`

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

CREATE TABLE "indy_500_results" (
  "year" text,
  "start" text,
  "qual" text,
  "rank" text,
  "finish" text,
  "laps" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the finish with 200 laps and a start of 3?`:
```sql
                SELECT "finish" FROM "indy_500_results" WHERE "laps"=200 AND "start"='3';
```
## Task
Generate a SQL query to answer the following question:
`What is the qual with 200 laps and a rank of 27?`

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

CREATE TABLE "indy_500_results" (
  "year" text,
  "start" text,
  "qual" text,
  "rank" text,
  "finish" text,
  "laps" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the qual with 200 laps and a rank of 27?`:
```sql
                SELECT "qual" FROM "indy_500_results" WHERE "laps"=200 AND "rank"='27';
```
## Task
Generate a SQL query to answer the following question:
`What is the rank with a 14 finish?`

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

CREATE TABLE "indy_500_results" (
  "year" text,
  "start" text,
  "qual" text,
  "rank" text,
  "finish" text,
  "laps" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the rank with a 14 finish?`:
```sql
                SELECT "rank" FROM "indy_500_results" WHERE "finish"='14';
```
## Task
Generate a SQL query to answer the following question:
`When did Deng Xuan first win Women's singles?`

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

CREATE TABLE "previous_winners" (
  "year" 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 `When did Deng Xuan first win Women's singles?`:
```sql
                SELECT MIN("year") FROM "previous_winners" WHERE "women_s_singles"='deng xuan';
```
## Task
Generate a SQL query to answer the following question:
`When did Julie Still first win Women's singles?`

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

CREATE TABLE "previous_winners" (
  "year" 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 `When did Julie Still first win Women's singles?`:
```sql
                SELECT MIN("year") FROM "previous_winners" WHERE "women_s_singles"='julie still';
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest cuts made of the Masters tournament, which had a top-25 less than 0?`

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

CREATE TABLE "summary" (
  "tournament" text,
  "wins" real,
  "top_25" real,
  "events" real,
  "cuts_made" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest cuts made of the Masters tournament, which had a top-25 less than 0?`:
```sql
                SELECT MIN("cuts_made") FROM "summary" WHERE "tournament"='masters tournament' AND "top_25"<0;
```
## Task
Generate a SQL query to answer the following question:
`What is the highest number of wins a tournament with 1 cuts made, a top-25 less than 1, and less than 2 events has?`

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

CREATE TABLE "summary" (
  "tournament" text,
  "wins" real,
  "top_25" real,
  "events" real,
  "cuts_made" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest number of wins a tournament with 1 cuts made, a top-25 less than 1, and less than 2 events has?`:
```sql
                SELECT MAX("wins") FROM "summary" WHERE "cuts_made"=1 AND "top_25"<1 AND "events"<2;
```
## Task
Generate a SQL query to answer the following question:
`What is the average number of events the Masters tournament, which has more than 0 top-25, has?`

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

CREATE TABLE "summary" (
  "tournament" text,
  "wins" real,
  "top_25" real,
  "events" real,
  "cuts_made" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average number of events the Masters tournament, which has more than 0 top-25, has?`:
```sql
                SELECT AVG("events") FROM "summary" WHERE "tournament"='masters tournament' AND "top_25">0;
```
## Task
Generate a SQL query to answer the following question:
`What is the total number of top-25 a tournament with less than 2 events has?`

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

CREATE TABLE "summary" (
  "tournament" text,
  "wins" real,
  "top_25" real,
  "events" real,
  "cuts_made" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of top-25 a tournament with less than 2 events has?`:
```sql
                SELECT COUNT("top_25") FROM "summary" WHERE "events"<2;
```
## Task
Generate a SQL query to answer the following question:
`Who won Women's doubles when Nikhil Kanetkar won Men's singles?`

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

CREATE TABLE "previous_winners" (
  "year" 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 Women's doubles when Nikhil Kanetkar won Men's singles?`:
```sql
                SELECT "women_s_doubles" FROM "previous_winners" WHERE "men_s_singles"='nikhil kanetkar';
```