MMTU-benchmark/MMTU huggingface dataset:
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Home team       | Home team score   | Away team       | Away team score   | Venue                 |   Crowd | Date          |
|:----------------|:------------------|:----------------|:------------------|:----------------------|--------:|:--------------|
| richmond        | 7.11 (53)         | st kilda        | 7.14 (56)         | punt road oval        |   15000 | 6 august 1938 |
| essendon        | 13.9 (87)         | north melbourne | 16.8 (104)        | windy hill            |   10000 | 6 august 1938 |
| south melbourne | 9.16 (70)         | melbourne       | 14.15 (99)        | lake oval             |    8000 | 6 august 1938 |
| geelong         | 13.15 (93)        | footscray       | 10.10 (70)        | corio oval            |   18500 | 6 august 1938 |
| hawthorn        | 12.11 (83)        | collingwood     | 18.15 (123)       | glenferrie oval       |    8000 | 6 august 1938 |
| fitzroy         | 11.10 (76)        | carlton         | 19.12 (126)       | brunswick street oval |   17000 | 6 august 1938 |

Question: Which home team has an Away team score of 19.12 (126)?

table_id: 2-10806592-15
label: SELECT "Home team" FROM "table" WHERE "Away team score" = "19.12 (126)"
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:
|   Vol. # | Title                         | Material collected   |   Pages | ISBN          |
|---------:|:------------------------------|:---------------------|--------:|:--------------|
|        1 | welcome to the treehouse      | tiny titans #1-6     |     144 | 1-40122-078-9 |
|        2 | adventures in awesomeness     | tiny titans #7-12    |     144 | 1-40122-328-1 |
|        3 | sidekickin' it                | tiny titans #13-18   |     144 | 1-40122-653-1 |
|        4 | the first rule of pet club... | tiny titans #19-25   |     160 | 1-40122-892-5 |
|        5 | field trippin'                | tiny titans #26-32   |     160 | 1-40123-173-x |
|        6 | the treehouse and beyond!     | tiny titans #33-38   |     144 | 1401233104    |
|        7 | growing up tiny!              | tiny titans #39-44   |     128 | 1-40123-525-5 |
|        8 | aw yeah titans!               | tiny titans #45-50   |     128 | 1401238122    |

Question: How many pages does the edition with a volume # smaller than 8 and an ISBM of 1-40122-892-5 have?

table_id: 2-15995992-1
label: SELECT SUM("Pages") FROM "table" WHERE "Vol. #" < 8 AND "ISBN" = "1-40122-892-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:
| Tournament             | 2008                   | 2009                   | 2010                   | 2011                   | 2012                   |
|:-----------------------|:-----------------------|:-----------------------|:-----------------------|:-----------------------|:-----------------------|
| grand slam tournaments | grand slam tournaments | grand slam tournaments | grand slam tournaments | grand slam tournaments | grand slam tournaments |
| australian open        | a                      | a                      | a                      | a                      | q1                     |
| french open            | q2                     | a                      | q1                     | q1                     | a                      |
| wimbledon              | a                      | a                      | a                      | q2                     | a                      |
| us open                | a                      | a                      | q2                     | a                      | q1                     |
| win–loss               | 0–0                    | 0–0                    | 0–0                    | 0–0                    | 0–0                    |

Question: What is the 2012 value at the Grand Slam Tournaments?

table_id: 2-12923427-5
label: SELECT "2012" FROM "table" WHERE "Tournament" = "grand slam tournaments"
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:
| Reactor Unit   | Type               | Average Output   | Rated Power   | Began construction   | Finish construction   | Commercial operation   | Close of reactor   |
|:---------------|:-------------------|:-----------------|:--------------|:---------------------|:----------------------|:-----------------------|:-------------------|
| bugey 1        | gas-cooled reactor | 540 mw           | 555 mw        | december 1, 1965     | april 15, 1972        | july 1, 1972           | may 27, 1994       |
| bugey 2        | pwr                | 910 mw           | 945 mw        | november 1, 1972     | may 10, 1978          | march 1, 1979          | 2019 planned       |
| bugey 3        | pwr                | 910 mw           | 945 mw        | september 1, 1973    | september 21, 1978    | march 1, 1979          | 2019 planned       |
| bugey 4        | pwr                | 880 mw           | 917 mw        | june 1, 1974         | march 8, 1979         | july 1, 1979           | 2019 planned       |
| bugey 5        | pwr                | 880 mw           | 917 mw        | july 1, 1974         | july 31, 1979         | january 30, 1980       | 2020 planned       |

