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:
| Institution                     | Location         |   Founded | Affiliation       |   Enrollment | Team Nickname    | Primary conference         |
|:--------------------------------|:-----------------|----------:|:------------------|-------------:|:-----------------|:---------------------------|
| adrian college                  | adrian, mi       |      1859 | private/methodist |         1650 | bulldogs         | miaa ( d-iii )             |
| davenport university            | grand rapids, mi |      1866 | private           |        12471 | panthers         | wolverine–hoosier ( naia ) |
| eastern michigan university     | ypsilanti, mi    |      1849 | public            |        22974 | eagles           | mid-american ( d-i )       |
| kent state university           | kent, oh         |      1910 | public            |        33457 | golden flashes   | mid-american ( d-i )       |
| university of michigan–dearborn | dearborn, mi     |      1959 | public            |         8634 | wolves           | wolverine–hoosier ( naia ) |
| oakland university              | rochester, mi    |      1957 | public            |        17737 | golden grizzlies | the summit league ( d-i )  |

Question: What is the lowest enrollment for Eastern Michigan University?

table_id: 1-26351260-1
label: SELECT MIN("Enrollment") FROM "table" WHERE "Institution" = "Eastern Michigan University"
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 in the final   | Score in the final      |
|:----------|-------:|:---------------|:----------|:----------|:-------------------------|:------------------------|
| runner-up |   1978 | wimbledon      | grass     | fleming   | hewitt mcmillan          | 1–6, 4–6, 2–6           |
| winner    |   1979 | wimbledon      | grass     | fleming   | gottfried ramírez        | 4–6, 6–4, 6–2, 6–2      |
| winner    |   1979 | us open        | hard      | fleming   | lutz smith               | 6–2, 6–4                |
| runner-up |   1980 | us open        | hard      | fleming   | lutz smith               | 6–7, 6–3, 1–6, 6–3, 3–6 |
| winner    |   1981 | wimbledon (2)  | grass     | fleming   | lutz smith               | 6–4, 6–4, 6–4           |
| winner    |   1981 | us open (2)    | hard      | fleming   | günthardt mcnamara       | walkover                |
| runner-up |   1982 | wimbledon (2)  | grass     | fleming   | mcnamara mcnamee         | 3–6, 2–6                |
| winner    |   1983 | wimbledon (3)  | grass     | fleming   | gullikson tom gullikson  | 6–4, 6–3, 6–4           |
| winner    |   1983 | us open (3)    | hard      | fleming   | buehning winitsky        | 6–3, 6–4, 6–2           |
| winner    |   1984 | wimbledon (4)  | grass     | fleming   | cash mcnamee             | 6–2, 5–7, 6–2, 3–6, 6–3 |
| winner    |   1989 | us open (4)    | hard      | woodforde | flach seguso             | 6–4, 4–6, 6–3, 6–3      |

Question: What is the surface made of if the year is 1979 and the championship is US Open?

table_id: 1-22597626-2
label: SELECT "Surface" FROM "table" WHERE "Championship" = "US Open" AND "Year" = 1979
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:
| Season   | Winner            | Runner-up         | Final Score   | 3rd place             |
|:---------|:------------------|:------------------|:--------------|:----------------------|
| 2005–06  | biolars ozolnieki | pere leib tartu   | 3 : 1         | sk riga/ lu inčukalns |
| 2006–07  | vk selver tallinn | lase-r/riga       | 3 : 2         | sk riga               |
| 2007–08  | vk selver tallinn | pere leib tartu   | 3 : 1         | lase-r/riga           |
| 2008–09  | vk selver tallinn | pere leib tartu   | 3 : 1         | lase-r/riga           |
| 2009–10  | vk selver tallinn | pere leib tartu   | 3 : 0         | lase-r/riga           |
| 2010–11  | vk selver tallinn | vk pärnu          | 3 : 0         | poliurs/ozolnieki     |
| 2011–12  | pere leib tartu   | vk selver tallinn | 3 : 2         | vk pärnu              |

