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:
| Place   | Player          | Country             | Score        | To par   |
|:--------|:----------------|:--------------------|:-------------|:---------|
| 1       | jesper parnevik | sweden              | 70-66-66=202 | –11      |
| 2       | darren clarke   | northern ireland    | 67-66-71=204 | –9       |
| t3      | fred couples    | united states       | 69-68-70=207 | –6       |
| t3      | justin leonard  | united states       | 69-66-72=207 | –6       |
| t5      | stephen ames    | trinidad and tobago | 74-69-66=209 | –4       |
| t5      | jim furyk       | united states       | 67-72-70=209 | –4       |
| t5      | eduardo romero  | argentina           | 74-68-67=209 | –4       |
| t8      | robert allenby  | australia           | 76-68-66=210 | –3       |
| t8      | lee westwood    | england             | 73-70-67=210 | –3       |
| t8      | tiger woods     | united states       | 72-74-64=210 | –3       |

Question: What was the to par for the game with a score of 74-69-66=209?

table_id: 2-18060467-6
label: SELECT "To par" FROM "table" WHERE "Score" = "74-69-66=209"
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:
| Episode                        | Air Date       | Timeslot   |   Rating |   Share | 18-49      | Viewers   | Weekly Rank   |
|:-------------------------------|:---------------|:-----------|---------:|--------:|:-----------|:----------|:--------------|
| "goodbye city...hello country" | april 30, 2008 | 9:00 p.m.  |      1.7 |       3 | 1.0/3 (#5) | 2.37 (#5) | 89/96         |
| "pigs & cows & sheeps...oh my" | may 7, 2008    | 9:00 p.m.  |      1.5 |       2 | 1.0/3 (#5) | 2.11 (#5) | 90/97         |
| "wet 'n wild"                  | may 14, 2008   | 9:00 p.m.  |      1.3 |       2 | 0.9/2 (#5) | 1.96 (#5) | 90/96         |
| "do-si-do"                     | may 28, 2008   | 9:00 p.m.  |      1.8 |       3 | 0.9/2 (#5) | 2.44 (#5) | 75/87         |
| "as country as apple pie"      | june 4, 2008   | 9:00 p.m.  |      1.3 |       2 | 0.8/2 (#5) | 2.01 (#5) | 79/91         |
| "it's show time"               | june 11, 2008  | 9:00 p.m.  |      1.3 |       2 | 0.8/2 (#5) | 2.04 (#5) | 76/88         |
| "a family affair"              | june 18, 2008  | 9:00 p.m.  |      1.5 |       3 | 0.8/2 (#5) | 2.00 (#5) | tba           |
| "farmer picks a wife"          | june 25, 2008  | 9:00 p.m.  |      1.6 |       3 | 1.0/3 (#5) | 2.45 (#5) | tba           |

Question: What is the lowest Share, when Rating is greater than 1.3, and when Air Date is May 28, 2008?

table_id: 2-16225725-4
label: SELECT MIN("Share") FROM "table" WHERE "Rating" > 1.3 AND "Air Date" = "may 28, 2008"
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           | Position   | Height   |   Weight | Year      | Home Town       |
|:---------------|:-----------|:---------|---------:|:----------|:----------------|
| anthony tucker | guard      | 6–4      |      200 | freshman  | minnetonka, mn  |
| david palmer   | center     | 6–9      |      240 | junior    | antioch, tn     |
| j.r. angle     | guard      | 6–7      |      215 | senior    | franklin, in    |
| matt gatens    | guard      | 6–5      |      215 | freshman  | iowa city, ia   |
| devan bawinkel | guard      | 6–5      |      210 | junior    | winnebago, il   |
| andrew brommer | forward    | 6–9      |      235 | freshman  | rosemount, mn   |
| jermain davis  | guard      | 6–4      |      200 | junior    | plymouth, mn    |
| aaron fuller   | forward    | 6–6      |      210 | freshman  | mesa, az        |
| jeff peterson  | guard      | 6–0      |      192 | sophomore | springfield, mo |
| jake kelly     | guard      | 6–6      |      185 | sophomore | carmel, in      |
| john lickliter | guard      | 5–11     |      175 | freshman  | iowa city, ia   |
| cyrus tate     | forward    | 6–8      |      255 | senior    | chicago, il     |
| jarryd cole    | forward    | 6–7      |      250 | sophomore | kansas city, mo |

Question: What is the total combined weight of players from minnetonka, mn?

table_id: 2-16389461-1
label: SELECT SUM("Weight") FROM "table" WHERE "Home Town" = "minnetonka, mn"
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   |
|:--------|:-----------------|:--------------|:-------------|:---------|
| 1       | tze-chung chen   | taiwan        | 65-69-69=203 | –7       |
| 2       | andy north       | united states | 70-65-70=205 | –5       |
| 3       | dave barr        | canada        | 70-68-70=208 | –2       |
| 4       | rick fehr        | united states | 69-67-73=209 | –1       |
| t5      | seve ballesteros | spain         | 71-70-69=210 | e        |
| t5      | tom kite         | united states | 69-70-71=210 | e        |
| t5      | denis watson     | zimbabwe      | 72-65-73=210 | e        |
| t8      | payne stewart    | united states | 70-70-71=211 | +1       |
| t8      | lanny wadkins    | united states | 70-72-69=211 | +1       |
| t10     | raymond floyd    | united states | 72-67-73=212 | +2       |
| t10     | jay haas         | united states | 69-66-77=212 | +2       |
| t10     | fuzzy zoeller    | united states | 71-69-72=212 | +2       |

Question: What country has Dave Barr as a player?

table_id: 2-17231246-6
label: SELECT "Country" FROM "table" WHERE "Player" = "dave barr"
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:
| Model number   | sSpec number   |   Cores | Frequency   | Turbo    | L2 cache   | L3 cache   | GPU model        | GPU frequency   | Socket    | I/O bus   | Release date   | Part number(s)                 | Release price ( USD )   |
|:---------------|:---------------|--------:|:------------|:---------|:-----------|:-----------|:-----------------|:----------------|:----------|:----------|:---------------|:-------------------------------|:------------------------|
| core i7-4700mq | sr15h(c0)      |       4 | 2.4 ghz     | 8/8/9/10 | 4 × 256 kb | 6 mb       | hd graphics 4600 | 400–1150 mhz    | socket g3 | dmi 2.0   | june 2013      | cw8064701470702                | $383                    |
| core i7-4702mq | sr15j(c0)      |       4 | 2.2 ghz     | 7/7/9/10 | 4 × 256 kb | 6 mb       | hd graphics 4600 | 400–1150 mhz    | socket g3 | dmi 2.0   | june 2013      | cw8064701470802                | $383                    |
| core i7-4800mq | sr15l(c0)      |       4 | 2.7 ghz     | 8/8/9/10 | 4 × 256 kb | 6 mb       | hd graphics 4600 | 400–1300 mhz    | socket g3 | dmi 2.0   | june 2013      | cw8064701471001bx80647i74800mq | $378                    |
| core i7-4900mq | sr15k(c0)      |       4 | 2.8 ghz     | 8/8/9/10 | 4 × 256 kb | 8 mb       | hd graphics 4600 | 400–1300 mhz    | socket g3 | dmi 2.0   | june 2013      | cw8064701470901bx80647i74900mq | $568                    |
| core i7-4930mx | sr15m(c0)      |       4 | 3 ghz       | 7/7/8/9  | 4 × 256 kb | 8 mb       | hd graphics 4600 | 400–1350 mhz    | socket g3 | dmi 2.0   | june 2013      | cw8064701471101                | $1096                   |

Question: what is the release date when the sspec number is sr15h(c0)?

table_id: 2-18823880-18
label: SELECT "Release date" FROM "table" WHERE "sSpec number" = "sr15h(c0)"
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 | Category             | Nominee(s)                    | Episode                  | Result    |
|-------:|:---------------------|:------------------------------|:-------------------------|:----------|
|   2001 | best episodic comedy | gary murphy and neil thompson | " grandparents "         | nominated |
|   2001 | best episodic comedy | alex reid                     | " bowling "              | nominated |
|   2003 | best episodic comedy | dan kopelman                  | " malcolm films reese "  | nominated |
|   2003 | best episodic comedy | gary murphy and neil thompson | " day care "             | nominated |
|   2004 | best episodic comedy | neil thompson                 | " ida's boyfriend "      | won       |
|   2005 | best episodic comedy | rob ulin                      | " motivational speaker " | nominated |
|   2006 | best episodic comedy | rob ulin                      | " bomb shelter "         | nominated |

Question: What is the average year with nominated result?

table_id: 2-18541288-12
label: SELECT AVG("Year") FROM "table" WHERE "Result" = "nominated"
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:
| Composition                               | s Hindu   | s Muslim   | Christians   | s Sikh   | Buddhist   | s Jain   | Others   |
|:------------------------------------------|:----------|:-----------|:-------------|:---------|:-----------|:---------|:---------|
| % total of population 2001                | 80.5%     | 13.4%      | 2.3%         | 1.9%     | 0.8%       | 0.4%     | 0.6%     |
| 10-yr growth % (est '91–'01)              | 20.3%     | 29.5%      | 22.6%        | 18.2%    | 24.5%      | 26.0%    | 103.1%   |
| no. of females/1000 males. (avg. = 944)   | 935       | 940        | 1009         | 895      | 955        | 940      | 1000     |
| literacy rate (71.7% for age 7 and above) | 75.5%     | 60.0%      | 90.3%        | 70.4%    | 73.0%      | 95.0%    | 50.0%    |
| work participation rate                   | 40.4      | 31.3       | 39.7         | 37.7     | 40.6       | 32.9     | 48.4     |
| rural sex ratio                           | 1000      | 953        | 1001         | 895      | 958        | 937      | 995      |
| urban sex ratio                           | 922       | 907        | 1026         | 886      | 944        | 941      | 966      |

Question: How many buddhists are where s jain have 941?

table_id: 1-14598-5
label: SELECT "Buddhist" FROM "table" WHERE "s Jain" = "941"
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:
|   Week | Date               | Opponent               | Result   | Attendance   |
|-------:|:-------------------|:-----------------------|:---------|:-------------|
|      1 | bye                | bye                    | bye      | bye          |
|      2 | september 18, 1966 | new york giants        | w 52–7   | 60,010       |
|      3 | september 25, 1966 | minnesota vikings      | w 28–17  | 64,116       |
|      4 | october 2, 1966    | at atlanta falcons     | w 47–14  | 56,990       |
|      5 | october 9, 1966    | philadelphia eagles    | w 56–7   | 69,372       |
|      6 | october 16, 1966   | at st. louis cardinals | t 10–10  | 50,673       |
|      7 | october 23, 1966   | at cleveland browns    | l 30–21  | 84,721       |
|      8 | october 30, 1966   | pittsburgh steelers    | w 52–21  | 58,453       |
|      9 | november 6, 1966   | at philadelphia eagles | l 24–23  | 60,658       |
|     10 | november 13, 1966  | at washington redskins | w 31–30  | 50,927       |
|     11 | november 20, 1966  | at pittsburgh steelers | w 20–7   | 42,185       |
|     12 | november 24, 1966  | cleveland browns       | w 26–14  | 80,259       |
|     13 | december 4, 1966   | st. louis cardinals    | w 31–17  | 76,965       |
|     14 | december 11, 1966  | washington redskins    | l 34–31  | 64,198       |
|     15 | december 18, 1966  | at new york giants     | w 17–7   | 62,735       |

Question: The game played on October 2, 1966 had what result?

table_id: 2-17946785-1
label: SELECT "Result" FROM "table" WHERE "Date" = "october 2, 1966"
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:
| Episode No.   | Episode Title                          | UK Broadcast Date   | Presenter             | Countries Visited                             |
|:--------------|:---------------------------------------|:--------------------|:----------------------|:----------------------------------------------|
| #3.1          | "crewe to crewe"                       | 1996-09-04          | victoria wood         | united kingdom                                |
| #3.2          | "aleppo to aqaba"                      | 1996-09-11          | alexei sayle          | syria , jordan                                |
| #3.3          | "great zimbabwe to kilimatinde"        | 1996-09-18          | henry louis gates jr. | zimbabwe , zambia , tanzania                  |
| #3.4          | "the high andes to patagonia"          | 1996-09-25          | buck henry            | argentina                                     |
| #3.5          | "mombasa to the mountains of the moon" | 1996-10-02          | benedict allen        | kenya , uganda                                |
| #3.6          | "london to arcadia"                    | 1996-10-09          | ben okri              | england, france, switzerland , italy , greece |

Question: What episode number is presented by Ben Okri ?

table_id: 1-15211468-3
label: SELECT "Episode No." FROM "table" WHERE "Presenter" = "Ben Okri"
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:
| Class     | Number(s)   | DRG Number(s)   |   Quantity | Year(s) of Manufacture   | Type     |
|:----------|:------------|:----------------|-----------:|:-------------------------|:---------|
| le        | i–v         | 99 071–99 075   |          5 | 1885–1900                | c n2t    |
| pts 3/4   | 1101–1103   | 99 131–99 132   |          3 | 1906                     | 1′c h2t  |
| pts 3/4   | 1104        | 99 133          |          1 | 1923                     | 1′c h2t  |
| gts 4/4   | 991         | 99 151          |          1 | 1909                     | d n2t    |
| gts 2x3/3 | 996         | 99 201          |          1 | 1917                     | c′c h4vt |

Question: What is the average quantity that has 1104 as the number(s)?

table_id: 2-17941795-7
label: SELECT AVG("Quantity") FROM "table" WHERE "Number(s)" = "1104"
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         | Decision   | Attendance   | Record   |   Points |
|:------------|:-------------|:--------|:-------------|:-----------|:-------------|:---------|---------:|
| february 5  | philadelphia | 1 – 6   | chicago      | cude       | 8,000        | 2–27–2   |        6 |
| february 10 | ny rangers   | 3 – 1   | philadelphia | cude       | n/a          | 2–28–2   |        6 |
| february 14 | ny americans | 1 – 1   | philadelphia | cude       | 3,000        | 2–28–3   |        7 |
| february 17 | philadelphia | 2 – 0   | detroit      | cude       | 5,000        | 3–28–3   |        9 |
| february 22 | philadelphia | 1 – 6   | ny rangers   | cude       | 8,000        | 3–29–3   |        9 |
| february 24 | boston       | 5 – 1   | philadelphia | cude       | 2,000        | 3–30–3   |        9 |
| february 28 | philadelphia | 1 – 4   | mtl maroons  | cude       | 9,500        | 3–31–3   |        9 |

Question: What's the sum of the points when attendance is 8,000 on february 22?

table_id: 2-16785772-5
label: SELECT SUM("Points") FROM "table" WHERE "Attendance" = "8,000" AND "Date" = "february 22"
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   |
|:--------|:-----------------|:--------------|:-------------|:---------|
| 1       | andy north       | united states | 70-70-71=211 | –2       |
| 2       | gary player      | south africa  | 71-71-70=212 | –1       |
| t3      | j. c. snead      | united states | 70-72-72=214 | +1       |
| t3      | dave stockton    | united states | 71-73-70=214 | +1       |
| t5      | seve ballesteros | spain         | 75-69-71=215 | +2       |
| t5      | andy bean        | united states | 72-72-71=215 | +2       |
| t5      | johnny miller    | united states | 78-69-68=215 | +2       |
| t10     | tom kite         | united states | 73-73-70=216 | +3       |
| t10     | billy kratzert   | united states | 72-74-70=216 | +3       |
| t10     | jack nicklaus    | united states | 73-69-74=216 | +3       |

Question: What was Tom Kite's to par?

table_id: 2-17245471-5
label: SELECT "To par" FROM "table" WHERE "Player" = "tom kite"
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:
| Team                     | Car(s)                                 |   # | Driver(s)        | Primary Sponsor(s)     | Owner(s)          | Crew Chief     |   Rounds |
|:-------------------------|:---------------------------------------|----:|:-----------------|:-----------------------|:------------------|:---------------|---------:|
| circle sport             | chevrolet ss                           |  33 | tony raines      | little joe's auto      | joe falk          | john rahlf     |       25 |
| go green racing          | ford fusion                            |  52 | brian keselowski | my 3 sons vending      | bob keselowski    | ben leslie     |        7 |
| hillman racing           | chevrolet ss                           |  40 | landon cassill   | crc brakleen           | mike hillman      | mike abner     |        9 |
| humphrey smith racing    | chevrolet ss [ disambiguation needed ] |  19 | mike bliss       | n/a                    | randy humphrey    | peter sospenzo |       22 |
| leavine family racing    | ford fusion                            |  95 | reed sorenson    | n/a                    | bob leavine       | wally rogers   |       16 |
| phil parsons racing      | ford fusion                            |  98 | michael mcdowell | k-love / curb records  | mike curb         | gene nead      |       26 |
| richard childress racing | chevrolet ss                           |  33 | austin dillon    | advocare               | richard childress | scott naset    |        4 |
| wood brothers racing     | ford fusion                            |  21 | trevor bayne     | motorcraft /quick lane | glen wood         | donnie wingo   |        8 |

Question: Which teams used Wally Rogers as their crew chief?

table_id: 1-1266602-2
label: SELECT "Team" FROM "table" WHERE "Crew Chief" = "Wally Rogers"
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 | Date      | Location          | Time   |   Attendance |
|-------:|:----------|:------------------|:-------|-------------:|
|      1 | october 3 | polo grounds (iv) | 2:07   |        46672 |
|      2 | october 4 | polo grounds (iv) | 2:09   |        35461 |
|      3 | october 5 | griffith stadium  | 1:55   |        25727 |
|      4 | october 6 | griffith stadium  | 2:59   |        26762 |
|      5 | october 7 | griffith stadium  | 2:38   |        28454 |

Question: What is the number of the game that was played in the time of 2:38?

table_id: 2-1332349-1
label: SELECT MAX("Game") FROM "table" WHERE "Time" = "2:38"
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:
| Nominative   | Old orthography   | New orthography   | /e/ or /æ/ (IPA)   | Tone (Latvian notation: /~/ - level, /^/ - broken)   | Translation                  |
|:-------------|:------------------|:------------------|:-------------------|:-----------------------------------------------------|:-----------------------------|
| mēris        | mēŗa              | mēra              | /meːra/            | /mẽra/                                               | gen.sing. plague             |
| mērs         | mēra              | mēra              | /meːra/            | /mẽra/                                               | gen.sing. mayor              |
| mērs         | mēra              | mēra              | /mæːra/            | /mẽra/                                               | gen.sing. measure            |
| mērīt        | mēra              | mēra              | /mæːra/            | /mẽra/                                               | 3rd pers.ind. - he measures  |
| bērt         | bēru              | bēru              | /beːru/            | /bêru/                                               | i poured (sand, grain, etc.) |
| bēres        | bēŗu              | bēru              | /bæːru/            | /bêru/                                               | gen.pl. funeral              |

Question: What is the tone for gen.sing. plague?

table_id: 1-10409754-5
label: SELECT "Tone (Latvian notation: /~/ - level, /^/ - broken)" FROM "table" WHERE "Translation" = "Gen.Sing. plague"
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                    |   Bodyweight |   Snatch | Clean & jerk   | Total (kg)   |
|:------------------------|-------------:|---------:|:---------------|:-------------|
| álvaro velasco ( col )  |        83.92 |    162.5 | 190.0          | 352.5        |
| josé llerena ( ecu )    |        83.07 |    147.5 | 192.5          | 340.0        |
| tim mcrae ( usa )       |        83.23 |    155   | 185.0          | 340.0        |
| corey barrett ( usa )   |        84.72 |    145   | 182.5          | 327.5        |
| henrry coy ( gua )      |        83.29 |    132.5 | 170.0          | 302.5        |
| reynaldo vélez ( pur )  |        84.93 |    130   | 170.0          | 300.0        |
| sergio lafuente ( uru ) |        84.17 |    120   | 160.0          | 280.0        |
| isnardo faro ( aru )    |        84.68 |    120   | 155.0          | 275.0        |
| joël mckenzie ( cub )   |        84.55 |    155   | –              | –            |
| josé barros ( arg )     |        84.06 |    140   | –              | –            |

Question: What's the name of the athlete with a Snatch larger than 140, Bodyweight smaller than 84.55, and Clean and Jerk of 192.5?

table_id: 2-11279593-5
label: SELECT "Name" FROM "table" WHERE "Snatch" > 140 AND "Bodyweight" < 84.55 AND "Clean & jerk" = "192.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:
| Episode #   | Original Air Date (UK)   | Episode Title   | Director      | Writer       | Cast                                        |
|:------------|:-------------------------|:----------------|:--------------|:-------------|:--------------------------------------------|
| 2-01        | 18 june 1979             | new brooms      | james ormerod | nick mccarty | stafford gordon , roy holder , robin davies |
| 2-02        | 25 june 1979             | matrimony       | james ormerod | nick mccarty | stafford gordon, roy holder, robin davies   |
| 2-03        | 2 july 1979              | pressures       | james ormerod | nick mccarty | stafford gordon, roy holder, robin davies   |
| 2-04        | 9 july 1979              | leave takers    | james ormerod | nick mccarty | stafford gordon, roy holder, robin davies   |
| 2-05        | 16 july 1979             | repercussions   | james ormerod | nick mccarty | stafford gordon, roy holder, robin davies   |

Question: For episode number 2-03, what are the names of the cast?

table_id: 1-2570269-2
label: SELECT "Cast" FROM "table" WHERE "Episode #" = "2-03"
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              |
|:-------------------|:---------------------------|:----------|:------------------------|:-------------------|
| april 28, 1999     | hatfield , united kingdom  | clay      | jean-rené lisnard       | 7–6, 1–6, 6–0      |
| august 16, 1999    | bronx , u.s.               | hard      | alexander popp          | 4 6–7, 7–6 4 , 6–0 |
| october 15, 2001   | brasilia , brazil          | clay      | sebastián prieto        | 6–4, 4–6, 7–6 6    |
| september 22, 2003 | san antonio , u.s.         | hard      | dmitry tursunov         | 6–2, 3 6–7, 6–4    |
| september 29, 2003 | nevers , france            | hard      | jean-michel pequery     | 6–4, 6–4           |
| march 13, 2006     | lille , france             | hard      | jo-wilfried tsonga      | 7–5, 7–5           |
| january 7, 2008    | nußloch , germany          | carpet    | karol beck              | 6–4, 6–4           |
| april 7, 2008      | angers , france            | clay      | alexandre sidorenko     | 7 6–7, 6–2, 7–6 5  |
| may 11, 2009       | newcastle , united kingdom | clay      | david guez              | 6–3, 3–6, 6–0      |

Question: What was the April 7, 2008 score on a clay surface?

table_id: 2-17637180-3
label: SELECT "Score" FROM "table" WHERE "Surface" = "clay" AND "Date" = "april 7, 2008"