MMTU-benchmark/MMTU huggingface dataset:
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
|   Year | Competition                   | Venue                   | Position   | Notes   |
|-------:|:------------------------------|:------------------------|:-----------|:--------|
|   2005 | world youth championships     | marrakesh, morocco      | 2nd        | 56.16 m |
|   2006 | world junior championships    | beijing , pr china      | 2nd        | 57.79 m |
|   2007 | european junior championships | hengelo , netherlands   | 1st        | 58.48 m |
|   2008 | world junior championships    | bydgoszcz, poland       | 1st        | 63.01 m |
|   2008 | olympic games                 | beijing , pr china      | 16th (q)   | 59.05 m |
|   2009 | universiade                   | belgrade, serbia        | 2nd        | 61.02 m |
|   2009 | european u23 championships    | kaunas, lithuania       | 2nd        | 61.43 m |
|   2009 | world championships           | berlin, germany         | 9th        | 58.25 m |
|   2010 | european championships        | barcelona, spain        | 17th (q)   | 52.31 m |
|   2011 | universiade                   | shenzhen, china         | 4th        | 58.25 m |
|   2011 | world championships           | daegu, south korea      | 16th (q)   | 58.50 m |
|   2012 | european championships        | helsinki, finland       | 1st        | 66.86 m |
|   2012 | olympic games                 | london , united kingdom | 19th (q)   | 58.97 m |
|   2013 | world championships           | moscow, russia          | 11th       | 58.33 m |

Question: Which Venue has Notes of 58.48 m?

table_id: 2-19007736-1
label: SELECT "Venue" FROM "table" WHERE "Notes" = "58.48 m"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
|   Order | Couple             |   Karen |   Nicky |   Jason |   Ruthie |   Robin |   Total | Skating song                                       | Scoreboard   | Public vote   |
|--------:|:-------------------|--------:|--------:|--------:|---------:|--------:|--------:|:---------------------------------------------------|:-------------|:--------------|
|       1 | jeremy & darya     |     3.5 |     3.5 |     3   |      2   |     3   |    15   | " true "— spandau ballet                           | =3rd         | 3.233%        |
|       2 | donal & florentine |     2.5 |     3   |     2.5 |      2   |     3.5 |    13.5 | " rockstar "— nickelback                           | 6th          | 7.691%        |
|       3 | todd & susie       |     2   |     1.5 |     1   |      1.5 |     1.5 |     7.5 | " (everything i do) i do it for you "— bryan adams | 7th          | 18.155%       |
|       4 | ellery & frankie   |     3.5 |     4   |     3   |      3   |     4   |    17.5 | " born to run "— bruce springsteen                 | 2nd          | 9.515%        |
|       5 | ray & maria        |     4.5 |     5   |     4.5 |      4.5 |     5   |    23.5 | " mmmbop "— hanson                                 | 1st          | 42.658%       |
|       6 | graeme & kristina  |     3   |     2.5 |     3   |      2.5 |     3.5 |    14.5 | " i've got you under my skin "— frank sinatra      | 5th          | 5.886%        |

Question: what is robin's stat when jason was 2.5

table_id: 1-19744915-3
label: SELECT "Robin" FROM "table" WHERE "Jason" = "2.5"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Date         | Tournament                         | Winning score         | Margin of victory   | Runner(s)-up                             |
|:-------------|:-----------------------------------|:----------------------|:--------------------|:-----------------------------------------|
| feb 21, 1987 | tsumura hawaiian ladies open       | –9 (69-71-67=207)     | 2 strokes           | jane geddes                              |
| may 31, 1987 | lpga corning classic               | –13 (70-69-69-67=275) | 1 stroke            | jane geddes , betsy king , patty sheehan |
| may 14, 1989 | chrysler-plymouth classic          | –5 (70-72-72=214)     | 2 strokes           | laura davies                             |
| may 20, 1990 | planters pat bradley international | 25 points (3-4-12-6)  | 1 point             | beth daniel                              |
| aug 18, 1991 | northgate computer classic         | –13 (75-68-68=211)    | playoff             | jody anschutz , beth daniel              |

Question: What tournament had a winning score of –9 (69-71-67=207)?

