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:
|   # | Title                             | Director        | Writer(s)                                 | Original air date   | Production Code   |   U.S. viewers (millions) |
|----:|:----------------------------------|:----------------|:------------------------------------------|:--------------------|:------------------|--------------------------:|
|   1 | "i'm gonna love college"          | adam bernstein  | tom fontana , julie martin                | march29,2006        | 476291            |                      2    |
|   2 | "the truth about sex"             | adam bernstein  | tom fontana, julie martin                 | april5,2006         | 2t7251            |                      1.69 |
|   3 | "tell me no secrets"              | ed bianchi      | bradford winters                          | april12,2006        | 2t7252            |                      1.79 |
|   4 | "zen and the art of manipulation" | david anspaugh  | tom fontana, chris dingess , julie martin | april19,2006        | 2t7253            |                      1.58 |
|   5 | "love and the tenth planet"       | whitney ransick | jessica brickman                          | april26,2006        | 2t7254            |                      1.6  |
|   6 | "the passion of the beaver"       | adam bernstein  | jason yoshimura                           | may3,2006           | 2t7255            |                      1.37 |
|   7 | "risky business"                  | ron lagomarsino | brant englestein                          | may10,2006          | 2t7256            |                      1.06 |

Question: Who directed the episode titled "Risky Business"?

table_id: 1-2345558-1
label: SELECT "Director" FROM "table" WHERE "Title" = """Risky Business"""
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   Pick # | NFL Team          | Player          | Position       | College          |
|---------:|:------------------|:----------------|:---------------|:-----------------|
|       11 | green bay packers | tim lewis       | cornerback     | pittsburgh       |
|       48 | green bay packers | dave drechsler  | guard          | north carolina   |
|      104 | green bay packers | mike miller     | wide receiver  | tennessee        |
|      132 | green bay packers | brian thomas    | running back   | pittsburgh       |
|      160 | green bay packers | ron sams        | guard          | pittsburgh       |
|      188 | green bay packers | jessie clark    | running back   | arkansas         |
|      216 | green bay packers | carlton briscoe | defensive back | mcneese state    |
|      243 | green bay packers | robin ham       | center         | west texas state |
|      253 | green bay packers | byron williams  | wide receiver  | texas arlington  |
|      271 | green bay packers | jimmy thomas    | defensive back | indiana          |
|      299 | green bay packers | bucky scribner  | punter         | kansas           |

Question: What college did Byron Williams attend?

table_id: 1-14655757-1
label: SELECT "College" FROM "table" WHERE "Player" = "Byron Williams"
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        | Wins   | Losses   | Points   | WPct.   | G.F.   | G.A.   | Assists   | Penalties   | P.I.M.   |
|:------------|:-------|:---------|:---------|:--------|:-------|:-------|:----------|:------------|:---------|
| team        | wins   | losses   | points   | wpct.   | g.f.   | g.a.   | assists   | penalties   | p.i.m.   |
| germany     | 5      | 0        | 10       | 1       | 67     | 25     | 29        | 34          | 25       |
| scotland    | 3      | 2        | 6        | 0.6     | 55     | 36     | 13        | 38          | 31       |
| wales       | 3      | 2        | 6        | 0.6     | 46     | 31     | 8         | 65          | 54       |
| bermuda     | 3      | 2        | 6        | 0.6     | 40     | 42     | 5         | 51          | 38.5     |
| south korea | 1      | 4        | 2        | 0.2     | 27     | 61     | 3         | 50          | 40       |
| finland     | 0      | 5        | 0        | 0       | 18     | 58     | 1         | 34          | 28       |

Question: What's the P.I.M. for the G.F. of 55?