Question: What is the rated power for the reactor that ended construction on May 10, 1978?

table_id: 2-12576299-1
label: SELECT "Rated Power" FROM "table" WHERE "Finish construction" = "may 10, 1978"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Rank   | Nation               |   Gold |   Silver |   Bronze |   Total |
|:-------|:---------------------|-------:|---------:|---------:|--------:|
| 1      | soviet union (urs)   |      9 |        8 |        5 |      22 |
| 2      | east germany (gdr)   |      2 |        3 |        6 |      11 |
| 3      | romania (rou)        |      2 |        3 |        2 |       7 |
| 4      | bulgaria (bul)       |      1 |        0 |        1 |       2 |
| 4      | hungary (hun)        |      1 |        0 |        1 |       2 |
| 5      | czechoslovakia (tch) |      0 |        0 |        1 |       1 |
| total  | total                |     15 |       14 |       16 |      45 |

Question: Rank of 5, and a Silver larger than 0 had what sum of total?

table_id: 2-1467991-3
label: SELECT SUM("Total") FROM "table" WHERE "Rank" = "5" AND "Silver" > 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:
| 8:00                   | 8:30                   | 9:00                             | 9:30                             | 10:00             |
|:-----------------------|:-----------------------|:---------------------------------|:---------------------------------|:------------------|
| dancing with the stars | dancing with the stars | dancing with the stars           | surviving suburbia               | castle            |
| the big bang theory    | how i met your mother  | two and a half men               | rules of engagement              | csi: miami        |
| gossip girl            | gossip girl            | one tree hill                    | one tree hill                    | local programming |
| house                  | house                  | 24                               | 24                               | local programming |
| the twilight zone      | the twilight zone      | magic's biggest secrets revealed | magic's biggest secrets revealed | local programming |
| chuck                  | chuck                  | heroes                           | heroes                           | medium            |
| deal or no deal        | deal or no deal        | medium                           | medium                           | medium            |

Question: What is airing at 10:00 on the channel that airs Medium at 9:00?

table_id: 2-15708593-9
label: SELECT "10:00" FROM "table" WHERE "9:00" = "medium"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Home team       | Home team score   | Away team       | Away team score   | Venue                 |   Crowd | Date          |
|:----------------|:------------------|:----------------|:------------------|:----------------------|--------:|:--------------|
| north melbourne | 14.16 (100)       | south melbourne | 9.20 (74)         | arden street oval     |   10000 | 6 august 1960 |
| fitzroy         | 13.13 (91)        | richmond        | 10.11 (71)        | brunswick street oval |   14232 | 6 august 1960 |
| essendon        | 14.11 (95)        | footscray       | 8.10 (58)         | windy hill            |   21000 | 6 august 1960 |
| st kilda        | 9.16 (70)         | geelong         | 13.9 (87)         | junction oval         |   16300 | 6 august 1960 |
| melbourne       | 16.15 (111)       | collingwood     | 9.11 (65)         | mcg                   |   81099 | 6 august 1960 |
| hawthorn        | 13.10 (88)        | carlton         | 9.7 (61)          | glenferrie oval       |   16000 | 6 august 1960 |

Question: When the VFL played Brunswick Street Oval what was the home team score?

table_id: 2-10775890-15
label: SELECT "Home team score" FROM "table" WHERE "Venue" = "brunswick street oval"
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:
| Outcome   |   Year | Championship   | Surface   | Partner          | Opponents                                          | Score                   |
|:----------|-------:|:---------------|:----------|:-----------------|:---------------------------------------------------|:------------------------|
| runner-up |   2006 | berlin         | clay      | elena dementieva | yan zi zheng jie                                   | 2–6, 3–6                |
| runner-up |   2008 | montreal (1)   | hard      | maria kirilenko  | cara black liezel huber                            | 1–6, 1–6                |
| winner    |   2010 | key biscayne   | hard      | gisela dulko     | nadia petrova samantha stosur                      | 6–3, 4–6, [10–7]        |
| winner    |   2010 | rome           | clay      | gisela dulko     | nuria llagostera vives maría josé martínez sánchez | 6–4, 6–2                |
| runner-up |   2010 | madrid         | clay      | gisela dulko     | serena williams venus williams                     | 2–6, 5–7                |
| winner    |   2010 | montreal (2)   | hard      | gisela dulko     | květa peschke katarina srebotnik                   | 7–5, 3–6, [12–10]       |
| runner-up |   2010 | beijing        | hard      | gisela dulko     | chuang chia-jung olga govortsova                   | 6–7 (2-7) , 6–1, [7–10] |
| runner-up |   2011 | tokyo          | hard      | gisela dulko     | liezel huber lisa raymond                          | 6–7 (4-7) , 6–0, [6–10] |

