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    | Platform   | Indication                          | Status       | Collaboration                  |
|:--------|:-----------|:------------------------------------|:-------------|:-------------------------------|
| tru-015 | smip       | rheumatoid arthritis                | phase 2b     | wyeth                          |
| sbi-087 | smip       | rheumatoid arthritis                | phase 1      | wyeth                          |
| sbi-087 | smip       | systemic lupus erythematosus        | phase 1      | wyeth                          |
| tru-016 | smip       | chronic lymphocytic leukemia        | phase 1/2    | trubion proprietary technology |
| tru-016 | smip       | non-hodgkin lymphoma                | pre-clinical | trubion proprietary technology |
| tru-016 | smip       | autoimmune disease and inflammation | pre-clinical | trubion proprietary technology |

Question: Which study included autoimmune disease and inflammation?

table_id: 2-18649568-1
label: SELECT "Name" FROM "table" WHERE "Indication" = "autoimmune disease and inflammation"
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       | lee trevino      | united states |      67 | –5       |
| 2       | nick faldo       | england       |      68 | –4       |
| 3       | scott hoch       | united states |      69 | –3       |
| t4      | andy bean        | united states |      70 | –2       |
| t4      | don pooley       | united states |      70 | –2       |
| t6      | seve ballesteros | spain         |      71 | –1       |
| t6      | t.c. chen        | taiwan        |      71 | –1       |
| t6      | ben crenshaw     | united states |      71 | –1       |
| t6      | jumbo ozaki      | japan         |      71 | –1       |
| t6      | tom purtzer      | united states |      71 | –1       |

Question: When Tom Purtzer of the United States played what is the maximum score?

table_id: 2-16514242-3
label: SELECT MAX("Score") FROM "table" WHERE "Country" = "united states" AND "Player" = "tom purtzer"
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:
| Publication      | Country        | Accolade                                         |   Year |   Rank |
|:-----------------|:---------------|:-------------------------------------------------|-------:|-------:|
| dagsavisen       | norway         | the 21 best albums of the 21st century           |   2005 |     16 |
| vpro             | netherlands    | 299 nominations of the best album of all time    |   2006 |     33 |
| harp             | united states  | 50 most essential albums since 2001"             |   2006 |     48 |
| nme              | united kingdom | the 100 greatest albums of the decade            |   2009 |     15 |
| uncut            | united kingdom | uncut's albums of the decade                     |   2009 |     28 |
| pitchfork media  | united states  | the top 200 albums of the 2000s                  |   2009 |    134 |
| decibel magazine | united states  | the 100 greatest metal albums of the decade      |   2009 |      7 |
| rock hard        | germany        | the 500 greatest rock & metal albums of all time |   2005 |    380 |

Question: What is the highest Year, when Rank is less than 28, and when Accolade is "The 100 greatest metal albums of the decade"?

table_id: 2-159123-2
label: SELECT MAX("Year") FROM "table" WHERE "Rank" < 28 AND "Accolade" = "the 100 greatest metal albums of the decade"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Date               | Tournament     | Surface   | Opponent in final    | Score          | Prize Money   |
|:-------------------|:---------------|:----------|:---------------------|:---------------|:--------------|
| march 27, 2005     | athens         | clay      | mădălina gojnea      | 6-1 6-3        | $10,000       |
| june 11, 2006      | haskovo        | clay      | dia evtimova         | 6-4 6-7(5) 6-3 | $10,000       |
| february 24, 2007  | melilla        | hard      | carla suárez navarro | 6-4 6-4        | $10,000       |
| september 22, 2007 | telavi         | clay      | corinna dentoni      | 6-2 1-6 6-0    | $25,000       |
| july 6, 2008       | mont-de-marsan | clay      | anastasiya yakimova  | 6-3 1-6 6-4    | $25,000       |
| november 2, 2008   | istanbul       | hard      | andrea petkovic      | 6-2 6-2        | $25,000       |
| october 18, 2009   | lagos          | hard      | zuzana kučová        | 6-3 7-5        | $25,000       |
| january 17, 2010   | pingguo        | hard      | zhou yi-miao         | 6-3 6-0        | $25,000       |

Question: What is the Score of the Pingguo Tournament?