table_id: 2-18347755-2
label: SELECT "P.I.M." FROM "table" WHERE "G.F." = "55"
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               | No.    | Nationality   | Position       | Years in Toronto   | School/Club Team   |
|:---------------------|:-------|:--------------|:---------------|:-------------------|:-------------------|
| aleksandar radojević | 25     | serbia        | center         | 1999-2000          | barton cc (ks)     |
| shawn respert        | 31     | united states | guard          | 1997-98            | michigan state     |
| quentin richardson   | n/a    | united states | forward        | 2013-present       | depaul             |
| alvin robertson      | 7, 21  | united states | guard          | 1995-96            | arkansas           |
| carlos rogers        | 33, 34 | united states | forward-center | 1995-98            | tennessee state    |
| roy rogers           | 9      | united states | forward        | 1998               | alabama            |
| jalen rose           | 5      | united states | guard-forward  | 2003-06            | michigan           |
| terrence ross        | 31     | united states | guard          | 2012-present       | washington         |

Question: how many schools or teams had jalen rose

table_id: 1-10015132-16
label: SELECT COUNT("School/Club Team") FROM "table" WHERE "Player" = "Jalen Rose"
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                                 |   No. Specimens | Abbr.   | Country   | City      |
|:-------------------------------------|----------------:|:--------|:----------|:----------|
| estonian university of life sciences |          336000 | taa     | estonia   | tartu     |
| university of tartu                  |          324000 | tu      | estonia   | tartu     |
| vilnius university                   |          300000 | wi      | lithuania | vilnius   |
| university of latvia , riga          |          176000 | rig     | latvia    | riga      |
| university of latvia , salaspils     |          175000 | latv    | latvia    | salaspils |
| institute of botany, lithuania       |          130000 | bilas   | lithuania | vilnius   |
| estonian museum of natural history   |          100000 | tam     | estonia   | tallinn   |
| tallinn botanic garden               |           85000 | tall    | estonia   | tallinn   |
| national botanic garden of latvia    |           50000 | hba     | latvia    | salaspils |

Question: What is the abbreviation for the University of Tartu?

table_id: 2-18032715-3
label: SELECT "Abbr." FROM "table" WHERE "Name" = "university of tartu"
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 | Award                                | Category                          | Motive                            | Result    |
|-------:|:-------------------------------------|:----------------------------------|:----------------------------------|:----------|
|   2006 | mvpa award                           | directorial debut of the year     | switchfoot - " stars "            | won       |
|   2007 | premios lo nuestro                   | "video of the year"               | belinda - " ni freud ni tu mama " | nominated |
|   2007 | mtv video music awards latin america | "video of the year"               | belinda - " bella traición "      | won       |
|   2007 | ovmala                               | "best lighting"                   | belinda - " luz sin gravedad "    | won       |
|   2007 | ovmala                               | "best costume in a video (women)" | belinda - " bella traición "      | nominated |
|   2007 | ovmala                               | "best female video"               | belinda - " luz sin gravedad "    | won       |

Question: What is the category for the premios lo nuestro award?

table_id: 2-12618081-1
label: SELECT "Category" FROM "table" WHERE "Award" = "premios lo nuestro"
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       | Starter   |   Touchdowns |   Extra points |   Field goals |   Points |
|:-----------|:---------------|:----------|-------------:|---------------:|--------------:|---------:|
| webber     | left halfback  | yes       |            1 |              2 |             0 |        7 |
| marks      | right tackle   | yes       |            1 |              0 |             0 |        5 |
| boggs      | right tackle   | no        |            1 |              0 |             0 |        5 |
| begle      | fullback       | no        |            1 |              0 |             0 |        5 |
| snow       | right end      | yes       |            0 |              1 |             0 |        1 |
| herrnstein | right halfback | no        |            0 |              1 |             0 |        1 |

Question: What is the smallest number of extra points?

table_id: 1-25517718-3
label: SELECT MIN("Extra points") FROM "table"
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             | Status   | Authors                    | Unit                    | Location     |
|:-----------------|:---------|:---------------------------|:------------------------|:-------------|
| delectosaurus    | valid    | kurkin                     | vyazniki assemblage     | russia       |
| interpresosaurus | valid    | kurkin                     | vyazniki assemblage     | russia       |
| lumkuia          | valid    | hopson kitching            | burgersdorp formation   | south africa |
| malasaurus       | valid    | tatarinov                  | vyazniki assemblage     | russia       |
| mitredon         | valid    | shapiro jenkins            | fleming fjord formation | greenland    |
| prozostrodon     | valid    | bonaparte barberena        | santa maria formation   | brazil       |
| riograndia       | valid    | bonaparte ferigolo ribeiro | caturrita formation     | brazil       |

