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:
| Home team       | Home team score   | Away team   | Away team score   | Venue                 |   Crowd | Date           |
|:----------------|:------------------|:------------|:------------------|:----------------------|--------:|:---------------|
| north melbourne | 11.13 (79)        | st kilda    | 12.12 (84)        | arden street oval     |    5000 | 25 august 1934 |
| fitzroy         | 20.19 (139)       | melbourne   | 16.10 (106)       | brunswick street oval |    9500 | 25 august 1934 |
| south melbourne | 23.18 (156)       | footscray   | 9.16 (70)         | lake oval             |   17420 | 25 august 1934 |
| hawthorn        | 11.15 (81)        | essendon    | 11.13 (79)        | glenferrie oval       |    5000 | 25 august 1934 |
| richmond        | 12.14 (86)        | collingwood | 11.9 (75)         | punt road oval        |   26500 | 25 august 1934 |
| geelong         | 13.17 (95)        | carlton     | 10.10 (70)        | corio oval            |   18500 | 25 august 1934 |

Question: What is the away team score when Home team is fitzroy?

table_id: 2-10790510-15
label: SELECT "Away team score" FROM "table" WHERE "Home team" = "fitzroy"
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          | Name          | Nationality    | Casualties   |   Tonnage | Sunk by…   |
|:--------------|:--------------|:---------------|:-------------|----------:|:-----------|
| 29 april 1943 | mckeesport    | united states  | 1            |      6198 | u-258      |
| 4 may 1943    | lorient       | united kingdom | 46           |      4737 | u-125      |
| 4 may 1943    | north britain | united kingdom | 29+          |      4635 | u-707      |
| 5 may 1943    | harbury       | united kingdom | 7            |      5081 | u-628      |
| 5 may 1943    | west maximus  | united states  | 5            |      5561 | u-264      |
| 5 may 1943    | harperley     | united kingdom | 11           |      4586 | u-264      |
| 5 may 1943    | bristol city  | united kingdom | 15           |      2864 | u-358      |
| 5 may 1943    | wentworth     | united kingdom | 5            |      5212 | u-358      |
| 5 may 1943    | dolius        | united kingdom | 4            |      5507 | u-638      |
| 5 may 1943    | west makadet  | united states  | 0            |      5565 | u-584      |
| 5 may 1943    | selvistan     | united kingdom | 6            |      5136 | u-266      |
| 5 may 1943    | gharinda      | united kingdom | 0            |      5306 | u-266      |
| 5 may 1943    | bonde         | norway         | 5            |      1570 | u-266      |

Question: What were the casulaties on the McKeesport, which had a tonnage larger than 5,136?

table_id: 2-12018584-1
label: SELECT "Casualties" FROM "table" WHERE "Tonnage" > 5136 AND "Name" = "mckeesport"
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:
| Place   | Player             | Country       | Score           | To par   |   Money ( $ ) |
|:--------|:-------------------|:--------------|:----------------|:---------|--------------:|
| 1       | scott simpson      | united states | 71-68-70-68=277 | –3       |        150000 |
| 2       | tom watson         | united states | 72-65-71-70=278 | –2       |         75000 |
| 3       | seve ballesteros   | spain         | 68-75-68-71=282 | +2       |         46240 |
| t4      | ben crenshaw       | united states | 67-72-72-72=283 | +3       |         24542 |
| t4      | bernhard langer    | west germany  | 69-69-73-72=283 | +3       |         24542 |
| t4      | larry mize         | united states | 71-68-72-72=283 | +3       |         24542 |
| t4      | curtis strange     | united states | 71-72-69-71=283 | +3       |         24542 |
| t4      | bobby wadkins      | united states | 71-71-70-71=283 | +3       |         24542 |
| t9      | lennie clements    | united states | 70-70-70-74=284 | +4       |         15004 |
| t9      | tsuneyuki nakajima | japan         | 68-70-74-72=284 | +4       |         15004 |
| t9      | mac o'grady        | united states | 71-69-72-72=284 | +4       |         15004 |
| t9      | dan pohl           | united states | 75-71-69-69=284 | +4       |         15004 |
| t9      | jim thorpe         | united states | 70-68-73-73=284 | +4       |         15004 |

