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:
| Name                 | Design   | Manufacturer      |   Acquired | Disposed      |
|:---------------------|:---------|:------------------|-----------:|:--------------|
| adler                | 1a1      | stephenson 1835   |       1835 | sold 1857     |
| pfeil                | 1a1      | stephenson 1836   |       1836 | sold          |
| nürnberg-fürth       | 1a1      | henschel 1852/14  |       1852 | scrapped 1889 |
| phoenix              | 1a1      | maffei 1853/127   |       1853 | scrapped 1869 |
| adler ii             | 1a1      | maffei 1857/279   |       1857 | scrapped 1889 |
| johannes scharrer    | 1a1      | henschel 1865/108 |       1865 | scrapped 1887 |
| faust                | 1a1      | maffei 1845/6     |       1872 | scrapped 1881 |
| henlein              | 1a1      | maffei 1845/8     |       1873 | scrapped 1880 |
| wallenstein          | 1a1      | kessler 1845/30   |       1875 | scrapped 1885 |
| bavaria              | bn2t     | maffei 1879/1204  |       1879 | sold 1923     |
| pegnitz              | bn2t     | maffei 1880/1224  |       1880 | sold 1923     |
| franconia            | bn2t     | maffei 1881/1248  |       1881 | sold 1923     |
| daniel ley           | 1bn2t    | maffei 1886/1414  |       1886 | sold 1923     |
| johannes scharrer ii | bn2t     | maffei 1887/1453  |       1887 | sold 1923     |
| nürnberg-fürth ii    | bn2t     | maffei 1889/1538  |       1889 | sold 1923     |
| germania             | 1bn2t    | maffei 1906/2511  |       1906 | sold 1923     |
| ludwig               | 1bn2t    | maffei 1906/2549  |       1906 | sold 1923     |

Question: What design was acquired in 1875?

table_id: 2-12185768-1
label: SELECT "Design" FROM "table" WHERE "Acquired" = 1875
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 is the lowest pick number?

table_id: 1-14655757-1
label: SELECT MIN("Pick #") 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:
| Benalla DFL   |   Wins |   Losses |   Draws |   Byes |   Against |
|:--------------|-------:|---------:|--------:|-------:|----------:|
| goorambat     |     13 |        3 |       0 |      4 |      1045 |
| longwood      |     10 |        6 |       0 |      4 |      1316 |
| bonnie doon   |     10 |        6 |       0 |      4 |      1411 |
| tatong        |      7 |        9 |       0 |      4 |      1709 |
| swanpool      |      0 |       16 |       0 |      4 |      1878 |

Question: What is the most wins for draws greater than 0?

table_id: 2-17982145-1
label: SELECT MAX("Wins") FROM "table" WHERE "Draws" > 0
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| 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: Who was the home team on April 20 against Boston?

table_id: 2-17342287-11
label: SELECT "Home Team" FROM "table" WHERE "Road Team" = "boston" AND "Date" = "april 20"
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 |   Year | Name               | Moving from      | Moving to            |
|-------:|-------:|:-------------------|:-----------------|:---------------------|
|      1 |   2013 | willian            | shakhtar donetsk | anzhi makhachkala    |
|      2 |   2009 | dmytro chygrynskiy | shakhtar donetsk | barcelona            |
|      3 |   1999 | andriy shevchenko  | dynamo kyiv      | milan                |
|      4 |   2007 | anatoliy tymoschuk | shakhtar donetsk | zenit st. petersburg |
|      5 |   2000 | serhiy rebrov      | dynamo kyiv      | tottenham hotspur    |
|      6 |   2007 | elano              | shakhtar donetsk | manchester city      |
|      7 |   2007 | matuzalém          | shakhtar donetsk | real zaragoza        |
|      8 |   2009 | ismaël bangoura    | dynamo kyiv      | rennes               |
|      9 |   2000 | kakha kaladze      | dynamo kyiv      | milan                |
|     10 |   2007 | ciprian marica     | shakhtar donetsk | stuttgart            |

Question: Where did the player move from that went to stuttgart?