Question: In which season is the runner-up Lase-R/Riga?

table_id: 1-25058269-1
label: SELECT "Season" FROM "table" WHERE "Runner-up" = "Lase-R/Riga"
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:
| Municipality       |   Inhabitants | Mayor               | Party                 |   Election |
|:-------------------|--------------:|:--------------------|:----------------------|-----------:|
| milan              |       1324110 | giuliano pisapia    | left ecology freedom  |       2011 |
| brescia            |        193879 | emilio del bono     | democratic party      |       2013 |
| monza              |        122712 | roberto scanagatti  | democratic party      |       2012 |
| bergamo            |        119551 | franco tentorio     | the people of freedom |       2009 |
| como               |         85263 | mario lucini        | democratic party      |       2012 |
| busto arsizio      |         81760 | gianluigi farioli   | the people of freedom |       2011 |
| varese             |         81579 | attilio fontana     | lega lombarda         |       2011 |
| sesto san giovanni |         81130 | monica chittò       | democratic party      |       2012 |
| cinisello balsamo  |         74150 | daniela gasparini   | democratic party      |       2009 |
| cremona            |         72147 | oreste perri        | the people of freedom |       2009 |
| pavia              |         71142 | alessandro cattaneo | the people of freedom |       2009 |
| vigevano           |         63700 | andrea sala         | lega lombarda         |       2010 |
| legnano            |         59147 | alberto centinaio   | democratic party      |       2012 |
| gallarate          |         51751 | edoardo guenzani    | democratic party      |       2011 |
| rho                |         50686 | pietro romano       | democratic party      |       2011 |

Question: What is the lowest election that has cinisello balsamo as the municipality?

table_id: 2-17857470-4
label: SELECT MIN("Election") FROM "table" WHERE "Municipality" = "cinisello balsamo"
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 | Name              | Nationality   | Time    |
|-------:|-------:|:------------------|:--------------|:--------|
|      1 |      4 | ágnes kovács      | hungary       | 2:24.03 |
|      2 |      5 | qi hui            | china         | 2:24.21 |
|      3 |      2 | olga bakaldina    | russia        | 2:25.41 |
|      4 |      3 | masami tanaka     | japan         | 2:26.24 |
|      5 |      6 | amanda beard      | united states | 2:26.62 |
|      6 |      1 | christin petelski | canada        | 2:29.43 |
|      7 |      7 | rebecca brown     | australia     | 2:29.90 |
|      8 |      8 | alicja pęczak     | poland        | 2:30.02 |

Question: What is the average lane that is called rebecca brown?

table_id: 2-12382876-5
label: SELECT AVG("Lane") FROM "table" WHERE "Name" = "rebecca brown"
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 11, 1965 | denver broncos        | w 34–31  |        27022 |
|      2 | september 19, 1965 | at oakland raiders    | w 17–6   |        21406 |
|      3 | september 26, 1965 | kansas city chiefs    | t 10–10  |        28126 |
|      4 | october 3, 1965    | houston oilers        | w 31–14  |        28190 |
|      5 | october 10, 1965   | at buffalo bills      | w 34–3   |        45260 |
|      6 | october 17, 1965   | at boston patriots    | t 13–13  |        20924 |
|      7 | october 23, 1965   | at new york jets      | w 34–9   |        60679 |
|      8 | october 31, 1965   | boston patriots       | l 22–6   |        33366 |
|      9 | november 7, 1965   | at denver broncos     | w 35–21  |        33073 |
|     10 | november 14, 1965  | at kansas city chiefs | l 31–7   |        21968 |
|     11 | november 25, 1965  | buffalo bills         | t 20–20  |        27473 |
|     12 | december 4, 1965   | new york jets         | w 38–7   |        32169 |
|     13 | december 12, 1965  | at houston oilers     | w 37–26  |        24120 |
|     14 | december 19, 1965  | oakland raiders       | w 24–14  |        26056 |