Question: How much money does player ben crenshaw, who has a t4 place, have?

table_id: 2-17231211-7
label: SELECT "Money ( $ )" FROM "table" WHERE "Place" = "t4" AND "Player" = "ben crenshaw"
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                  |
|:-------------|:--------------------------------------|:----------------------|:--------------------|:------------------------------|
| may 21, 1967 | colonial national invitation          | –2 (65-66-74-73=278)  | 2 strokes           | charles coody                 |
| jun 30, 1968 | cleveland open invitational           | –8 (69-68-67-72=276)  | 2 strokes           | bob dickson                   |
| jul 14, 1968 | greater milwaukee open                | –13 (68-67-71-69=275) | 4 strokes           | sam snead                     |
| aug 16, 1970 | pga championship                      | –1 (70-70-66-73=279)  | 2 strokes           | bob murphy , arnold palmer    |
| aug 15, 1971 | massachusetts classic                 | –13 (71-69-69-66=275) | 1 stroke            | raymond floyd                 |
| jul 8, 1973  | greater milwaukee open                | –12 (69-63-71-73=276) | 1 stroke            | homero blancas , hubert green |
| feb 17, 1974 | glen campbell-los angeles open        | –8 (68-68-71-69=276)  | 2 strokes           | john mahaffey , sam snead     |
| jul 14, 1974 | quad cities open                      | –13 (68-68-71-64=271) | 1 stroke            | bruce fleisher                |
| aug 18, 1974 | sammy davis jr.-greater hartford open | –12 (65-65-69-69=268) | 4 strokes           | raymond floyd                 |
| aug 15, 1976 | pga championship                      | +1 (70-72-69-70=281)  | 1 stroke            | raymond floyd , don january   |

Question: Who was the runner-up on Jul 14, 1968?

table_id: 2-1586876-1
label: SELECT "Runner(s)-up" FROM "table" WHERE "Date" = "jul 14, 1968"
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:
| Tournament      | 2007        | 2009        | 2010        | 2011        |
|:----------------|:------------|:------------|:------------|:------------|
| grand slams     | grand slams | grand slams | grand slams | grand slams |
| australian open | w           | w           | f           | f           |
| french open     | f           | f           | f           | f           |
| wimbledon       | w           | f           | w           | f           |
| us open         | f           | f           | f           | f           |
| win–loss        | 6–2         | 5–3         | 5–3         | 4–4         |

Question: What was the result in 2007 when the 2011 was F and 2009 was W?

table_id: 2-10510022-2
label: SELECT "2007" FROM "table" WHERE "2011" = "f" AND "2009" = "w"
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: Who was the opponent on December 1, before Game 28?

table_id: 2-17562956-4
label: SELECT "Opponent" FROM "table" WHERE "Game" < 28 AND "December" = 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:
| Name                      | Years   | Area               | Authority        |   Decile |   Roll |
|:--------------------------|:--------|:-------------------|:-----------------|---------:|-------:|
| buller high school        | 9–15    | westport           | state            |        3 |    361 |
| granity school            | 1–8     | granity            | state            |        4 |     37 |
| inangahua junction school | 1–6     | inangahua junction | state            |        6 |     14 |
| karamea area school       | 1–15    | karamea            | state            |        5 |     93 |
| maruia school             | 1–8     | maruia             | state            |        9 |     19 |
| reefton area school       | 1–15    | reefton            | state            |        3 |    206 |
| sacred heart school       | 1–8     | reefton            | state integrated |        4 |     34 |
| st canice's school        | 1–8     | westport           | state integrated |        4 |    160 |
| waimangaroa school        | 1–8     | waimangaroa        | state            |        2 |     18 |
| westport north school     | 1–8     | westport           | state            |        4 |    260 |
| westport south school     | 1–8     | westport           | state            |        4 |    274 |

Question: What is the average roll of a school with state authority and a decile of 9?