Question: What is the name of the partner that has a winner outcome and a hard surface?

table_id: 1-28948937-3
label: SELECT "Partner" FROM "table" WHERE "Outcome" = "Winner" AND "Surface" = "Hard"
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:
| Official Name   | Status   | Area km 2   |   Population | Census Ranking   |
|:----------------|:---------|:------------|-------------:|:-----------------|
| drummond        | parish   | 1,014.90    |         2250 | 1,231 of 5,008   |
| denmark         | parish   | 750.51      |         1592 | 1,561 of 5,008   |
| gordon          | parish   | 1,430.98    |         1567 | 1,574 of 5,008   |
| grand falls     | parish   | 158.43      |         1172 | 1,871 of 5,008   |
| perth           | parish   | 318.06      |         1096 | 1,956 of 5,008   |
| andover         | parish   | 123.57      |          942 | 2,160 of 5,008   |

Question: What is the census ranking for the Perth parish?

table_id: 1-176524-2
label: SELECT "Census Ranking" FROM "table" WHERE "Official Name" = "Perth"
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 |   Lane | Athlete             | Nationality         |   Time |   React |
|-------:|-------:|:--------------------|:--------------------|-------:|--------:|
|      1 |      6 | rondell sorillo     | trinidad and tobago |  20.58 |   0.193 |
|      2 |      4 | usain bolt          | jamaica             |  20.64 |   0.177 |
|      3 |      2 | kristof beyens      | belgium             |  20.69 |   0.148 |
|      4 |      9 | marc schneeberger   | switzerland         |  20.86 |   0.137 |
|      5 |      7 | josé acevedo        | venezuela           |  21.06 |   0.27  |
|      6 |      8 | ihor bodrov         | ukraine             |  21.38 |   0.172 |
|      7 |      3 | mohamad siraj tamim | lebanon             |  21.8  |   0.206 |
|      8 |      1 | oleg juravlyov      | uzbekistan          |  22.31 |   0.145 |
|      9 |      5 | juan zeledon        | nicaragua           |  23.39 |   0.173 |

Question: What is the average ranking for a react of 0.17300000000000001 and less than 5 lanes?

table_id: 2-18569011-7
label: SELECT AVG("Rank") FROM "table" WHERE "React" = 0.17300000000000001 AND "Lane" < 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:
|   Year | Team                 | League                   | Record   | Finish   | Organization     |
|-------:|:---------------------|:-------------------------|:---------|:---------|:-----------------|
|   1968 | johnson city yankees | appalachian league       | 39-32    | 3rd      | new york yankees |
|   1969 | kinston eagles       | carolina league          | 74-68    | 5th      | new york yankees |
|   1970 | manchester yankees   | eastern league           | 66-73    | 5th      | new york yankees |
|   1971 | kinston eagles       | carolina league          | 83-52    | 2nd      | new york yankees |
|   1972 | kinston eagles       | carolina league          | 73-64    | 3rd      | new york yankees |
|   1973 | kinston eagles       | carolina league          | 68-69    | 4th      | new york yankees |
|   1974 | johnson city yankees | appalachian league       | 31-38    | 6th      | new york yankees |
|   1975 | kingsport braves     | appalachian league       | 33-33    | 6th      | atlanta braves   |
|   1976 | greenwood braves     | western carolinas league | 75-64    | 2nd      | atlanta braves   |
|   1977 | savannah braves      | southern league          | 77-63    | 3rd      | atlanta braves   |
|   1979 | kingsport braves     | appalachian league       | 39-31    | 2nd      | atlanta braves   |

Question: What is the total of the year with a Team of johnson city yankees, and a Finish of 6th?

table_id: 2-11763491-1
label: SELECT SUM("Year") FROM "table" WHERE "Team" = "johnson city yankees" AND "Finish" = "6th"
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 | Park                   | Artist          |   Mintage | Issue Price   |
|-------:|:-----------------------|:----------------|----------:|:--------------|
|   2005 | pacific rim (b.c.)     | susanna blunt   |     20000 | $69.95        |
|   2005 | mingan (québec)        | pierre leduc    |     20000 | $69.95        |
|   2006 | georgian bay (ontario) | tony bianco     |     20000 | $69.95        |
|   2006 | nahanni (nwt)          | virginia boulay |     15000 | $69.95        |
|   2006 | jasper (alberta)       | michelle grant  |     15000 | $69.95        |