table_id: 2-12601456-2
label: SELECT "Moving from" FROM "table" WHERE "Moving to" = "stuttgart"
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 title                  | Directed by    | Written by                      | Original airdate   | Duration   | Viewership   |
|----------:|:--------------------------------|:---------------|:--------------------------------|:-------------------|:-----------|:-------------|
|        16 | " but is it art? "              | dewi humphreys | jim sullivan                    | 2november2007      | 30 minutes | 5.34 million |
|        17 | " the lonely herdsman "         | dewi humphreys | jim sullivan                    | 9november2007      | 30 minutes | 4.62 million |
|        18 | " if you go down to the woods " | dewi humphreys | jim sullivan                    | 23november2007     | 30 minutes | 5.20 million |
|        19 | " sweet sorrow "                | dewi humphreys | john sullivan and keith lindsay | 30november2007     | 30 minutes | 6.05 million |
|        20 | " fifteen minutes "             | dewi humphreys | david cantor                    | 7december2007      | 30 minutes | 5.08 million |
|        21 | " the final curtain "           | dewi humphreys | john sullivan                   | 14december2007     | 30 minutes | 5.46 million |

Question: Name the total number of episodes written by david cantor

table_id: 1-17641206-6
label: SELECT COUNT("Episode") FROM "table" WHERE "Written by" = "David Cantor"
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       | Season    | Playing for   | Opponent       | Final score   |
|:-----------|:----------|:--------------|:---------------|:--------------|
| 2008-07-31 | 2008–09 a | motagua       | hispano        | 2 – 1 w       |
| 2009-02-26 | 2008–09 c | motagua       | platense       | 3 – 4 l       |
| 2009-03-01 | 2008–09 c | motagua       | victoria       | 1 – 1 d       |
| 2009-07-19 | 2009–10 a | motagua       | real juventud  | 2 – 0 w       |
| 2009-09-13 | 2009–10 a | motagua       | real juventud  | 3 – 0 w       |
| 2009-09-20 | 2009–10 a | motagua       | deportes savio | 2 – 0 w       |
| 2010-02-03 | 2009–10 c | motagua       | real juventud  | 3 – 1 w       |
| 2010-03-11 | 2009–10 c | motagua       | deportes savio | 1 – 1 d       |
| 2010-09-11 | 2010–11 a | motagua       | vida           | 2 – 2 d       |
| 2010-11-07 | 2010–11 a | motagua       | real españa    | 1 – 1 d       |

Question: what is the date when the opponent is real juventud?

table_id: 2-18429683-1
label: SELECT "Date" FROM "table" WHERE "Opponent" = "real juventud"
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:
| Goalkeeper       |   Goals |   Matches |   Average | Team             |
|:-----------------|--------:|----------:|----------:|:-----------------|
| víctor valdés    |      31 |        35 |      0.89 | barcelona        |
| andrés palop     |      35 |        35 |      1    | sevilla          |
| daniel aranzubia |      45 |        37 |      1.22 | deportivo        |
| toño martínez    |      41 |        33 |      1.24 | racing santander |
| carlos kameni    |      47 |        37 |      1.27 | espanyol         |
| iker casillas    |      52 |        38 |      1.37 | real madrid      |
| diego lópez      |      54 |        38 |      1.42 | villarreal       |
| asier riesgo     |      57 |        38 |      1.5  | recreativo       |
| leo franco       |      48 |        32 |      1.5  | atlético madrid  |
| gorka iraizoz    |      60 |        36 |      1.67 | athletic bilbao  |

Question: How many goals were scored on the goalkeeper with fewer than 37 matches and an average of 1.5?

table_id: 2-17201869-9
label: SELECT "Goals" FROM "table" WHERE "Matches" < 37 AND "Average" = 1.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:
| Team 1             | Agg.   | Team 2                 | 1st leg   | 2nd leg   |
|:-------------------|:-------|:-----------------------|:----------|:----------|
| abaluhya united    | 4-2    | saint-george sa        | 1-1       | 3-1       |
| africa sports      | 6-4 1  | tp englebert           | 2-0       | 4-4       |
| etoile du congo    | 4-6    | oryx douala            | 1-2       | 3-4       |
| far rabat          | 3-0    | foyer france           | 2-0       | 1-0       |
| mighty barolle     | 1-4    | conakry ii             | 1-2       | 0-2 2     |
| police (mogadishu) | 2-4    | al-mourada             | 1-1       | 1-3       |
| stationery stores  | 4-4 3  | cape coast dwarfs      | 3-2       | 1-2       |
| us ouagadougou     | 1-6    | etoile filante de lomé | 1-4       | 0-2       |