table_id: 2-18910203-3
label: SELECT "Score" FROM "table" WHERE "Tournament" = "pingguo"
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         | City                    | Opponent     | Results¹   | Type of game       |
|:-------------|:------------------------|:-------------|:-----------|:-------------------|
| april 4      | split                   | netherlands  | 2:0        | euro 72' qualifier |
| april 21     | novi sad                | romania      | 0:1        | friendly           |
| may 9        | leipzig , germany       | east germany | 2:1        | euro 72' qualifier |
| july 18      | rio de janeiro , brazil | brazil       | 2:2        | friendly           |
| september 1  | budapest , hungary      | hungary      | 1:2        | friendly           |
| september 22 | sarajevo                | mexico       | 4:0        | friendly           |
| october 16   | belgrade                | east germany | 0:0        | euro 72' qualifier |
| october 27   | podgorica               | luxembourg   | 0:0        | euro 72' qualifier |

Question: What was the result of the game against Luxembourg?

table_id: 2-14305653-49
label: SELECT "Results¹" FROM "table" WHERE "Opponent" = "luxembourg"
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 | Player        | Team                | Position   |   Year |
|-------:|:--------------|:--------------------|:-----------|-------:|
|     13 | rick leach    | detroit tigers      | of         |   1979 |
|     16 | steve howe    | los angeles dodgers | lhp        |   1979 |
|     25 | steve perry   | los angeles dodgers | rhp        |   1979 |
|     14 | rich stoll    | montreal expos      | rhp        |   1983 |
|      4 | barry larkin  | cincinnati reds     | ss         |   1985 |
|      8 | jim abbott    | california angels   | lhp        |   1988 |
|     28 | david parrish | new york yankees    | c          |   2000 |

Question: What is the average pick in 1983?

table_id: 2-18233834-8
label: SELECT AVG("Pick") FROM "table" WHERE "Year" = 1983
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Province      |   Rd 1 | Rd 2 1   |   Rd 3 |   Rd 4 |
|:--------------|-------:|:---------|-------:|-------:|
| drenthe       |      2 | 1+1      |      1 |      0 |
| flevoland     |      0 | 0+1      |      1 |      0 |
| friesland     |      1 | 0+2      |      2 |      1 |
| gelderland    |      7 | 5+4      |      6 |      4 |
| groningen     |      4 | 1+2      |      1 |      1 |
| limburg       |      2 | 1+4      |      2 |      1 |
| north brabant |      9 | 1+10     |      6 |      1 |
| north holland |      4 | 2+5      |      4 |      2 |
| overijssel    |      5 | 3+5      |      2 |      1 |
| south holland |     11 | 7+5      |      7 |      5 |
| utrecht       |      3 | 3+1      |      0 |      0 |
| zeeland       |      0 | 0+0      |      0 |      0 |
| total         |     48 | 24+40 64 |     32 |     16 |

Question: What Rd 3 has a Rd 2 1 of 0+1?

table_id: 2-18347334-1
label: SELECT "Rd 3" FROM "table" WHERE "Rd 2 1" = "0+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:
|   Week | Date               | Opponent               | Result   | Attendance   |
|-------:|:-------------------|:-----------------------|:---------|:-------------|
|      1 | september 6, 1992  | los angeles raiders    | w 17–13  | 75,418       |
|      2 | september 13, 1992 | san diego chargers     | w 21–13  | 74,367       |
|      3 | september 20, 1992 | at philadelphia eagles | l 30–0   | 65,833       |
|      4 | september 27, 1992 | at cleveland browns    | w 12–0   | 78,064       |
|      5 | october 4, 1992    | kansas city chiefs     | w 20–19  | 75,629       |
|      6 | october 12, 1992   | at washington redskins | l 34–3   | 56,371       |
|      7 | october 18, 1992   | houston oilers         | w 27–21  | 74,827       |
|      8 | october 25, 1992   | at san diego chargers  | l 24–21  | 53,576       |
|      9 | bye                | bye                    | bye      | bye          |
|     10 | november 8, 1992   | new york jets          | w 27–16  | 74,678       |
|     11 | november 15, 1992  | new york giants        | w 27–13  | 75,269       |
|     12 | november 22, 1992  | at los angeles raiders | l 24–0   | 50,011       |
|     13 | november 30, 1992  | at seattle seahawks    | l 16–13  | 51,612       |
|     14 | december 6, 1992   | dallas cowboys         | l 31–27  | 74,946       |
|     15 | december 12, 1992  | at buffalo bills       | l 27–17  | 71,740       |
|     16 | december 20, 1992  | seattle seahawks       | w 10–6   | 72,570       |
|     17 | december 27, 1992  | at kansas city chiefs  | l 42–20  | 76,240       |