Question: What is the name of the non-mammal from brazil of the unit of caturrita formation?

table_id: 2-15313481-14
label: SELECT "Name" FROM "table" WHERE "Location" = "brazil" AND "Unit" = "caturrita formation"
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 at the T5 for the player with a score of 74-69-66=209?

table_id: 2-18060467-6
label: SELECT "To par" FROM "table" WHERE "Place" = "t5" AND "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:
| Tone               | Standard Thai   | Phonemic   | Phonetic   | Example meaning in English   |
|:-------------------|:----------------|:-----------|:-----------|:-----------------------------|
| high               | ผ่า              | /pʰáː/     | [pʰaː˥˥]   | to split                     |
| mid rising-falling | ปลา             | /plâː/     | [plaː˧˦˧]  | fish                         |
| low-rising         | ถ้า              | /tʰǎː/     | [tʰaː˩˦]   | landing                      |
| mid-high           | ห้า              | /haː/      | [haː˦˦]    | five                         |
| low                | ค้า              | /kʰàː/     | [kʰaː˩˩]   | to trade                     |

Question: Which tone goes with Phonetic of [pʰaː˥˥]?

table_id: 2-1517041-1
label: SELECT "Tone" FROM "table" WHERE "Phonetic" = "[pʰaː˥˥]"
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          |
|:----------------|:------------------|:----------------|:------------------|:--------------|--------:|:--------------|
| geelong         | 15.13 (103)       | richmond        | 9.11 (65)         | kardinia park |   19565 | 30 april 1955 |
| essendon        | 11.14 (80)        | north melbourne | 9.15 (69)         | windy hill    |   21000 | 30 april 1955 |
| collingwood     | 16.20 (116)       | st kilda        | 8.11 (59)         | victoria park |   18095 | 30 april 1955 |
| carlton         | 17.4 (106)        | fitzroy         | 6.13 (49)         | princes park  |   23435 | 30 april 1955 |
| south melbourne | 7.14 (56)         | hawthorn        | 15.8 (98)         | lake oval     |   18000 | 30 april 1955 |
| melbourne       | 6.22 (58)         | footscray       | 6.10 (46)         | mcg           |   49280 | 30 april 1955 |

Question: When did Geelong play as the home team?

table_id: 2-10773753-3
label: SELECT "Date" FROM "table" WHERE "Home team" = "geelong"
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:
| Version   | Year    | Bore x stroke   | Displacement   | Power       |
|:----------|:--------|:----------------|:---------------|:------------|
| db        | 1929-32 | 76.2x110 mm     | cc (cuin)      | hp (kw; ps) |
| eb        | 1932-35 | 79.4x110 mm     | cc (cuin)      | hp (kw; ps) |
| ec        | 1935-45 | 84.14x110 mm    | cc (cuin)      | hp (kw; ps) |
| ecg       | 1940-45 | 84.14x110 mm    | cc (cuin)      | hp (kw; ps) |
| ed        | 1946-58 | 84.14x110 mm    | cc (cuin)      | hp (kw; ps) |

Question: Tell me the power for 1935-45

table_id: 2-11677066-1
label: SELECT "Power" FROM "table" WHERE "Year" = "1935-45"
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:
| Character     | Portrayed by    | Main cast seasons   | Recurring cast seasons    |   # of episodes |
|:--------------|:----------------|:--------------------|:--------------------------|----------------:|
| nick lucas    | nick jonas      | seasons 1–2         | appears in all seasons    |              34 |
| joe lucas     | joe jonas       | seasons 1–2         | appears in all seasons    |              34 |
| kevin lucas   | kevin jonas     | seasons 1–2         | appears in all seasons    |              34 |
| stella malone | chelsea kane    | seasons 1–2         | appears in all seasons    |              34 |
| macy misa     | nicole anderson | seasons 1–2         | appears in all seasons    |              30 |
| tom lucas     | john ducey      | season 1            | season 2 (episode 9 only) |              22 |