Question: What is the Attendance with a Date that is october 31, 1965?

table_id: 2-15412888-1
label: SELECT "Attendance" FROM "table" WHERE "Date" = "october 31, 1965"
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   |     11 |        4 |        2 |      17 |
| 2      | hungary        |      2 |        1 |        1 |       4 |
| 3      | poland         |      2 |        1 |        0 |       3 |
| 4      | north korea    |      2 |        0 |        0 |       2 |
| 5      | bulgaria       |      1 |        4 |        5 |      10 |
| 6      | united states  |      1 |        3 |        3 |       7 |
| 7      | cuba           |      1 |        0 |        1 |       2 |
| 7      | sweden         |      1 |        0 |        1 |       2 |
| 9      | east germany   |      0 |        2 |        1 |       3 |
| 10     | japan          |      0 |        1 |        1 |       2 |
| 10     | romania        |      0 |        1 |        1 |       2 |
| 12     | finland        |      0 |        1 |        0 |       1 |
| 12     | norway         |      0 |        1 |        0 |       1 |
| 14     | czechoslovakia |      0 |        0 |        2 |       2 |
| 15     | greece         |      0 |        0 |        1 |       1 |
| 15     | mongolia       |      0 |        0 |        1 |       1 |
| 15     | west germany   |      0 |        0 |        1 |       1 |
| total  | total          |     21 |       19 |       21 |      61 |

Question: Which nation has a bronze greater than 0, a gold greater than 0, a silver greater than 0, and 5 as the rank?

table_id: 2-15759218-1
label: SELECT "Nation" FROM "table" WHERE "Bronze" > 0 AND "Gold" > 0 AND "Silver" > 0 AND "Rank" = "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:
|   Rank | Athlete             | Country        | Time    | Notes   |
|-------:|:--------------------|:---------------|:--------|:--------|
|      1 | ondřej synek        | czech republic | 7:03.57 | fa      |
|      2 | alan campbell       | great britain  | 7:05.24 | fa      |
|      3 | mahé drysdale       | new zealand    | 7:05.57 | fa      |
|      4 | ioannis christou    | greece         | 7:06.02 | fb      |
|      5 | ken jurkowski       | united states  | 7:11.52 | fb      |
|      6 | mindaugas griskonis | lithuania      | 7:20.32 | fb      |

Question: What is Alan Campbell's Country with Notes of FA?

table_id: 2-18662643-17
label: SELECT "Country" FROM "table" WHERE "Notes" = "fa" AND "Athlete" = "alan campbell"
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      | russia        |      8 |        2 |        4 |      14 |
| 2      | france        |      7 |        9 |        4 |      20 |
| 3      | italy         |      5 |        5 |        8 |      18 |
| 4      | netherlands   |      5 |        2 |        2 |       9 |
| 5      | spain         |      2 |        3 |        2 |       7 |
| 6      | croatia       |      2 |        0 |        2 |       4 |
| 7      | slovenia      |      2 |        0 |        1 |       3 |
| 8      | germany       |      1 |        3 |        2 |       6 |
| 9      | denmark       |      1 |        2 |        3 |       6 |
| 10     | austria       |      1 |        2 |        1 |       4 |
| 10     | ukraine       |      1 |        2 |        1 |       4 |
| 12     | serbia        |      1 |        1 |        0 |       2 |
| 12     | sweden        |      1 |        1 |        0 |       2 |
| 14     | great britain |      1 |        0 |        4 |       5 |
| 15     | finland       |      1 |        0 |        0 |       1 |
| 16     | hungary       |      0 |        3 |        1 |       4 |
| 17     | switzerland   |      0 |        1 |        1 |       2 |
| 18     | lithuania     |      0 |        1 |        0 |       1 |
| 18     | norway        |      0 |        1 |        0 |       1 |
| 20     | poland        |      0 |        0 |        1 |       1 |
| 20     | slovakia      |      0 |        0 |        1 |       1 |
| total  | total         |     39 |       38 |       38 |     115 |