Question: What was the score of the second leg with an agg of 4-6?

table_id: 2-12330040-2
label: SELECT "2nd leg" FROM "table" WHERE "Agg." = "4-6"
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:
|   Position | Club                   |   Games played |   Wins |   Draws |   Loses |   Goals scored |   Goals conceded |   Points |
|-----------:|:-----------------------|---------------:|-------:|--------:|--------:|---------------:|-----------------:|---------:|
|          1 | sm šilutė-2            |             20 |     16 |       3 |       1 |             88 |               12 |       51 |
|          2 | sakuona plikiai        |             20 |     17 |       0 |       3 |             96 |               23 |       51 |
|          3 | tauras ir erra tauragė |             20 |     13 |       3 |       4 |             71 |               28 |       42 |
|          4 | švyturys klaipėda      |             20 |     12 |       3 |       5 |             55 |               23 |       39 |
|          5 | glestum klaipėda       |             20 |     12 |       3 |       5 |             48 |               22 |       39 |
|          6 | minija kretinga        |             20 |      9 |       4 |       7 |             40 |               30 |       31 |
|          7 | bangele gargždai       |             20 |      8 |       1 |      11 |             40 |               42 |       25 |
|          8 | salantas salantai      |             20 |      5 |       1 |      14 |             23 |               66 |       16 |
|          9 | piritas klaipėda       |             20 |      4 |       2 |      14 |             25 |               48 |       14 |
|         10 | fk pagėgiai            |             20 |      3 |       1 |      16 |             18 |               96 |       10 |

Question: How many points did piritas klaipėda get?

table_id: 1-16034882-4
label: SELECT "Points" FROM "table" WHERE "Club" = "Piritas Klaipėda"
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       | tiger woods          | united states |      65 | –6       |
| 2       | miguel ángel jiménez | spain         |      66 | –5       |
| 3       | john huston          | united states |      67 | –4       |
| t4      | bobby clampett       | united states |      68 | –3       |
| t4      | hale irwin           | united states |      68 | –3       |
| t4      | loren roberts        | united states |      68 | –3       |
| t7      | ángel cabrera        | argentina     |      69 | –2       |
| t7      | nick faldo           | england       |      69 | –2       |
| t7      | rocco mediate        | united states |      69 | –2       |
| t7      | hal sutton           | united states |      69 | –2       |

Question: WHAT IS THE PLAYER WITH A SCORE OF 66?

table_id: 2-17128242-4
label: SELECT "Player" FROM "table" WHERE "Score" = 66
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 | Host Nation(s)   | Final Venue   | Winner             | Result                                    | Runner-up          |
|-------:|:-----------------|:--------------|:-------------------|:------------------------------------------|:-------------------|
|   2000 | england          | northampton   | ireland 6 points   | ireland won on points table               | [[|]] 2 points     |
|   2001 | scotland         | edinburgh     | [[|]] 6 points     | scotland won on points table              | ireland 4 points   |
|   2002 | england          | oundle        | [[|]] 6 points     | scotland won on points table              | [[|]] 4 points     |
|   2003 | netherlands      | deventer      | ireland 6 points   | ireland won on points table               | [[|]] 2 points     |
|   2004 | england          | oundle        | ireland 4 points   | ireland and scotland drew on points table | [[|]] 4 points     |
|   2005 | scotland         | dundee        | [[|]] 6 points     | scotland won on points table              | ireland 4 points   |
|   2006 | northern ireland | belfast       | ireland 59 points  | ireland won on points table               | [[|]] 37 points    |
|   2007 | northern ireland | belfast       | ireland 6 points   | ireland won on points table               | [[|]] 4 points     |
|   2008 | scotland         | glasgow       | [[|]] +3.49(nrr)   | scotland won on net run rate table        | ireland +1.22(nrr) |
|   2009 | jersey           | jersey        | ireland +1.69(nrr) | ireland won on net run rate table         | [[|]] +1.45(nrr)   |

Question: Which nation hosted the competition in 2004?