table_id: 2-17581785-1
label: SELECT "Tournament" FROM "table" WHERE "Winning score" = "–9 (69-71-67=207)"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
|   Game |   December | Opponent              | Score   | Record   |
|-------:|-----------:|:----------------------|:--------|:---------|
|     25 |          1 | @ st. louis blues     | 2 - 0   | 10-13-2  |
|     26 |          3 | montreal canadiens    | 3 - 3   | 10-13-3  |
|     27 |          5 | chicago black hawks   | 3 - 3   | 10-13-4  |
|     28 |          7 | @ hartford whalers    | 7 - 4   | 11-13-4  |
|     29 |          9 | new york islanders    | 5 - 4   | 12-13-4  |
|     30 |         11 | @ detroit red wings   | 2 - 1   | 13-13-4  |
|     31 |         12 | @ chicago black hawks | 5 - 2   | 14-13-4  |
|     32 |         15 | @ washington capitals | 5 - 4   | 14-14-4  |
|     33 |         16 | philadelphia flyers   | 1 - 1   | 14-14-5  |
|     34 |         19 | vancouver canucks     | 5 - 3   | 15-14-5  |
|     35 |         22 | @ pittsburgh penguins | 4 - 3   | 16-14-5  |
|     36 |         23 | boston bruins         | 4 - 3   | 16-15-5  |
|     37 |         30 | washington capitals   | 5 - 2   | 17-15-5  |

Question: What was the score when the opponent was Montreal Canadiens?

table_id: 2-17562956-4
label: SELECT "Score" FROM "table" WHERE "Opponent" = "montreal canadiens"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
|   Pick | Team               | Player                                     | Position      | College           |
|-------:|:-------------------|:-------------------------------------------|:--------------|:------------------|
|    137 | boston patriots    | david lee category:articles with hcards    | end           | louisiana tech    |
|    138 | houston oilers     | russ mundy category:articles with hcards   | halfback      | west texas a&m    |
|    139 | oakland raiders    | john dugan category:articles with hcards   | tackle        | holy cross        |
|    140 | new york jets      | larry dupree category:articles with hcards | halfback      | florida           |
|    141 | kansas city chiefs | jerry smith category:articles with hcards  | tight end     | arizona state     |
|    142 | san diego chargers | bob evans category:articles with hcards    | defensive end | texas a&m         |
|    143 | boston patriots    | ed meixler category:articles with hcards   | linebacker    | boston university |
|    144 | buffalo bills      | ray hinze category:articles with hcards    | tackle        | texas a&m         |

Question: what is the position of the player from florida?

table_id: 2-18652198-18
label: SELECT "Position" FROM "table" WHERE "College" = "florida"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| South West DFL         |   Wins |   Byes |   Losses |   Draws |   Against |
|:-----------------------|-------:|-------:|---------:|--------:|----------:|
| tyrendarra             |     16 |      0 |        2 |       0 |      1091 |
| heathmere              |     12 |      0 |        6 |       0 |      1253 |
| coleraine              |     12 |      0 |        6 |       0 |      1396 |
| sandford               |     10 |      0 |        8 |       0 |      1453 |
| dartmoor               |      8 |      0 |       10 |       0 |      1626 |
| westerns               |      8 |      0 |       10 |       0 |      1568 |
| cavendish              |      3 |      0 |       15 |       0 |      1706 |
| branxholme-wallacedale |      3 |      0 |       15 |       0 |      1800 |

Question: What is the lowest value for Draws, when South West DFL is "Tyrendarra", and when Byes is greater than 0?

table_id: 2-17746037-11
label: SELECT MIN("Draws") FROM "table" WHERE "South West DFL" = "tyrendarra" AND "Byes" > 0
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Station Code   | Station Name              | Arrival          | Departure   | Platform   |
|:---------------|:--------------------------|:-----------------|:------------|:-----------|
| ndls           | new delhi railway station | starting station | 17:30       | 16         |
| cnb            | kanpur central            | 22:55            | 23:03       | 5          |
| mgs            | mughal sarai junction     | 03:30            | 03:40       | n/a        |
| pnbe           | patna junction            | 06:55            | 07:05       | 1          |
| rjpb           | rajendranagar terminal    | starting station | 07:35       | n/a        |

Question: What is the Departure time at Kanpur Central Station?