Question: What is the sum of all mintage created by Pierre Leduc?

table_id: 2-11916083-42
label: SELECT SUM("Mintage") FROM "table" WHERE "Artist" = "pierre leduc"
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 17, 1972 | at san francisco 49ers | l 34–3   |        59438 |
|      2 | september 24, 1972 | denver broncos         | w 37–14  |        49048 |
|      3 | october 1, 1972    | at oakland raiders     | t 17–17  |        53455 |
|      4 | october 8, 1972    | at baltimore colts     | w 23–20  |        55459 |
|      5 | october 15, 1972   | at miami dolphins      | l 24–10  |        80010 |
|      6 | october 22, 1972   | at detroit lions       | l 34–20  |        54371 |
|      7 | october 29, 1972   | kansas city chiefs     | l 26–14  |        54533 |
|      8 | november 5, 1972   | dallas cowboys         | l 34–28  |        54476 |
|      9 | november 13, 1972  | cleveland browns       | l 21–17  |        54205 |
|     10 | november 19, 1972  | at kansas city chiefs  | w 27–17  |        79011 |
|     11 | november 26, 1972  | houston oilers         | w 34–20  |        46289 |
|     12 | december 3, 1972   | oakland raiders        | l 21–19  |        54611 |
|     13 | december 10, 1972  | at denver broncos      | l 38–13  |        51478 |
|     14 | december 17, 1972  | pittsburgh steelers    | l 24–2   |        52873 |

Question: What is the lowest week on December 3, 1972 with more than 54,533 in attendance?

table_id: 2-15386342-2
label: SELECT MIN("Week") FROM "table" WHERE "Attendance" > 54533 AND "Date" = "december 3, 1972"
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        | 13.7 (85)         | st kilda    | 11.20 (86)        | punt road oval    |   22000 | 13 may 1961 |
| geelong         | 7.13 (55)         | melbourne   | 17.18 (120)       | kardinia park     |   18673 | 13 may 1961 |
| collingwood     | 8.7 (55)          | fitzroy     | 16.20 (116)       | victoria park     |   30560 | 13 may 1961 |
| south melbourne | 12.12 (84)        | footscray   | 12.10 (82)        | lake oval         |   26748 | 13 may 1961 |
| hawthorn        | 9.21 (75)         | essendon    | 12.4 (76)         | glenferrie oval   |   31000 | 13 may 1961 |
| north melbourne | 11.17 (83)        | carlton     | 17.7 (109)        | arden street oval |   21500 | 13 may 1961 |

Question: What venue featured the away side scoring 16.20 (116)?

table_id: 2-10776330-5
label: SELECT "Venue" FROM "table" WHERE "Away team score" = "16.20 (116)"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Date       | Visitor      | Score   | Home         | Record   |
|:-----------|:-------------|:--------|:-------------|:---------|
| october 5  | pittsburgh   | 3 - 3   | new jersey   | 0-0-1    |
| october 8  | ny rangers   | 2 - 3   | new jersey   | 1-0-1    |
| october 9  | new jersey   | 5 - 5   | toronto      | 1-0-2    |
| october 12 | boston       | 2 - 2   | new jersey   | 1-0-3    |
| october 14 | montreal     | 5 - 3   | new jersey   | 1-1-3    |
| october 16 | new jersey   | 6 - 5   | pittsburgh   | 2-1-3    |
| october 18 | philadelphia | 1 - 3   | new jersey   | 3-1-3    |
| october 20 | new jersey   | 4 - 7   | los angeles  | 3-2-3    |
| october 22 | new jersey   | 1 - 3   | winnipeg     | 3-3-3    |
| october 26 | minnesota    | 5 - 3   | new jersey   | 3-4-3    |
| october 28 | ny islanders | 4 - 2   | new jersey   | 3-5-3    |
| october 30 | new jersey   | 5 - 8   | ny islanders | 3-6-3    |

Question: What was the Record for the game on October 30?