Question: Which main cast seasons were portrayed by Joe Jonas?

table_id: 2-12441518-1
label: SELECT "Main cast seasons" FROM "table" WHERE "Portrayed by" = "joe jonas"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Home team       | Home team score   | Away team       | Away team score   | Venue          |   Crowd | Date        |
|:----------------|:------------------|:----------------|:------------------|:---------------|--------:|:------------|
| fitzroy         | 15.17 (107)       | hawthorn        | 12.13 (85)        | junction oval  |   10706 | 12 may 1973 |
| collingwood     | 15.10 (100)       | melbourne       | 10.16 (76)        | victoria park  |   21360 | 12 may 1973 |
| geelong         | 11.14 (80)        | footscray       | 14.14 (98)        | kardinia park  |   15305 | 12 may 1973 |
| st kilda        | 18.13 (121)       | essendon        | 21.14 (140)       | moorabbin oval |   23120 | 12 may 1973 |
| richmond        | 18.20 (128)       | carlton         | 15.12 (102)       | mcg            |   54139 | 12 may 1973 |
| north melbourne | 18.16 (124)       | south melbourne | 11.14 (80)        | vfl park       |   10020 | 12 may 1973 |

Question: Where was the game played when the home team scored 11.14 (80)?

table_id: 2-10869537-6
label: SELECT "Venue" FROM "table" WHERE "Home team score" = "11.14 (80)"
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                      | Title                    | Genre   | Label                 | Result   |
|:-------|:------------------------------|:-------------------------|:--------|:----------------------|:---------|
| year   | category                      | title                    | genre   | label                 | result   |
| 2007   | best traditional gospel album | still keeping it real    | gospel  | mcg                   | nominee  |
| 2000   | best traditional gospel album | music in the air         | gospel  | house of blues        | nominee  |
| 1994   | best traditional gospel album | in good health           | gospel  | atlanta international | nominee  |
| 1973   | best soul gospel performance  | " loves me like a rock " | gospel  | mcg                   | winner   |

Question: What category did MCG get a nominee in?

table_id: 2-1255353-1
label: SELECT "Category" FROM "table" WHERE "Label" = "mcg" AND "Result" = "nominee"
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 |   Gold |   Silver |   Bronze |   Total |
|-------:|-------:|---------:|---------:|--------:|
|      1 |     10 |        6 |        3 |      19 |
|      2 |      3 |        4 |        1 |       8 |
|      3 |      2 |        2 |        1 |       5 |
|      4 |      2 |        0 |        5 |       7 |
|      5 |      2 |        0 |        1 |       3 |
|      6 |      1 |        1 |        2 |       4 |
|      7 |      1 |        0 |        0 |       1 |
|      8 |      0 |        3 |        3 |       6 |
|      9 |      0 |        2 |        0 |       2 |
|     10 |      0 |        1 |        0 |       1 |
|     13 |      0 |        0 |        2 |       2 |
|     14 |      0 |        0 |        1 |       1 |

Question: Bronze smaller than 3, and a Total smaller than 2, and a Gold larger than 1 has how many average silvers?

table_id: 2-13149986-2
label: SELECT AVG("Silver") FROM "table" WHERE "Bronze" < 3 AND "Total" < 2 AND "Gold" > 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:
| Game   | Date     | Home Team   | Result   | Road Team   |
|:-------|:---------|:------------|:---------|:------------|
| game 1 | april 17 | boston      | 129-133  | los angeles |
| game 2 | april 19 | boston      | 129-109  | los angeles |
| game 3 | april 20 | los angeles | 106-120  | boston      |
| game 4 | april 22 | los angeles | 117-122  | boston      |
| game 5 | april 24 | boston      | 117-121  | los angeles |
| game 6 | april 26 | los angeles | 123-115  | boston      |
| game 7 | april 28 | boston      | 95-93    | los angeles |