table_id: 2-14313164-2
label: SELECT "Departure" FROM "table" WHERE "Station Name" = "kanpur central"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Date              | Tournament         | Surface    | Opponent in the final       | Score         |
|:------------------|:-------------------|:-----------|:----------------------------|:--------------|
| 15 september 1996 | zadar              | clay       | magdalena zděnovcová        | 4–6, 6–3, 6–3 |
| 29 june 1997      | plzeň              | clay       | kateřina šišková            | 6–2, 6–7, 6–4 |
| 31 may 1998       | warsaw             | clay       | rosa maria andres rodriguez | 7–5, 6–3      |
| 2 february 2003   | rockford, illinois | hard (i)   | petra rampre                | 6–3, 3–6, 6–4 |
| 23 february 2003  | columbus, ohio     | hard (i)   | teryn ashley                | 3–6, 7–5, 7–5 |
| 16 march 2003     | kaunas             | carpet (i) | magdalena zděnovcová        | 6–3, 6–3      |
| 21 november 2004  | prague             | hard (i)   | sandra klösel               | 6–3, 6–2      |
| 30 september 2007 | podgorica          | clay       | martina suchá               | 5–7, 7–5, 7–6 |

Question: What opponent in the final has rockford, Illinois as the tournament?

table_id: 2-13848569-2
label: SELECT "Opponent in the final" FROM "table" WHERE "Tournament" = "rockford, illinois"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Date        | Visitor      | Score   | Home         | Record   |   Points |
|:------------|:-------------|:--------|:-------------|:---------|---------:|
| november 1  | minnesota    | 3–6     | pittsburgh   | 2–4–3    |        7 |
| november 2  | pittsburgh   | 3–4     | detroit      | 2–5–3    |        7 |
| november 5  | detroit      | 4–2     | pittsburgh   | 2–6–3    |        7 |
| november 8  | chicago      | 4–1     | pittsburgh   | 2–7–3    |        7 |
| november 12 | pittsburgh   | 3–0     | toronto      | 3–7–3    |        9 |
| november 13 | pittsburgh   | 0–4     | st. louis    | 3–8–3    |        9 |
| november 15 | los angeles  | 1–3     | pittsburgh   | 4–8–3    |       11 |
| november 19 | st. louis    | 4–0     | pittsburgh   | 4–9–3    |       11 |
| november 22 | philadelphia | 3–5     | pittsburgh   | 5–9–3    |       13 |
| november 23 | pittsburgh   | 2–3     | chicago      | 5–10–3   |       13 |
| november 26 | pittsburgh   | 4–4     | minnesota    | 5–10–4   |       14 |
| november 29 | oakland      | 3–5     | pittsburgh   | 6–10–4   |       16 |
| november 30 | pittsburgh   | 3–3     | philadelphia | 6–10–5   |       17 |

Question: What record has pittsburgh as the visitor, and November 23 as the date?

table_id: 2-14335332-3
label: SELECT "Record" FROM "table" WHERE "Visitor" = "pittsburgh" AND "Date" = "november 23"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| English Name     | Simplified Chinese   | Traditional Chinese   | Pinyin        |   Area |   Population |   Density |
|:-----------------|:---------------------|:----------------------|:--------------|-------:|-------------:|----------:|
| langya district  | 琅琊区               | 瑯琊區                | lángyá qū     |    181 |       310427 |      1715 |
| nanqiao district | 南谯区               | 南譙區                | nánqiáo qū    |   1187 |       251894 |       212 |
| tianchang city   | 天长市               | 天長市                | tiāncháng shì |   1770 |       602840 |       341 |
| mingguang city   | 明光市               | 明光市                | míngguāng shì |   2335 |       532732 |       228 |
| lai'an county    | 来安县               | 來安縣                | láiān xiàn    |   1481 |       432021 |       292 |
| quanjiao county  | 全椒县               | 全椒縣                | quánjiāo xiàn |   1572 |       383885 |       244 |
| dingyuan county  | 定远县               | 定遠縣                | dìngyuǎn xiàn |   2998 |       779174 |       260 |

Question: What is the number of English names that have a Traditional Chinese name of 全椒縣?

table_id: 1-1982739-2
label: SELECT COUNT("English Name") FROM "table" WHERE "Traditional Chinese" = "全椒縣"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Source         | Date   | GERB   | Attack   | Blue Coalition   |
|:---------------|:-------|:-------|:---------|:-----------------|
| alpha research | march  | 19,2%  | 6,8%     | 4,9%             |
| alpha research | april  | 24%    | 8%       | 7%               |
| nciom          | 19 may | 32,4%  | 11%      | 6,2%             |
| skala          | 28 may | 31,99% | 9,70%    | 10,21%           |
| mbmd           | 31 may | 30,00% | 8,10%    | 6,07%            |
| skala          | 1 june | 30,30% | 9,77%    | 8,94%            |
| skala          | 2 june | 31,15% | 9,46%    | 8,80%            |
| barometar info | 3 june | 26,07% | 8,53%    | 9,24%            |
| skala          | 4 june | 29,50% | 10,30%   | 8,22%            |