Question: Which Opponent has Attendance of 71,740?

table_id: 2-18332184-1
label: SELECT "Opponent" FROM "table" WHERE "Attendance" = "71,740"
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         |
|:------------|:------------------|:----------------|:------------------|:----------------|--------:|:-------------|
| richmond    | 12.18 (90)        | south melbourne | 11.13 (79)        | mcg             |   22870 | 10 july 1971 |
| hawthorn    | 20.5 (125)        | st kilda        | 15.12 (102)       | glenferrie oval |   21647 | 10 july 1971 |
| essendon    | 11.12 (78)        | melbourne       | 12.17 (89)        | windy hill      |   14093 | 10 july 1971 |
| carlton     | 21.15 (141)       | geelong         | 15.14 (104)       | princes park    |   21000 | 10 july 1971 |
| fitzroy     | 11.18 (84)        | collingwood     | 16.6 (102)        | junction oval   |   24926 | 10 july 1971 |
| footscray   | 22.31 (163)       | north melbourne | 11.5 (71)         | vfl park        |   10075 | 10 july 1971 |

Question: When the away team was north melbourne, what was the away team score?

table_id: 2-10826072-15
label: SELECT "Away team score" FROM "table" WHERE "Away team" = "north melbourne"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Model Number      | sSpec Number               | Frequency   | L2 Cache   | Mult   | Voltage   | Socket     | Release Date    | Part Number(s)   |
|:------------------|:---------------------------|:------------|:-----------|:-------|:----------|:-----------|:----------------|:-----------------|
| pentium iii 1000  | sl5gr                      | 1ghz        | 256 kb     | 7.5×   | 1.475 v   | socket 370 | july 2001       | rk80530pz001256  |
| pentium iii 1000s | sl5ps                      | 1ghz        | 512 kb     | 7.5×   | 1.475 v   | socket 370 | june 2001       | rk80530kz001512  |
| pentium iii 1133  | sl5gq, sl5lt, sl6c4, sl6jk | 1.13ghz     | 256 kb     | 8.5×   | 1.475 v   | socket 370 | july 2001       | rk80530pz006256  |
| pentium iii 1133s | sl5lv, sl5pu, sl6bw, sl6jm | 1.13ghz     | 512 kb     | 8.5×   | 1.45 v    | socket 370 | june 2001       | rk80530kz006512  |
| pentium iii 1200  | sl5gn, sl5pm, sl6c3, sl6jl | 1.2ghz      | 256 kb     | 9×     | 1.475 v   | socket 370 | july 2001       | rk80530pz009256  |
| pentium iii 1266s | sl5lw, sl5ql, sl6bx, sl6jn | 1.26ghz     | 512 kb     | 9.5×   | 1.45 v    | socket 370 | july 2001       | rk80530kz012512  |
| pentium iii 1333  | sl5vx, sl6bz, sl6hs        | 1.33ghz     | 256 kb     | 10×    | 1.475 v   | socket 370 | december 2001   | rk80530pz014256  |
| pentium iii 1400  | sl64w, sl6c2, sl6hr        | 1.4ghz      | 256 kb     | 10.5×  | 1.5 v     | socket 370 | december 2001   | rk80530pz017256  |
| pentium iii 1400s | sl5xl, sl657, sl6by, sl6jp | 1.4ghz      | 512 kb     | 10.5×  | 1.45 v    | socket 370 | january 8, 2002 | rk80530kz017512  |

Question: What is the L2 Cache when the Part Number(s) is rk80530pz014256?