Question: What was the lowest total of medals won by Croatia?

table_id: 2-18565772-1
label: SELECT MIN("Total") FROM "table" WHERE "Nation" = "croatia"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Player         | Height   | School               | Hometown          | College               | NBA Draft                                       |
|:---------------|:---------|:---------------------|:------------------|:----------------------|:------------------------------------------------|
| delray brooks  | 6-4      | rogers high school   | michigan city, in | indiana / providence  | undrafted in 1988 nba draft                     |
| john williams  | 6-8      | crenshaw high school | los angeles, ca   | lsu                   | 1st round - 12th pick of 1986 draft ( bullets ) |
| danny manning  | 6-11     | lawrence high school | lawrence, ks      | kansas                | 1st round - 1st pick of 1988 draft ( clippers ) |
| kevin walls    | 6-2      | camden high school   | camden, nj        | louisville / guilford | undrafted in 1988 nba draft                     |
| chris washburn | 6-11     | hickory high school  | hickory, nc       | north carolina state  | 1st round - 3rd pick of 1986 draft ( warriors ) |

Question: Who has a hometown of los angeles, ca?

table_id: 2-11677760-6
label: SELECT "Player" FROM "table" WHERE "Hometown" = "los angeles, ca"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Home team       | Home team score   | Away team       | Away team score   | Venue                 |   Crowd | Date        |
|:----------------|:------------------|:----------------|:------------------|:----------------------|--------:|:------------|
| geelong         | 15.10 (100)       | south melbourne | 17.12 (114)       | corio oval            |   14700 | 25 may 1935 |
| fitzroy         | 8.9 (57)          | richmond        | 14.14 (98)        | brunswick street oval |   35000 | 25 may 1935 |
| essendon        | 13.20 (98)        | hawthorn        | 12.14 (86)        | windy hill            |   10000 | 25 may 1935 |
| north melbourne | 12.16 (88)        | footscray       | 13.12 (90)        | arden street oval     |   12000 | 25 may 1935 |
| melbourne       | 9.15 (69)         | collingwood     | 13.20 (98)        | mcg                   |   16057 | 25 may 1935 |
| st kilda        | 16.14 (110)       | carlton         | 20.9 (129)        | junction oval         |   29000 | 25 may 1935 |

Question: When the Home team of geelong played, what was their lowest Crowd number?

table_id: 2-10790651-5
label: SELECT MIN("Crowd") FROM "table" WHERE "Home team" = "geelong"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Shipyard                                         | Laid down          | Launched           | Commissioned      | Fleet   | Status                            |
|:-------------------------------------------------|:-------------------|:-------------------|:------------------|:--------|:----------------------------------|
| leninskiy komsomol shipyard, komsomolsk-na-amure | december 20, 1958  | may 12, 1960       | june 28, 1961     | pacific | decommissioned 1989 for scrapping |
| leninskiy komsomol shipyard, komsomolsk-na-amure | september 30, 1959 | september 25, 1960 | december 16, 1961 | pacific | decommissioned 1989 for scrapping |
| leninskiy komsomol shipyard, komsomolsk-na-amure | march 26, 1960     | july 30, 1961      | december 28, 1961 | pacific | decommissioned 1985 for scrapping |
| leninskiy komsomol shipyard, komsomolsk-na-amure | january 21, 1961   | september 17, 1961 | july 6, 1962      | pacific | decommissioned 1985 for scrapping |
| leninskiy komsomol shipyard, komsomolsk-na-amure | april 21, 1962     | september 30, 1962 | july 28, 1963     | pacific | decommissioned 1989 for scrapping |

Question: Which fleet launched on July 30, 1961?

