cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`What is the highest number of wins when draws are larger than 1, and byes are larger than 0?`

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

CREATE TABLE "2010_ladder" (
  "hampden_fl" text,
  "wins" real,
  "byes" real,
  "losses" real,
  "draws" real,
  "against" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the highest number of wins when draws are larger than 1, and byes are larger than 0?`:
```sql
                SELECT MAX("wins") FROM "2010_ladder" WHERE "draws">1 AND "byes">0;
```
## Task
Generate a SQL query to answer the following question:
`Which team were runners-up in 2007 and had 1 under winners?`

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

CREATE TABLE "performance_in_uefa_super_cup_by_club" (
  "team" text,
  "winners" real,
  "runners_up" real,
  "years_won" text,
  "years_runners_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which team were runners-up in 2007 and had 1 under winners?`:
```sql
                SELECT "team" FROM "performance_in_uefa_super_cup_by_club" WHERE "winners"=1 AND "years_runners_up"='2007';
```
## Task
Generate a SQL query to answer the following question:
`What is the sum of winners when 1983 is the years won?`

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

CREATE TABLE "performance_in_uefa_super_cup_by_club" (
  "team" text,
  "winners" real,
  "runners_up" real,
  "years_won" text,
  "years_runners_up" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the sum of winners when 1983 is the years won?`:
```sql
                SELECT COUNT("winners") FROM "performance_in_uefa_super_cup_by_club" WHERE "years_won"='1983';
```
## Task
Generate a SQL query to answer the following question:
`Which Rank has a Total of 12?`

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

CREATE TABLE "single_game" (
  "rank" real,
  "player" text,
  "county" text,
  "tally" text,
  "total" real,
  "opposition" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Rank has a Total of 12?`:
```sql
                SELECT AVG("rank") FROM "single_game" WHERE "total"=12;
```
## Task
Generate a SQL query to answer the following question:
`Which Rank has an Opposition of limerick?`

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

CREATE TABLE "single_game" (
  "rank" real,
  "player" text,
  "county" text,
  "tally" text,
  "total" real,
  "opposition" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Rank has an Opposition of limerick?`:
```sql
                SELECT "rank" FROM "single_game" WHERE "opposition"='limerick';
```
## Task
Generate a SQL query to answer the following question:
`How much Rank has a Tally of 0-10, and an Opposition of cork?`

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

CREATE TABLE "single_game" (
  "rank" real,
  "player" text,
  "county" text,
  "tally" text,
  "total" real,
  "opposition" text
);
### SQL
Given the database schema, here is the SQL query that answers `How much Rank has a Tally of 0-10, and an Opposition of cork?`:
```sql
                SELECT COUNT("rank") FROM "single_game" WHERE "tally"='0-10' AND "opposition"='cork';
```
## Task
Generate a SQL query to answer the following question:
`Which Total has a Rank smaller than 3, and a County of cork?`

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

CREATE TABLE "single_game" (
  "rank" real,
  "player" text,
  "county" text,
  "tally" text,
  "total" real,
  "opposition" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Total has a Rank smaller than 3, and a County of cork?`:
```sql
                SELECT MIN("total") FROM "single_game" WHERE "rank"<3 AND "county"='cork';
```
## Task
Generate a SQL query to answer the following question:
`Which Rank has a Tally of 4-0?`

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

CREATE TABLE "single_game" (
  "rank" real,
  "player" text,
  "county" text,
  "tally" text,
  "total" real,
  "opposition" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Rank has a Tally of 4-0?`:
```sql
                SELECT AVG("rank") FROM "single_game" WHERE "tally"='4-0';
```
## Task
Generate a SQL query to answer the following question:
`Which Lane has a Rank larger than 3, and a Time larger than 45.63, and a Reaction smaller than 0.28800000000000003, and an Athlete of geiner mosquera?`

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

CREATE TABLE "heat_5" (
  "rank" real,
  "lane" real,
  "athlete" text,
  "nationality" text,
  "time" real,
  "react" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Lane has a Rank larger than 3, and a Time larger than 45.63, and a Reaction smaller than 0.28800000000000003, and an Athlete of geiner mosquera?`:
```sql
                SELECT MAX("lane") FROM "heat_5" WHERE "rank">3 AND "time">45.63 AND "react"<0.28800000000000003 AND "athlete"='geiner mosquera';
```
## Task
Generate a SQL query to answer the following question:
`How many reactions have an Athlete of alleyne francique, and a Lane larger than 9?`

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

CREATE TABLE "heat_5" (
  "rank" real,
  "lane" real,
  "athlete" text,
  "nationality" text,
  "time" real,
  "react" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many reactions have an Athlete of alleyne francique, and a Lane larger than 9?`:
```sql
                SELECT COUNT("react") FROM "heat_5" WHERE "athlete"='alleyne francique' AND "lane">9;
```
## Task
Generate a SQL query to answer the following question:
`What yeae has 6-08 (24) as a waterford score?`

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

CREATE TABLE "previous_championship_encounters" (
  "year" real,
  "venue" text,
  "competition" text,
  "kilkenny_score" text,
  "waterford_score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What yeae has 6-08 (24) as a waterford score?`:
```sql
                SELECT "year" FROM "previous_championship_encounters" WHERE "waterford_score"='6-08 (24)';
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest year that has all-ireland hurling final as the competition, and 6-08 (24) as the waterford score?`

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

CREATE TABLE "previous_championship_encounters" (
  "year" real,
  "venue" text,
  "competition" text,
  "kilkenny_score" text,
  "waterford_score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest year that has all-ireland hurling final as the competition, and 6-08 (24) as the waterford score?`:
```sql
                SELECT MIN("year") FROM "previous_championship_encounters" WHERE "competition"='all-ireland hurling final' AND "waterford_score"='6-08 (24)';
```
## Task
Generate a SQL query to answer the following question:
`What is the waterford score that has a year prior to 1963, with all-ireland hurling final replay as the competition?`

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

CREATE TABLE "previous_championship_encounters" (
  "year" real,
  "venue" text,
  "competition" text,
  "kilkenny_score" text,
  "waterford_score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the waterford score that has a year prior to 1963, with all-ireland hurling final replay as the competition?`:
```sql
                SELECT "waterford_score" FROM "previous_championship_encounters" WHERE "year"<1963 AND "competition"='all-ireland hurling final replay';
```
## Task
Generate a SQL query to answer the following question:
`What rounds did RML Racing Silverline and James Nash compete?`

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

CREATE TABLE "entry_list" (
  "team" text,
  "car_spec" text,
  "drivers" text,
  "class" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What rounds did RML Racing Silverline and James Nash compete?`:
```sql
                SELECT "rounds" FROM "entry_list" WHERE "team"='rml racing silverline' AND "drivers"='james nash';
```
## Task
Generate a SQL query to answer the following question:
`What class is Rob Collard in?`

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

CREATE TABLE "entry_list" (
  "team" text,
  "car_spec" text,
  "drivers" text,
  "class" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What class is Rob Collard in?`:
```sql
                SELECT "class" FROM "entry_list" WHERE "drivers"='rob collard';
```
## Task
Generate a SQL query to answer the following question:
`What is the car specs for team Airwaves BMW's driver Rob Collard?`

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

CREATE TABLE "entry_list" (
  "team" text,
  "car_spec" text,
  "drivers" text,
  "class" text,
  "rounds" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the car specs for team Airwaves BMW's driver Rob Collard?`:
```sql
                SELECT "car_spec" FROM "entry_list" WHERE "team"='airwaves bmw' AND "drivers"='rob collard';
```
## Task
Generate a SQL query to answer the following question:
`What is the language of TV3?`

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

CREATE TABLE "channel_listing" (
  "name" text,
  "language" text,
  "owner" text,
  "group" text,
  "type" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the language of TV3?`:
```sql
                SELECT "language" FROM "channel_listing" WHERE "name"='tv3';
```
## Task
Generate a SQL query to answer the following question:
`What is the group of ESPN International Sports?`

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

CREATE TABLE "channel_listing" (
  "name" text,
  "language" text,
  "owner" text,
  "group" text,
  "type" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the group of ESPN International Sports?`:
```sql
                SELECT "group" FROM "channel_listing" WHERE "name"='espn international sports';
```
## Task
Generate a SQL query to answer the following question:
`What is the type of station for ESPN International Sports?`

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

CREATE TABLE "channel_listing" (
  "name" text,
  "language" text,
  "owner" text,
  "group" text,
  "type" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the type of station for ESPN International Sports?`:
```sql
                SELECT "type" FROM "channel_listing" WHERE "name"='espn international sports';
```
## Task
Generate a SQL query to answer the following question:
`What is the type of station that is in the movies group?`

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

CREATE TABLE "channel_listing" (
  "name" text,
  "language" text,
  "owner" text,
  "group" text,
  "type" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the type of station that is in the movies group?`:
```sql
                SELECT "type" FROM "channel_listing" WHERE "group"='movies';
```
## Task
Generate a SQL query to answer the following question:
`What is the total sum ranked less than 5 with a 37.076 (2) 3rd run?`

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

CREATE TABLE "heat_2" (
  "rank" real,
  "name" text,
  "1st_run" text,
  "2nd_run" text,
  "3rd_run" text,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total sum ranked less than 5 with a 37.076 (2) 3rd run?`:
```sql
                SELECT SUM("total") FROM "heat_2" WHERE "rank"<5 AND "3rd_run"='37.076 (2)';
```
## Task
Generate a SQL query to answer the following question:
`What is the name of the person with a total of 22?`

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

CREATE TABLE "heat_2" (
  "rank" real,
  "name" text,
  "1st_run" text,
  "2nd_run" text,
  "3rd_run" text,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the name of the person with a total of 22?`:
```sql
                SELECT "name" FROM "heat_2" WHERE "total"=22;
```
## Task
Generate a SQL query to answer the following question:
`What is the total with a rank less than 8 and a 40.143 (4) 2nd run?`

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

CREATE TABLE "heat_2" (
  "rank" real,
  "name" text,
  "1st_run" text,
  "2nd_run" text,
  "3rd_run" text,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the total with a rank less than 8 and a 40.143 (4) 2nd run?`:
```sql
                SELECT "total" FROM "heat_2" WHERE "rank"<8 AND "2nd_run"='40.143 (4)';
```
## Task
Generate a SQL query to answer the following question:
`What's the nationality of Henry Carr having a time of 20.3y?`

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

CREATE TABLE "records_1951_1976" (
  "time" text,
  "athlete" text,
  "nationality" text,
  "location_of_race" text,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the nationality of Henry Carr having a time of 20.3y?`:
```sql
                SELECT "nationality" FROM "records_1951_1976" WHERE "athlete"='henry carr' AND "time"='20.3y';
```
## Task
Generate a SQL query to answer the following question:
`What's the nationality of Livio Berruti?`

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

CREATE TABLE "records_1951_1976" (
  "time" text,
  "athlete" text,
  "nationality" text,
  "location_of_race" text,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the nationality of Livio Berruti?`:
```sql
                SELECT "nationality" FROM "records_1951_1976" WHERE "athlete"='livio berruti';
```
## Task
Generate a SQL query to answer the following question:
`What's the nationality of Ray norton with a time of 20.6?`

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

CREATE TABLE "records_1951_1976" (
  "time" text,
  "athlete" text,
  "nationality" text,
  "location_of_race" text,
  "date" text
);
### SQL
Given the database schema, here is the SQL query that answers `What's the nationality of Ray norton with a time of 20.6?`:
```sql
                SELECT "nationality" FROM "records_1951_1976" WHERE "time"='20.6' AND "athlete"='ray norton';
```
## Task
Generate a SQL query to answer the following question:
`What is the sum of the prominence in m of slovakia?`

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

CREATE TABLE "list_of_european_ultra_prominent_peaks" (
  "peak" text,
  "country" text,
  "elevation_m" real,
  "prominence_m" real,
  "col_m" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the sum of the prominence in m of slovakia?`:
```sql
                SELECT SUM("prominence_m") FROM "list_of_european_ultra_prominent_peaks" WHERE "country"='slovakia';
```
## Task
Generate a SQL query to answer the following question:
`What is the prominence in m of a col in m greater than 738?`

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

CREATE TABLE "list_of_european_ultra_prominent_peaks" (
  "peak" text,
  "country" text,
  "elevation_m" real,
  "prominence_m" real,
  "col_m" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the prominence in m of a col in m greater than 738?`:
```sql
                SELECT "prominence_m" FROM "list_of_european_ultra_prominent_peaks" WHERE "col_m">738;
```
## Task
Generate a SQL query to answer the following question:
`Whta is the lowest col in m of gerlachovský štít peak, which has an elevation greater than 2,655 m?`

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

CREATE TABLE "list_of_european_ultra_prominent_peaks" (
  "peak" text,
  "country" text,
  "elevation_m" real,
  "prominence_m" real,
  "col_m" real
);
### SQL
Given the database schema, here is the SQL query that answers `Whta is the lowest col in m of gerlachovský štít peak, which has an elevation greater than 2,655 m?`:
```sql
                SELECT MIN("col_m") FROM "list_of_european_ultra_prominent_peaks" WHERE "peak"='gerlachovský štít' AND "elevation_m">'2,655';
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest elevation in m of moldoveanu peak, which has a prominence in m less than 2,103 and a col in m less than 498?`

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

CREATE TABLE "list_of_european_ultra_prominent_peaks" (
  "peak" text,
  "country" text,
  "elevation_m" real,
  "prominence_m" real,
  "col_m" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest elevation in m of moldoveanu peak, which has a prominence in m less than 2,103 and a col in m less than 498?`:
```sql
                SELECT MIN("elevation_m") FROM "list_of_european_ultra_prominent_peaks" WHERE "prominence_m"<'2,103' AND "peak"='moldoveanu peak' AND "col_m"<498;
```
## Task
Generate a SQL query to answer the following question:
`What is the average prominence in m of pietrosul rodnei peak, which has an elevation less than 2,303?`

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

CREATE TABLE "list_of_european_ultra_prominent_peaks" (
  "peak" text,
  "country" text,
  "elevation_m" real,
  "prominence_m" real,
  "col_m" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average prominence in m of pietrosul rodnei peak, which has an elevation less than 2,303?`:
```sql
                SELECT AVG("prominence_m") FROM "list_of_european_ultra_prominent_peaks" WHERE "peak"='pietrosul rodnei' AND "elevation_m"<'2,303';
```
## Task
Generate a SQL query to answer the following question:
`What is the Score of the Shooter with a Comp of OG?`

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

CREATE TABLE "world_record_progression" (
  "score" text,
  "shooter" text,
  "date" text,
  "comp" text,
  "place" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Score of the Shooter with a Comp of OG?`:
```sql
                SELECT "score" FROM "world_record_progression" WHERE "comp"='og';
```
## Task
Generate a SQL query to answer the following question:
`What is the B Score when the total is more than 16.125, and position is 3rd?`

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

CREATE TABLE "qualified_competitors" (
  "position" text,
  "gymnast" text,
  "a_score" real,
  "b_score" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the B Score when the total is more than 16.125, and position is 3rd?`:
```sql
                SELECT SUM("b_score") FROM "qualified_competitors" WHERE "total">16.125 AND "position"='3rd';
```
## Task
Generate a SQL query to answer the following question:
`What is the lowest A Score when the B Score is 9.15, and total is 16.05?`

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

CREATE TABLE "qualified_competitors" (
  "position" text,
  "gymnast" text,
  "a_score" real,
  "b_score" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the lowest A Score when the B Score is 9.15, and total is 16.05?`:
```sql
                SELECT MIN("a_score") FROM "qualified_competitors" WHERE "b_score"=9.15 AND "total"=16.05;
```
## Task
Generate a SQL query to answer the following question:
`Who had a time of 7:14.64?`

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

CREATE TABLE "heat_3" (
  "rank" real,
  "athlete" text,
  "country" text,
  "time" text,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who had a time of 7:14.64?`:
```sql
                SELECT "athlete" FROM "heat_3" WHERE "time"='7:14.64';
```
## Task
Generate a SQL query to answer the following question:
`What rank was Lassi Karonen?`

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

CREATE TABLE "heat_3" (
  "rank" real,
  "athlete" text,
  "country" text,
  "time" text,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What rank was Lassi Karonen?`:
```sql
                SELECT COUNT("rank") FROM "heat_3" WHERE "athlete"='lassi karonen';
```
## Task
Generate a SQL query to answer the following question:
`What was the rank when then time was 7:52.53?`

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

CREATE TABLE "heat_3" (
  "rank" real,
  "athlete" text,
  "country" text,
  "time" text,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the rank when then time was 7:52.53?`:
```sql
                SELECT MIN("rank") FROM "heat_3" WHERE "time"='7:52.53';
```
## Task
Generate a SQL query to answer the following question:
`Who was the athlete from Germany with notes of Q?`

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

CREATE TABLE "heat_3" (
  "rank" real,
  "athlete" text,
  "country" text,
  "time" text,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the athlete from Germany with notes of Q?`:
```sql
                SELECT "athlete" FROM "heat_3" WHERE "notes"='q' AND "country"='germany';
```
## Task
Generate a SQL query to answer the following question:
`What rank is Germany?`

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

CREATE TABLE "heat_3" (
  "rank" real,
  "athlete" text,
  "country" text,
  "time" text,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What rank is Germany?`:
```sql
                SELECT "rank" FROM "heat_3" WHERE "country"='germany';
```
## Task
Generate a SQL query to answer the following question:
`Who was the athlete from Hong Kong?`

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

CREATE TABLE "heat_3" (
  "rank" real,
  "athlete" text,
  "country" text,
  "time" text,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the athlete from Hong Kong?`:
```sql
                SELECT "athlete" FROM "heat_3" WHERE "country"='hong kong';
```
## Task
Generate a SQL query to answer the following question:
`Which school has a mascot of the Blazers and in the Northeast Corner conference?`

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

CREATE TABLE "former_members" (
  "school" text,
  "location" text,
  "mascot" text,
  "enrollment_08_09" real,
  "ihsaa_class_football_class" text,
  "county" text,
  "year_joined" real,
  "previous_conference" text,
  "year_left" real,
  "conference_joined" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which school has a mascot of the Blazers and in the Northeast Corner conference?`:
```sql
                SELECT "school" FROM "former_members" WHERE "conference_joined"='northeast corner' AND "mascot"='blazers';
```
## Task
Generate a SQL query to answer the following question:
`Which mascot has an IHSAA Class and Football class of 2A/2A?`

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

CREATE TABLE "former_members" (
  "school" text,
  "location" text,
  "mascot" text,
  "enrollment_08_09" real,
  "ihsaa_class_football_class" text,
  "county" text,
  "year_joined" real,
  "previous_conference" text,
  "year_left" real,
  "conference_joined" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which mascot has an IHSAA Class and Football class of 2A/2A?`:
```sql
                SELECT "mascot" FROM "former_members" WHERE "ihsaa_class_football_class"='2a/2a';
```
## Task
Generate a SQL query to answer the following question:
`Which player was selected in rounds under 3?`

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

CREATE TABLE "amateur_draft" (
  "round" real,
  "pick" real,
  "player" text,
  "nationality" text,
  "college_junior_club_team" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which player was selected in rounds under 3?`:
```sql
                SELECT "player" FROM "amateur_draft" WHERE "round"<3;
```
## Task
Generate a SQL query to answer the following question:
`Which Water (sqmi) has a Pop (2010) of 359, and a Longitude smaller than -97.176811?`

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

CREATE TABLE "f" (
  "township" text,
  "county" text,
  "pop_2010" real,
  "land_sqmi" real,
  "water_sqmi" real,
  "latitude" real,
  "longitude" real,
  "geo_id" real,
  "ansi_code" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Water (sqmi) has a Pop (2010) of 359, and a Longitude smaller than -97.176811?`:
```sql
                SELECT MAX("water_sqmi") FROM "f" WHERE "pop_2010"=359 AND "longitude"<-97.176811;
```
## Task
Generate a SQL query to answer the following question:
`Which Land (sqmi) has a Water (sqmi) smaller than 0.04, and a Longitude of -96.794706?`

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

CREATE TABLE "f" (
  "township" text,
  "county" text,
  "pop_2010" real,
  "land_sqmi" real,
  "water_sqmi" real,
  "latitude" real,
  "longitude" real,
  "geo_id" real,
  "ansi_code" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which Land (sqmi) has a Water (sqmi) smaller than 0.04, and a Longitude of -96.794706?`:
```sql
                SELECT MIN("land_sqmi") FROM "f" WHERE "water_sqmi"<0.04 AND "longitude"=-96.794706;
```
## Task
Generate a SQL query to answer the following question:
`How much Latitude has a Water (sqmi) of 0.267, and an ANSI code larger than 1759605?`

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

CREATE TABLE "f" (
  "township" text,
  "county" text,
  "pop_2010" real,
  "land_sqmi" real,
  "water_sqmi" real,
  "latitude" real,
  "longitude" real,
  "geo_id" real,
  "ansi_code" real
);
### SQL
Given the database schema, here is the SQL query that answers `How much Latitude has a Water (sqmi) of 0.267, and an ANSI code larger than 1759605?`:
```sql
                SELECT SUM("latitude") FROM "f" WHERE "water_sqmi"=0.267 AND "ansi_code">1759605;
```
## Task
Generate a SQL query to answer the following question:
`Which ANSI code has a GEO ID larger than 3809927140, and a Water (sqmi) smaller than 0.492, and a Pop (2010) of 37, and a Latitude larger than 48.245979?`

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

CREATE TABLE "f" (
  "township" text,
  "county" text,
  "pop_2010" real,
  "land_sqmi" real,
  "water_sqmi" real,
  "latitude" real,
  "longitude" real,
  "geo_id" real,
  "ansi_code" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which ANSI code has a GEO ID larger than 3809927140, and a Water (sqmi) smaller than 0.492, and a Pop (2010) of 37, and a Latitude larger than 48.245979?`:
```sql
                SELECT MIN("ansi_code") FROM "f" WHERE "geo_id">3809927140 AND "water_sqmi"<0.492 AND "pop_2010"=37 AND "latitude">48.245979;
```
## Task
Generate a SQL query to answer the following question:
`What is the Owner of Frequency 00 99.3?`

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

CREATE TABLE "radio" (
  "frequency" text,
  "call_sign" text,
  "branding" text,
  "format" text,
  "owner" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Owner of Frequency 00 99.3?`:
```sql
                SELECT "owner" FROM "radio" WHERE "frequency"='00 99.3';
```
## Task
Generate a SQL query to answer the following question:
`What is the Branding of Frequency 00 94.5?`

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

CREATE TABLE "radio" (
  "frequency" text,
  "call_sign" text,
  "branding" text,
  "format" text,
  "owner" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Branding of Frequency 00 94.5?`:
```sql
                SELECT "branding" FROM "radio" WHERE "frequency"='00 94.5';
```
## Task
Generate a SQL query to answer the following question:
`What is the Call Sign of the Frequency by Owner CKUA Radio Foundation?`

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

CREATE TABLE "radio" (
  "frequency" text,
  "call_sign" text,
  "branding" text,
  "format" text,
  "owner" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Call Sign of the Frequency by Owner CKUA Radio Foundation?`:
```sql
                SELECT "call_sign" FROM "radio" WHERE "owner"='ckua radio foundation';
```
## Task
Generate a SQL query to answer the following question:
`What is the Owner of the Frequency with a Format of First Nations Community Radio?`

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

CREATE TABLE "radio" (
  "frequency" text,
  "call_sign" text,
  "branding" text,
  "format" text,
  "owner" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the Owner of the Frequency with a Format of First Nations Community Radio?`:
```sql
                SELECT "owner" FROM "radio" WHERE "format"='first nations community radio';
```
## Task
Generate a SQL query to answer the following question:
`Which School has a Previous Conference of none (new school), and a Year Joined larger than 1960, and a Location of versailles?`

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

CREATE TABLE "membership" (
  "school" text,
  "location" text,
  "mascot" text,
  "size" real,
  "ihsaa_class" text,
  "county" text,
  "year_joined" real,
  "previous_conference" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which School has a Previous Conference of none (new school), and a Year Joined larger than 1960, and a Location of versailles?`:
```sql
                SELECT "school" FROM "membership" WHERE "previous_conference"='none (new school)' AND "year_joined">1960 AND "location"='versailles';
```
## Task
Generate a SQL query to answer the following question:
`Which Location has a Previous Conference of independents, and a Mascot of hilltoppers?`

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

CREATE TABLE "membership" (
  "school" text,
  "location" text,
  "mascot" text,
  "size" real,
  "ihsaa_class" text,
  "county" text,
  "year_joined" real,
  "previous_conference" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Location has a Previous Conference of independents, and a Mascot of hilltoppers?`:
```sql
                SELECT "location" FROM "membership" WHERE "previous_conference"='independents' AND "mascot"='hilltoppers';
```
## Task
Generate a SQL query to answer the following question:
`Which Year Joined has a Size larger than 93, and a Previous Conference of none (new school), and a Mascot of rebels?`

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

CREATE TABLE "membership" (
  "school" text,
  "location" text,
  "mascot" text,
  "size" real,
  "ihsaa_class" text,
  "county" text,
  "year_joined" real,
  "previous_conference" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Year Joined has a Size larger than 93, and a Previous Conference of none (new school), and a Mascot of rebels?`:
```sql
                SELECT AVG("year_joined") FROM "membership" WHERE "size">93 AND "previous_conference"='none (new school)' AND "mascot"='rebels';
```
## Task
Generate a SQL query to answer the following question:
`How many years Joined have a Size smaller than 417, and an IHSAA Class of A, and a School of jac-cen-del?`

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

CREATE TABLE "membership" (
  "school" text,
  "location" text,
  "mascot" text,
  "size" real,
  "ihsaa_class" text,
  "county" text,
  "year_joined" real,
  "previous_conference" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many years Joined have a Size smaller than 417, and an IHSAA Class of A, and a School of jac-cen-del?`:
```sql
                SELECT COUNT("year_joined") FROM "membership" WHERE "size"<417 AND "ihsaa_class"='a' AND "school"='jac-cen-del';
```
## Task
Generate a SQL query to answer the following question:
`What is the 1957 number when the 1955 is smaller than 0.63, and 1952 is larger than 0.22?`

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

CREATE TABLE "1950s" (
  "country" text,
  "1951" real,
  "1952" real,
  "1953" real,
  "1954" real,
  "1955" real,
  "1956" real,
  "1957" real,
  "1958" real,
  "1959" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the 1957 number when the 1955 is smaller than 0.63, and 1952 is larger than 0.22?`:
```sql
                SELECT COUNT("1957") FROM "1950s" WHERE "1955"<0.63 AND "1952">0.22;
```
## Task
Generate a SQL query to answer the following question:
`What is the 1952 rate when the 1954 is more than 4.2?`

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

CREATE TABLE "1950s" (
  "country" text,
  "1951" real,
  "1952" real,
  "1953" real,
  "1954" real,
  "1955" real,
  "1956" real,
  "1957" real,
  "1958" real,
  "1959" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the 1952 rate when the 1954 is more than 4.2?`:
```sql
                SELECT SUM("1952") FROM "1950s" WHERE "1954">4.2;
```
## Task
Generate a SQL query to answer the following question:
`What is the 1955 rate when the 1956 is more than 2.9, and 1953 is larger than 4.5?`

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

CREATE TABLE "1950s" (
  "country" text,
  "1951" real,
  "1952" real,
  "1953" real,
  "1954" real,
  "1955" real,
  "1956" real,
  "1957" real,
  "1958" real,
  "1959" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the 1955 rate when the 1956 is more than 2.9, and 1953 is larger than 4.5?`:
```sql
                SELECT SUM("1955") FROM "1950s" WHERE "1956">2.9 AND "1953">4.5;
```
## Task
Generate a SQL query to answer the following question:
`Where was Alex Song signed from after 2010?`

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

CREATE TABLE "signings" (
  "rank" real,
  "player" text,
  "from" text,
  "transfer_fee_millions" text,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `Where was Alex Song signed from after 2010?`:
```sql
                SELECT "from" FROM "signings" WHERE "year">2010 AND "player"='alex song';
```
## Task
Generate a SQL query to answer the following question:
`How many players were signed from Sevilla?`

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

CREATE TABLE "signings" (
  "rank" real,
  "player" text,
  "from" text,
  "transfer_fee_millions" text,
  "year" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many players were signed from Sevilla?`:
```sql
                SELECT COUNT("year") FROM "signings" WHERE "from"='sevilla';
```
## Task
Generate a SQL query to answer the following question:
`In what Week resulting in the bottom 3 was Endre Jansen Partner?`

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

CREATE TABLE "dansefeber" (
  "week" real,
  "partner" text,
  "dance" text,
  "music" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `In what Week resulting in the bottom 3 was Endre Jansen Partner?`:
```sql
                SELECT MAX("week") FROM "dansefeber" WHERE "result"='bottom 3' AND "partner"='endre jansen';
```
## Task
Generate a SQL query to answer the following question:
`What Dance in Week 1 resulted in Safe?`

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

CREATE TABLE "dansefeber" (
  "week" real,
  "partner" text,
  "dance" text,
  "music" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Dance in Week 1 resulted in Safe?`:
```sql
                SELECT "dance" FROM "dansefeber" WHERE "result"='safe' AND "week"=1;
```
## Task
Generate a SQL query to answer the following question:
`In what Week was the Locking Dance?`

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

CREATE TABLE "dansefeber" (
  "week" real,
  "partner" text,
  "dance" text,
  "music" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `In what Week was the Locking Dance?`:
```sql
                SELECT MAX("week") FROM "dansefeber" WHERE "dance"='locking';
```
## Task
Generate a SQL query to answer the following question:
`What position has 7 as the round, with a pick # less than 214?`

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

CREATE TABLE "nfl_draft" (
  "round" real,
  "pick_num" real,
  "player" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What position has 7 as the round, with a pick # less than 214?`:
```sql
                SELECT "position" FROM "nfl_draft" WHERE "round"=7 AND "pick_num"<214;
```
## Task
Generate a SQL query to answer the following question:
`What college has a round greater than 1, with dylan mcfarland as the player?`

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

CREATE TABLE "nfl_draft" (
  "round" real,
  "pick_num" real,
  "player" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What college has a round greater than 1, with dylan mcfarland as the player?`:
```sql
                SELECT "college" FROM "nfl_draft" WHERE "round">1 AND "player"='dylan mcfarland';
```
## Task
Generate a SQL query to answer the following question:
`What player has a pick # greater than 207?`

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

CREATE TABLE "nfl_draft" (
  "round" real,
  "pick_num" real,
  "player" text,
  "position" text,
  "college" text
);
### SQL
Given the database schema, here is the SQL query that answers `What player has a pick # greater than 207?`:
```sql
                SELECT "player" FROM "nfl_draft" WHERE "pick_num">207;
```
## Task
Generate a SQL query to answer the following question:
`Which artist had a 4x platinum?`

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

CREATE TABLE "top_10_american_albums" (
  "rank" real,
  "artist" text,
  "album" text,
  "peak_position" real,
  "sales" real,
  "certification" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which artist had a 4x platinum?`:
```sql
                SELECT "artist" FROM "top_10_american_albums" WHERE "certification"='4x platinum';
```
## Task
Generate a SQL query to answer the following question:
`What was the highest peak position for the album one of the boys?`

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

CREATE TABLE "top_10_american_albums" (
  "rank" real,
  "artist" text,
  "album" text,
  "peak_position" real,
  "sales" real,
  "certification" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the highest peak position for the album one of the boys?`:
```sql
                SELECT MAX("peak_position") FROM "top_10_american_albums" WHERE "album"='one of the boys';
```
## Task
Generate a SQL query to answer the following question:
`How many sales had a peak position of 1 and a certification of 6x platinum?`

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

CREATE TABLE "top_10_american_albums" (
  "rank" real,
  "artist" text,
  "album" text,
  "peak_position" real,
  "sales" real,
  "certification" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many sales had a peak position of 1 and a certification of 6x platinum?`:
```sql
                SELECT COUNT("sales") FROM "top_10_american_albums" WHERE "peak_position"=1 AND "certification"='6x platinum';
```
## Task
Generate a SQL query to answer the following question:
`What album had a peak position of 6 and a certification of 3x platinum?`

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

CREATE TABLE "top_10_american_albums" (
  "rank" real,
  "artist" text,
  "album" text,
  "peak_position" real,
  "sales" real,
  "certification" text
);
### SQL
Given the database schema, here is the SQL query that answers `What album had a peak position of 6 and a certification of 3x platinum?`:
```sql
                SELECT "album" FROM "top_10_american_albums" WHERE "certification"='3x platinum' AND "peak_position"=6;
```
## Task
Generate a SQL query to answer the following question:
`How many sales had a peak position more than 2 and a Certification of 3x platinum?`

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

CREATE TABLE "top_10_american_albums" (
  "rank" real,
  "artist" text,
  "album" text,
  "peak_position" real,
  "sales" real,
  "certification" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many sales had a peak position more than 2 and a Certification of 3x platinum?`:
```sql
                SELECT COUNT("sales") FROM "top_10_american_albums" WHERE "peak_position">2 AND "certification"='3x platinum';
```
## Task
Generate a SQL query to answer the following question:
`Who were the rowers who had a time of 7:39.70?`

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

CREATE TABLE "heat_3" (
  "rank" real,
  "rowers" text,
  "country" text,
  "time" text,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who were the rowers who had a time of 7:39.70?`:
```sql
                SELECT "rowers" FROM "heat_3" WHERE "time"='7:39.70';
```
## Task
Generate a SQL query to answer the following question:
`Who were the rowers from china wh had a rank smaller than 4?`

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

CREATE TABLE "heat_3" (
  "rank" real,
  "rowers" text,
  "country" text,
  "time" text,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who were the rowers from china wh had a rank smaller than 4?`:
```sql
                SELECT "rowers" FROM "heat_3" WHERE "rank"<4 AND "country"='china';
```
## Task
Generate a SQL query to answer the following question:
`What is the notes for the rowers from denmark?`

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

CREATE TABLE "heat_3" (
  "rank" real,
  "rowers" text,
  "country" text,
  "time" text,
  "notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the notes for the rowers from denmark?`:
```sql
                SELECT "notes" FROM "heat_3" WHERE "country"='denmark';
```
## Task
Generate a SQL query to answer the following question:
`Which Bronze has a Nation of austria, and a Total larger than 6?`

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

CREATE TABLE "medals_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 `Which Bronze has a Nation of austria, and a Total larger than 6?`:
```sql
                SELECT MAX("bronze") FROM "medals_table" WHERE "nation"='austria' AND "total">6;
```
## Task
Generate a SQL query to answer the following question:
`Which Rank has a Silver of 1, and a Gold of 0, and a Nation of austria?`

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

CREATE TABLE "medals_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 `Which Rank has a Silver of 1, and a Gold of 0, and a Nation of austria?`:
```sql
                SELECT "rank" FROM "medals_table" WHERE "silver"=1 AND "gold"=0 AND "nation"='austria';
```
## Task
Generate a SQL query to answer the following question:
`Which Total has a Rank of 5, and a Bronze smaller than 0?`

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

CREATE TABLE "medals_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 `Which Total has a Rank of 5, and a Bronze smaller than 0?`:
```sql
                SELECT AVG("total") FROM "medals_table" WHERE "rank"='5' AND "bronze"<0;
```
## Task
Generate a SQL query to answer the following question:
`Which Total has a Bronze of 5, and a Silver smaller than 1?`

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

CREATE TABLE "medals_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 `Which Total has a Bronze of 5, and a Silver smaller than 1?`:
```sql
                SELECT MIN("total") FROM "medals_table" WHERE "bronze"=5 AND "silver"<1;
```