table_id: 1-28601467-1
label: SELECT "Host Nation(s)" FROM "table" WHERE "Year" = 2004
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:
| Res.   | Record   | Opponent           | Method                | Event                   |   Round | Time   | Location                  |
|:-------|:---------|:-------------------|:----------------------|:------------------------|--------:|:-------|:--------------------------|
| loss   | 4-2-1    | valdas pocevičius  | decision (split)      | ng 4 - noc gladiatora 4 |       3 | 5:00   | dubrovnik , croatia       |
| loss   | 4-1-1    | mostapha al-turk   | submission (punches)  | cage rage 25            |       1 | 3:19   | london , england          |
| win    | 4-0-1    | julius francis     | submission (punches)  | cage rage 23            |       2 | 2:17   | london , england          |
| win    | 3-0-1    | edson claas vieira | tko (corner stoppage) | cage rage 22            |       2 | 5:00   | london , england          |
| win    | 2-0-1    | tank abbott        | tko (punches)         | cage rage 21            |       1 | 2:31   | london , england          |
| draw   | 1-0-1    | lee macguinness    | draw                  | total fight krg 5       |       2 | 5:00   | buckinghamshire , england |
| win    | 1-0      | joe akano          | ko                    | night of the samurai 3  |       2 | n/a    | milton keynes , england   |

Question: At what Location was the match Method TKO (punches)?

table_id: 2-15791836-3
label: SELECT "Location" FROM "table" WHERE "Method" = "tko (punches)"
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:
| Institution          | Location                  |   Founded | Type    |   Enrollment | Nickname   |   Joined |   Left | Current Conference     |
|:---------------------|:--------------------------|----------:|:--------|-------------:|:-----------|---------:|-------:|:-----------------------|
| anna maria college   | paxton, massachusetts     |      1946 | private |         1432 | amcats     |     1984 |   2011 | great northeast (gnac) |
| colby–sawyer college | new london, new hampshire |      1837 | private |         1200 | chargers   |     1994 |   2011 | north atlantic (nac)   |
| emerson college      | boston, massachusetts     |      1880 | private |         4290 | lions      |     1984 |   1989 | newmac                 |
| hellenic college     | brookline, massachusetts  |      1937 | private |          222 | owls       |     1984 |   1985 | dropped athletics      |
| new england college  | henniker, new hampshire   |      1946 | private |         1460 | pilgrims   |     1989 |   2011 | north atlantic (nac)   |
| regis college †      | weston, massachusetts     |      1927 | private |         1737 | pride      |     1988 |   2011 | necc                   |

Question: Which conference has the nickname Lions?

table_id: 1-1973729-2
label: SELECT "Current Conference" FROM "table" WHERE "Nickname" = "Lions"
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             | Round          | Opponents        | Result F–A              |   Attendance |
|:-----------------|:---------------|:-----------------|:------------------------|-------------:|
| 8 january 2005   | round 3        | exeter city      | 0–0                     |        67551 |
| 19 january 2005  | round 3 replay | exeter city      | 2–0                     |         9033 |
| 29 january 2005  | round 4        | middlesbrough    | 3–0                     |        67251 |
| 19 february 2005 | round 5        | everton          | 2–0                     |        38664 |
| 12 march 2005    | round 6        | southampton      | 4–0                     |        30971 |
| 17 april 2005    | semi-final     | newcastle united | 4–1                     |        69280 |
| 21 may 2005      | final          | arsenal          | 0–0 ( a.e.t. ) (4–5 p ) |        71876 |

Question: Name the most attendance for 19 february 2005

table_id: 2-13005521-5
label: SELECT MAX("Attendance") FROM "table" WHERE "Date" = "19 february 2005"
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   |   Number | School/Club Team   | Season    | Acquisition via   |
|:------------------|:-----------|---------:|:-------------------|:----------|:------------------|
| edgar echavez     | guard      |       12 | misamis institute  | 2007      | free agency       |
| rosell ellis      | forward    |       26 | mcneese state      | 2002      | import            |
| ronjay enrile     | guard      |       21 | letran             | 2006-2012 | rookie draft      |
| dennis espino     | center     |       16 | santo tomas        | 2009-2011 | free agency       |
| tony boy espinosa | guard      |       13 | la salle           | 2006      | free agency       |

