cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`What is the highest points scored for the team with a position larger than 5, who had less than 4 wins and more than 8 draws?`

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

CREATE TABLE "torneo_apertura" (
  "position" real,
  "team" text,
  "played" real,
  "wins" real,
  "draws" real,
  "losses" real,
  "scored" real,
  "conceded" real,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest points scored for the team with a position larger than 5, who had less than 4 wins and more than 8 draws?`:
```sql
                SELECT MAX("scored") FROM "torneo_apertura" WHERE "position">5 AND "wins"<4 AND "draws">8;
```
## Task
Generate a SQL query to answer the following question:
`What is the average number conceded for hte team that had less than 19 points, played more than 18 games and had a position less than 10?`

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

CREATE TABLE "torneo_apertura" (
  "position" real,
  "team" text,
  "played" real,
  "wins" real,
  "draws" real,
  "losses" real,
  "scored" real,
  "conceded" real,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average number conceded for hte team that had less than 19 points, played more than 18 games and had a position less than 10?`:
```sql
                SELECT AVG("conceded") FROM "torneo_apertura" WHERE "points"<19 AND "position"<10 AND "played">18;
```
## Task
Generate a SQL query to answer the following question:
`What was the sum of the draws for the team that had 11 wins, less than 38 points, and a position smaller than 4?`

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

CREATE TABLE "torneo_apertura" (
  "position" real,
  "team" text,
  "played" real,
  "wins" real,
  "draws" real,
  "losses" real,
  "scored" real,
  "conceded" real,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the sum of the draws for the team that had 11 wins, less than 38 points, and a position smaller than 4?`:
```sql
                SELECT SUM("draws") FROM "torneo_apertura" WHERE "position"<4 AND "wins"=11 AND "points"<38;
```
## Task
Generate a SQL query to answer the following question:
`What was the lowest number of wins for the team that scored more than 14 points and had a position of 7?`

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

CREATE TABLE "torneo_apertura" (
  "position" real,
  "team" text,
  "played" real,
  "wins" real,
  "draws" real,
  "losses" real,
  "scored" real,
  "conceded" real,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the lowest number of wins for the team that scored more than 14 points and had a position of 7?`:
```sql
                SELECT MIN("wins") FROM "torneo_apertura" WHERE "position"=7 AND "scored">14;
```
## Task
Generate a SQL query to answer the following question:
`What is the total number scored for the team that had 19 points and a position larger than 4?`

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

CREATE TABLE "torneo_apertura" (
  "position" real,
  "team" text,
  "played" real,
  "wins" real,
  "draws" real,
  "losses" real,
  "scored" real,
  "conceded" real,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number scored for the team that had 19 points and a position larger than 4?`:
```sql
                SELECT COUNT("scored") FROM "torneo_apertura" WHERE "position">4 AND "points"=19;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest number conceded for the team that had less than 8 wins, scored 21, and had less than 23 points?`

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

CREATE TABLE "torneo_apertura" (
  "position" real,
  "team" text,
  "played" real,
  "wins" real,
  "draws" real,
  "losses" real,
  "scored" real,
  "conceded" real,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest number conceded for the team that had less than 8 wins, scored 21, and had less than 23 points?`:
```sql
                SELECT MIN("conceded") FROM "torneo_apertura" WHERE "wins"<8 AND "scored"=21 AND "points"<23;
```
## Task
Generate a SQL query to answer the following question:
`Which Date has a Result of l 14–13?`

### 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,
  "game_site" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Date has a Result of l 14–13?`:
```sql
                SELECT "date" FROM "schedule" WHERE "result"='l 14–13';
```
## Task
Generate a SQL query to answer the following question:
`Which Date has a Result of w 13–6?`

### 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,
  "game_site" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Date has a Result of w 13–6?`:
```sql
                SELECT "date" FROM "schedule" WHERE "result"='w 13–6';
```
## Task
Generate a SQL query to answer the following question:
`What is the Result of Week larger than 3 on 1971-11-07?`

### 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,
  "game_site" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Result of Week larger than 3 on 1971-11-07?`:
```sql
                SELECT "result" FROM "schedule" WHERE "week">3 AND "date"='1971-11-07';
```
## Task
Generate a SQL query to answer the following question:
`What is the pos with more than 1 tier during Pokal Slovenije 1. round?`

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

CREATE TABLE "season_by_season" (
  "season" text,
  "tier" real,
  "division" text,
  "pos" real,
  "cup_competitions" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the pos with more than 1 tier during Pokal Slovenije 1. round?`:
```sql
                SELECT "pos" FROM "season_by_season" WHERE "tier">1 AND "cup_competitions"='pokal slovenije 1. round';
```
## Task
Generate a SQL query to answer the following question:
`What are the exact Cubic inches of the Metric value of 104.955 L?`

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

CREATE TABLE "dry_measures" (
  "unit" text,
  "russian" text,
  "translation" text,
  "ratio" text,
  "cubic_inches_exact" text,
  "metric_value" text,
  "imperial_value" text,
  "us_customary" text
);
### SQL
Given the database schema, here is the SQL query that answers `What are the exact Cubic inches of the Metric value of 104.955 L?`:
```sql
                SELECT "cubic_inches_exact" FROM "dry_measures" WHERE "metric_value"='104.955 l';
```
## Task
Generate a SQL query to answer the following question:
`What is the Translation of the US Customary value 0.263 pt?`

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

CREATE TABLE "dry_measures" (
  "unit" text,
  "russian" text,
  "translation" text,
  "ratio" text,
  "cubic_inches_exact" text,
  "metric_value" text,
  "imperial_value" text,
  "us_customary" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Translation of the US Customary value 0.263 pt?`:
```sql
                SELECT "translation" FROM "dry_measures" WHERE "us_customary"='0.263 pt';
```
## Task
Generate a SQL query to answer the following question:
`What is the Metric value of Russian че́тверть?`

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

CREATE TABLE "dry_measures" (
  "unit" text,
  "russian" text,
  "translation" text,
  "ratio" text,
  "cubic_inches_exact" text,
  "metric_value" text,
  "imperial_value" text,
  "us_customary" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Metric value of Russian че́тверть?`:
```sql
                SELECT "metric_value" FROM "dry_measures" WHERE "russian"='че́тверть';
```
## Task
Generate a SQL query to answer the following question:
`What are the exact Cubic inches of the Unit of kruzhka?`

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

CREATE TABLE "dry_measures" (
  "unit" text,
  "russian" text,
  "translation" text,
  "ratio" text,
  "cubic_inches_exact" text,
  "metric_value" text,
  "imperial_value" text,
  "us_customary" text
);
### SQL
Given the database schema, here is the SQL query that answers `What are the exact Cubic inches of the Unit of kruzhka?`:
```sql
                SELECT "cubic_inches_exact" FROM "dry_measures" WHERE "unit"='kruzhka';
```
## Task
Generate a SQL query to answer the following question:
`Which Zero Fighter has a count of 10?`

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

CREATE TABLE "a_part_of_yanagiya_s_flight_log_in_april" (
  "date" text,
  "id_code_of_his_zero_fighter" text,
  "flight_hours" text,
  "count" text,
  "sub_total" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Zero Fighter has a count of 10?`:
```sql
                SELECT "id_code_of_his_zero_fighter" FROM "a_part_of_yanagiya_s_flight_log_in_april" WHERE "count"='10';
```
## Task
Generate a SQL query to answer the following question:
`On which day were the subtotal hours 9:30?`

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

CREATE TABLE "a_part_of_yanagiya_s_flight_log_in_april" (
  "date" text,
  "id_code_of_his_zero_fighter" text,
  "flight_hours" text,
  "count" text,
  "sub_total" text
);
### SQL
Given the database schema, here is the SQL query that answers `On which day were the subtotal hours 9:30?`:
```sql
                SELECT "date" FROM "a_part_of_yanagiya_s_flight_log_in_april" WHERE "sub_total"='9:30';
```
## Task
Generate a SQL query to answer the following question:
`What is the count for the Zero Fighter with hours of 2:00?`

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

CREATE TABLE "a_part_of_yanagiya_s_flight_log_in_april" (
  "date" text,
  "id_code_of_his_zero_fighter" text,
  "flight_hours" text,
  "count" text,
  "sub_total" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the count for the Zero Fighter with hours of 2:00?`:
```sql
                SELECT "count" FROM "a_part_of_yanagiya_s_flight_log_in_april" WHERE "flight_hours"='2:00';
```
## Task
Generate a SQL query to answer the following question:
`Which record has Katsuomi Inagaki as an opponent?`

### 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,
  "round" real,
  "time" text,
  "location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which record has Katsuomi Inagaki as an opponent?`:
```sql
                SELECT "record" FROM "mixed_martial_arts_record" WHERE "opponent"='katsuomi inagaki';
```
## Task
Generate a SQL query to answer the following question:
`Which method has a 1:46 time?`

### 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,
  "round" real,
  "time" text,
  "location" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which method has a 1:46 time?`:
```sql
                SELECT "method" FROM "mixed_martial_arts_record" WHERE "time"='1:46';
```
## Task
Generate a SQL query to answer the following question:
`What is Henri Crockett's highest overall with more than 3 picks?`

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

CREATE TABLE "atlanta_falcons_draft_history" (
  "round" real,
  "pick_num" real,
  "overall" real,
  "name" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is Henri Crockett's highest overall with more than 3 picks?`:
```sql
                SELECT MAX("overall") FROM "atlanta_falcons_draft_history" WHERE "pick_num">3 AND "name"='henri crockett';
```
## Task
Generate a SQL query to answer the following question:
`Which college has fewer than 2 rounds?`

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

CREATE TABLE "atlanta_falcons_draft_history" (
  "round" real,
  "pick_num" real,
  "overall" real,
  "name" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which college has fewer than 2 rounds?`:
```sql
                SELECT "college" FROM "atlanta_falcons_draft_history" WHERE "round"<2;
```
## Task
Generate a SQL query to answer the following question:
`What are the total number of picks for a guard with fewer than 6 rounds?`

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

CREATE TABLE "atlanta_falcons_draft_history" (
  "round" real,
  "pick_num" real,
  "overall" real,
  "name" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What are the total number of picks for a guard with fewer than 6 rounds?`:
```sql
                SELECT COUNT("pick_num") FROM "atlanta_falcons_draft_history" WHERE "position"='guard' AND "round"<6;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest overall for a quarterback with fewer than 7 rounds?`

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

CREATE TABLE "atlanta_falcons_draft_history" (
  "round" real,
  "pick_num" real,
  "overall" real,
  "name" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest overall for a quarterback with fewer than 7 rounds?`:
```sql
                SELECT MIN("overall") FROM "atlanta_falcons_draft_history" WHERE "position"='quarterback' AND "round"<7;
```
## Task
Generate a SQL query to answer the following question:
`What Playoffs had an Open Cup of 3rd round?`

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

CREATE TABLE "year_by_year" (
  "year" real,
  "division" real,
  "league" text,
  "reg_season" text,
  "playoffs" text,
  "open_cup" text,
  "avg_attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What Playoffs had an Open Cup of 3rd round?`:
```sql
                SELECT "playoffs" FROM "year_by_year" WHERE "open_cup"='3rd round';
```
## Task
Generate a SQL query to answer the following question:
`What was the D segment for episode 60?`

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

CREATE TABLE "season_5_2005" (
  "series_ep" text,
  "episode" real,
  "netflix" text,
  "segment_a" text,
  "segment_b" text,
  "segment_c" text,
  "segment_d" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the D segment for episode 60?`:
```sql
                SELECT "segment_d" FROM "season_5_2005" WHERE "episode"=60;
```
## Task
Generate a SQL query to answer the following question:
`What was the B segmint for Netlix S03E01?`

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

CREATE TABLE "season_5_2005" (
  "series_ep" text,
  "episode" real,
  "netflix" text,
  "segment_a" text,
  "segment_b" text,
  "segment_c" text,
  "segment_d" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the B segmint for Netlix S03E01?`:
```sql
                SELECT "segment_b" FROM "season_5_2005" WHERE "netflix"='s03e01';
```
## Task
Generate a SQL query to answer the following question:
`What racing club team made supercopa 1996?`

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

CREATE TABLE "argentine_clubs_in_international_competi" (
  "team" text,
  "intercontinental" text,
  "recopa_1996" text,
  "supercopa_1996" text,
  "conmebol_1996" text,
  "copa_libertadores_1997" text
);
### SQL
Given the database schema, here is the SQL query that answers `What racing club team made supercopa 1996?`:
```sql
                SELECT "supercopa_1996" FROM "argentine_clubs_in_international_competi" WHERE "team"='racing club';
```
## Task
Generate a SQL query to answer the following question:
`Name the # country for new palestine`

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

CREATE TABLE "indiana_high_school_athletics_conference" (
  "school" text,
  "location" text,
  "mascot" text,
  "enrollment" real,
  "ihsaa_class" text,
  "ihsaa_football_class" text,
  "num_county" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the # country for new palestine`:
```sql
                SELECT "num_county" FROM "indiana_high_school_athletics_conference" WHERE "school"='new palestine';
```
## Task
Generate a SQL query to answer the following question:
`Name the number of enrollment for county of 48 madison`

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

CREATE TABLE "indiana_high_school_athletics_conference" (
  "school" text,
  "location" text,
  "mascot" text,
  "enrollment" real,
  "ihsaa_class" text,
  "ihsaa_football_class" text,
  "num_county" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the number of enrollment for county of 48 madison`:
```sql
                SELECT COUNT("enrollment") FROM "indiana_high_school_athletics_conference" WHERE "num_county"='48 madison';
```
## Task
Generate a SQL query to answer the following question:
`Name the IHSAA class with county 18 delaware and tigers mascot`

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

CREATE TABLE "indiana_high_school_athletics_conference" (
  "school" text,
  "location" text,
  "mascot" text,
  "enrollment" real,
  "ihsaa_class" text,
  "ihsaa_football_class" text,
  "num_county" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the IHSAA class with county 18 delaware and tigers mascot`:
```sql
                SELECT "ihsaa_class" FROM "indiana_high_school_athletics_conference" WHERE "num_county"='18 delaware' AND "mascot"='tigers';
```
## Task
Generate a SQL query to answer the following question:
`Name the mascot for shelbyville`

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

CREATE TABLE "indiana_high_school_athletics_conference" (
  "school" text,
  "location" text,
  "mascot" text,
  "enrollment" real,
  "ihsaa_class" text,
  "ihsaa_football_class" text,
  "num_county" text
);
### SQL
Given the database schema, here is the SQL query that answers `Name the mascot for shelbyville`:
```sql
                SELECT "mascot" FROM "indiana_high_school_athletics_conference" WHERE "school"='shelbyville';
```
## Task
Generate a SQL query to answer the following question:
`What's the capacity that has the highest greater than 1,763 and is at Hampden Park?`

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

CREATE TABLE "attendances" (
  "team" text,
  "stadium" text,
  "capacity" real,
  "highest" real,
  "lowest" real,
  "average" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the capacity that has the highest greater than 1,763 and is at Hampden Park?`:
```sql
                SELECT MIN("capacity") FROM "attendances" WHERE "stadium"='hampden park' AND "highest">'1,763';
```
## Task
Generate a SQL query to answer the following question:
`What's the highest with a capacity of greater than 4,000 and an average of 615?`

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

CREATE TABLE "attendances" (
  "team" text,
  "stadium" text,
  "capacity" real,
  "highest" real,
  "lowest" real,
  "average" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the highest with a capacity of greater than 4,000 and an average of 615?`:
```sql
                SELECT MAX("highest") FROM "attendances" WHERE "average"=615 AND "capacity">'4,000';
```
## Task
Generate a SQL query to answer the following question:
`At Balmoor Stadium, what's the total average having a greater than 400 lowest?`

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

CREATE TABLE "attendances" (
  "team" text,
  "stadium" text,
  "capacity" real,
  "highest" real,
  "lowest" real,
  "average" real
);
### SQL
Given the database schema, here is the SQL query that answers `At Balmoor Stadium, what's the total average having a greater than 400 lowest?`:
```sql
                SELECT COUNT("average") FROM "attendances" WHERE "stadium"='balmoor' AND "lowest">400;
```
## Task
Generate a SQL query to answer the following question:
`What was the score of Tommy Aaron (2) when the tournament was in georgia?`

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

CREATE TABLE "tournament_results" (
  "date" text,
  "tournament" text,
  "location" text,
  "winner" text,
  "score" text,
  "1st_prize" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score of Tommy Aaron (2) when the tournament was in georgia?`:
```sql
                SELECT "score" FROM "tournament_results" WHERE "location"='georgia' AND "winner"='tommy aaron (2)';
```
## Task
Generate a SQL query to answer the following question:
`What was the tournament that had a first prize of $12,600?`

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

CREATE TABLE "tournament_results" (
  "date" text,
  "tournament" text,
  "location" text,
  "winner" text,
  "score" text,
  "1st_prize" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the tournament that had a first prize of $12,600?`:
```sql
                SELECT "tournament" FROM "tournament_results" WHERE "1st_prize"='12,600';
```
## Task
Generate a SQL query to answer the following question:
`What was the score of Ken Still (3) when he won first place?`

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

CREATE TABLE "tournament_results" (
  "date" text,
  "tournament" text,
  "location" text,
  "winner" text,
  "score" text,
  "1st_prize" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score of Ken Still (3) when he won first place?`:
```sql
                SELECT "score" FROM "tournament_results" WHERE "winner"='ken still (3)';
```
## Task
Generate a SQL query to answer the following question:
`Who beat Chic by 8fm?`

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

CREATE TABLE "race_performances" (
  "date" text,
  "placing" text,
  "beat_by" text,
  "location" text,
  "distance" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who beat Chic by 8fm?`:
```sql
                SELECT "beat_by" FROM "race_performances" WHERE "distance"='8fm';
```
## Task
Generate a SQL query to answer the following question:
`What was the placing of the race in which Chic won by 8gf?`

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

CREATE TABLE "race_performances" (
  "date" text,
  "placing" text,
  "beat_by" text,
  "location" text,
  "distance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the placing of the race in which Chic won by 8gf?`:
```sql
                SELECT "placing" FROM "race_performances" WHERE "beat_by"='won' AND "distance"='8gf';
```
## Task
Generate a SQL query to answer the following question:
`What was the date in which Chic won at CHS?`

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

CREATE TABLE "race_performances" (
  "date" text,
  "placing" text,
  "beat_by" text,
  "location" text,
  "distance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the date in which Chic won at CHS?`:
```sql
                SELECT "date" FROM "race_performances" WHERE "beat_by"='won' AND "location"='chs';
```
## Task
Generate a SQL query to answer the following question:
`Who is the opponent of game 54, which was in Los Angeles and was before day 18?`

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

CREATE TABLE "schedule_and_results" (
  "game" real,
  "date" real,
  "opponent" text,
  "score" text,
  "location_attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the opponent of game 54, which was in Los Angeles and was before day 18?`:
```sql
                SELECT "opponent" FROM "schedule_and_results" WHERE "location_attendance"='los angeles' AND "date"<18 AND "game"=54;
```
## Task
Generate a SQL query to answer the following question:
`What is the earliest date of the game with a score of 2-2?`

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

CREATE TABLE "schedule_and_results" (
  "game" real,
  "date" real,
  "opponent" text,
  "score" text,
  "location_attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the earliest date of the game with a score of 2-2?`:
```sql
                SELECT MIN("date") FROM "schedule_and_results" WHERE "score"='2-2';
```
## Task
Generate a SQL query to answer the following question:
`What is the average date of the game with the Detroit Red Wings as the opponent?`

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

CREATE TABLE "schedule_and_results" (
  "game" real,
  "date" real,
  "opponent" text,
  "score" text,
  "location_attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average date of the game with the Detroit Red Wings as the opponent?`:
```sql
                SELECT AVG("date") FROM "schedule_and_results" WHERE "opponent"='detroit red wings';
```
## Task
Generate a SQL query to answer the following question:
`What is the date of the game with a score of 4-2?`

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

CREATE TABLE "schedule_and_results" (
  "game" real,
  "date" real,
  "opponent" text,
  "score" text,
  "location_attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the date of the game with a score of 4-2?`:
```sql
                SELECT "date" FROM "schedule_and_results" WHERE "score"='4-2';
```
## Task
Generate a SQL query to answer the following question:
`What was the loss of the game that had a record of 3-3?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the loss of the game that had a record of 3-3?`:
```sql
                SELECT "loss" FROM "game_log" WHERE "record"='3-3';
```
## Task
Generate a SQL query to answer the following question:
`What was the score of the game with a loss of Mercedes (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" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score of the game with a loss of Mercedes (0-1)?`:
```sql
                SELECT "score" FROM "game_log" WHERE "loss"='mercedes (0-1)';
```
## Task
Generate a SQL query to answer the following question:
`Who was the opponent at the game with a loss of Weaver (1-2)?`

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

CREATE TABLE "game_log" (
  "date" text,
  "opponent" text,
  "score" text,
  "loss" text,
  "attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the opponent at the game with a loss of Weaver (1-2)?`:
```sql
                SELECT "opponent" FROM "game_log" WHERE "loss"='weaver (1-2)';
```
## Task
Generate a SQL query to answer the following question:
`What's the Remixed by with a Version of Strings for Soul's Mix?`

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

CREATE TABLE "official_versions" (
  "version" text,
  "length" text,
  "album" text,
  "remixed_by" text,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the Remixed by with a Version of Strings for Soul's Mix?`:
```sql
                SELECT "remixed_by" FROM "official_versions" WHERE "version"='strings for soul''s mix';
```
## Task
Generate a SQL query to answer the following question:
`What the highest Year with a Remixed by Laurent Boutonnat?`

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

CREATE TABLE "official_versions" (
  "version" text,
  "length" text,
  "album" text,
  "remixed_by" text,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `What the highest Year with a Remixed by Laurent Boutonnat?`:
```sql
                SELECT MAX("year") FROM "official_versions" WHERE "remixed_by"='laurent boutonnat';
```
## Task
Generate a SQL query to answer the following question:
`What's the total Year with a Length of 4:45 an has an Album of Les Mots?`

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

CREATE TABLE "official_versions" (
  "version" text,
  "length" text,
  "album" text,
  "remixed_by" text,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the total Year with a Length of 4:45 an has an Album of Les Mots?`:
```sql
                SELECT SUM("year") FROM "official_versions" WHERE "length"='4:45' AND "album"='les mots';
```
## Task
Generate a SQL query to answer the following question:
`What's the Length with the Version of Album Version?`

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

CREATE TABLE "official_versions" (
  "version" text,
  "length" text,
  "album" text,
  "remixed_by" text,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the Length with the Version of Album Version?`:
```sql
                SELECT "length" FROM "official_versions" WHERE "version"='album version';
```
## Task
Generate a SQL query to answer the following question:
`What Album has a Year that's larger than 2001?`

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

CREATE TABLE "official_versions" (
  "version" text,
  "length" text,
  "album" text,
  "remixed_by" text,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `What Album has a Year that's larger than 2001?`:
```sql
                SELECT "album" FROM "official_versions" WHERE "year">2001;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest position for bruce taylor?`

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

CREATE TABLE "race_2_20_12_2007" (
  "position" real,
  "pilot" text,
  "glider" text,
  "speed" text,
  "distance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest position for bruce taylor?`:
```sql
                SELECT MIN("position") FROM "race_2_20_12_2007" WHERE "pilot"='bruce taylor';
```
## Task
Generate a SQL query to answer the following question:
`Which pilot has a position above 5 and a speed of 118.8km/h?`

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

CREATE TABLE "race_2_20_12_2007" (
  "position" real,
  "pilot" text,
  "glider" text,
  "speed" text,
  "distance" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which pilot has a position above 5 and a speed of 118.8km/h?`:
```sql
                SELECT "pilot" FROM "race_2_20_12_2007" WHERE "position">5 AND "speed"='118.8km/h';
```
## Task
Generate a SQL query to answer the following question:
`What is Erwin Sommer's average position?`

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

CREATE TABLE "race_2_20_12_2007" (
  "position" real,
  "pilot" text,
  "glider" text,
  "speed" text,
  "distance" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is Erwin Sommer's average position?`:
```sql
                SELECT AVG("position") FROM "race_2_20_12_2007" WHERE "pilot"='erwin sommer';
```
## Task
Generate a SQL query to answer the following question:
`What is the highest rank of the day with a gross of $38,916 and more than 6 screens?`

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

CREATE TABLE "opening_weekend_gross" (
  "date" text,
  "territory" text,
  "screens" real,
  "rank" real,
  "gross" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest rank of the day with a gross of $38,916 and more than 6 screens?`:
```sql
                SELECT MAX("rank") FROM "opening_weekend_gross" WHERE "gross"='$38,916' AND "screens">6;
```
## Task
Generate a SQL query to answer the following question:
`What is the gross in the United Kingdom?`

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

CREATE TABLE "opening_weekend_gross" (
  "date" text,
  "territory" text,
  "screens" real,
  "rank" real,
  "gross" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the gross in the United Kingdom?`:
```sql
                SELECT "gross" FROM "opening_weekend_gross" WHERE "territory"='united kingdom';
```
## Task
Generate a SQL query to answer the following question:
`What is the territory with 17 screens?`

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

CREATE TABLE "opening_weekend_gross" (
  "date" text,
  "territory" text,
  "screens" real,
  "rank" real,
  "gross" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the territory with 17 screens?`:
```sql
                SELECT "territory" FROM "opening_weekend_gross" WHERE "screens"=17;
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest number of Golds that has Participants smaller than 14, and Rank of 1, and Total larger than 1?`

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

CREATE TABLE "medal_table" (
  "rank" real,
  "gold" real,
  "silver" real,
  "bronze" real,
  "total" real,
  "participants" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest number of Golds that has Participants smaller than 14, and Rank of 1, and Total larger than 1?`:
```sql
                SELECT MIN("gold") FROM "medal_table" WHERE "participants"<14 AND "rank"=1 AND "total">1;
```
## Task
Generate a SQL query to answer the following question:
`On what date was the record 39–54?`

### 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 `On what date was the record 39–54?`:
```sql
                SELECT "date" FROM "game_log" WHERE "record"='39–54';
```
## Task
Generate a SQL query to answer the following question:
`What was the record on July 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,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the record on July 1?`:
```sql
                SELECT "record" FROM "game_log" WHERE "date"='july 1';
```
## Task
Generate a SQL query to answer the following question:
`How many total matches with less than 1 win and a position higher than 8?`

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

CREATE TABLE "group_a_helsinki" (
  "pos" real,
  "matches" real,
  "wins" real,
  "loses" real,
  "results" text,
  "points" real,
  "diff" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many total matches with less than 1 win and a position higher than 8?`:
```sql
                SELECT SUM("matches") FROM "group_a_helsinki" WHERE "wins"<1 AND "pos">8;
```
## Task
Generate a SQL query to answer the following question:
`Which Liberal leader has Seats won smaller than 100, and Seats in House of 215, and a % of popular vote of 43.1%?`

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

CREATE TABLE "liberal_party_federal_electoral_results" (
  "year" text,
  "seats_in_house" real,
  "liberal_candidates" real,
  "seats_won" real,
  "seat_change" text,
  "popular_vote" real,
  "pct_of_popular_vote" text,
  "result" text,
  "liberal_leader" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Liberal leader has Seats won smaller than 100, and Seats in House of 215, and a % of popular vote of 43.1%?`:
```sql
                SELECT "liberal_leader" FROM "liberal_party_federal_electoral_results" WHERE "seats_won"<100 AND "seats_in_house"=215 AND "pct_of_popular_vote"='43.1%';
```
## Task
Generate a SQL query to answer the following question:
`Which Popular vote has a Liberal leader of king, and Seats won larger than 116, and a Year of 1921?`

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

CREATE TABLE "liberal_party_federal_electoral_results" (
  "year" text,
  "seats_in_house" real,
  "liberal_candidates" real,
  "seats_won" real,
  "seat_change" text,
  "popular_vote" real,
  "pct_of_popular_vote" text,
  "result" text,
  "liberal_leader" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Popular vote has a Liberal leader of king, and Seats won larger than 116, and a Year of 1921?`:
```sql
                SELECT AVG("popular_vote") FROM "liberal_party_federal_electoral_results" WHERE "liberal_leader"='king' AND "seats_won">116 AND "year"='1921';
```
## Task
Generate a SQL query to answer the following question:
`How many Liberal candidates have a Liberal leader of pearson, and a % of popular vote of 40.2%, and Seats won smaller than 131?`

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

CREATE TABLE "liberal_party_federal_electoral_results" (
  "year" text,
  "seats_in_house" real,
  "liberal_candidates" real,
  "seats_won" real,
  "seat_change" text,
  "popular_vote" real,
  "pct_of_popular_vote" text,
  "result" text,
  "liberal_leader" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many Liberal candidates have a Liberal leader of pearson, and a % of popular vote of 40.2%, and Seats won smaller than 131?`:
```sql
                SELECT COUNT("liberal_candidates") FROM "liberal_party_federal_electoral_results" WHERE "liberal_leader"='pearson' AND "pct_of_popular_vote"='40.2%' AND "seats_won"<131;
```
## Task
Generate a SQL query to answer the following question:
`Which % of popular vote has a Liberal leader of laurier, and a Popular vote larger than 521,041, and Liberal candidates of 213, and Seats in House smaller than 235?`

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

CREATE TABLE "liberal_party_federal_electoral_results" (
  "year" text,
  "seats_in_house" real,
  "liberal_candidates" real,
  "seats_won" real,
  "seat_change" text,
  "popular_vote" real,
  "pct_of_popular_vote" text,
  "result" text,
  "liberal_leader" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which % of popular vote has a Liberal leader of laurier, and a Popular vote larger than 521,041, and Liberal candidates of 213, and Seats in House smaller than 235?`:
```sql
                SELECT "pct_of_popular_vote" FROM "liberal_party_federal_electoral_results" WHERE "liberal_leader"='laurier' AND "popular_vote">'521,041' AND "liberal_candidates"=213 AND "seats_in_house"<235;
```
## Task
Generate a SQL query to answer the following question:
`How many Liberal candidates have Seats in House smaller than 245, and a Popular vote larger than 350,512, and Seats won smaller than 139, and a Seat Change of +28?`

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

CREATE TABLE "liberal_party_federal_electoral_results" (
  "year" text,
  "seats_in_house" real,
  "liberal_candidates" real,
  "seats_won" real,
  "seat_change" text,
  "popular_vote" real,
  "pct_of_popular_vote" text,
  "result" text,
  "liberal_leader" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many Liberal candidates have Seats in House smaller than 245, and a Popular vote larger than 350,512, and Seats won smaller than 139, and a Seat Change of +28?`:
```sql
                SELECT COUNT("liberal_candidates") FROM "liberal_party_federal_electoral_results" WHERE "seats_in_house"<245 AND "popular_vote">'350,512' AND "seats_won"<139 AND "seat_change"='+28';
```
## Task
Generate a SQL query to answer the following question:
`What is the score during the 2006-2007 year?`

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

CREATE TABLE "winners" (
  "year" text,
  "winners" text,
  "score" text,
  "runner_up" text,
  "venue" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the score during the 2006-2007 year?`:
```sql
                SELECT "score" FROM "winners" WHERE "year"='2006-2007';
```
## Task
Generate a SQL query to answer the following question:
`Who were the winners in 2010-2011?`

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

CREATE TABLE "winners" (
  "year" text,
  "winners" text,
  "score" text,
  "runner_up" text,
  "venue" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who were the winners in 2010-2011?`:
```sql
                SELECT "winners" FROM "winners" WHERE "year"='2010-2011';
```
## Task
Generate a SQL query to answer the following question:
`What is the score of the match with UTC as the runner-up and Saint-Gaudens Bears as the winners?`

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

CREATE TABLE "winners" (
  "year" text,
  "winners" text,
  "score" text,
  "runner_up" text,
  "venue" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the score of the match with UTC as the runner-up and Saint-Gaudens Bears as the winners?`:
```sql
                SELECT "score" FROM "winners" WHERE "runner_up"='utc' AND "winners"='saint-gaudens bears';
```
## Task
Generate a SQL query to answer the following question:
`Which year had UTC as the runner-up and Saint-Gaudens Bears as the winners?`

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

CREATE TABLE "winners" (
  "year" text,
  "winners" text,
  "score" text,
  "runner_up" text,
  "venue" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which year had UTC as the runner-up and Saint-Gaudens Bears as the winners?`:
```sql
                SELECT "year" FROM "winners" WHERE "runner_up"='utc' AND "winners"='saint-gaudens bears';
```
## Task
Generate a SQL query to answer the following question:
`What is the venue of the match with a score of 33-22?`

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

CREATE TABLE "winners" (
  "year" text,
  "winners" text,
  "score" text,
  "runner_up" text,
  "venue" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the venue of the match with a score of 33-22?`:
```sql
                SELECT "venue" FROM "winners" WHERE "score"='33-22';
```
## Task
Generate a SQL query to answer the following question:
`Who had the highest assists during the game on February 22?`

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

CREATE TABLE "game_log" (
  "game" real,
  "date" text,
  "team" text,
  "score" text,
  "high_points" text,
  "high_rebounds" text,
  "high_assists" text,
  "location_attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who had the highest assists during the game on February 22?`:
```sql
                SELECT "high_assists" FROM "game_log" WHERE "date"='february 22';
```
## Task
Generate a SQL query to answer the following question:
`What team did the Heat play against at the TD Waterhouse Centre?`

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

CREATE TABLE "game_log" (
  "game" real,
  "date" text,
  "team" text,
  "score" text,
  "high_points" text,
  "high_rebounds" text,
  "high_assists" text,
  "location_attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What team did the Heat play against at the TD Waterhouse Centre?`:
```sql
                SELECT "team" FROM "game_log" WHERE "location_attendance"='td waterhouse centre';
```
## Task
Generate a SQL query to answer the following question:
`What date was the game against Toronto which had a game number higher than 53?`

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

CREATE TABLE "game_log" (
  "game" real,
  "date" text,
  "team" text,
  "score" text,
  "high_points" text,
  "high_rebounds" text,
  "high_assists" text,
  "location_attendance" text,
  "record" text
);
### SQL
Given the database schema, here is the SQL query that answers `What date was the game against Toronto which had a game number higher than 53?`:
```sql
                SELECT "date" FROM "game_log" WHERE "game">53 AND "team"='toronto';
```