table_id: 2-12300697-1
label: SELECT AVG("Roll") FROM "table" WHERE "Authority" = "state" AND "Decile" = 9
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            | Position   | Round   |   Overall | MLB Team             |
|:------------------|:-----------|:--------|----------:|:---------------------|
| ryan verdugo      | lhp        | 9th     |       267 | san francisco giants |
| matt clark        | 1b         | 12th    |       375 | san diego padres     |
| louis coleman     | rhp        | 14th    |       421 | washington nationals |
| blake martin      | lhp        | 17th    |       516 | minnesota twins      |
| jared bradford    | rhp        | 18th    |       545 | st. louis cardinals  |
| michael hollander | 3b         | 20th    |       603 | texas rangers        |
| jordan brown      | rhp        | 39th    |      1181 | chicago cubs         |

Question: What was the lowest overall for Louis Coleman?

table_id: 2-12225593-17
label: SELECT MIN("Overall") FROM "table" WHERE "Player" = "louis coleman"
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 | Tournament                    | Venue                 | Result   | Extra           |
|-------:|:------------------------------|:----------------------|:---------|:----------------|
|   1971 | european indoor championships | sofia , bulgaria      | 2nd      | 4 x 200 m relay |
|   1971 | european championships        | helsinki , finland    | 3rd      | 100 m           |
|   1971 | european championships        | helsinki , finland    | 1st      | 4 x 100 m relay |
|   1972 | european indoor championships | grenoble , france     | 1st      | 4 x 180 m relay |
|   1973 | universiade                   | moscow , soviet union | 2nd      | 100 m           |
|   1974 | european championships        | rome , italy          | 2nd      | 4 x 100 m relay |

Question: what is the result when extra is 4 x 100 m relay and the year is later than 1971?

table_id: 2-12070470-1
label: SELECT "Result" FROM "table" WHERE "Extra" = "4 x 100 m relay" AND "Year" > 1971
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:
| Rank   | Nation         |   Gold |   Silver |   Bronze |   Total |
|:-------|:---------------|-------:|---------:|---------:|--------:|
| 1      | soviet union   |     11 |        4 |        2 |      17 |
| 2      | hungary        |      2 |        1 |        1 |       4 |
| 3      | poland         |      2 |        1 |        0 |       3 |
| 4      | north korea    |      2 |        0 |        0 |       2 |
| 5      | bulgaria       |      1 |        4 |        5 |      10 |
| 6      | united states  |      1 |        3 |        3 |       7 |
| 7      | cuba           |      1 |        0 |        1 |       2 |
| 7      | sweden         |      1 |        0 |        1 |       2 |
| 9      | east germany   |      0 |        2 |        1 |       3 |
| 10     | japan          |      0 |        1 |        1 |       2 |
| 10     | romania        |      0 |        1 |        1 |       2 |
| 12     | finland        |      0 |        1 |        0 |       1 |
| 12     | norway         |      0 |        1 |        0 |       1 |
| 14     | czechoslovakia |      0 |        0 |        2 |       2 |
| 15     | greece         |      0 |        0 |        1 |       1 |
| 15     | mongolia       |      0 |        0 |        1 |       1 |
| 15     | west germany   |      0 |        0 |        1 |       1 |
| total  | total          |     21 |       19 |       21 |      61 |

Question: What nation has 1 as the gold and 2 as the total?

table_id: 2-15759218-1
label: SELECT "Nation" FROM "table" WHERE "Gold" = 1 AND "Total" = 2
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:
| Name                     | Profession       | City     | Entered the house   | Evicted   |
|:-------------------------|:-----------------|:---------|:--------------------|:----------|
| borko sarić              | actor            | belgrade | day 1               | day 26    |
| mimi đurović             | fashion designer | nikšić   | day 1               | day 30    |
| milić vukašinović        | musician         | belgrade | day 1               | day 30    |
| katarina "kaja" ostojić  | singer           | belgrade | day 1               | day 29    |
| slobodan "bićko" bićanin | actor            | belgrade | day 1               | day 22    |
| slađana pejić            | model            | doboj    | day 1               | day 29    |
| skaj vikler              | rapper           | belgrade | day 1               | day 29    |
| ajs nigrutin             | rapper           | belgrade | day 1               | day 30    |
| zorica marković          | folk singer      | belgrade | day 1               | day 15    |
| petar perović            | model            | belgrade | day 1               | day 29    |
| maša stanisavljević      | tv presenter     | belgrade | day 1               | day 8     |
| era ojdanić              | folk musician    | leskovac | day 1               | day 28    |
| anastasija buđić         | model            | belgrade | day 15              | day 28    |