table_id: 2-12019734-3
label: SELECT "Record" FROM "table" WHERE "Date" = "october 30"
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            | Ship              | Nationality   |   Tonnage | Fate    |
|:----------------|:------------------|:--------------|----------:|:--------|
| 16 may 1941     | llangibby castle  | great britain |     11951 | damaged |
| 13 april 1942   | empire progress   | great britain |      5249 | sunk    |
| 30 april 1942   | ashkhabad         | soviet union  |      5284 | sunk    |
| 2 may 1942      | uss cythera       | usa           |       602 | sunk    |
| 2 november 1942 | dalcroy           | great britain |      4558 | sunk    |
| 2 november 1942 | empire antelope   | great britain |      4945 | sunk    |
| 2 november 1942 | empire leopard    | great britain |      5676 | sunk    |
| 2 november 1942 | empire sunrise    | great britain |      7459 | damaged |
| 2 november 1942 | rinos             | greece        |      4649 | sunk    |
| 7 february 1942 | afrika            | great britain |      8597 | sunk    |
| 7 february 1942 | daghild           | norway        |      9272 | damaged |
| 7 february 1942 | henry r. mallory  | usa           |      6063 | sunk    |
| 7 february 1942 | kalliopi          | greece        |      4695 | sunk    |
| 7 february 1942 | robert e. hopkins | great britain |      6625 | sunk    |
| 7 february 1942 | toward            | great britain |      1571 | sunk    |
| 8 february 1942 | newton ash        | great britain |      1571 | sunk    |
| 11 may 1943     | antigone          | great britain |      4545 | sunk    |
| 11 may 1943     | grado             | norway        |      3082 | sunk    |

Question: What is the highest tonnage for a ship from Great Britain named Newton Ash?

table_id: 2-18670594-1
label: SELECT MAX("Tonnage") FROM "table" WHERE "Nationality" = "great britain" AND "Ship" = "newton ash"
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 |   November | Opponent              | Score    | Record   |
|-------:|-----------:|:----------------------|:---------|:---------|
|     14 |          3 | vancouver canucks     | 6 - 3    | 8-5-1    |
|     15 |          6 | @ quebec nordiques    | 4 - 2    | 9-5-1    |
|     16 |          8 | tampa bay lightning   | 6 - 3    | 10-5-1   |
|     17 |         10 | winnipeg jets         | 2 - 1    | 11-5-1   |
|     18 |         13 | @ washington capitals | 2 - 0    | 12-5-1   |
|     19 |         14 | san jose sharks       | 3 - 3 ot | 12-5-2   |
|     20 |         16 | @ florida panthers    | 4 - 2    | 13-5-2   |
|     21 |         19 | @ tampa bay lightning | 5 - 3    | 14-5-2   |
|     22 |         23 | montreal canadiens    | 5 - 4    | 15-5-2   |
|     23 |         24 | @ ottawa senators     | 7 - 1    | 16-5-2   |
|     24 |         27 | @ new york islanders  | 6 - 4    | 16-6-2   |
|     25 |         28 | washington capitals   | 3 - 1    | 17-6-2   |
|     26 |         30 | @ new jersey devils   | 3 - 1    | 18-6-2   |

Question: What is the latest day in November with a game 15?

table_id: 2-13909382-3
label: SELECT MAX("November") FROM "table" WHERE "Game" = 15
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             | Opponent              | Score    | Location              |   Attendance | Record   |   Points |
|-------:|:-----------------|:----------------------|:---------|:----------------------|-------------:|:---------|---------:|
|      1 | october 9, 2008  | @ detroit red wings   | 3–2      | joe louis arena       |        20066 | 1–0–0    |        2 |
|      2 | october 11, 2008 | montreal canadiens    | 1–6      | air canada centre     |        19370 | 1–1–0    |        2 |
|      3 | october 13, 2008 | st. louis blues       | 4–5 (so) | air canada centre     |        19045 | 1–1–1    |        3 |
|      4 | october 17, 2008 | @ new york rangers    | 0–1 (so) | madison square garden |        18200 | 1–1–2    |        4 |
|      5 | october 18, 2008 | @ pittsburgh penguins | 1–4      | mellon arena          |        17033 | 1–2–2    |        4 |
|      6 | october 21, 2008 | anaheim ducks         | 2–3 (so) | air canada centre     |        19222 | 1–2–3    |        5 |
|      7 | october 23, 2008 | @ boston bruins       | 4–2      | td banknorth garden   |        12274 | 2–2–3    |        7 |
|      8 | october 25, 2008 | ottawa senators       | 3–2      | air canada centre     |        19232 | 3–2–3    |        9 |
|      9 | october 28, 2008 | tampa bay lightning   | 2–3      | air canada centre     |        19348 | 3–3–3    |        9 |
|     10 | october 29, 2008 | @ new jersey devils   | 6–5 (so) | prudential center     |        14119 | 4–3–3    |       11 |

Question: Which score has a Date of october 29, 2008?

table_id: 2-16864968-3
label: SELECT "Score" FROM "table" WHERE "Date" = "october 29, 2008"