table_id: 2-16400024-4
label: SELECT "L2 Cache" FROM "table" WHERE "Part Number(s)" = "rk80530pz014256"
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           |
|:----------------|:------------------|:----------------|:------------------|:----------------------|--------:|:---------------|
| hawthorn        | 10.11 (71)        | st kilda        | 5.5 (35)          | glenferrie oval       |   12000 | 15 august 1959 |
| fitzroy         | 10.23 (83)        | north melbourne | 7.11 (53)         | brunswick street oval |   14774 | 15 august 1959 |
| collingwood     | 17.17 (119)       | richmond        | 5.10 (40)         | victoria park         |   23856 | 15 august 1959 |
| south melbourne | 11.10 (76)        | footscray       | 12.13 (85)        | lake oval             |   14100 | 15 august 1959 |
| geelong         | 12.9 (81)         | essendon        | 15.16 (106)       | kardinia park         |   15076 | 15 august 1959 |
| melbourne       | 13.14 (92)        | carlton         | 7.5 (47)          | mcg                   |   53479 | 15 august 1959 |

Question: What is the home team score when st kilda is the away team?

table_id: 2-10775038-16
label: SELECT "Home team score" FROM "table" WHERE "Away team" = "st kilda"
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            | Label   | Region                       | Format    | Catalog   |
|:----------------|:--------|:-----------------------------|:----------|:----------|
| early july 2008 | polydor | belgium, switzerland         | digital   | —         |
| 19 july 2008    | polydor | france                       | digital   | —         |
| 18 august 2008  | polydor | belgium, france, switzerland | cd maxi   | 5310110   |
| 18 august 2008  | polydor | belgium, france, switzerland | 12"       | 5310111   |
| 18 august 2008  | polydor | belgium, france, switzerland | cd single | 5310112   |

Question: In what region was Degeneration released in digital format on 19 July 2008?

table_id: 2-17540670-1
label: SELECT "Region" FROM "table" WHERE "Format" = "digital" AND "Date" = "19 july 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:
| Region         | Date              | Label                              | Format       | Catalogue   |
|:---------------|:------------------|:-----------------------------------|:-------------|:------------|
| japan          | 25 september 2001 | epic japan                         | compact disc | esca-8341   |
| united kingdom | 23 july 2001      | epic                               | compact disc | 5024132     |
| united kingdom | 23 july 2001      | epic                               | minidisc     | 5024130     |
| united kingdom | 23 july 2001      | epic                               | dvd          | 201457 9    |
| united kingdom | 23 july 2001      | epic                               | vinyl record | 5024139     |
| united states  | 19 march 2002     | xl recordings / beggars banquet us | compact disc | bxl 026 cd  |

Question: What format has United Kingdom as its region and is catalogued as 201457 9?

table_id: 2-1111379-1
label: SELECT "Format" FROM "table" WHERE "Region" = "united kingdom" AND "Catalogue" = "201457 9"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   NGC number | Object type       | Constellation   | Right ascension ( J2000 )   | Declination ( J2000 )   |
|-------------:|:------------------|:----------------|:----------------------------|:------------------------|
|         6302 | planetary nebula  | scorpius        | 17h13m44.2s                 | °06′16″                 |
|         6304 | globular cluster  | ophiuchus       | 17h14m32.5s                 | °27′44″                 |
|         6333 | globular cluster  | ophiuchus       | 17h19m11.8s                 | °30′59″                 |
|         6334 | supernova remnant | scorpius        | 17h19m58.0s                 | °57′47″                 |
|         6340 | spiral galaxy     | draco           | 17h10m25.1s                 | °18′17″                 |
|         6341 | globular cluster  | hercules        | 17h17m07.3s                 | °08′12″                 |
|         6357 | diffuse nebula    | scorpius        | 17h24m                      | °20′                    |
|         6369 | planetary nebula  | ophiuchus       | 17h29m20.4s                 | °45′34″                 |
|         6397 | globular cluster  | ara             | 17h40m41.4s                 | °40′25″                 |

Question: For the constellation scorpius and object of planetary nebula, what was the declination (J2000)?