Question: What was the result of game 3?

table_id: 2-17342287-11
label: SELECT "Result" FROM "table" WHERE "Game" = "game 3"
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       | thomas bjørn     | denmark       | 73-70-69=212 | −1       |
| 2       | davis love iii   | united states | 69-72-72=213 | e        |
| t3      | ben curtis       | united states | 72-72-70=214 | +1       |
| t3      | sergio garcía    | spain         | 73-71-70=214 | +1       |
| t3      | kenny perry      | united states | 74-70-70=214 | +1       |
| t3      | vijay singh      | fiji          | 75-70-69=214 | +1       |
| t3      | tiger woods      | united states | 73-72-69=214 | +1       |
| t8      | s.k. ho          | south korea   | 70-73-72=215 | +2       |
| t8      | phillip price    | wales         | 74-72-69=215 | +2       |
| t10     | gary evans       | england       | 71-75-70=216 | +3       |
| t10     | pierre fulke     | sweden        | 77-72-67=216 | +3       |
| t10     | fredrik jacobson | sweden        | 70-76-70=216 | +3       |
| t10     | peter lonard     | australia     | 73-73-70=216 | +3       |

Question: What is the Place of the Player with a Score of 69-72-72=213?

table_id: 2-17991748-6
label: SELECT "Place" FROM "table" WHERE "Score" = "69-72-72=213"
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 | Club                 | Home   | Away   | Aggregate   |
|--------:|:---------------------|:-------|:-------|:------------|
|       1 | dws amsterdam        | 1-1    | 2-1    | 2-3         |
|       1 | anorthosis famagusta | 7-0    | 0-1    | 8-0         |
|       2 | dinamo berlin        | 1-3    | 3-1    | 2-6         |
|       1 | vitoria setubal      | 0-2    | 2-0    | 0-4         |
|       1 | nk rijeka            | 0-0    | 2-1    | 1-2         |

Question: What club has a home score of 0-2 in Round 1?

table_id: 2-1508381-1
label: SELECT "Club" FROM "table" WHERE "Round" = 1 AND "Home" = "0-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:
| Driver               | Constructor     |   Laps | Time/Retired   |   Grid |
|:---------------------|:----------------|-------:|:---------------|-------:|
| jackie stewart       | matra - ford    |     90 | 2:46:11.2      |      5 |
| jean-pierre beltoise | matra           |     90 | + 1:33.93      |     16 |
| pedro rodríguez      | brm             |     89 | + 1 lap        |     11 |
| jacky ickx           | ferrari         |     88 | + 2 laps       |      6 |
| silvio moser         | brabham - repco |     87 | + 3 laps       |     17 |
| chris amon           | ferrari         |     85 | + 5 laps       |      1 |
| richard attwood      | brm             |     85 | + 5 laps       |     15 |
| jo bonnier           | mclaren - brm   |     82 | + 8 laps       |     19 |
| graham hill          | lotus - ford    |     81 | accident       |      3 |
| jackie oliver        | lotus - ford    |     80 | not classified |     10 |
| dan gurney           | brabham - repco |     63 | throttle       |     12 |
| jo siffert           | lotus - ford    |     55 | gearbox        |     13 |
| john surtees         | honda           |     50 | alternator     |      9 |
| piers courage        | brm             |     50 | spun off       |     14 |
| jochen rindt         | brabham - repco |     39 | ignition       |      2 |
| jack brabham         | brabham - repco |     22 | spun off       |      4 |
| bruce mclaren        | mclaren - ford  |     19 | accident       |      8 |
| denny hulme          | mclaren - ford  |     10 | ignition       |      7 |
| lucien bianchi       | cooper - brm    |      9 | accident       |     18 |

Question: What is the highest number of laps for chris amon?

table_id: 2-1122384-2
label: SELECT MAX("Laps") FROM "table" WHERE "Driver" = "chris amon"