Question: What is School/Club Team, when Season is 2006-2012?

table_id: 2-15463188-5
label: SELECT "School/Club Team" FROM "table" WHERE "Season" = "2006-2012"
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 | Title                             | Role             | Director         | Notes             |
|-------:|:----------------------------------|:-----------------|:-----------------|:------------------|
|   2002 | the angry brigade                 | john barker      | peter kavanagh   | bbc radio 4       |
|   2006 | dracula                           | jonathan harker  | marion nancarrow | bbc world service |
|   2006 | another country                   | tommy judd       | marc beeby       | bbc radio 4       |
|   2007 | caesar iii: an empire without end | romulus          | jeremy mortimer  | bbc radio 4       |
|   2008 | othello                           | cassio           | michael grandage | bbc radio 3       |
|   2008 | the leopard                       | tancredi         | lucy bailey      | bbc radio 3       |
|   2008 | cyrano de bergerac                | christian        | david timson     | bbc radio 3       |
|   2009 | carnival                          | lords of misrule | zahid warley     | bbc radio 3       |

Question: Year larger than 2008 includes which notes?

table_id: 2-15003874-4
label: SELECT "Notes" FROM "table" WHERE "Year" > 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:
| Headphone Model   | Headphone Class        | Sensitivity (dB)   |   Impedance (Ohms) | Driver-matched dB   | Construction   | Earpads   | Termination                          | Succeeded by   |
|:------------------|:-----------------------|:-------------------|-------------------:|:--------------------|:---------------|:----------|:-------------------------------------|:---------------|
| sr40              | unknown                | 100                |                 32 | unknown             | plastic        | foam      | 1/8" (3.5 mm) plug with 1/4" adaptor | igrado         |
| sr325             | prestige               | 98                 |                 32 | 0.05                | aluminum alloy | bowls     | 1/4" (6.5 mm) plug                   | sr325i         |
| hp1000            | joseph grado signature | unknown            |                 40 | unknown             | aluminum alloy | flats     | 1/4" (6.5 mm) plug                   | no successor   |
| sr100             | prestige               | unknown            |                 32 | unknown             | plastic        | flats     | 1/4" (6.5 mm) plug                   | sr125          |
| sr200             | prestige               | unknown            |                 32 | unknown             | plastic        | flats     | 1/4" (6.5 mm) plug                   | sr225          |

Question: Name the headphone model for succeeded by sr125

table_id: 1-1601027-2
label: SELECT "Headphone Model" FROM "table" WHERE "Succeeded by" = "SR125"
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   | Player          | Position   | Nationality    | College/Junior/Club Team (League)   |
|:--------|:----------------|:-----------|:---------------|:------------------------------------|
| 1       | claude boivin   | left wing  | canada         | drummondville voltigeurs ( qmjhl )  |
| 2       | pat murray      | left wing  | canada         | michigan state spartans ( ccha )    |
| 3       | craig fisher    | left wing  | canada         | oshawa legionaires ( metjhl )       |
| 3       | dominic roussel | goaltender | canada         | trois-rivières draveurs (qmjhl)     |
| 4       | scott lagrand   | goaltender | united states  | hotchkiss school (conn.)            |
| 5       | edward o'brien  | left wing  | united states  | cushing academy (massachusetts)     |
| 6       | gord frantti    | defense    | united states  | calumet high school (mich.)         |
| 7       | jamie cooke     | right wing | canada         | bramalea blues (metjhl)             |
| 8       | johann salle    | defense    | sweden         | malmö if ( elitserien )             |
| 9       | brian arthur    | defense    | canada         | etobicoke capitals (cjbhl)          |
| 10      | jeff dandreta   | right wing | united states  | cushing academy (massachusetts)     |
| 11      | scott billey    | right wing | united states  | madison capitols ( ushl )           |
| 12      | dragomir kadlec | defense    | czech republic | dukla jihlava (cze)                 |
| sup     | paul connell    | goaltender | united states  | bowling green falcons (ccha)        |

Question: What is the nationality of the player in round 7?

table_id: 2-14323142-16
label: SELECT "Nationality" FROM "table" WHERE "Round" = "7"