Question: What is slađana pejić's profession?

table_id: 2-16042656-1
label: SELECT "Profession" FROM "table" WHERE "Name" = "slađana pejić"
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 | Entrant                   | Chassis         | Engine              |   Points |
|-------:|:--------------------------|:----------------|:--------------------|---------:|
|   1953 | équipe gordini            | gordini type 16 | gordini straight-6  |        0 |
|   1954 | roberto mieres            | maserati a6gcm  | maserati straight-6 |        6 |
|   1954 | roberto mieres            | maserati 250f   | maserati straight-6 |        6 |
|   1954 | officine alfieri maserati | maserati 250f   | maserati straight-6 |        6 |
|   1955 | officine alfieri maserati | maserati 250f   | maserati straight-6 |        7 |

Question: What entrant had a chassis of Maserati 250f in 1954?

table_id: 2-1235941-1
label: SELECT "Entrant" FROM "table" WHERE "Chassis" = "maserati 250f" AND "Year" = 1954
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                                       | Nationality   | Position      |   From | School/Country       |
|:---------------------------------------------|:--------------|:--------------|-------:|:---------------------|
| cotton nash category:articles with hcards    | united states | forward       |   1965 | kentucky             |
| steve nash category:articles with hcards     | canada        | guard         |   2012 | santa clara          |
| swen nater category:articles with hcards     | netherlands   | center        |   1984 | ucla                 |
| don nelson category:articles with hcards     | united states | forward       |   1964 | iowa                 |
| johnny neumann category:articles with hcards | united states | guard/forward |   1977 | ole miss             |
| chuck nevitt category:articles with hcards   | united states | center        |   1985 | north carolina state |
| ira newble category:articles with hcards     | united states | forward       |   2008 | miami (ohio)         |
| norm nixon category:articles with hcards     | united states | guard         |   1978 | duquesne             |

Question: Which player plays forward and is from Kentucky?

table_id: 2-10560886-15
label: SELECT "Player" FROM "table" WHERE "Position" = "forward" AND "School/Country" = "kentucky"
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:
| Province     | Formed date     | Formed from   | Dissolution date   | Reason              |
|:-------------|:----------------|:--------------|:-------------------|:--------------------|
| auckland     | 17 january 1853 | new ulster    | 1 november 1876    | provinces abolished |
| new plymouth | 17 january 1853 | new ulster    | 1 november 1876    | provinces abolished |
| hawke's bay  | 1 november 1858 | wellington    | 1 november 1876    | provinces abolished |
| wellington   | 17 january 1853 | new munster   | 1 november 1876    | provinces abolished |
| nelson       | 17 january 1853 | new munster   | 1 november 1876    | provinces abolished |
| marlborough  | 1 november 1859 | nelson        | 1 november 1876    | provinces abolished |
| westland     | 1 december 1873 | canterbury    | 1 november 1876    | provinces abolished |
| canterbury   | 17 january 1853 | new munster   | 1 november 1876    | provinces abolished |
| otago        | 17 january 1853 | new munster   | 1 november 1876    | provinces abolished |

Question: What provinces were formed from New Munster?

