cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`Is it material or non-material when there are 2 suits for either opponent?`

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

CREATE TABLE "classification" (
  "positional_or_automatic" text,
  "opponents" text,
  "suits" text,
  "material_or_non_material" text,
  "count_rectified" text
);
### SQL
Given the database schema, here is the SQL query that answers `Is it material or non-material when there are 2 suits for either opponent?`:
```sql
                SELECT "material_or_non_material" FROM "classification" WHERE "suits"='2' AND "opponents"='either';
```
## Task
Generate a SQL query to answer the following question:
`Which suits have no material or non-material, either opponent, and are positional?`

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

CREATE TABLE "classification" (
  "positional_or_automatic" text,
  "opponents" text,
  "suits" text,
  "material_or_non_material" text,
  "count_rectified" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which suits have no material or non-material, either opponent, and are positional?`:
```sql
                SELECT "suits" FROM "classification" WHERE "material_or_non_material"='no' AND "opponents"='either' AND "positional_or_automatic"='positional';
```
## Task
Generate a SQL query to answer the following question:
`Is the count rectified for single opponents, either positional or automatic, and no material or non-material?`

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

CREATE TABLE "classification" (
  "positional_or_automatic" text,
  "opponents" text,
  "suits" text,
  "material_or_non_material" text,
  "count_rectified" text
);
### SQL
Given the database schema, here is the SQL query that answers `Is the count rectified for single opponents, either positional or automatic, and no material or non-material?`:
```sql
                SELECT "count_rectified" FROM "classification" WHERE "opponents"='single' AND "positional_or_automatic"='either' AND "material_or_non_material"='no';
```
## Task
Generate a SQL query to answer the following question:
`How many points did Happy Valley score before game 14?`

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

CREATE TABLE "finalised_league_table" (
  "team" text,
  "game" real,
  "draw" real,
  "loss" real,
  "goal_gain" real,
  "goal_loss" real,
  "goal_diff" real,
  "point" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many points did Happy Valley score before game 14?`:
```sql
                SELECT COUNT("point") FROM "finalised_league_table" WHERE "team"='happy valley' AND "game"<14;
```
## Task
Generate a SQL query to answer the following question:
`How many points were there in the game with a goal loss of 16 and a goal diff less than 26 after game 14?`

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

CREATE TABLE "finalised_league_table" (
  "team" text,
  "game" real,
  "draw" real,
  "loss" real,
  "goal_gain" real,
  "goal_loss" real,
  "goal_diff" real,
  "point" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many points were there in the game with a goal loss of 16 and a goal diff less than 26 after game 14?`:
```sql
                SELECT COUNT("point") FROM "finalised_league_table" WHERE "goal_loss"=16 AND "goal_diff"<26 AND "game">14;
```
## Task
Generate a SQL query to answer the following question:
`How many draws did the game after game 14 with goal gain 17 have?`

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

CREATE TABLE "finalised_league_table" (
  "team" text,
  "game" real,
  "draw" real,
  "loss" real,
  "goal_gain" real,
  "goal_loss" real,
  "goal_diff" real,
  "point" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many draws did the game after game 14 with goal gain 17 have?`:
```sql
                SELECT MAX("draw") FROM "finalised_league_table" WHERE "goal_gain"=17 AND "game">14;
```
## Task
Generate a SQL query to answer the following question:
`How many total draws were there with a less than 8 loss, more than 30 points, and a goal diff larger than 26?`

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

CREATE TABLE "finalised_league_table" (
  "team" text,
  "game" real,
  "draw" real,
  "loss" real,
  "goal_gain" real,
  "goal_loss" real,
  "goal_diff" real,
  "point" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many total draws were there with a less than 8 loss, more than 30 points, and a goal diff larger than 26?`:
```sql
                SELECT COUNT("draw") FROM "finalised_league_table" WHERE "loss"<8 AND "point">30 AND "goal_diff">26;
```
## Task
Generate a SQL query to answer the following question:
`What is the highest loss before game 14?`

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

CREATE TABLE "finalised_league_table" (
  "team" text,
  "game" real,
  "draw" real,
  "loss" real,
  "goal_gain" real,
  "goal_loss" real,
  "goal_diff" real,
  "point" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest loss before game 14?`:
```sql
                SELECT MAX("loss") FROM "finalised_league_table" WHERE "game"<14;
```
## Task
Generate a SQL query to answer the following question:
`How many average points did the player with a time/retired of +16.789 and have more laps than 68 have?`

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

CREATE TABLE "race" (
  "driver" text,
  "team" text,
  "laps" real,
  "time_retired" text,
  "grid" real,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many average points did the player with a time/retired of +16.789 and have more laps than 68 have?`:
```sql
                SELECT AVG("points") FROM "race" WHERE "time_retired"='+16.789' AND "laps">68;
```
## Task
Generate a SQL query to answer the following question:
`How many average points did the team Minardi Team USA have when there was a grid 3 and more laps than 68?`

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

CREATE TABLE "race" (
  "driver" text,
  "team" text,
  "laps" real,
  "time_retired" text,
  "grid" real,
  "points" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many average points did the team Minardi Team USA have when there was a grid 3 and more laps than 68?`:
```sql
                SELECT AVG("points") FROM "race" WHERE "team"='minardi team usa' AND "grid"=3 AND "laps">68;
```
## Task
Generate a SQL query to answer the following question:
`Which was the highest crowd drawn by an Away team in Richmond?`

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

CREATE TABLE "round_9" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which was the highest crowd drawn by an Away team in Richmond?`:
```sql
                SELECT MAX("crowd") FROM "round_9" WHERE "away_team"='richmond';
```
## Task
Generate a SQL query to answer the following question:
`Which home team has a venue of Arden Street Oval?`

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

CREATE TABLE "round_9" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which home team has a venue of Arden Street Oval?`:
```sql
                SELECT "home_team" FROM "round_9" WHERE "venue"='arden street oval';
```
## Task
Generate a SQL query to answer the following question:
`Which away team has a venue of Arden Street Oval?`

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

CREATE TABLE "round_9" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which away team has a venue of Arden Street Oval?`:
```sql
                SELECT "away_team" FROM "round_9" WHERE "venue"='arden street oval';
```
## Task
Generate a SQL query to answer the following question:
`What is the value for 2011 corresponding to a 2007 value of 1r?`

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

CREATE TABLE "doubles_performance_timeline" (
  "tournament" text,
  "2007" text,
  "2011" text,
  "2012" text,
  "2013" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the value for 2011 corresponding to a 2007 value of 1r?`:
```sql
                SELECT "2011" FROM "doubles_performance_timeline" WHERE "2007"='1r';
```
## Task
Generate a SQL query to answer the following question:
`What value in 2013 corresponds to Grand Slam Tournaments in 2012?`

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

CREATE TABLE "doubles_performance_timeline" (
  "tournament" text,
  "2007" text,
  "2011" text,
  "2012" text,
  "2013" text
);
### SQL
Given the database schema, here is the SQL query that answers `What value in 2013 corresponds to Grand Slam Tournaments in 2012?`:
```sql
                SELECT "2013" FROM "doubles_performance_timeline" WHERE "2012"='grand slam tournaments';
```
## Task
Generate a SQL query to answer the following question:
`What is the 2012 value when the 2011 and 2007 values are 1R?`

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

CREATE TABLE "doubles_performance_timeline" (
  "tournament" text,
  "2007" text,
  "2011" text,
  "2012" text,
  "2013" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the 2012 value when the 2011 and 2007 values are 1R?`:
```sql
                SELECT "2012" FROM "doubles_performance_timeline" WHERE "2011"='1r' AND "2007"='1r';
```
## Task
Generate a SQL query to answer the following question:
`What value for 2013 corresponds to the US Open Tournament?`

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

CREATE TABLE "doubles_performance_timeline" (
  "tournament" text,
  "2007" text,
  "2011" text,
  "2012" text,
  "2013" text
);
### SQL
Given the database schema, here is the SQL query that answers `What value for 2013 corresponds to the US Open Tournament?`:
```sql
                SELECT "2013" FROM "doubles_performance_timeline" WHERE "tournament"='us open';
```
## Task
Generate a SQL query to answer the following question:
`The school nicknamed the wildcats has what sum of enrollment?`

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

CREATE TABLE "current_members" (
  "institution" text,
  "location" text,
  "founded" real,
  "affiliation" text,
  "enrollment" real,
  "team_nickname" text
);
### SQL
Given the database schema, here is the SQL query that answers `The school nicknamed the wildcats has what sum of enrollment?`:
```sql
                SELECT SUM("enrollment") FROM "current_members" WHERE "team_nickname"='wildcats';
```
## Task
Generate a SQL query to answer the following question:
`What is the Founded year of the school located in Paul Smiths, New York?`

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

CREATE TABLE "current_members" (
  "institution" text,
  "location" text,
  "founded" real,
  "affiliation" text,
  "enrollment" real,
  "team_nickname" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Founded year of the school located in Paul Smiths, New York?`:
```sql
                SELECT "founded" FROM "current_members" WHERE "location"='paul smiths, new york';
```
## Task
Generate a SQL query to answer the following question:
`What home side scored 9.4 (58)?`

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

CREATE TABLE "round_11" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What home side scored 9.4 (58)?`:
```sql
                SELECT "home_team" FROM "round_11" WHERE "home_team_score"='9.4 (58)';
```
## Task
Generate a SQL query to answer the following question:
`What was fitzroy's away side score?`

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

CREATE TABLE "round_11" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was fitzroy's away side score?`:
```sql
                SELECT "away_team_score" FROM "round_11" WHERE "away_team"='fitzroy';
```
## Task
Generate a SQL query to answer the following question:
`What is the away team's score when the home side scores 9.4 (58)?`

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

CREATE TABLE "round_11" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the away team's score when the home side scores 9.4 (58)?`:
```sql
                SELECT "away_team_score" FROM "round_11" WHERE "home_team_score"='9.4 (58)';
```
## Task
Generate a SQL query to answer the following question:
`What player attended UAB college?`

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

CREATE TABLE "2002_new_york_jets_season" (
  "round" real,
  "pick" real,
  "player" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What player attended UAB college?`:
```sql
                SELECT "player" FROM "2002_new_york_jets_season" WHERE "college"='uab';
```
## Task
Generate a SQL query to answer the following question:
`What was the score of the game at RIch Stadium?`

### 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,
  "stadium" text,
  "record" text,
  "attendance" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the score of the game at RIch Stadium?`:
```sql
                SELECT "result" FROM "schedule" WHERE "stadium"='rich stadium';
```
## Task
Generate a SQL query to answer the following question:
`Who had the best time of 1:32.269?`

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

CREATE TABLE "qualifying_results" (
  "name" text,
  "team" text,
  "qual_1" text,
  "qual_2" text,
  "best" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who had the best time of 1:32.269?`:
```sql
                SELECT "name" FROM "qualifying_results" WHERE "best"='1:32.269';
```
## Task
Generate a SQL query to answer the following question:
`Who from Conquest Racing had the best time of 1:34.748 in Qual 1?`

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

CREATE TABLE "qualifying_results" (
  "name" text,
  "team" text,
  "qual_1" text,
  "qual_2" text,
  "best" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who from Conquest Racing had the best time of 1:34.748 in Qual 1?`:
```sql
                SELECT "best" FROM "qualifying_results" WHERE "team"='conquest racing' AND "qual_1"='1:34.748';
```
## Task
Generate a SQL query to answer the following question:
`Who in Qual 2 had the best time of 1:31.327?`

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

CREATE TABLE "qualifying_results" (
  "name" text,
  "team" text,
  "qual_1" text,
  "qual_2" text,
  "best" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who in Qual 2 had the best time of 1:31.327?`:
```sql
                SELECT "qual_2" FROM "qualifying_results" WHERE "best"='1:31.327';
```
## Task
Generate a SQL query to answer the following question:
`What was Dan Selznick best time?`

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

CREATE TABLE "qualifying_results" (
  "name" text,
  "team" text,
  "qual_1" text,
  "qual_2" text,
  "best" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was Dan Selznick best time?`:
```sql
                SELECT "best" FROM "qualifying_results" WHERE "name"='dan selznick';
```
## Task
Generate a SQL query to answer the following question:
`What team had 1:34.578 in Qual 2?`

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

CREATE TABLE "qualifying_results" (
  "name" text,
  "team" text,
  "qual_1" text,
  "qual_2" text,
  "best" text
);
### SQL
Given the database schema, here is the SQL query that answers `What team had 1:34.578 in Qual 2?`:
```sql
                SELECT "team" FROM "qualifying_results" WHERE "qual_2"='1:34.578';
```
## Task
Generate a SQL query to answer the following question:
`Jiang Tengyi is on which team?`

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

CREATE TABLE "qualifying_results" (
  "name" text,
  "team" text,
  "qual_1" text,
  "qual_2" text,
  "best" text
);
### SQL
Given the database schema, here is the SQL query that answers `Jiang Tengyi is on which team?`:
```sql
                SELECT "team" FROM "qualifying_results" WHERE "name"='jiang tengyi';
```
## Task
Generate a SQL query to answer the following question:
`What is the away team's score when footscray is the away team?`

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

CREATE TABLE "round_9" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the away team's score when footscray is the away team?`:
```sql
                SELECT "away_team_score" FROM "round_9" WHERE "away_team"='footscray';
```
## Task
Generate a SQL query to answer the following question:
`What venue has an Away team score of 8.8 (56)?`

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

CREATE TABLE "round_9" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What venue has an Away team score of 8.8 (56)?`:
```sql
                SELECT "venue" FROM "round_9" WHERE "away_team_score"='8.8 (56)';
```
## Task
Generate a SQL query to answer the following question:
`Whom is the away team when the Away team score is 23.14 (152)?`

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

CREATE TABLE "round_9" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Whom is the away team when the Away team score is 23.14 (152)?`:
```sql
                SELECT "away_team" FROM "round_9" WHERE "away_team_score"='23.14 (152)';
```
## Task
Generate a SQL query to answer the following question:
`Whom is the home team when the home team score is 12.13 (85)?`

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

CREATE TABLE "round_9" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Whom is the home team when the home team score is 12.13 (85)?`:
```sql
                SELECT "home_team" FROM "round_9" WHERE "home_team_score"='12.13 (85)';
```
## Task
Generate a SQL query to answer the following question:
`What was the rank for czechoslovakia with 1 bronze?`

### 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 was the rank for czechoslovakia with 1 bronze?`:
```sql
                SELECT "rank" FROM "medal_table" WHERE "bronze"=1 AND "nation"='czechoslovakia';
```
## Task
Generate a SQL query to answer the following question:
`How many bronze medals for the nation with over 9 golds?`

### 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 `How many bronze medals for the nation with over 9 golds?`:
```sql
                SELECT COUNT("bronze") FROM "medal_table" WHERE "gold">9;
```
## Task
Generate a SQL query to answer the following question:
`What is the average number of goals that occurred in Hong Kong Stadium, Hong Kong?`

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

CREATE TABLE "international_career" (
  "date" text,
  "venue" text,
  "result" text,
  "goals" real,
  "competition" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average number of goals that occurred in Hong Kong Stadium, Hong Kong?`:
```sql
                SELECT AVG("goals") FROM "international_career" WHERE "venue"='hong kong stadium, hong kong';
```
## Task
Generate a SQL query to answer the following question:
`Which country uses pound sterling with a value higher than 1.33 USD?`

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

CREATE TABLE "currency_and_central_banks" (
  "country" text,
  "currency" text,
  "value_in_euro" text,
  "value_in_usd" real,
  "central_bank" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which country uses pound sterling with a value higher than 1.33 USD?`:
```sql
                SELECT "country" FROM "currency_and_central_banks" WHERE "value_in_usd">1.33 AND "currency"='pound sterling';
```
## Task
Generate a SQL query to answer the following question:
`Who is the away side, when the home side scores 13.22 (100)?`

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

CREATE TABLE "round_7" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the away side, when the home side scores 13.22 (100)?`:
```sql
                SELECT "away_team" FROM "round_7" WHERE "home_team_score"='13.22 (100)';
```
## Task
Generate a SQL query to answer the following question:
`What venue features carlton at home?`

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

CREATE TABLE "round_7" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What venue features carlton at home?`:
```sql
                SELECT "venue" FROM "round_7" WHERE "home_team"='carlton';
```
## Task
Generate a SQL query to answer the following question:
`What venue features fitzroy as the away side?`

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

CREATE TABLE "round_7" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What venue features fitzroy as the away side?`:
```sql
                SELECT "venue" FROM "round_7" WHERE "away_team"='fitzroy';
```
## Task
Generate a SQL query to answer the following question:
`What was the crowd size when the home team scored 17.14 (116)?`

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

CREATE TABLE "round_2" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the crowd size when the home team scored 17.14 (116)?`:
```sql
                SELECT "crowd" FROM "round_2" WHERE "home_team_score"='17.14 (116)';
```
## Task
Generate a SQL query to answer the following question:
`What was the smallest crowd that Melbourne played for at home?`

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

CREATE TABLE "round_2" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the smallest crowd that Melbourne played for at home?`:
```sql
                SELECT MIN("crowd") FROM "round_2" WHERE "home_team"='melbourne';
```
## Task
Generate a SQL query to answer the following question:
`What was the home teams score when the away team scored 7.5 (47)?`

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

CREATE TABLE "round_2" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the home teams score when the away team scored 7.5 (47)?`:
```sql
                SELECT "home_team_score" FROM "round_2" WHERE "away_team_score"='7.5 (47)';
```
## Task
Generate a SQL query to answer the following question:
`What was the home teams score at Victoria Park?`

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

CREATE TABLE "round_2" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the home teams score at Victoria Park?`:
```sql
                SELECT "home_team_score" FROM "round_2" WHERE "venue"='victoria park';
```
## Task
Generate a SQL query to answer the following question:
`What was the away team against which the home team scored 10.14 (74)?`

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

CREATE TABLE "round_2" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the away team against which the home team scored 10.14 (74)?`:
```sql
                SELECT "away_team" FROM "round_2" WHERE "home_team_score"='10.14 (74)';
```
## Task
Generate a SQL query to answer the following question:
`What home team played the away team of Richmond?`

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

CREATE TABLE "round_2" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What home team played the away team of Richmond?`:
```sql
                SELECT "home_team" FROM "round_2" WHERE "away_team"='richmond';
```
## Task
Generate a SQL query to answer the following question:
`What is the high score for the player with 0 stumps, 4 catches, more than 14 inns and an average smaller than 56.1?`

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

CREATE TABLE "batting_averages" (
  "player" text,
  "matches" real,
  "inns" real,
  "runs" real,
  "high_score" real,
  "average" real,
  "catches" real,
  "stump" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the high score for the player with 0 stumps, 4 catches, more than 14 inns and an average smaller than 56.1?`:
```sql
                SELECT SUM("high_score") FROM "batting_averages" WHERE "stump"=0 AND "catches"=4 AND "average"<56.1 AND "inns">14;
```
## Task
Generate a SQL query to answer the following question:
`What is the total number of runs for the player with fewer than 9 Inns?`

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

CREATE TABLE "batting_averages" (
  "player" text,
  "matches" real,
  "inns" real,
  "runs" real,
  "high_score" real,
  "average" real,
  "catches" real,
  "stump" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total number of runs for the player with fewer than 9 Inns?`:
```sql
                SELECT COUNT("runs") FROM "batting_averages" WHERE "inns"<9;
```
## Task
Generate a SQL query to answer the following question:
`What is the smallest average for the player with 13 matches and fewer than 7 catches?`

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

CREATE TABLE "batting_averages" (
  "player" text,
  "matches" real,
  "inns" real,
  "runs" real,
  "high_score" real,
  "average" real,
  "catches" real,
  "stump" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the smallest average for the player with 13 matches and fewer than 7 catches?`:
```sql
                SELECT MIN("average") FROM "batting_averages" WHERE "matches"=13 AND "catches"<7;
```
## Task
Generate a SQL query to answer the following question:
`Which city is the host of the University of Texas?`

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

CREATE TABLE "first_and_second_rounds" (
  "region" text,
  "host" text,
  "venue" text,
  "city" text,
  "state" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which city is the host of the University of Texas?`:
```sql
                SELECT "city" FROM "first_and_second_rounds" WHERE "host"='university of texas';
```
## Task
Generate a SQL query to answer the following question:
`In which region is the Thompson-Boling arena located?`

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

CREATE TABLE "first_and_second_rounds" (
  "region" text,
  "host" text,
  "venue" text,
  "city" text,
  "state" text
);
### SQL
Given the database schema, here is the SQL query that answers `In which region is the Thompson-Boling arena located?`:
```sql
                SELECT "region" FROM "first_and_second_rounds" WHERE "venue"='thompson-boling arena';
```
## Task
Generate a SQL query to answer the following question:
`Who is the host in the city of Philadelphia?`

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

CREATE TABLE "first_and_second_rounds" (
  "region" text,
  "host" text,
  "venue" text,
  "city" text,
  "state" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the host in the city of Philadelphia?`:
```sql
                SELECT "host" FROM "first_and_second_rounds" WHERE "city"='philadelphia';
```
## Task
Generate a SQL query to answer the following question:
`Which city in the mideast region is the hot of Temple University?`

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

CREATE TABLE "first_and_second_rounds" (
  "region" text,
  "host" text,
  "venue" text,
  "city" text,
  "state" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which city in the mideast region is the hot of Temple University?`:
```sql
                SELECT "city" FROM "first_and_second_rounds" WHERE "region"='mideast' AND "host"='temple university';
```
## Task
Generate a SQL query to answer the following question:
`Which city is the University of Montana located in?`

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

CREATE TABLE "first_and_second_rounds" (
  "region" text,
  "host" text,
  "venue" text,
  "city" text,
  "state" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which city is the University of Montana located in?`:
```sql
                SELECT "city" FROM "first_and_second_rounds" WHERE "host"='university of montana';
```
## Task
Generate a SQL query to answer the following question:
`What was the away team score at Hawthorn?`

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

CREATE TABLE "round_13" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the away team score at Hawthorn?`:
```sql
                SELECT "away_team_score" FROM "round_13" WHERE "home_team"='hawthorn';
```
## Task
Generate a SQL query to answer the following question:
`Who went to Geelong to play?`

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

CREATE TABLE "round_13" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who went to Geelong to play?`:
```sql
                SELECT "away_team" FROM "round_13" WHERE "home_team"='geelong';
```
## Task
Generate a SQL query to answer the following question:
`Who did Collingwood play at home?`

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

CREATE TABLE "round_13" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who did Collingwood play at home?`:
```sql
                SELECT "home_team" FROM "round_13" WHERE "away_team"='collingwood';
```
## Task
Generate a SQL query to answer the following question:
`When did an away team score 7.8 (50)?`

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

CREATE TABLE "round_13" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `When did an away team score 7.8 (50)?`:
```sql
                SELECT "date" FROM "round_13" WHERE "away_team_score"='7.8 (50)';
```
## Task
Generate a SQL query to answer the following question:
`What population has an area (km²) of 62,848 and a density less than 37.7?`

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

CREATE TABLE "by_density" (
  "rank" text,
  "state" text,
  "population" real,
  "area_km" real,
  "density" real
);
### SQL
Given the database schema, here is the SQL query that answers `What population has an area (km²) of 62,848 and a density less than 37.7?`:
```sql
                SELECT COUNT("population") FROM "by_density" WHERE "area_km"='62,848' AND "density"<37.7;
```
## Task
Generate a SQL query to answer the following question:
`Which population is the greatest, has a density of 20.3, and an area (km²) larger than 50,350?`

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

CREATE TABLE "by_density" (
  "rank" text,
  "state" text,
  "population" real,
  "area_km" real,
  "density" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which population is the greatest, has a density of 20.3, and an area (km²) larger than 50,350?`:
```sql
                SELECT MAX("population") FROM "by_density" WHERE "density"=20.3 AND "area_km">'50,350';
```
## Task
Generate a SQL query to answer the following question:
`The state of Aguascalientes has an area (km²) larger than 151,571 and a density greater than 80.9, what is the rank?`

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

CREATE TABLE "by_density" (
  "rank" text,
  "state" text,
  "population" real,
  "area_km" real,
  "density" real
);
### SQL
Given the database schema, here is the SQL query that answers `The state of Aguascalientes has an area (km²) larger than 151,571 and a density greater than 80.9, what is the rank?`:
```sql
                SELECT "rank" FROM "by_density" WHERE "area_km">'151,571' AND "density">80.9 AND "state"='aguascalientes';
```
## Task
Generate a SQL query to answer the following question:
`Who was the home team at the game held at the Junction Oval?`

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

CREATE TABLE "round_15" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the home team at the game held at the Junction Oval?`:
```sql
                SELECT "home_team" FROM "round_15" WHERE "venue"='junction oval';
```
## Task
Generate a SQL query to answer the following question:
`Where was the game held when Fitzroy was the away team?`

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

CREATE TABLE "round_15" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where was the game held when Fitzroy was the away team?`:
```sql
                SELECT "venue" FROM "round_15" WHERE "away_team"='fitzroy';
```
## Task
Generate a SQL query to answer the following question:
`How many people attended the Rams game against the Kansas City Chiefs?`

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

CREATE TABLE "schedule" (
  "week" real,
  "date" text,
  "opponent" text,
  "result" text,
  "attendance" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many people attended the Rams game against the Kansas City Chiefs?`:
```sql
                SELECT "attendance" FROM "schedule" WHERE "opponent"='kansas city chiefs';
```
## Task
Generate a SQL query to answer the following question:
`What is China's IATA?`

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

CREATE TABLE "references" (
  "city" text,
  "country" text,
  "iata" text,
  "icao" text,
  "airport" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is China's IATA?`:
```sql
                SELECT "iata" FROM "references" WHERE "country"='china';
```
## Task
Generate a SQL query to answer the following question:
`Where is the City of Douala?`

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

CREATE TABLE "references" (
  "city" text,
  "country" text,
  "iata" text,
  "icao" text,
  "airport" text
);
### SQL
Given the database schema, here is the SQL query that answers `Where is the City of Douala?`:
```sql
                SELECT "country" FROM "references" WHERE "city"='douala';
```
## Task
Generate a SQL query to answer the following question:
`Which airport is in South Africa and has a ICAO fajs?`

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

CREATE TABLE "references" (
  "city" text,
  "country" text,
  "iata" text,
  "icao" text,
  "airport" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which airport is in South Africa and has a ICAO fajs?`:
```sql
                SELECT "airport" FROM "references" WHERE "country"='south africa' AND "icao"='fajs';
```
## Task
Generate a SQL query to answer the following question:
`What is Cuba's ICAO?`

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

CREATE TABLE "references" (
  "city" text,
  "country" text,
  "iata" text,
  "icao" text,
  "airport" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is Cuba's ICAO?`:
```sql
                SELECT "icao" FROM "references" WHERE "country"='cuba';
```
## Task
Generate a SQL query to answer the following question:
`What is Angola's airport and ICAO of fnsa?`

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

CREATE TABLE "references" (
  "city" text,
  "country" text,
  "iata" text,
  "icao" text,
  "airport" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is Angola's airport and ICAO of fnsa?`:
```sql
                SELECT "airport" FROM "references" WHERE "country"='angola' AND "icao"='fnsa';
```
## Task
Generate a SQL query to answer the following question:
`What team plays at home at Windy Hill?`

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

CREATE TABLE "round_9" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What team plays at home at Windy Hill?`:
```sql
                SELECT "home_team" FROM "round_9" WHERE "venue"='windy hill';
```
## Task
Generate a SQL query to answer the following question:
`What was the size of the crowd that saw the Home team score 11.10 (76)?`

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

CREATE TABLE "round_9" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the size of the crowd that saw the Home team score 11.10 (76)?`:
```sql
                SELECT COUNT("crowd") FROM "round_9" WHERE "home_team_score"='11.10 (76)';
```
## Task
Generate a SQL query to answer the following question:
`What was Footscray's score as an away team?`

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

CREATE TABLE "round_9" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was Footscray's score as an away team?`:
```sql
                SELECT "away_team_score" FROM "round_9" WHERE "away_team"='footscray';
```
## Task
Generate a SQL query to answer the following question:
`What was the home teams score agains the team that scored 7.15 (57)?`

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

CREATE TABLE "round_9" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the home teams score agains the team that scored 7.15 (57)?`:
```sql
                SELECT "home_team_score" FROM "round_9" WHERE "away_team_score"='7.15 (57)';
```
## Task
Generate a SQL query to answer the following question:
`What day is richmond the away side?`

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

CREATE TABLE "round_17" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What day is richmond the away side?`:
```sql
                SELECT "date" FROM "round_17" WHERE "away_team"='richmond';
```
## Task
Generate a SQL query to answer the following question:
`Who is the home team when hawthorn is the away team?`

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

CREATE TABLE "round_17" (
  "home_team" text,
  "home_team_score" text,
  "away_team" text,
  "away_team_score" text,
  "venue" text,
  "crowd" real,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the home team when hawthorn is the away team?`:
```sql
                SELECT "home_team" FROM "round_17" WHERE "away_team"='hawthorn';
```
## Task
Generate a SQL query to answer the following question:
`What is the name of the game with odds of winning 1 in 4.23 with a top prize of $15,000?`

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

CREATE TABLE "scratchers" (
  "game_name" text,
  "price" text,
  "top_prize" text,
  "launch_date" text,
  "odds_of_winning" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the name of the game with odds of winning 1 in 4.23 with a top prize of $15,000?`:
```sql
                SELECT "game_name" FROM "scratchers" WHERE "odds_of_winning"='1 in 4.23' AND "top_prize"='$15,000';
```
## Task
Generate a SQL query to answer the following question:
`What is the launch date odds of winning 1 in 4.23 with a top prize of $15,000?`

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

CREATE TABLE "scratchers" (
  "game_name" text,
  "price" text,
  "top_prize" text,
  "launch_date" text,
  "odds_of_winning" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the launch date odds of winning 1 in 4.23 with a top prize of $15,000?`:
```sql
                SELECT "launch_date" FROM "scratchers" WHERE "odds_of_winning"='1 in 4.23' AND "top_prize"='$15,000';
```
## Task
Generate a SQL query to answer the following question:
`What is the launch date odds of winning 1 in 4.54?`

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

CREATE TABLE "scratchers" (
  "game_name" text,
  "price" text,
  "top_prize" text,
  "launch_date" text,
  "odds_of_winning" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the launch date odds of winning 1 in 4.54?`:
```sql
                SELECT "launch_date" FROM "scratchers" WHERE "odds_of_winning"='1 in 4.54';
```
## Task
Generate a SQL query to answer the following question:
`What is the launch date odds of winning 1 in 4.44?`

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

CREATE TABLE "scratchers" (
  "game_name" text,
  "price" text,
  "top_prize" text,
  "launch_date" text,
  "odds_of_winning" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the launch date odds of winning 1 in 4.44?`:
```sql
                SELECT "launch_date" FROM "scratchers" WHERE "odds_of_winning"='1 in 4.44';
```