Question: What Attack has a Source of NCIOM?

table_id: 2-15125012-1
label: SELECT "Attack" FROM "table" WHERE "Source" = "nciom"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| SEASON   | TEAM                    | LEAGUE   | GAMES   | GOALS   |
|:---------|:------------------------|:---------|:--------|:--------|
| season   | team                    | league   | games   | goals   |
| 1909     | vancouver lacrosse club | bcla     | 10      | 9       |
| 1910     | vancouver lacrosse club | bcla     | 11      | 10      |
| 1911     | vancouver lacrosse club | bcla     | 14      | 4       |
| 1912     | vancouver lacrosse club | bcla     | 6       | 5       |
| 1913     | vancouver lacrosse club | bcla     | 7       | 4       |
| 1915     | vancouver lacrosse club | bcla     | 8       | 6       |

Question: What is the name of the team with a Games listing of 7?

table_id: 2-18476723-1
label: SELECT "TEAM" FROM "table" WHERE "GAMES" = "7"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Home team       | Home team score   | Away team   | Away team score   | Venue                 |   Crowd | Date        |
|:----------------|:------------------|:------------|:------------------|:----------------------|--------:|:------------|
| fitzroy         | 8.15 (63)         | st kilda    | 3.6 (24)          | brunswick street oval |   10300 | 7 june 1952 |
| north melbourne | 12.8 (80)         | hawthorn    | 7.8 (50)          | arden street oval     |   11000 | 7 june 1952 |
| melbourne       | 12.10 (82)        | collingwood | 6.14 (50)         | mcg                   |   58543 | 7 june 1952 |
| essendon        | 7.18 (60)         | richmond    | 10.9 (69)         | windy hill            |   29000 | 9 june 1952 |
| carlton         | 18.12 (120)       | geelong     | 13.15 (93)        | princes park          |   37500 | 9 june 1952 |
| south melbourne | 16.14 (110)       | footscray   | 11.13 (79)        | lake oval             |   26000 | 9 june 1952 |

Question: What is the Date in which the Crowed was over 10,300 and the Home team was Melbourne?

table_id: 2-10750694-7
label: SELECT "Date" FROM "table" WHERE "Crowd" > 10300 AND "Home team" = "melbourne"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| State                |   Preliminaries |   Interview |   Swimsuit |   Evening Gown |   Average |
|:---------------------|----------------:|------------:|-----------:|---------------:|----------:|
| mississippi          |           8.852 |       9.123 |      9.366 |          9.343 |     9.277 |
| north dakota         |           8.622 |       9.005 |      9.132 |          9.073 |     9.07  |
| oklahoma             |           8.467 |       8.554 |      8.948 |          9.027 |     8.843 |
| north carolina       |           8.425 |       8.766 |      8.788 |          8.854 |     8.802 |
| louisiana            |           8.35  |       8.712 |      8.908 |          8.754 |     8.791 |
| california           |           8.647 |       8.582 |      8.763 |          9.008 |     8.784 |
| district of columbia |           8.438 |       8.997 |      8.487 |          8.631 |     8.705 |
| massachusetts        |           8.4   |       8.608 |      8.703 |          8.698 |     8.669 |
| new york             |           8.292 |       8.811 |      8.503 |          8.675 |     8.663 |

Question: What is the interview score when the preliminaries score is 8.400?