table_id: 2-11051842-4
label: SELECT "Declination ( J2000 )" FROM "table" WHERE "Constellation" = "scorpius" AND "Object type" = "planetary nebula"
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   | Opponent       | Venue   | Result   |   Attendance |
|:-----------------|:--------|:---------------|:--------|:---------|-------------:|
| 25 november 1893 | r1      | cowlairs       | h       | 8–0      |         5000 |
| 16 december 1893 | r2      | leith athletic | h       | 2–0      |        25000 |
| 13 january 1894  | qf      | clyde          | a       | 5–0      |        10000 |
| 3 february 1894  | sf      | queen's park   | h       | 1–1      |        15000 |
| 10 february 1894 | sf rpl  | queen's park   | a       | 3–1      |        16000 |
| 17 february 1894 | f       | celtic         | n       | 3–1      |        17000 |

Question: Who was the opponent in the round of R2?

table_id: 2-17401571-2
label: SELECT "Opponent" FROM "table" WHERE "Round" = "r2"
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              | Home           | Score   | Away          |   Attendance |
|:------------------|:---------------|:--------|:--------------|-------------:|
| 27 september 2008 | marathon       | 0:2     | real espana   |         9335 |
| 27 september 2008 | vida           | 1:1     | hispano       |          507 |
| 27 september 2008 | platense       | 1:2     | olimpia       |         3518 |
| 27 september 2008 | deportes savio | 3:1     | victoria      |          135 |
| 27 september 2008 | motagua        | 2:1     | real juventud |         1134 |

Question: What was the total attendance for the 3:1 game?

table_id: 2-17026847-14
label: SELECT SUM("Attendance") FROM "table" WHERE "Score" = "3: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:
| Component         | Integrated           | Allied-Related   | Allied-Unrelated    | Holding                         |
|:------------------|:---------------------|:-----------------|:--------------------|:--------------------------------|
| business strategy | one                  | many             | many                | many                            |
| customers         | same                 | shared           | some shared         | many                            |
| corporate role    | resource allocations | define protocols | define protocols    | financial roll-ups and analysis |
| human capital     | common               | some shared      | some shared         | independent                     |
| it systems        | common               | common           | few, interconnected | different                       |

Question: What is the name of the integrated where the component are customers?

table_id: 1-11944282-1
label: SELECT "Integrated" FROM "table" WHERE "Component" = "Customers"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   Round |   Pick # | Player           | Position      | College              |
|--------:|---------:|:-----------------|:--------------|:---------------------|
|       1 |        5 | terry miller     | running back  | oklahoma state       |
|       2 |       33 | dee hardison     | defensive end | north carolina       |
|       2 |       38 | scott hutchinson | defensive end | florida              |
|       3 |       59 | dennis johnson   | running back  | mississippi state    |
|       3 |       65 | danny fulton     | wide receiver | nebraska-omaha       |
|       4 |       89 | lucius sanford   | linebacker    | georgia tech         |
|       5 |      114 | ken spaeth       | tight end     | nebraska             |
|       6 |      145 | eric smith       | tackle        | southern mississippi |
|       7 |      171 | mario celotto    | linebacker    | usc                  |
|       7 |      183 | steve powell     | running back  | n.e. missouri state  |
|      10 |      255 | will grant       | center        | kentucky             |
|      11 |      282 | jerry blanton    | linebacker    | kentucky             |
|      12 |      309 | richard crump    | running back  | n.e. oklahoma a&m    |

Question: Richard Crump picked after the 114 pick was drafted in what round?

table_id: 2-17386069-1
label: SELECT "Round" FROM "table" WHERE "Pick #" > 114 AND "Player" = "richard crump"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   Year | Entrant                 | Chassis         | Engine              |   Points |
|-------:|:------------------------|:----------------|:--------------------|---------:|
|   1963 | ecurie maarsbergen      | porsche 718     | porsche flat-4      |        3 |
|   1964 | team lotus              | lotus 25        | climax v8           |        0 |
|   1965 | team lotus              | lotus 25        | climax v8           |        0 |
|   1966 | ron harris / team lotus | lotus 44 f2     | cosworth straight-4 |        0 |
|   1967 | gerhard mitter          | brabham bt23 f2 | cosworth straight-4 |        0 |
|   1969 | bmw                     | bmw 269 f2      | bmw straight-4      |        0 |

Question: What year was there a lotus 25 Chassis?

table_id: 2-1228404-1
label: SELECT "Year" FROM "table" WHERE "Chassis" = "lotus 25"