cfahlgren1/wiki_sql_pg_converted huggingface dataset:
## Task
Generate a SQL query to answer the following question:
`Who was the outgoing manager when the incoming manager was augusto inácio?`

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

CREATE TABLE "managerial_changes" (
  "team" text,
  "outgoing_manage" text,
  "manner" text,
  "date_of_vacancy" text,
  "incoming_manager" text,
  "date_of_appointment" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the outgoing manager when the incoming manager was augusto inácio?`:
```sql
                SELECT "outgoing_manage" FROM "managerial_changes" WHERE "incoming_manager"='augusto inácio';
```
## Task
Generate a SQL query to answer the following question:
`How many matches did Atlético Ciudad have with an average higher than 0.61?`

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

CREATE TABLE "top_goalkeepers" (
  "goalkeeper" text,
  "goals" real,
  "matches" real,
  "average" real,
  "team" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many matches did Atlético Ciudad have with an average higher than 0.61?`:
```sql
                SELECT COUNT("matches") FROM "top_goalkeepers" WHERE "team"='atlético ciudad' AND "average">0.61;
```
## Task
Generate a SQL query to answer the following question:
`Who is the goalkeeper with fewer than 24 goals?`

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

CREATE TABLE "top_goalkeepers" (
  "goalkeeper" text,
  "goals" real,
  "matches" real,
  "average" real,
  "team" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who is the goalkeeper with fewer than 24 goals?`:
```sql
                SELECT "goalkeeper" FROM "top_goalkeepers" WHERE "goals"<24;
```
## Task
Generate a SQL query to answer the following question:
`What was the highest amount of losses when there were 45 goals and the play was smaller than 38?`

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

CREATE TABLE "relegation_playoff" (
  "position" real,
  "club" text,
  "played" real,
  "points" real,
  "wins" real,
  "draws" real,
  "losses" real,
  "goals_for" real,
  "goals_against" real,
  "goal_difference" real
);
### SQL
Given the database schema, here is the SQL query that answers `What was the highest amount of losses when there were 45 goals and the play was smaller than 38?`:
```sql
                SELECT MAX("losses") FROM "relegation_playoff" WHERE "goals_for"=45 AND "played"<38;
```
## Task
Generate a SQL query to answer the following question:
`What were the lowest goals when there were mor than 15 wins and the goal difference was larger than 35?`

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

CREATE TABLE "relegation_playoff" (
  "position" real,
  "club" text,
  "played" real,
  "points" real,
  "wins" real,
  "draws" real,
  "losses" real,
  "goals_for" real,
  "goals_against" real,
  "goal_difference" real
);
### SQL
Given the database schema, here is the SQL query that answers `What were the lowest goals when there were mor than 15 wins and the goal difference was larger than 35?`:
```sql
                SELECT MIN("goals_for") FROM "relegation_playoff" WHERE "wins">15 AND "goal_difference">35;
```
## Task
Generate a SQL query to answer the following question:
`What were the highest losses when the goal was smaller than 45 and the points was smaller than 18?`

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

CREATE TABLE "relegation_playoff" (
  "position" real,
  "club" text,
  "played" real,
  "points" real,
  "wins" real,
  "draws" real,
  "losses" real,
  "goals_for" real,
  "goals_against" real,
  "goal_difference" real
);
### SQL
Given the database schema, here is the SQL query that answers `What were the highest losses when the goal was smaller than 45 and the points was smaller than 18?`:
```sql
                SELECT MAX("losses") FROM "relegation_playoff" WHERE "goals_for"<45 AND "points"<18;
```
## Task
Generate a SQL query to answer the following question:
`What were the highest goals against when the position was larger than 19 and the goals smaller than 36?`

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

CREATE TABLE "relegation_playoff" (
  "position" real,
  "club" text,
  "played" real,
  "points" real,
  "wins" real,
  "draws" real,
  "losses" real,
  "goals_for" real,
  "goals_against" real,
  "goal_difference" real
);
### SQL
Given the database schema, here is the SQL query that answers `What were the highest goals against when the position was larger than 19 and the goals smaller than 36?`:
```sql
                SELECT MAX("goals_against") FROM "relegation_playoff" WHERE "position">19 AND "goals_for"<36;
```
## Task
Generate a SQL query to answer the following question:
`What is the to par for the player with fewer than 148 total points?`

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

CREATE TABLE "missed_the_cut" (
  "player" text,
  "country" text,
  "year_s_won" text,
  "total" real,
  "to_par" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the to par for the player with fewer than 148 total points?`:
```sql
                SELECT SUM("to_par") FROM "missed_the_cut" WHERE "total"<148;
```
## Task
Generate a SQL query to answer the following question:
`What is 2:00 pm, when 3:30 pm is "Animaniacs (Mon-Thu) Pinky and The Brain (Fri)"?`

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

CREATE TABLE "spring_1998" (
  "7_30_am" text,
  "8_00_am" text,
  "9_00_am" text,
  "11_00_am" text,
  "noon" text,
  "12_30_pm" text,
  "1_00_pm" text,
  "1_30_pm" text,
  "2_00_pm" text,
  "3_00_pm" text,
  "3_30_pm" text,
  "5_00_pm" text,
  "6_30_pm" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is 2:00 pm, when 3:30 pm is "Animaniacs (Mon-Thu) Pinky and The Brain (Fri)"?`:
```sql
                SELECT "2_00_pm" FROM "spring_1998" WHERE "3_30_pm"='animaniacs (mon-thu) pinky and the brain (fri)';
```
## Task
Generate a SQL query to answer the following question:
`What is 7:30 am, when 11:00 am is "The View"?`

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

CREATE TABLE "spring_1998" (
  "7_30_am" text,
  "8_00_am" text,
  "9_00_am" text,
  "11_00_am" text,
  "noon" text,
  "12_30_pm" text,
  "1_00_pm" text,
  "1_30_pm" text,
  "2_00_pm" text,
  "3_00_pm" text,
  "3_30_pm" text,
  "5_00_pm" text,
  "6_30_pm" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is 7:30 am, when 11:00 am is "The View"?`:
```sql
                SELECT "7_30_am" FROM "spring_1998" WHERE "11_00_am"='the view';
```
## Task
Generate a SQL query to answer the following question:
`What is 3:00 pm, when 1:00 pm is "Days of Our Lives"?`

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

CREATE TABLE "spring_1998" (
  "7_30_am" text,
  "8_00_am" text,
  "9_00_am" text,
  "11_00_am" text,
  "noon" text,
  "12_30_pm" text,
  "1_00_pm" text,
  "1_30_pm" text,
  "2_00_pm" text,
  "3_00_pm" text,
  "3_30_pm" text,
  "5_00_pm" text,
  "6_30_pm" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is 3:00 pm, when 1:00 pm is "Days of Our Lives"?`:
```sql
                SELECT "3_00_pm" FROM "spring_1998" WHERE "1_00_pm"='days of our lives';
```
## Task
Generate a SQL query to answer the following question:
`What is Noon, when 3:00 pm is "General Hospital"?`

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

CREATE TABLE "spring_1998" (
  "7_30_am" text,
  "8_00_am" text,
  "9_00_am" text,
  "11_00_am" text,
  "noon" text,
  "12_30_pm" text,
  "1_00_pm" text,
  "1_30_pm" text,
  "2_00_pm" text,
  "3_00_pm" text,
  "3_30_pm" text,
  "5_00_pm" text,
  "6_30_pm" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is Noon, when 3:00 pm is "General Hospital"?`:
```sql
                SELECT "noon" FROM "spring_1998" WHERE "3_00_pm"='general hospital';
```
## Task
Generate a SQL query to answer the following question:
`What is 9:00 am, when 6:30 pm is "Local Programs"?`

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

CREATE TABLE "spring_1998" (
  "7_30_am" text,
  "8_00_am" text,
  "9_00_am" text,
  "11_00_am" text,
  "noon" text,
  "12_30_pm" text,
  "1_00_pm" text,
  "1_30_pm" text,
  "2_00_pm" text,
  "3_00_pm" text,
  "3_30_pm" text,
  "5_00_pm" text,
  "6_30_pm" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is 9:00 am, when 6:30 pm is "Local Programs"?`:
```sql
                SELECT "9_00_am" FROM "spring_1998" WHERE "6_30_pm"='local programs';
```
## Task
Generate a SQL query to answer the following question:
`What school year is vaucluse public school?`

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

CREATE TABLE "v" (
  "school" text,
  "suburb_town" text,
  "years" text,
  "founded" real,
  "website" text
);
### SQL
Given the database schema, here is the SQL query that answers `What school year is vaucluse public school?`:
```sql
                SELECT "years" FROM "v" WHERE "school"='vaucluse public school';
```
## Task
Generate a SQL query to answer the following question:
`What are the websites of schools that were founded in 1872?`

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

CREATE TABLE "v" (
  "school" text,
  "suburb_town" text,
  "years" text,
  "founded" real,
  "website" text
);
### SQL
Given the database schema, here is the SQL query that answers `What are the websites of schools that were founded in 1872?`:
```sql
                SELECT "website" FROM "v" WHERE "founded"=1872;
```
## Task
Generate a SQL query to answer the following question:
`On average, when were vineyard schools founded?`

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

CREATE TABLE "v" (
  "school" text,
  "suburb_town" text,
  "years" text,
  "founded" real,
  "website" text
);
### SQL
Given the database schema, here is the SQL query that answers `On average, when were vineyard schools founded?`:
```sql
                SELECT AVG("founded") FROM "v" WHERE "suburb_town"='vineyard';
```
## Task
Generate a SQL query to answer the following question:
`What was the surface later than 1979, for the Melbourne Indoor, Australia, and the score was 2–6, 6–2, 6–2?`

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

CREATE TABLE "singles_55_25_30" (
  "outcome" text,
  "date" real,
  "championship" text,
  "surface" text,
  "opponent" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the surface later than 1979, for the Melbourne Indoor, Australia, and the score was 2–6, 6–2, 6–2?`:
```sql
                SELECT "surface" FROM "singles_55_25_30" WHERE "date">1979 AND "championship"='melbourne indoor, australia' AND "score"='2–6, 6–2, 6–2';
```
## Task
Generate a SQL query to answer the following question:
`What is the earliest date when the championship was Monterrey WCT, Mexico?`

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

CREATE TABLE "singles_55_25_30" (
  "outcome" text,
  "date" real,
  "championship" text,
  "surface" text,
  "opponent" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the earliest date when the championship was Monterrey WCT, Mexico?`:
```sql
                SELECT MIN("date") FROM "singles_55_25_30" WHERE "championship"='monterrey wct, mexico';
```
## Task
Generate a SQL query to answer the following question:
`What is the score when the outcome was runner-up, earlier than 1975?`

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

CREATE TABLE "singles_55_25_30" (
  "outcome" text,
  "date" real,
  "championship" text,
  "surface" text,
  "opponent" text,
  "score" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the score when the outcome was runner-up, earlier than 1975?`:
```sql
                SELECT "score" FROM "singles_55_25_30" WHERE "outcome"='runner-up' AND "date"<1975;
```
## Task
Generate a SQL query to answer the following question:
`How many Losses have a Geelong FL of newtown & chilwell, and more than 11 wins?`

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

CREATE TABLE "2011_ladder" (
  "geelong_fl" text,
  "wins" real,
  "byes" real,
  "losses" real,
  "draws" real,
  "against" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many Losses have a Geelong FL of newtown & chilwell, and more than 11 wins?`:
```sql
                SELECT COUNT("losses") FROM "2011_ladder" WHERE "geelong_fl"='newtown & chilwell' AND "wins">11;
```
## Task
Generate a SQL query to answer the following question:
`When were the shares 39.1%?`

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

CREATE TABLE "ratings" (
  "show" text,
  "date" text,
  "official_ratings_millions" real,
  "weekly_rank" text,
  "share" text
);
### SQL
Given the database schema, here is the SQL query that answers `When were the shares 39.1%?`:
```sql
                SELECT "date" FROM "ratings" WHERE "share"='39.1%';
```
## Task
Generate a SQL query to answer the following question:
`Which show aired on 19 april?`

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

CREATE TABLE "ratings" (
  "show" text,
  "date" text,
  "official_ratings_millions" real,
  "weekly_rank" text,
  "share" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which show aired on 19 april?`:
```sql
                SELECT "show" FROM "ratings" WHERE "date"='19 april';
```
## Task
Generate a SQL query to answer the following question:
`What was the original title for the film used in nomination of street days?`

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

CREATE TABLE "submissions" (
  "year_e_ceremony" text,
  "film_title_used_in_nomination" text,
  "original_title" text,
  "director" text,
  "main_language_s" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the original title for the film used in nomination of street days?`:
```sql
                SELECT "original_title" FROM "submissions" WHERE "film_title_used_in_nomination"='street days';
```
## Task
Generate a SQL query to answer the following question:
`What was the original title for the film used in nomination of keep smiling?`

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

CREATE TABLE "submissions" (
  "year_e_ceremony" text,
  "film_title_used_in_nomination" text,
  "original_title" text,
  "director" text,
  "main_language_s" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the original title for the film used in nomination of keep smiling?`:
```sql
                SELECT "original_title" FROM "submissions" WHERE "film_title_used_in_nomination"='keep smiling';
```
## Task
Generate a SQL query to answer the following question:
`How much were tickets for the show in Hartford, Connecticut?`

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

CREATE TABLE "not_all_data_are_listed_only_select_date" (
  "date_s" text,
  "city_state" text,
  "ticket_price_s" text,
  "ticket_sold_available" text,
  "ticket_grossing" text
);
### SQL
Given the database schema, here is the SQL query that answers `How much were tickets for the show in Hartford, Connecticut?`:
```sql
                SELECT "ticket_price_s" FROM "not_all_data_are_listed_only_select_date" WHERE "city_state"='hartford, connecticut';
```
## Task
Generate a SQL query to answer the following question:
`How many tickets were sold and how many were available for the shows that grossed $348,674?`

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

CREATE TABLE "not_all_data_are_listed_only_select_date" (
  "date_s" text,
  "city_state" text,
  "ticket_price_s" text,
  "ticket_sold_available" text,
  "ticket_grossing" text
);
### SQL
Given the database schema, here is the SQL query that answers `How many tickets were sold and how many were available for the shows that grossed $348,674?`:
```sql
                SELECT "ticket_sold_available" FROM "not_all_data_are_listed_only_select_date" WHERE "ticket_grossing"='$348,674';
```
## Task
Generate a SQL query to answer the following question:
`How much were tickets for the show in Indianapolis, Indiana?`

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

CREATE TABLE "not_all_data_are_listed_only_select_date" (
  "date_s" text,
  "city_state" text,
  "ticket_price_s" text,
  "ticket_sold_available" text,
  "ticket_grossing" text
);
### SQL
Given the database schema, here is the SQL query that answers `How much were tickets for the show in Indianapolis, Indiana?`:
```sql
                SELECT "ticket_price_s" FROM "not_all_data_are_listed_only_select_date" WHERE "city_state"='indianapolis, indiana';
```
## Task
Generate a SQL query to answer the following question:
`Which Production in 2009 had a Result of Nominated at the Helpmann awards Award Ceremony?`

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

CREATE TABLE "awards" (
  "year" real,
  "award_ceremony" text,
  "role" text,
  "production" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Production in 2009 had a Result of Nominated at the Helpmann awards Award Ceremony?`:
```sql
                SELECT "production" FROM "awards" WHERE "result"='nominated' AND "year"=2009 AND "award_ceremony"='helpmann awards';
```
## Task
Generate a SQL query to answer the following question:
`Which Award Ceremony in 2009 has a Role of Glinda?`

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

CREATE TABLE "awards" (
  "year" real,
  "award_ceremony" text,
  "role" text,
  "production" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Award Ceremony in 2009 has a Role of Glinda?`:
```sql
                SELECT "award_ceremony" FROM "awards" WHERE "role"='glinda' AND "year"=2009;
```
## Task
Generate a SQL query to answer the following question:
`Which Year saw the Production of Wicked at the Helpmann Awards Award ceremony?`

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

CREATE TABLE "awards" (
  "year" real,
  "award_ceremony" text,
  "role" text,
  "production" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Year saw the Production of Wicked at the Helpmann Awards Award ceremony?`:
```sql
                SELECT "year" FROM "awards" WHERE "production"='wicked' AND "award_ceremony"='helpmann awards';
```
## Task
Generate a SQL query to answer the following question:
`What was the Result in 2013?`

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

CREATE TABLE "awards" (
  "year" real,
  "award_ceremony" text,
  "role" text,
  "production" text,
  "result" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the Result in 2013?`:
```sql
                SELECT "result" FROM "awards" WHERE "year"=2013;
```
## Task
Generate a SQL query to answer the following question:
`Who was the rider riding the Kawasaki ZX-6r, that rode less than 22 laps, and the grid was greater than 19, and retirement was the time?`

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

CREATE TABLE "supersport_race_classification" (
  "rider" text,
  "bike" text,
  "laps" real,
  "time" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `Who was the rider riding the Kawasaki ZX-6r, that rode less than 22 laps, and the grid was greater than 19, and retirement was the time?`:
```sql
                SELECT "rider" FROM "supersport_race_classification" WHERE "laps"<22 AND "grid">19 AND "time"='retirement' AND "bike"='kawasaki zx-6r';
```
## Task
Generate a SQL query to answer the following question:
`What is the maximum grid when the laps were greater than 22?`

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

CREATE TABLE "supersport_race_classification" (
  "rider" text,
  "bike" text,
  "laps" real,
  "time" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the maximum grid when the laps were greater than 22?`:
```sql
                SELECT MAX("grid") FROM "supersport_race_classification" WHERE "laps">22;
```
## Task
Generate a SQL query to answer the following question:
`What is the minimum grid when there was more than 22 laps?`

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

CREATE TABLE "supersport_race_classification" (
  "rider" text,
  "bike" text,
  "laps" real,
  "time" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `What is the minimum grid when there was more than 22 laps?`:
```sql
                SELECT MIN("grid") FROM "supersport_race_classification" WHERE "laps">22;
```
## Task
Generate a SQL query to answer the following question:
`How many total laps were ridden when the grid was 7 and the rider rode the Honda CBR600RR?`

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

CREATE TABLE "supersport_race_classification" (
  "rider" text,
  "bike" text,
  "laps" real,
  "time" text,
  "grid" real
);
### SQL
Given the database schema, here is the SQL query that answers `How many total laps were ridden when the grid was 7 and the rider rode the Honda CBR600RR?`:
```sql
                SELECT SUM("laps") FROM "supersport_race_classification" WHERE "bike"='honda cbr600rr' AND "grid"=7;
```
## Task
Generate a SQL query to answer the following question:
`Which sign has a fall of Venus?`

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

CREATE TABLE "table_of_the_most_commonly_used_of_the_t" (
  "sign" text,
  "domicile" text,
  "detriment" text,
  "exaltation" text,
  "fall" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which sign has a fall of Venus?`:
```sql
                SELECT "sign" FROM "table_of_the_most_commonly_used_of_the_t" WHERE "fall"='venus';
```
## Task
Generate a SQL query to answer the following question:
`Which exaltation has a fall of moon?`

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

CREATE TABLE "table_of_the_most_commonly_used_of_the_t" (
  "sign" text,
  "domicile" text,
  "detriment" text,
  "exaltation" text,
  "fall" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which exaltation has a fall of moon?`:
```sql
                SELECT "exaltation" FROM "table_of_the_most_commonly_used_of_the_t" WHERE "fall"='moon';
```
## Task
Generate a SQL query to answer the following question:
`Which exaltation has a domicile of Saturn and a fall of Jupiter?`

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

CREATE TABLE "table_of_the_most_commonly_used_of_the_t" (
  "sign" text,
  "domicile" text,
  "detriment" text,
  "exaltation" text,
  "fall" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which exaltation has a domicile of Saturn and a fall of Jupiter?`:
```sql
                SELECT "exaltation" FROM "table_of_the_most_commonly_used_of_the_t" WHERE "domicile"='saturn' AND "fall"='jupiter';
```
## Task
Generate a SQL query to answer the following question:
`Which exaltation has a domicile of Saturn and Capricorn as a sign?`

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

CREATE TABLE "table_of_the_most_commonly_used_of_the_t" (
  "sign" text,
  "domicile" text,
  "detriment" text,
  "exaltation" text,
  "fall" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which exaltation has a domicile of Saturn and Capricorn as a sign?`:
```sql
                SELECT "exaltation" FROM "table_of_the_most_commonly_used_of_the_t" WHERE "domicile"='saturn' AND "sign"='capricorn';
```
## Task
Generate a SQL query to answer the following question:
`Which detriment has a domicile of mercury and Virgo as a sign?`

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

CREATE TABLE "table_of_the_most_commonly_used_of_the_t" (
  "sign" text,
  "domicile" text,
  "detriment" text,
  "exaltation" text,
  "fall" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which detriment has a domicile of mercury and Virgo as a sign?`:
```sql
                SELECT "detriment" FROM "table_of_the_most_commonly_used_of_the_t" WHERE "domicile"='mercury' AND "sign"='virgo';
```
## Task
Generate a SQL query to answer the following question:
`Which exaltation has a detriment of Saturn and Cancer as a sign?`

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

CREATE TABLE "table_of_the_most_commonly_used_of_the_t" (
  "sign" text,
  "domicile" text,
  "detriment" text,
  "exaltation" text,
  "fall" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which exaltation has a detriment of Saturn and Cancer as a sign?`:
```sql
                SELECT "exaltation" FROM "table_of_the_most_commonly_used_of_the_t" WHERE "detriment"='saturn' AND "sign"='cancer';
```
## Task
Generate a SQL query to answer the following question:
`What was the draw when the points against was 234?`

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

CREATE TABLE "league_table" (
  "club" text,
  "played" text,
  "drawn" text,
  "lost" text,
  "points_for" text,
  "points_against" text,
  "tries_for" text,
  "tries_against" text,
  "try_bonus" text,
  "losing_bonus" text,
  "points" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the draw when the points against was 234?`:
```sql
                SELECT "drawn" FROM "league_table" WHERE "points_against"='234';
```
## Task
Generate a SQL query to answer the following question:
`What was the try bonus when the points for was 608?`

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

CREATE TABLE "league_table" (
  "club" text,
  "played" text,
  "drawn" text,
  "lost" text,
  "points_for" text,
  "points_against" text,
  "tries_for" text,
  "tries_against" text,
  "try_bonus" text,
  "losing_bonus" text,
  "points" text
);
### SQL
Given the database schema, here is the SQL query that answers `What was the try bonus when the points for was 608?`:
```sql
                SELECT "try_bonus" FROM "league_table" WHERE "points_for"='608';
```
## Task
Generate a SQL query to answer the following question:
`Which Team has a Previous team of san diego rockets, and a Position of f?`

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

CREATE TABLE "selections" (
  "player" text,
  "pos" text,
  "nationality" text,
  "team" text,
  "previous_team" text,
  "years_of_nba_experience_a" real,
  "career_with_the_franchise_b" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Team has a Previous team of san diego rockets, and a Position of f?`:
```sql
                SELECT "team" FROM "selections" WHERE "previous_team"='san diego rockets' AND "pos"='f';
```
## Task
Generate a SQL query to answer the following question:
`Which Nationality has a Previous team of new york knicks, and more than 3 Years of NBA experience?`

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

CREATE TABLE "selections" (
  "player" text,
  "pos" text,
  "nationality" text,
  "team" text,
  "previous_team" text,
  "years_of_nba_experience_a" real,
  "career_with_the_franchise_b" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which Nationality has a Previous team of new york knicks, and more than 3 Years of NBA experience?`:
```sql
                SELECT "nationality" FROM "selections" WHERE "previous_team"='new york knicks' AND "years_of_nba_experience_a">3;
```
## Task
Generate a SQL query to answer the following question:
`What is team 1 when team 2 is Manchester United?`

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

CREATE TABLE "round_of_16" (
  "team_1" text,
  "agg" text,
  "team_2" text,
  "1st_leg" text,
  "2nd_leg" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is team 1 when team 2 is Manchester United?`:
```sql
                SELECT "team_1" FROM "round_of_16" WHERE "team_2"='manchester united';
```
## Task
Generate a SQL query to answer the following question:
`What is the agg when team 1 is Milan?`

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

CREATE TABLE "round_of_16" (
  "team_1" text,
  "agg" text,
  "team_2" text,
  "1st_leg" text,
  "2nd_leg" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the agg when team 1 is Milan?`:
```sql
                SELECT "agg" FROM "round_of_16" WHERE "team_1"='milan';
```
## Task
Generate a SQL query to answer the following question:
`Which team is ranked #10?`

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

CREATE TABLE "general_standings" (
  "rank" real,
  "cyclist" text,
  "team" text,
  "time" text,
  "uci_pro_tour_points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which team is ranked #10?`:
```sql
                SELECT "team" FROM "general_standings" WHERE "rank"=10;
```
## Task
Generate a SQL query to answer the following question:
`Which cyclist has UCI ProTour points of 40?`

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

CREATE TABLE "general_standings" (
  "rank" real,
  "cyclist" text,
  "team" text,
  "time" text,
  "uci_pro_tour_points" real
);
### SQL
Given the database schema, here is the SQL query that answers `Which cyclist has UCI ProTour points of 40?`:
```sql
                SELECT "cyclist" FROM "general_standings" WHERE "uci_pro_tour_points"=40;
```
## Task
Generate a SQL query to answer the following question:
`What is the province with a contestant of tatiana vargas rosales?`

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

CREATE TABLE "delegates" (
  "province_community" text,
  "contestant" text,
  "height" text,
  "hometown" text,
  "geographical_regions" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the province with a contestant of tatiana vargas rosales?`:
```sql
                SELECT "province_community" FROM "delegates" WHERE "contestant"='tatiana vargas rosales';
```
## Task
Generate a SQL query to answer the following question:
`Which province has the contestant elixandra tobias carasco?`

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

CREATE TABLE "delegates" (
  "province_community" text,
  "contestant" text,
  "height" text,
  "hometown" text,
  "geographical_regions" text
);
### SQL
Given the database schema, here is the SQL query that answers `Which province has the contestant elixandra tobias carasco?`:
```sql
                SELECT "province_community" FROM "delegates" WHERE "contestant"='elixandra tobias carasco';
```
## Task
Generate a SQL query to answer the following question:
`What is the 2005 sum with a 2009 less than 1,850,654?`

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

CREATE TABLE "statistics" (
  "2010" text,
  "2009" real,
  "2008" real,
  "2007" text,
  "2006" real,
  "2005" real,
  "2004" real,
  "2003" real,
  "2002" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the 2005 sum with a 2009 less than 1,850,654?`:
```sql
                SELECT SUM("2005") FROM "statistics" WHERE "2009"<'1,850,654';
```
## Task
Generate a SQL query to answer the following question:
`What is the average 2003 with 2,154,170 in 2010 and a 2008 less than 2,266,716?`

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

CREATE TABLE "statistics" (
  "2010" text,
  "2009" real,
  "2008" real,
  "2007" text,
  "2006" real,
  "2005" real,
  "2004" real,
  "2003" real,
  "2002" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average 2003 with 2,154,170 in 2010 and a 2008 less than 2,266,716?`:
```sql
                SELECT AVG("2003") FROM "statistics" WHERE "2010"='2,154,170' AND "2008"<'2,266,716';
```
## Task
Generate a SQL query to answer the following question:
`What is the average 2009 with a 2003 greater than 3,791, 107,982 in 2007, and a 2006 less than 98,264?`

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

CREATE TABLE "statistics" (
  "2010" text,
  "2009" real,
  "2008" real,
  "2007" text,
  "2006" real,
  "2005" real,
  "2004" real,
  "2003" real,
  "2002" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the average 2009 with a 2003 greater than 3,791, 107,982 in 2007, and a 2006 less than 98,264?`:
```sql
                SELECT AVG("2009") FROM "statistics" WHERE "2003">'3,791' AND "2007"='107,982' AND "2006"<'98,264';
```
## Task
Generate a SQL query to answer the following question:
`What is the sum of the 2008 with a 2007 of 4,244,115 and less than 3,296,267 in 2003?`

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

CREATE TABLE "statistics" (
  "2010" text,
  "2009" real,
  "2008" real,
  "2007" text,
  "2006" real,
  "2005" real,
  "2004" real,
  "2003" real,
  "2002" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the sum of the 2008 with a 2007 of 4,244,115 and less than 3,296,267 in 2003?`:
```sql
                SELECT SUM("2008") FROM "statistics" WHERE "2007"='4,244,115' AND "2003"<'3,296,267';
```
## Task
Generate a SQL query to answer the following question:
`What is 2011, when 2009 is "A"?`

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

CREATE TABLE "doubles" (
  "tournament" text,
  "2009" text,
  "2010" text,
  "2011" text,
  "2012" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is 2011, when 2009 is "A"?`:
```sql
                SELECT "2011" FROM "doubles" WHERE "2009"='a';
```
## Task
Generate a SQL query to answer the following question:
`What is 2009, when Tournament is "Year-End Ranking"?`

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

CREATE TABLE "doubles" (
  "tournament" text,
  "2009" text,
  "2010" text,
  "2011" text,
  "2012" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is 2009, when Tournament is "Year-End Ranking"?`:
```sql
                SELECT "2009" FROM "doubles" WHERE "tournament"='year-end ranking';
```
## Task
Generate a SQL query to answer the following question:
`What is 2011, when 2012 is "1R"?`

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

CREATE TABLE "doubles" (
  "tournament" text,
  "2009" text,
  "2010" text,
  "2011" text,
  "2012" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is 2011, when 2012 is "1R"?`:
```sql
                SELECT "2011" FROM "doubles" WHERE "2012"='1r';
```
## Task
Generate a SQL query to answer the following question:
`What is 2012, when 2009 is "A"?`

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

CREATE TABLE "doubles" (
  "tournament" text,
  "2009" text,
  "2010" text,
  "2011" text,
  "2012" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is 2012, when 2009 is "A"?`:
```sql
                SELECT "2012" FROM "doubles" WHERE "2009"='a';
```
## Task
Generate a SQL query to answer the following question:
`What is 2011, when 2012 is "A", and when Tournament is "French Open"?`

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

CREATE TABLE "doubles" (
  "tournament" text,
  "2009" text,
  "2010" text,
  "2011" text,
  "2012" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is 2011, when 2012 is "A", and when Tournament is "French Open"?`:
```sql
                SELECT "2011" FROM "doubles" WHERE "2012"='a' AND "tournament"='french open';
```
## Task
Generate a SQL query to answer the following question:
`What is the largest Against with an Opposing Teams of wales?`

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

CREATE TABLE "1989" (
  "opposing_teams" text,
  "against" real,
  "date" text,
  "venue" text,
  "status" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the largest Against with an Opposing Teams of wales?`:
```sql
                SELECT MAX("against") FROM "1989" WHERE "opposing_teams"='wales';
```
## Task
Generate a SQL query to answer the following question:
`What Status has a Date of 18/03/1989?`

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

CREATE TABLE "1989" (
  "opposing_teams" text,
  "against" real,
  "date" text,
  "venue" text,
  "status" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Status has a Date of 18/03/1989?`:
```sql
                SELECT "status" FROM "1989" WHERE "date"='18/03/1989';
```
## Task
Generate a SQL query to answer the following question:
`What Venue has a Status of five nations, and Against of 0?`

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

CREATE TABLE "1989" (
  "opposing_teams" text,
  "against" real,
  "date" text,
  "venue" text,
  "status" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Venue has a Status of five nations, and Against of 0?`:
```sql
                SELECT "venue" FROM "1989" WHERE "status"='five nations' AND "against"=0;
```
## Task
Generate a SQL query to answer the following question:
`What is the smallest Against with a Date of 18/02/1989?`

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

CREATE TABLE "1989" (
  "opposing_teams" text,
  "against" real,
  "date" text,
  "venue" text,
  "status" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the smallest Against with a Date of 18/02/1989?`:
```sql
                SELECT MIN("against") FROM "1989" WHERE "date"='18/02/1989';
```
## Task
Generate a SQL query to answer the following question:
`What are the additional notes for Cotabato?`

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

CREATE TABLE "domestic_violence" (
  "perpetrator" text,
  "date" text,
  "year" real,
  "location" text,
  "country" text,
  "killed" real,
  "additional_notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What are the additional notes for Cotabato?`:
```sql
                SELECT "additional_notes" FROM "domestic_violence" WHERE "location"='cotabato';
```
## Task
Generate a SQL query to answer the following question:
`What country in Kunlong in?`

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

CREATE TABLE "domestic_violence" (
  "perpetrator" text,
  "date" text,
  "year" real,
  "location" text,
  "country" text,
  "killed" real,
  "additional_notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `What country in Kunlong in?`:
```sql
                SELECT "country" FROM "domestic_violence" WHERE "location"='kunlong';
```
## Task
Generate a SQL query to answer the following question:
`Who went on a rampage in Baghdad?`

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

CREATE TABLE "domestic_violence" (
  "perpetrator" text,
  "date" text,
  "year" real,
  "location" text,
  "country" text,
  "killed" real,
  "additional_notes" text
);
### SQL
Given the database schema, here is the SQL query that answers `Who went on a rampage in Baghdad?`:
```sql
                SELECT "perpetrator" FROM "domestic_violence" WHERE "location"='baghdad';
```
## Task
Generate a SQL query to answer the following question:
`What's the rank that has a total of less than 1?`

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

CREATE TABLE "performances_by_nation" (
  "rank" real,
  "gold" real,
  "silver" real,
  "bronze" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the rank that has a total of less than 1?`:
```sql
                SELECT SUM("rank") FROM "performances_by_nation" WHERE "total"<1;
```
## Task
Generate a SQL query to answer the following question:
`What's the bronze medal count when the silver is less than 3 and the gold is 1?`

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

CREATE TABLE "performances_by_nation" (
  "rank" real,
  "gold" real,
  "silver" real,
  "bronze" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the bronze medal count when the silver is less than 3 and the gold is 1?`:
```sql
                SELECT SUM("bronze") FROM "performances_by_nation" WHERE "gold"=1 AND "silver"<3;
```
## Task
Generate a SQL query to answer the following question:
`What's the gold medal count ranked 2 with a total of more than 21?`

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

CREATE TABLE "performances_by_nation" (
  "rank" real,
  "gold" real,
  "silver" real,
  "bronze" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the gold medal count ranked 2 with a total of more than 21?`:
```sql
                SELECT COUNT("gold") FROM "performances_by_nation" WHERE "rank"=2 AND "total">21;
```
## Task
Generate a SQL query to answer the following question:
`What's the smallest total with a bronze count of 5 and a gold count less than 8?`

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

CREATE TABLE "performances_by_nation" (
  "rank" real,
  "gold" real,
  "silver" real,
  "bronze" real,
  "total" real
);
### SQL
Given the database schema, here is the SQL query that answers `What's the smallest total with a bronze count of 5 and a gold count less than 8?`:
```sql
                SELECT MIN("total") FROM "performances_by_nation" WHERE "bronze"=5 AND "gold"<8;
```
## Task
Generate a SQL query to answer the following question:
`What is the party for the representative who was first elected before 2002 and the results were re-elected?`

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

CREATE TABLE "oklahoma" (
  "district" text,
  "incumbent" text,
  "party" text,
  "first_elected" real,
  "results" text
);
### SQL
Given the database schema, here is the SQL query that answers `What is the party for the representative who was first elected before 2002 and the results were re-elected?`:
```sql
                SELECT "party" FROM "oklahoma" WHERE "results"='re-elected' AND "first_elected"<2002;
```
## Task
Generate a SQL query to answer the following question:
`Incumbent John Sullivan has what as biggest first elected?`

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

CREATE TABLE "oklahoma" (
  "district" text,
  "incumbent" text,
  "party" text,
  "first_elected" real,
  "results" text
);
### SQL
Given the database schema, here is the SQL query that answers `Incumbent John Sullivan has what as biggest first elected?`:
```sql
                SELECT MAX("first_elected") FROM "oklahoma" WHERE "incumbent"='john sullivan';
```
## Task
Generate a SQL query to answer the following question:
`What Location has Years Member of 1963–1968?`

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

CREATE TABLE "former_members" (
  "school" text,
  "location" text,
  "nickname_s" text,
  "colors" text,
  "years_member" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Location has Years Member of 1963–1968?`:
```sql
                SELECT "location" FROM "former_members" WHERE "years_member"='1963–1968';
```
## Task
Generate a SQL query to answer the following question:
`What School has Colors of navy blue orange?`

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

CREATE TABLE "former_members" (
  "school" text,
  "location" text,
  "nickname_s" text,
  "colors" text,
  "years_member" text
);
### SQL
Given the database schema, here is the SQL query that answers `What School has Colors of navy blue orange?`:
```sql
                SELECT "school" FROM "former_members" WHERE "colors"='navy blue orange';
```
## Task
Generate a SQL query to answer the following question:
`What Years Member has a School of cairo high school?`

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

CREATE TABLE "former_members" (
  "school" text,
  "location" text,
  "nickname_s" text,
  "colors" text,
  "years_member" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Years Member has a School of cairo high school?`:
```sql
                SELECT "years_member" FROM "former_members" WHERE "school"='cairo high school';
```
## Task
Generate a SQL query to answer the following question:
`What Colors has a School of sesser high school?`

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

CREATE TABLE "former_members" (
  "school" text,
  "location" text,
  "nickname_s" text,
  "colors" text,
  "years_member" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Colors has a School of sesser high school?`:
```sql
                SELECT "colors" FROM "former_members" WHERE "school"='sesser high school';
```
## Task
Generate a SQL query to answer the following question:
`What Colors has a School of zeigler high school?`

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

CREATE TABLE "former_members" (
  "school" text,
  "location" text,
  "nickname_s" text,
  "colors" text,
  "years_member" text
);
### SQL
Given the database schema, here is the SQL query that answers `What Colors has a School of zeigler high school?`:
```sql
                SELECT "colors" FROM "former_members" WHERE "school"='zeigler high school';
```