table_id: 2-1014206-1
label: SELECT "Fleet" FROM "table" WHERE "Launched" = "july 30, 1961"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Episode   | 7 Deadly Sin   | Challenge Winner   | Challenge Loser   | Voted In To 'El Duelo'   | Eliminated         |
|:----------|:---------------|:-------------------|:------------------|:-------------------------|:-------------------|
| 1a        | passion        | silvia & vinci     | janet             | jainmy & maria           | maria              |
| 1b        | passion        | roseny             | janet             | jainmy                   | jainmy             |
| 2         | lust           | berto              | alexcy            | geovannie                | alexcy             |
| 3         | vanity         | jenn               | janet             | vinci                    | kalain 1 & janet   |
| 4         | drama          | jenn & geovannie   | enrique           | vinci                    | vinci              |
| 5         | fire           | gisel              | enrique           | geovannie                | silvia 3 & enrique |
| 6         | seduction      | geovannie          | roseny            | jenn                     | roseny             |
| 7         | scandal        | geovannie          | gisel             | geovannie                | geovannie          |

Question: Which winner has a Challenge Loser of gisel?

table_id: 2-16921290-2
label: SELECT "Challenge Winner" FROM "table" WHERE "Challenge Loser" = "gisel"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Date       | Visitor   | Score   | Home        | Decision   |   Attendance | Record   |
|:-----------|:----------|:--------|:------------|:-----------|-------------:|:---------|
| october 4  | colorado  | 0 – 4   | nashville   | mason      |        16363 | 1–0–0    |
| october 6  | dallas    | 1 – 5   | nashville   | mason      |        13079 | 2–0–0    |
| october 10 | nashville | 1 – 4   | st. louis   | mason      |        19150 | 2–1–0    |
| october 11 | phoenix   | 6 – 3   | nashville   | mason      |        12155 | 2–2–0    |
| october 13 | calgary   | 7 – 4   | nashville   | mason      |        13152 | 2–3–0    |
| october 17 | nashville | 1 – 3   | anaheim     | mason      |        17174 | 2–4–0    |
| october 20 | nashville | 0 – 3   | san jose    | mason      |        17496 | 2–5–0    |
| october 23 | nashville | 0 – 6   | los angeles | mason      |        14026 | 2–6–0    |
| october 25 | atlanta   | 0 – 3   | nashville   | ellis      |        13383 | 3–6–0    |
| october 27 | florida   | 3 – 4   | nashville   | ellis      |        15767 | 4–6–0    |
| october 30 | nashville | 1 – 5   | calgary     | mason      |        19289 | 4–7–0    |

Question: Who was the home team at the game with a decision of Mason and a visiting team of Dallas?

table_id: 2-11756731-3
label: SELECT "Home" FROM "table" WHERE "Decision" = "mason" AND "Visitor" = "dallas"
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:
| District         | Incumbent          | Party      | First elected   | Result                       | Candidates                                        |
|:-----------------|:-------------------|:-----------|:----------------|:-----------------------------|:--------------------------------------------------|
| south carolina 1 | richard s. whaley  | democratic | 1913 (special)  | re-elected                   | richard s. whaley (d) 95.4% j. o. ladd (r) 4.6%   |
| south carolina 2 | james f. byrnes    | democratic | 1910            | re-elected                   | james f. byrnes (d) 98.5% isaac myers (r) 1.5%    |
| south carolina 3 | wyatt aiken        | democratic | 1902            | lost primary democratic hold | frederick h. dominick (d) 100%                    |
| south carolina 4 | samuel j. nicholls | democratic | 1915 (special)  | re-elected                   | samuel j. nicholls (d) 99.4% g. f. mills (r) 0.6% |
| south carolina 5 | david e. finley    | democratic | 1898            | re-elected                   | david e. finley (d) 100%                          |

Question: What was the winning party when the incumbent was richard s. whaley?