table_id: 1-12094300-1
label: SELECT "Interview" FROM "table" WHERE "Preliminaries" = "8.400"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
|   1st built | 1913 Class   | W.A.   |   No. Built | Builder                    | Date    | LNER Class   |
|------------:|:-------------|:-------|------------:|:---------------------------|:--------|:-------------|
|         868 | i            | 4-4-2  |          20 | nbl (14) r. stephenson (6) | 1906–11 | c10          |
|           1 | m            | 4-4-2t |          30 | yorkshire engine co.       | 1911–13 | c15          |
|         438 | l            | 4-4-2t |          21 | nbl                        | 1915–21 | c16          |
|         895 | j            | 4-4-0  |          16 | nbl (6) nbr cowlairs (10)  | 1909–11 | d29          |
|         400 | j            | 4-4-0  |          27 | nbr cowlairs               | 1912–20 | d30          |
|         882 | k            | 4-4-0  |          12 | nbr cowlairs               | 1906–07 | d32          |
|         331 | k            | 4-4-0  |          12 | nbr cowlairs               | 1909–10 | d33          |
|         149 | k            | 4-4-0  |          32 | nbr cowlairs               | 1913–20 | d34          |
|         239 | m            | 0-4-4t |          12 | nbl                        | 1909    | g9           |
|         848 | b            | 0-6-0  |          76 | nbl (40) nbr cowlairs (36) | 1906–13 | j35          |
|           8 | s            | 0-6-0  |         104 | nbr cowlairs (35) nbl (69) | 1914–21 | j37          |
|         836 | f            | 0-6-0t |          35 | nbr cowlairs               | 1905–19 | j88          |
|         858 | a            | 0-6-2t |           6 | nbl                        | 1909–20 | n14          |
|           7 | a            | 0-6-2t |          69 | nbl                        | 1910–24 | n15          |

Question: What is the W.A. of the 1 1st built?

table_id: 2-16062061-6
label: SELECT "W.A." FROM "table" WHERE "1st built" = 1
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
|   No. | Title                                       | Directed by   | Written by               | Original air date   | Production code   | U.S. viewers (million)   |
|------:|:--------------------------------------------|:--------------|:-------------------------|:--------------------|:------------------|:-------------------------|
|     1 | "don't be yourself"                         | james burrows | ricky blitt              | april19,2010        | 2j5351            | 10.67                    |
|     2 | "the charade"                               | james burrows | ricky blitt              | april26,2010        | 2j5353            | 9.06                     |
|     3 | "perry and rebecca's high school reunion"   | james burrows | ted cohen & andrew reich | may3,2010           | 2j5355            | 9.64                     |
|     4 | "rebecca's one night stand"                 | james burrows | ted cohen & andrew reich | may17,2010          | 2j5354            | n/a                      |
|     5 | "perry dates his assistant"                 | james burrows | ted cohen & andrew reich | unaired             | 2j5352            | n/a                      |
|     6 | "hey now hey now perry's girlfriend's back" | n/a           | n/a                      | unaired             | 2j5356            | n/a                      |

Question: How many dates did "Rebecca's one night stand" originally air on?

table_id: 1-24625467-1
label: SELECT COUNT("Original air date") FROM "table" WHERE "Title" = """Rebecca''s One Night Stand"""
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Player          |   Touchdowns |   Extra points |   Field goals |   Points |
|:----------------|-------------:|---------------:|--------------:|---------:|
| tom hammond     |           15 |             63 |             5 |      163 |
| herb graver     |           15 |              1 |             0 |       76 |
| willie heston   |           14 |              0 |             0 |       70 |
| joe curtis      |            8 |             13 |             0 |       53 |
| joe maddock     |           10 |              0 |             0 |       50 |
| duncan thompson |           10 |              0 |             0 |       50 |
| fred norcross   |            9 |              0 |             0 |       45 |
| rolla bigelow   |            5 |              0 |             0 |       25 |

Question: How many touchdowns were made where field goals were less than 0?

table_id: 2-14342480-15
label: SELECT SUM("Touchdowns") FROM "table" WHERE "Field goals" < 0
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Home team       | Home team score   | Away team       | Away team score   | Venue             |   Crowd | Date         |
|:----------------|:------------------|:----------------|:------------------|:------------------|--------:|:-------------|
| st kilda        | 15.13 (103)       | essendon        | 22.17 (149)       | junction oval     |   17000 | 13 june 1938 |
| north melbourne | 14.3 (87)         | richmond        | 12.11 (83)        | arden street oval |   11000 | 9 july 1938  |
| footscray       | 19.19 (133)       | south melbourne | 10.10 (70)        | western oval      |   16000 | 9 july 1938  |
| collingwood     | 10.19 (79)        | fitzroy         | 10.13 (73)        | victoria park     |   15000 | 9 july 1938  |
| carlton         | 12.12 (84)        | hawthorn        | 8.15 (63)         | princes park      |   14000 | 9 july 1938  |
| melbourne       | 11.8 (74)         | geelong         | 13.14 (92)        | mcg               |   20185 | 9 july 1938  |

Question: Who is playing against st kilda against their home more than 16,000?

table_id: 2-10806592-12
label: SELECT "Away team" FROM "table" WHERE "Crowd" > 16000 AND "Home team" = "st kilda"