cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`Which ICAO is found in Vavuniya?`

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

CREATE TABLE "destinations" (
  "city" text,
  "country" text,
  "iata" text,
  "icao" text,
  "airport" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which ICAO is found in Vavuniya?`:
```sql
                SELECT "icao" FROM "destinations" WHERE "city"='vavuniya';
```
## Task
Generate a SQL query to answer the following question:
`Which country has Weerawila Airport?`

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

CREATE TABLE "destinations" (
  "city" text,
  "country" text,
  "iata" text,
  "icao" text,
  "airport" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which country has Weerawila Airport?`:
```sql
                SELECT "country" FROM "destinations" WHERE "airport"='weerawila airport';
```
## Task
Generate a SQL query to answer the following question:
`Which opponent has april 1 as the date?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which opponent has april 1 as the date?`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "date"='april 1';
```
## Task
Generate a SQL query to answer the following question:
`What opponent has tomko (1-1) as a loss?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What opponent has tomko (1-1) as a loss?`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "loss"='tomko (1-1)';
```
## Task
Generate a SQL query to answer the following question:
`What opponent has 8-10 as the record?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What opponent has 8-10 as the record?`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "record"='8-10';
```
## Task
Generate a SQL query to answer the following question:
`Whcih was the Class AAA in school year 2006-07?`

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

CREATE TABLE "individual_chemistry" (
  "school_year" text,
  "class_a" text,
  "class_aa" text,
  "class_aaa" text,
  "class_aaaa" text
);
### SQL
Given the database schema, here is the SQL query that answers `Whcih was the Class AAA in school year 2006-07?`:
```sql
                SELECT "class_aaa" FROM "individual_chemistry" WHERE "school_year"='2006-07';
```
## Task
Generate a SQL query to answer the following question:
`What team was class AA in years 1994-95?`

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

CREATE TABLE "individual_chemistry" (
  "school_year" text,
  "class_a" text,
  "class_aa" text,
  "class_aaa" text,
  "class_aaaa" text
);
### SQL
Given the database schema, here is the SQL query that answers `What team was class AA in years 1994-95?`:
```sql
                SELECT "class_aa" FROM "individual_chemistry" WHERE "school_year"='1994-95';
```
## Task
Generate a SQL query to answer the following question:
`Who was Class AA in School Year 1994-95?`

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

CREATE TABLE "individual_chemistry" (
  "school_year" text,
  "class_a" text,
  "class_aa" text,
  "class_aaa" text,
  "class_aaaa" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was Class AA in School Year 1994-95?`:
```sql
                SELECT "class_aa" FROM "individual_chemistry" WHERE "school_year"='1994-95';
```
## Task
Generate a SQL query to answer the following question:
`What's the date of the game that has the Bulls as a visiting team?`

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

CREATE TABLE "march" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "leading_scorer" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the date of the game that has the Bulls as a visiting team?`:
```sql
                SELECT "date" FROM "march" WHERE "visitor"='bulls';
```
## Task
Generate a SQL query to answer the following question:
`What is the average game number that took place after February 13 against the Toronto Maple Leafs and more than 47 points were scored?`

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

CREATE TABLE "regular_season" (
  "game" real,
  "february" real,
  "opponent" text,
  "score" text,
  "record" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average game number that took place after February 13 against the Toronto Maple Leafs and more than 47 points were scored?`:
```sql
                SELECT AVG("game") FROM "regular_season" WHERE "february">13 AND "opponent"='toronto maple leafs' AND "points">47;
```
## Task
Generate a SQL query to answer the following question:
`Who was the opponent at the game at Sullivan Stadium before week 11?`

### 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,
  "record" text,
  "game_site" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the opponent at the game at Sullivan Stadium before week 11?`:
```sql
                SELECT "opponent" FROM "schedule" WHERE "week"<11 AND "game_site"='sullivan stadium';
```
## Task
Generate a SQL query to answer the following question:
`What is the years coached by the person with a win percentage of 0.667 and 380 losses?`

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

CREATE TABLE "head_coaches_and_all_time_results" (
  "name" text,
  "years" text,
  "seasons" real,
  "lost" real,
  "pct" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the years coached by the person with a win percentage of 0.667 and 380 losses?`:
```sql
                SELECT "years" FROM "head_coaches_and_all_time_results" WHERE "pct"=0.667 AND "lost"=380;
```
## Task
Generate a SQL query to answer the following question:
`What is the average percent for the coach from 1905 and more than 7 losses?`

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

CREATE TABLE "head_coaches_and_all_time_results" (
  "name" text,
  "years" text,
  "seasons" real,
  "lost" real,
  "pct" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average percent for the coach from 1905 and more than 7 losses?`:
```sql
                SELECT AVG("pct") FROM "head_coaches_and_all_time_results" WHERE "years"='1905' AND "lost">7;
```
## Task
Generate a SQL query to answer the following question:
`How many percentages have 20 losses and more than 1 season?`

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

CREATE TABLE "head_coaches_and_all_time_results" (
  "name" text,
  "years" text,
  "seasons" real,
  "lost" real,
  "pct" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many percentages have 20 losses and more than 1 season?`:
```sql
                SELECT COUNT("pct") FROM "head_coaches_and_all_time_results" WHERE "lost"=20 AND "seasons">1;
```
## Task
Generate a SQL query to answer the following question:
`What home has February 10 as the date?`

### 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,
  "decision" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What home has February 10 as the date?`:
```sql
                SELECT "home" FROM "regular_season" WHERE "date"='february 10';
```
## Task
Generate a SQL query to answer the following question:
`What date has ny islanders as the visitor?`

### 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,
  "decision" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date has ny islanders as the visitor?`:
```sql
                SELECT "date" FROM "regular_season" WHERE "visitor"='ny islanders';
```
## Task
Generate a SQL query to answer the following question:
`What score has February 10 as the date?`

### 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,
  "decision" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What score has February 10 as the date?`:
```sql
                SELECT "score" FROM "regular_season" WHERE "date"='february 10';
```
## Task
Generate a SQL query to answer the following question:
`Name the course for 24 july`

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

CREATE TABLE "stage_results" (
  "date" text,
  "course" text,
  "distance" text,
  "type" text,
  "winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the course for 24 july`:
```sql
                SELECT "course" FROM "stage_results" WHERE "date"='24 july';
```
## Task
Generate a SQL query to answer the following question:
`Name the course for team time trial`

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

CREATE TABLE "stage_results" (
  "date" text,
  "course" text,
  "distance" text,
  "type" text,
  "winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the course for team time trial`:
```sql
                SELECT "course" FROM "stage_results" WHERE "type"='team time trial';
```
## Task
Generate a SQL query to answer the following question:
`Name the winner for rest day for 13 july`

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

CREATE TABLE "stage_results" (
  "date" text,
  "course" text,
  "distance" text,
  "type" text,
  "winner" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the winner for rest day for 13 july`:
```sql
                SELECT "winner" FROM "stage_results" WHERE "course"='rest day' AND "date"='13 july';
```
## Task
Generate a SQL query to answer the following question:
`Shawn Michaels entered the elimination chamber in what position?`

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

CREATE TABLE "elimination_chamber_entrances_and_elimin" (
  "elimination_no" text,
  "wrestler" text,
  "entered" real,
  "eliminated_by" text,
  "time" text
);
### SQL
Given the database schema, here is the SQL query that answers `Shawn Michaels entered the elimination chamber in what position?`:
```sql
                SELECT SUM("entered") FROM "elimination_chamber_entrances_and_elimin" WHERE "wrestler"='shawn michaels';
```
## Task
Generate a SQL query to answer the following question:
`Who Eliminated Kurt Angle?`

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

CREATE TABLE "elimination_chamber_entrances_and_elimin" (
  "elimination_no" text,
  "wrestler" text,
  "entered" real,
  "eliminated_by" text,
  "time" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who Eliminated Kurt Angle?`:
```sql
                SELECT "eliminated_by" FROM "elimination_chamber_entrances_and_elimin" WHERE "wrestler"='kurt angle';
```
## Task
Generate a SQL query to answer the following question:
`Who Eliminated Kane?`

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

CREATE TABLE "elimination_chamber_entrances_and_elimin" (
  "elimination_no" text,
  "wrestler" text,
  "entered" real,
  "eliminated_by" text,
  "time" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who Eliminated Kane?`:
```sql
                SELECT "eliminated_by" FROM "elimination_chamber_entrances_and_elimin" WHERE "wrestler"='kane';
```
## Task
Generate a SQL query to answer the following question:
`What is the sum of all gold medals for Algeria when total medals is less than 3?`

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

CREATE TABLE "medal_table" (
  "rank" text,
  "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 sum of all gold medals for Algeria when total medals is less than 3?`:
```sql
                SELECT SUM("gold") FROM "medal_table" WHERE "nation"='algeria' AND "total"<3;
```
## Task
Generate a SQL query to answer the following question:
`what is the population of Valencia, Spain?`

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

CREATE TABLE "major_urban_areas" (
  "urban_area" text,
  "country" text,
  "region" text,
  "population" real,
  "globalization_index" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the population of Valencia, Spain?`:
```sql
                SELECT AVG("population") FROM "major_urban_areas" WHERE "country"='spain' AND "urban_area"='valencia';
```
## Task
Generate a SQL query to answer the following question:
`which year holds rank 2?`

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

CREATE TABLE "tallest_buildings" (
  "rank" text,
  "name" text,
  "height_feet_m" text,
  "floors" real,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `which year holds rank 2?`:
```sql
                SELECT MAX("year") FROM "tallest_buildings" WHERE "rank"='2';
```
## Task
Generate a SQL query to answer the following question:
`with name meridian condominiums what is number of floors?`

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

CREATE TABLE "tallest_buildings" (
  "rank" text,
  "name" text,
  "height_feet_m" text,
  "floors" real,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `with name meridian condominiums what is number of floors?`:
```sql
                SELECT AVG("floors") FROM "tallest_buildings" WHERE "name"='meridian condominiums';
```
## Task
Generate a SQL query to answer the following question:
`with rank of 31 what is the year?`

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

CREATE TABLE "tallest_buildings" (
  "rank" text,
  "name" text,
  "height_feet_m" text,
  "floors" real,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `with rank of 31 what is the year?`:
```sql
                SELECT COUNT("year") FROM "tallest_buildings" WHERE "rank"='31';
```
## Task
Generate a SQL query to answer the following question:
`What was the date of the match against the visiting team, Toronto?`

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

CREATE TABLE "january" (
  "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 date of the match against the visiting team, Toronto?`:
```sql
                SELECT "date" FROM "january" WHERE "visitor"='toronto';
```
## Task
Generate a SQL query to answer the following question:
`Who played the home team during the game on January 6?`

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

CREATE TABLE "january" (
  "date" text,
  "visitor" text,
  "score" text,
  "home" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who played the home team during the game on January 6?`:
```sql
                SELECT "home" FROM "january" WHERE "date"='january 6';
```
## Task
Generate a SQL query to answer the following question:
`What was the cougars record during the game where Boston were the visitors?`

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

CREATE TABLE "january" (
  "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 cougars record during the game where Boston were the visitors?`:
```sql
                SELECT "record" FROM "january" WHERE "visitor"='boston';
```
## Task
Generate a SQL query to answer the following question:
`What's the lowest Drawn that has a Lost that's less than 0?`

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

CREATE TABLE "group_2" (
  "games" real,
  "drawn" real,
  "lost" real,
  "points_difference" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the lowest Drawn that has a Lost that's less than 0?`:
```sql
                SELECT MIN("drawn") FROM "group_2" WHERE "lost"<0;
```
## Task
Generate a SQL query to answer the following question:
`What's the total Lost with Games that's less than 4?`

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

CREATE TABLE "group_2" (
  "games" real,
  "drawn" real,
  "lost" real,
  "points_difference" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the total Lost with Games that's less than 4?`:
```sql
                SELECT SUM("lost") FROM "group_2" WHERE "games"<4;
```
## Task
Generate a SQL query to answer the following question:
`What's the total of Games with a Lost that's larger than 2, and has Points that's smaller than 0?`

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

CREATE TABLE "group_2" (
  "games" real,
  "drawn" real,
  "lost" real,
  "points_difference" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the total of Games with a Lost that's larger than 2, and has Points that's smaller than 0?`:
```sql
                SELECT SUM("games") FROM "group_2" WHERE "lost">2 AND "points"<0;
```
## Task
Generate a SQL query to answer the following question:
`What's the Lost average that has a Drawn less than 0?`

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

CREATE TABLE "group_2" (
  "games" real,
  "drawn" real,
  "lost" real,
  "points_difference" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the Lost average that has a Drawn less than 0?`:
```sql
                SELECT AVG("lost") FROM "group_2" WHERE "drawn"<0;
```
## Task
Generate a SQL query to answer the following question:
`What record has @ ottawa senators as the opponent?`

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

CREATE TABLE "regular_season" (
  "game" real,
  "december" real,
  "opponent" text,
  "score" text,
  "record" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What record has @ ottawa senators as the opponent?`:
```sql
                SELECT "record" FROM "regular_season" WHERE "opponent"='@ ottawa senators';
```
## Task
Generate a SQL query to answer the following question:
`What game has 28 points, and tampa bay lightning as the opponent?`

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

CREATE TABLE "regular_season" (
  "game" real,
  "december" real,
  "opponent" text,
  "score" text,
  "record" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What game has 28 points, and tampa bay lightning as the opponent?`:
```sql
                SELECT "game" FROM "regular_season" WHERE "points"=28 AND "opponent"='tampa bay lightning';
```
## Task
Generate a SQL query to answer the following question:
`What is the average points that have a December less than 6, with a game greater than 26?`

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

CREATE TABLE "regular_season" (
  "game" real,
  "december" real,
  "opponent" text,
  "score" text,
  "record" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average points that have a December less than 6, with a game greater than 26?`:
```sql
                SELECT AVG("points") FROM "regular_season" WHERE "december"<6 AND "game">26;
```
## Task
Generate a SQL query to answer the following question:
`Who was the opponent at the game with a loss of Sele (0-1)?`

### 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,
  "series" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the opponent at the game with a loss of Sele (0-1)?`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "loss"='sele (0-1)';
```
## Task
Generate a SQL query to answer the following question:
`Record of 42–16–8, and a March larger than 5 has what average points?`

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

CREATE TABLE "regular_season" (
  "game" real,
  "march" real,
  "opponent" text,
  "score" text,
  "record" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Record of 42–16–8, and a March larger than 5 has what average points?`:
```sql
                SELECT AVG("points") FROM "regular_season" WHERE "record"='42–16–8' AND "march">5;
```
## Task
Generate a SQL query to answer the following question:
`Points smaller than 96, and a Record of 43–16–8 belongs to what game?`

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

CREATE TABLE "regular_season" (
  "game" real,
  "march" real,
  "opponent" text,
  "score" text,
  "record" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Points smaller than 96, and a Record of 43–16–8 belongs to what game?`:
```sql
                SELECT "game" FROM "regular_season" WHERE "points"<96 AND "record"='43–16–8';
```
## Task
Generate a SQL query to answer the following question:
`Game smaller than 70, and a Record of 43–16–8 is what opponent?`

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

CREATE TABLE "regular_season" (
  "game" real,
  "march" real,
  "opponent" text,
  "score" text,
  "record" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Game smaller than 70, and a Record of 43–16–8 is what opponent?`:
```sql
                SELECT "opponent" FROM "regular_season" WHERE "game"<70 AND "record"='43–16–8';
```
## Task
Generate a SQL query to answer the following question:
`Record of 44–18–8 involves which score?`

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

CREATE TABLE "regular_season" (
  "game" real,
  "march" real,
  "opponent" text,
  "score" text,
  "record" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Record of 44–18–8 involves which score?`:
```sql
                SELECT "score" FROM "regular_season" WHERE "record"='44–18–8';
```
## Task
Generate a SQL query to answer the following question:
`Which college is Kellen Davis from?`

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

CREATE TABLE "nfl_draft" (
  "round" text,
  "pick" text,
  "player" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which college is Kellen Davis from?`:
```sql
                SELECT "college" FROM "nfl_draft" WHERE "player"='kellen davis';
```
## Task
Generate a SQL query to answer the following question:
`Which round's position is according to official website?`

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

CREATE TABLE "nfl_draft" (
  "round" text,
  "pick" text,
  "player" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which round's position is according to official website?`:
```sql
                SELECT "round" FROM "nfl_draft" WHERE "position"='according to official website';
```
## Task
Generate a SQL query to answer the following question:
`Which position's round was 3 when pick was 70?`

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

CREATE TABLE "nfl_draft" (
  "round" text,
  "pick" text,
  "player" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which position's round was 3 when pick was 70?`:
```sql
                SELECT "position" FROM "nfl_draft" WHERE "round"='3' AND "pick"='70';
```
## Task
Generate a SQL query to answer the following question:
`Which pick's round was 5 when Kellen Davis was a player?`

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

CREATE TABLE "nfl_draft" (
  "round" text,
  "pick" text,
  "player" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which pick's round was 5 when Kellen Davis was a player?`:
```sql
                SELECT "pick" FROM "nfl_draft" WHERE "round"='5' AND "player"='kellen davis';
```
## Task
Generate a SQL query to answer the following question:
`Which college's pick was 14?`

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

CREATE TABLE "nfl_draft" (
  "round" text,
  "pick" text,
  "player" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which college's pick was 14?`:
```sql
                SELECT "college" FROM "nfl_draft" WHERE "pick"='14';
```
## Task
Generate a SQL query to answer the following question:
`Which Rec has an Average smaller than 32, and a Touchdown smaller than 3, and an Opponent of oregon state?`

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

CREATE TABLE "michigan_single_game_reception_yardage" (
  "player" text,
  "rec" real,
  "yards" real,
  "average" real,
  "s_touchdown" real,
  "year" real,
  "opponent" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Rec has an Average smaller than 32, and a Touchdown smaller than 3, and an Opponent of oregon state?`:
```sql
                SELECT SUM("rec") FROM "michigan_single_game_reception_yardage" WHERE "average"<32 AND "s_touchdown"<3 AND "opponent"='oregon state';
```
## Task
Generate a SQL query to answer the following question:
`Which rec has Yards of 192, and a Touchdown smaller than 1?`

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

CREATE TABLE "michigan_single_game_reception_yardage" (
  "player" text,
  "rec" real,
  "yards" real,
  "average" real,
  "s_touchdown" real,
  "year" real,
  "opponent" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which rec has Yards of 192, and a Touchdown smaller than 1?`:
```sql
                SELECT AVG("rec") FROM "michigan_single_game_reception_yardage" WHERE "yards"=192 AND "s_touchdown"<1;
```
## Task
Generate a SQL query to answer the following question:
`Which Opponent has Yards smaller than 197, and an Average smaller than 32, and a Year of 1966?`

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

CREATE TABLE "michigan_single_game_reception_yardage" (
  "player" text,
  "rec" real,
  "yards" real,
  "average" real,
  "s_touchdown" real,
  "year" real,
  "opponent" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Opponent has Yards smaller than 197, and an Average smaller than 32, and a Year of 1966?`:
```sql
                SELECT "opponent" FROM "michigan_single_game_reception_yardage" WHERE "yards"<197 AND "average"<32 AND "year"=1966;
```
## Task
Generate a SQL query to answer the following question:
`How many Touchdowns have a rec of 10, and an Opponent of oregon state, and an Average smaller than 19.7?`

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

CREATE TABLE "michigan_single_game_reception_yardage" (
  "player" text,
  "rec" real,
  "yards" real,
  "average" real,
  "s_touchdown" real,
  "year" real,
  "opponent" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many Touchdowns have a rec of 10, and an Opponent of oregon state, and an Average smaller than 19.7?`:
```sql
                SELECT COUNT("s_touchdown") FROM "michigan_single_game_reception_yardage" WHERE "rec"=10 AND "opponent"='oregon state' AND "average"<19.7;
```
## Task
Generate a SQL query to answer the following question:
`Which Points have an Opponent of @ atlanta thrashers, and a Game smaller than 28?`

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

CREATE TABLE "regular_season" (
  "game" real,
  "december" real,
  "opponent" text,
  "score" text,
  "record" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Points have an Opponent of @ atlanta thrashers, and a Game smaller than 28?`:
```sql
                SELECT SUM("points") FROM "regular_season" WHERE "opponent"='@ atlanta thrashers' AND "game"<28;
```
## Task
Generate a SQL query to answer the following question:
`How many Points have a Game smaller than 37, and a Score of 2–3, and a December of 13?`

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

CREATE TABLE "regular_season" (
  "game" real,
  "december" real,
  "opponent" text,
  "score" text,
  "record" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many Points have a Game smaller than 37, and a Score of 2–3, and a December of 13?`:
```sql
                SELECT COUNT("points") FROM "regular_season" WHERE "game"<37 AND "score"='2–3' AND "december"=13;
```
## Task
Generate a SQL query to answer the following question:
`Which Game is the highest one that has a Score of 3–2?`

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

CREATE TABLE "regular_season" (
  "game" real,
  "december" real,
  "opponent" text,
  "score" text,
  "record" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Game is the highest one that has a Score of 3–2?`:
```sql
                SELECT MAX("game") FROM "regular_season" WHERE "score"='3–2';
```
## Task
Generate a SQL query to answer the following question:
`What spans were built in 1896?`

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

CREATE TABLE "references" (
  "name" text,
  "county" text,
  "location" text,
  "built" text,
  "length_ft" real,
  "spans" text
);
### SQL
Given the database schema, here is the SQL query that answers `What spans were built in 1896?`:
```sql
                SELECT "spans" FROM "references" WHERE "built"='1896';
```
## Task
Generate a SQL query to answer the following question:
`Who has a length of 71 ft?`

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

CREATE TABLE "references" (
  "name" text,
  "county" text,
  "location" text,
  "built" text,
  "length_ft" real,
  "spans" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who has a length of 71 ft?`:
```sql
                SELECT "name" FROM "references" WHERE "length_ft"=71;
```
## Task
Generate a SQL query to answer the following question:
`Where was the county of rockingham?`

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

CREATE TABLE "references" (
  "name" text,
  "county" text,
  "location" text,
  "built" text,
  "length_ft" real,
  "spans" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where was the county of rockingham?`:
```sql
                SELECT "location" FROM "references" WHERE "county"='rockingham';
```
## Task
Generate a SQL query to answer the following question:
`What is the propulsion for the RB 04 earlier than 1962?`

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

CREATE TABLE "comparison" (
  "name" text,
  "year" real,
  "propulsion" text,
  "launched_by" text,
  "country" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the propulsion for the RB 04 earlier than 1962?`:
```sql
                SELECT "propulsion" FROM "comparison" WHERE "year"<1962 AND "name"='rb 04';
```
## Task
Generate a SQL query to answer the following question:
`What is the name of the anti-ship missile that had a turbojet propulsion that was launched by a surface, sub after 1985?`

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

CREATE TABLE "comparison" (
  "name" text,
  "year" real,
  "propulsion" text,
  "launched_by" text,
  "country" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the name of the anti-ship missile that had a turbojet propulsion that was launched by a surface, sub after 1985?`:
```sql
                SELECT "name" FROM "comparison" WHERE "propulsion"='turbojet' AND "year">1985 AND "launched_by"='surface, sub';
```
## Task
Generate a SQL query to answer the following question:
`What country had an anti-ship missile that had a solid rocket propulsion?`

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

CREATE TABLE "comparison" (
  "name" text,
  "year" real,
  "propulsion" text,
  "launched_by" text,
  "country" text
);
### SQL
Given the database schema, here is the SQL query that answers `What country had an anti-ship missile that had a solid rocket propulsion?`:
```sql
                SELECT "country" FROM "comparison" WHERE "propulsion"='solid rocket';
```
## Task
Generate a SQL query to answer the following question:
`How many seats in 2001 with a quantity greater than 4?`

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

CREATE TABLE "current_fleet" (
  "length_feet" text,
  "year" text,
  "make_and_model" text,
  "floor_type" text,
  "number_of_seats" real,
  "bicycle_capacity" real,
  "fuel_propulsion" text,
  "quantity" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many seats in 2001 with a quantity greater than 4?`:
```sql
                SELECT COUNT("number_of_seats") FROM "current_fleet" WHERE "year"='2001' AND "quantity">4;
```
## Task
Generate a SQL query to answer the following question:
`What make and model of the diesel vehicle with a high floor type, bike capacity less than 3, and a quantity of 4?`

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

CREATE TABLE "current_fleet" (
  "length_feet" text,
  "year" text,
  "make_and_model" text,
  "floor_type" text,
  "number_of_seats" real,
  "bicycle_capacity" real,
  "fuel_propulsion" text,
  "quantity" real
);
### SQL
Given the database schema, here is the SQL query that answers `What make and model of the diesel vehicle with a high floor type, bike capacity less than 3, and a quantity of 4?`:
```sql
                SELECT "make_and_model" FROM "current_fleet" WHERE "fuel_propulsion"='diesel' AND "floor_type"='high' AND "bicycle_capacity"<3 AND "quantity"=4;
```
## Task
Generate a SQL query to answer the following question:
`What score has nashville predators as the opponent?`

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

CREATE TABLE "regular_season" (
  "game" real,
  "december" real,
  "opponent" text,
  "score" text,
  "record" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What score has nashville predators as the opponent?`:
```sql
                SELECT "score" FROM "regular_season" WHERE "opponent"='nashville predators';
```
## Task
Generate a SQL query to answer the following question:
`What are the average points that have december 27?`

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

CREATE TABLE "regular_season" (
  "game" real,
  "december" real,
  "opponent" text,
  "score" text,
  "record" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What are the average points that have december 27?`:
```sql
                SELECT AVG("points") FROM "regular_season" WHERE "december"=27;
```
## Task
Generate a SQL query to answer the following question:
`What record has points greater than 39, with 38 as the game?`

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

CREATE TABLE "regular_season" (
  "game" real,
  "december" real,
  "opponent" text,
  "score" text,
  "record" text,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What record has points greater than 39, with 38 as the game?`:
```sql
                SELECT "record" FROM "regular_season" WHERE "points">39 AND "game"=38;
```
## Task
Generate a SQL query to answer the following question:
`What is the Stuffit ability that has a gzip of yes, ISO/CD images of no and LHA/LZH of no?`

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

CREATE TABLE "writing" (
  "gzip" text,
  "bzip2" text,
  "lha_lzh" text,
  "stuff_it" text,
  "stuff_it_x" text,
  "iso_cd_image" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Stuffit ability that has a gzip of yes, ISO/CD images of no and LHA/LZH of no?`:
```sql
                SELECT "stuff_it" FROM "writing" WHERE "gzip"='yes' AND "iso_cd_image"='no' AND "lha_lzh"='no';
```
## Task
Generate a SQL query to answer the following question:
`What is the gzip value associated with a stuffit of no, bzip2 of no, and LHA.LZH of no?`

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

CREATE TABLE "writing" (
  "gzip" text,
  "bzip2" text,
  "lha_lzh" text,
  "stuff_it" text,
  "stuff_it_x" text,
  "iso_cd_image" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the gzip value associated with a stuffit of no, bzip2 of no, and LHA.LZH of no?`:
```sql
                SELECT "gzip" FROM "writing" WHERE "stuff_it"='no' AND "bzip2"='no' AND "lha_lzh"='no';
```
## Task
Generate a SQL query to answer the following question:
`What is the bzip2 value associated with a gzip of yes, StuffitX of unknown, and ISO/CD image of unknown?`

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

CREATE TABLE "writing" (
  "gzip" text,
  "bzip2" text,
  "lha_lzh" text,
  "stuff_it" text,
  "stuff_it_x" text,
  "iso_cd_image" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the bzip2 value associated with a gzip of yes, StuffitX of unknown, and ISO/CD image of unknown?`:
```sql
                SELECT "bzip2" FROM "writing" WHERE "gzip"='yes' AND "stuff_it_x"='unknown' AND "iso_cd_image"='unknown';
```
## Task
Generate a SQL query to answer the following question:
`What is the StuffitX value that has a Stuffit of unknown, LHA/LZH of yes, and unknown ISO/CD image?`

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

CREATE TABLE "writing" (
  "gzip" text,
  "bzip2" text,
  "lha_lzh" text,
  "stuff_it" text,
  "stuff_it_x" text,
  "iso_cd_image" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the StuffitX value that has a Stuffit of unknown, LHA/LZH of yes, and unknown ISO/CD image?`:
```sql
                SELECT "stuff_it_x" FROM "writing" WHERE "stuff_it"='unknown' AND "lha_lzh"='yes' AND "iso_cd_image"='unknown';
```
## Task
Generate a SQL query to answer the following question:
`What is the stuffit that has bzip and LHA/LZH of no?`

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

CREATE TABLE "writing" (
  "gzip" text,
  "bzip2" text,
  "lha_lzh" text,
  "stuff_it" text,
  "stuff_it_x" text,
  "iso_cd_image" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the stuffit that has bzip and LHA/LZH of no?`:
```sql
                SELECT "stuff_it" FROM "writing" WHERE "bzip2"='no' AND "lha_lzh"='no';
```
## Task
Generate a SQL query to answer the following question:
`What is the ISO/CD image value associated with StuffitX of no, gzip of yes, and LHA/LZH of yes?`

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

CREATE TABLE "writing" (
  "gzip" text,
  "bzip2" text,
  "lha_lzh" text,
  "stuff_it" text,
  "stuff_it_x" text,
  "iso_cd_image" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the ISO/CD image value associated with StuffitX of no, gzip of yes, and LHA/LZH of yes?`:
```sql
                SELECT "iso_cd_image" FROM "writing" WHERE "stuff_it_x"='no' AND "gzip"='yes' AND "lha_lzh"='yes';
```
## Task
Generate a SQL query to answer the following question:
`Which round was Robert Deciantis taken in?`

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

CREATE TABLE "nhl_entry_draft" (
  "round" real,
  "player" text,
  "position" text,
  "nationality" text,
  "college_junior_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which round was Robert Deciantis taken in?`:
```sql
                SELECT "round" FROM "nhl_entry_draft" WHERE "player"='robert deciantis';
```
## Task
Generate a SQL query to answer the following question:
`Which round was Brian Elder taken in?`

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

CREATE TABLE "nhl_entry_draft" (
  "round" real,
  "player" text,
  "position" text,
  "nationality" text,
  "college_junior_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which round was Brian Elder taken in?`:
```sql
                SELECT MIN("round") FROM "nhl_entry_draft" WHERE "player"='brian elder';
```
## Task
Generate a SQL query to answer the following question:
`what is the date of the tournament in michalovce`

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

CREATE TABLE "singles_5_11" (
  "outcome" text,
  "date" text,
  "tournament" text,
  "surface" text,
  "opponent" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `what is the date of the tournament in michalovce`:
```sql
                SELECT "date" FROM "singles_5_11" WHERE "tournament"='michalovce';
```
## Task
Generate a SQL query to answer the following question:
`What was the winning score of the Valero Texas Open?`

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

CREATE TABLE "pga_tour_wins_12" (
  "date" text,
  "tournament" text,
  "winning_score" text,
  "margin_of_victory" text,
  "runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the winning score of the Valero Texas Open?`:
```sql
                SELECT "winning_score" FROM "pga_tour_wins_12" WHERE "tournament"='valero texas open';
```
## Task
Generate a SQL query to answer the following question:
`When was the winning score –12 (69-66-72-65=272)?`

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

CREATE TABLE "pga_tour_wins_12" (
  "date" text,
  "tournament" text,
  "winning_score" text,
  "margin_of_victory" text,
  "runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `When was the winning score –12 (69-66-72-65=272)?`:
```sql
                SELECT "date" FROM "pga_tour_wins_12" WHERE "winning_score"='–12 (69-66-72-65=272)';
```
## Task
Generate a SQL query to answer the following question:
`Who was the runner-up when the winning score was –28 (66-67-68-64-67=332)?`

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

CREATE TABLE "pga_tour_wins_12" (
  "date" text,
  "tournament" text,
  "winning_score" text,
  "margin_of_victory" text,
  "runner_s_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the runner-up when the winning score was –28 (66-67-68-64-67=332)?`:
```sql
                SELECT "runner_s_up" FROM "pga_tour_wins_12" WHERE "winning_score"='–28 (66-67-68-64-67=332)';
```
## Task
Generate a SQL query to answer the following question:
`Which party had a Retired Democratic hold?`

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

CREATE TABLE "california" (
  "district" text,
  "incumbent" text,
  "party" text,
  "first_elected" real,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which party had a Retired Democratic hold?`:
```sql
                SELECT "party" FROM "california" WHERE "result"='retired democratic hold';
```
## Task
Generate a SQL query to answer the following question:
`What's the average year Charles N. Felton was re-elected?`

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

CREATE TABLE "california" (
  "district" text,
  "incumbent" text,
  "party" text,
  "first_elected" real,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the average year Charles N. Felton was re-elected?`:
```sql
                SELECT AVG("first_elected") FROM "california" WHERE "result"='re-elected' AND "incumbent"='charles n. felton';
```
## Task
Generate a SQL query to answer the following question:
`What year was Barclay Henley first elected?`

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

CREATE TABLE "california" (
  "district" text,
  "incumbent" text,
  "party" text,
  "first_elected" real,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What year was Barclay Henley first elected?`:
```sql
                SELECT COUNT("first_elected") FROM "california" WHERE "incumbent"='barclay henley';
```