table_id: 1-1346137-4
label: SELECT "Party" FROM "table" WHERE "Incumbent" = "Richard S. Whaley"
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:
| Runs   | Wicket   | Batting partners                          | Batting team   | Fielding team   | Venue               | Season   |
|:-------|:---------|:------------------------------------------|:---------------|:----------------|:--------------------|:---------|
| 624    | 3rd      | mahela jayawardene and kumar sangakkara   | sri lanka      | south africa    | colombo             | 2006     |
| 576    | 2nd      | roshan mahanama and sanath jayasuriya     | sri lanka      | india           | colombo             | 1997     |
| 467    | 3rd      | andrew jones and martin crowe             | new zealand    | sri lanka       | wellington          | 1990/91  |
| 451    | 2nd      | donald bradman and w h ponsford           | australia      | england         | sydney              | 1934     |
| 451    | 3rd      | mudassar nazar and javed miandad          | pakistan       | india           | hyderabad, pakistan | 1982/83  |
| 446    | 2nd      | conrad hunte and gary sobers              | west indies    | pakistan        | the oval            | 1957/58  |
| 438    | 2nd      | marvan atapattu and kumar sangakkara      | sri lanka      | zimbabwe        | bulawayo            | 2004     |
| 437    | 4th      | mahela jayawardene and thilan samaraweera | sri lanka      | pakistan        | karachi             | 2008/09  |
| 429*   | 3rd      | jacques rudolph and boeta dippenaar       | south africa   | bangladesh      | chittagong          | 2003     |
| 415    | 1st      | graeme smith and neil mckenzie            | south africa   | bangladesh      | chittagong          | 2008     |

Question: Which fielding team had 1st wicket?

table_id: 2-1670921-2
label: SELECT "Fielding team" FROM "table" WHERE "Wicket" = "1st"
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:
| Competition        | Final position   | First match       | Last match        | Final Place                            |
|:-------------------|:-----------------|:------------------|:------------------|:---------------------------------------|
| torneo apertura    | 14th             | august 23, 2009   | december 13, 2009 | argentina - coliseo de victoria        |
| torneo clausura    | 13th             | january 31, 2010  | may 15, 2010      | argentina - el monumental              |
| copa libertadores  | second stage     | february 12, 2009 | april 30, 2009    | argentina - el monumental              |
| carlsberg cup 2009 | winner           | july 22, 2009     | july 22, 2009     | canada - bmo field                     |
| edmonton cup       | winner           | july 25, 2009     | july 25, 2009     | canada - commonwealth stadium          |
| copa desafío       | winner           | january 20, 2010  | january 20, 2010  | argentina - estadio josé maría minella |

Question: Name the last match for  argentina - estadio josé maría minella

table_id: 1-23819979-3
label: SELECT "Last match" FROM "table" WHERE "Final Place" = "Argentina - Estadio José María Minella"
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   |
|:------------|:-------------|:--------|:-----------|:---------|
| november 1  | pittsburgh   | 5–4     | tampa bay  | 9-1-2    |
| november 3  | ny islanders | 0–2     | pittsburgh | 10-1-2   |
| november 5  | st. louis    | 4–8     | pittsburgh | 11-1-2   |
| november 7  | pittsburgh   | 2–4     | toronto    | 11-2-2   |
| november 8  | pittsburgh   | 2–7     | chicago    | 11-3-2   |
| november 10 | pittsburgh   | 4–1     | minnesota  | 12-3-2   |
| november 12 | quebec       | 4–4     | pittsburgh | 12-3-3   |
| november 13 | pittsburgh   | 0–8     | detroit    | 12-4-3   |
| november 17 | buffalo      | 2–4     | pittsburgh | 13-4-3   |
| november 20 | pittsburgh   | 4–1     | new jersey | 14-4-3   |
| november 21 | new jersey   | 0–2     | pittsburgh | 15-4-3   |
| november 23 | pittsburgh   | 5–2     | ny rangers | 16-4-3   |
| november 25 | ny rangers   | 11–3    | pittsburgh | 16-5-3   |
| november 27 | pittsburgh   | 4–6     | washington | 16-6-3   |
| november 28 | washington   | 3–5     | pittsburgh | 17-6-3   |

Question: What was the score when the home team was Toronto?

table_id: 2-14209289-3
label: SELECT "Score" FROM "table" WHERE "Home" = "toronto"