table_id: 1-275023-1
label: SELECT "Province" FROM "table" WHERE "Formed from" = "New Munster"
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:
|   Round |   Pick | Player           | Nationality   | College                       |
|--------:|-------:|:-----------------|:--------------|:------------------------------|
|       3 |     69 | willie glass     | united states | st. john's                    |
|       4 |     92 | ralph tally      | united states | norfolk state                 |
|       6 |    115 | kenny travis     | united states | new mexico state              |
|       6 |    138 | frank ford       | united states | auburn university             |
|       7 |    161 | ron vanderschaaf | netherlands   | central washington university |

Question: What is Player, when Round is less than 6, and when Pick is "69"?

table_id: 2-17387421-1
label: SELECT "Player" FROM "table" WHERE "Round" < 6 AND "Pick" = 69
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 | Opponent                | Venue   | Result        |   Attendance | Competition   |
|-------:|:------------------------|:--------|:--------------|-------------:|:--------------|
|      6 | milton keynes lightning | away    | lost 0-7      |          960 | premier cup   |
|      7 | sheffield scimitars     | home    | lost 3-5      |         1168 | league        |
|     13 | chelmsford chieftains   | home    | won 5-0       |         1576 | premier cup   |
|     14 | bracknell bees          | away    | lost 5-6 (ot) |         1400 | league        |
|     20 | wightlink raiders       | away    | won 5-4       |          375 | league        |
|     21 | telford tigers          | home    | won 7-3       |         1217 | league        |
|     28 | chelmsford chieftains   | away    | won 3-2       |          474 | premier cup   |

Question: What is the result when the attendance is 960?

table_id: 2-15213262-7
label: SELECT "Result" FROM "table" WHERE "Attendance" = 960
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:
| Location   | Aircraft        | Tail number   | Aircraft damage   | Fatalities   |
|:-----------|:----------------|:--------------|:------------------|:-------------|
| mogadishu  | viscount 700    | 6o-aaj        | w/o               | 5/30         |
| bosaso     | douglas c-47a   | 6o-sac        | w/o               | 0/11         |
| balad      | f-27-600rf      | 6o-say        | w/o               | 50/50        |
| nairobi    | boeing 707-320b | 6o-sbt        | w/o               | 0/70         |
| hargeisa   | f-27-600rf      | 6o-saz        | w/o               | 30/30        |

Question: What was the aircraft damage for the Boeing 707-320B?

table_id: 2-1618297-2
label: SELECT "Aircraft damage" FROM "table" WHERE "Aircraft" = "boeing 707-320b"
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:
| District   | Incumbent       | Party      |   First elected | Results                                     |
|:-----------|:----------------|:-----------|----------------:|:--------------------------------------------|
| iowa 1     | jim nussle      | republican |            1990 | retired to run for governor democratic gain |
| iowa 2     | jim leach       | republican |            1976 | lost re-election democratic gain            |
| iowa 3     | leonard boswell | democratic |            1996 | re-elected                                  |
| iowa 4     | tom latham      | republican |            1994 | re-elected                                  |
| iowa 5     | steve king      | republican |            2002 | re-elected                                  |

Question: Who is the incumbent that has been in office since before 1996 and was again re-elected?

table_id: 2-1805191-16
label: SELECT "Incumbent" FROM "table" WHERE "Results" = "re-elected" AND "First elected" < 1996
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            | Venue              | Score   | Result   | Competition                          |
|:----------------|:-------------------|:--------|:---------|:-------------------------------------|
| march 1, 2006   | karachi , pakistan | 1–4     | lost     | 2007 afc asian cup qualification     |
| april 2, 2006   | dhaka , bangladesh | 1–0     | won      | 2006 afc challenge cup               |
| april 6, 2006   | dhaka , bangladesh | 2–2     | draw     | 2006 afc challenge cup               |
| august 16, 2006 | quetta , pakistan  | 1–4     | lost     | 2007 afc asian cup qualification     |
| march 25, 2008  | pokhara , nepal    | 1–2     | lost     | friendly                             |
| april 2, 2008   | taipei , taiwan    | 2–1     | won      | 2008 afc challenge cup qualification |

Question: Which venue had a match played on August 16, 2006?

table_id: 2-10506264-1
label: SELECT "Venue" FROM "table" WHERE "Date" = "august 16, 2006"