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:
|   Game | Date   | Opponent                 | Score   | Location/Attendance        | Record   | Streak   |
|-------:|:-------|:-------------------------|:--------|:---------------------------|:---------|:---------|
|     45 | feb 1  | chicago bulls            | 100–95  | ford center                | 23–22    | won 3    |
|     46 | feb 4  | los angeles lakers       | 106–90  | ford center                | 24–22    | won 4    |
|     47 | feb 6  | @ new jersey nets        | 91–99   | continental airlines arena | 24–23    | lost 1   |
|     48 | feb 8  | seattle supersonics      | 109–102 | ford center                | 25–23    | won 1    |
|     49 | feb 10 | new york knicks          | 111–100 | ford center                | 26–23    | won 2    |
|     50 | feb 11 | @ minnesota timberwolves | 100–94  | target center              | 27–23    | won 3    |
|     51 | feb 13 | washington wizards       | 97–96   | ford center                | 28–23    | won 4    |
|     52 | feb 15 | portland trail blazers   | 102–86  | ford center                | 29–23    | won 5    |
|     53 | feb 21 | @ indiana pacers         | 75–97   | conseco fieldhouse         | 29–24    | lost 1   |
|     54 | feb 22 | utah jazz                | 76–82   | ford center                | 29–25    | lost 2   |
|     55 | feb 25 | @ utah jazz              | 100–95  | delta center               | 30–25    | won 1    |
|     56 | feb 26 | @ portland trail blazers | 88–75   | rose garden                | 31–25    | won 2    |
|     57 | feb 28 | @ seattle supersonics    | 104–114 | keyarena                   | 31–26    | lost 1   |

Question: What was the record on Feb 25?

table_id: 2-18289217-6
label: SELECT "Record" FROM "table" WHERE "Date" = "feb 25"
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 |   Tournaments played |   Cuts made |   Wins |   2nds |   3rds |   Top tens | Best finish   |   Earnings ( $ ) |   Money list rank |
|-------:|---------------------:|------------:|-------:|-------:|-------:|-----------:|:--------------|-----------------:|------------------:|
|   1998 |                   22 |          16 |      1 |      0 |      0 |          3 | 1st           |            81937 |                29 |
|   1999 |                   24 |          13 |      0 |      2 |      1 |          6 | 2nd           |           122742 |                14 |
|   2001 |                   21 |           9 |      0 |      0 |      0 |          0 | t-20          |            17197 |               143 |
|   2002 |                   14 |           5 |      0 |      0 |      1 |          1 | t-3           |            30218 |               117 |
|   2003 |                   22 |          11 |      0 |      0 |      0 |          0 | t-14          |            26553 |               123 |
|   2004 |                    8 |           2 |      0 |      0 |      0 |          0 | t-12          |            12653 |               174 |
|   2005 |                    9 |           1 |      0 |      0 |      0 |          0 | t-60          |             1934 |               300 |
|   2006 |                    5 |           1 |      0 |      0 |      0 |          0 | t-59          |             1328 |               310 |

Question: Name the wins for tournaments played being 14

table_id: 1-1697190-1
label: SELECT "Wins" FROM "table" WHERE "Tournaments played" = 14
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:
| School           | Base   | Bask   | Golf   | Soccer   | Swimming   | Tennis   | Indoor track   |
|:-----------------|:-------|:-------|:-------|:---------|:-----------|:---------|:---------------|
| cleveland state  | no     | yes    | yes    | yes      | yes        | yes      | no             |
| detroit          | no     | yes    | yes    | yes      | no         | yes      | yes            |
| green bay        | no     | yes    | yes    | yes      | yes        | yes      | no             |
| milwaukee        | yes    | yes    | no     | yes      | yes        | no       | yes            |
| oakland          | yes    | yes    | yes    | yes      | yes        | no       | yes            |
| uic              | yes    | yes    | no     | yes      | yes        | yes      | yes            |
| valparaiso       | yes    | yes    | yes    | yes      | yes        | yes      | yes            |
| wright state     | yes    | yes    | yes    | yes      | yes        | yes      | yes            |
| youngstown state | yes    | yes    | yes    | no       | no         | yes      | yes            |

Question: Which school has yes for soccer, tennis and indoor track.

table_id: 2-16645083-1
label: SELECT "School" FROM "table" WHERE "Soccer" = "yes" AND "Tennis" = "yes" AND "Indoor track" = "yes"
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:
|   Channel | Video   | Aspect   | PSIP Short Name   | Programming              |
|----------:|:--------|:---------|:------------------|:-------------------------|
|      56.1 | 720p    | 16:9     | kdoc-hd           | main kdoc-tv programming |
|      56.2 | 480i    | 4:3      | esne              | spanish catholic         |
|      56.3 | 480i    | 4:3      | metvla            | me-tv                    |
|      56.4 | 480i    | 4:3      | ndoc              | s infomercial            |
|      56.5 | 480i    | 4:3      | ibc-tv            | ibc-tv (vietnamese)      |

Question: Which Programming has an Aspect of 4:3 and a PSIP Short Name of metvla?

table_id: 2-1632976-1
label: SELECT "Programming" FROM "table" WHERE "Aspect" = "4:3" AND "PSIP Short Name" = "metvla"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   Pick | Player           | Position      | Nationality   | Former Team            |
|-------:|:-----------------|:--------------|:--------------|:-----------------------|
|      2 | dell curry       | guard         | united states | cleveland cavaliers    |
|      4 | dave hoppen      | forward       | united states | golden state warriors  |
|      6 | tyrone bogues    | point guard   | united states | washington bullets     |
|      8 | mike brown       | point guard   | united states | chicago bulls          |
|     10 | rickey green     | forward       | united states | utah jazz              |
|     12 | michael holton   | forward       | united states | portland trail blazers |
|     14 | michael brooks   | small forward | united states | denver nuggets         |
|     16 | bernard thompson | centre        | united states | phoenix suns           |
|     18 | ralph lewis      | guard-forward | united states | detroit pistons        |
|     20 | clinton wheeler  | forward       | united states | indiana pacers         |
|     22 | sedric toney     | centre        | united states | new york knicks        |

Question: Which Position has a Pick smaller than 14, and a Player of tyrone bogues?

table_id: 2-17116053-1
label: SELECT "Position" FROM "table" WHERE "Pick" < 14 AND "Player" = "tyrone bogues"
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:
|   Ranking | Nationality       | Name                    | Years               |   Goals |
|----------:|:------------------|:------------------------|:--------------------|--------:|
|         1 | spain             | josep samitier          | 1919–1932           |      65 |
|         2 | hungary           | lászló kubala           | 1950–1961           |      49 |
|         3 | spain             | césar rodríguez álvarez | 1942–1955           |      36 |
|         4 | philippines spain | paulino alcántara       | 1912–1916 1918–1927 |      35 |
|         4 | spain             | josep escolà            | 1934–1937 1940–1948 |      35 |
|         6 | paraguay spain    | eulogio martínez        | 1956–1962           |      32 |
|         7 | spain             | ángel arocha            | 1926–1933           |      29 |
|         8 | spain             | mariano martín          | 1939–1948           |      26 |
|         9 | spain             | josé antonio zaldúa     | 1961–1971           |      25 |
|        10 | argentina         | lionel messi            | 2004–               |      24 |

Question: What ranking has the nationality of spain and the goals of 26?

table_id: 2-14707564-5
label: SELECT "Ranking" FROM "table" WHERE "Nationality" = "spain" AND "Goals" = 26
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 |   Stage | Start of stage     | Distance (km)   | Category of climb   | Stage winner        | Yellow jersey     |
|-------:|--------:|:-------------------|:----------------|:--------------------|:--------------------|:------------------|
|   1989 |      10 | cauterets          | 136             | 1                   | robert millar       | laurent fignon    |
|   1986 |      13 | pau                | 186             | hc                  | greg lemond         | bernard hinault   |
|   1979 |       2 | bagnères-de-luchon | 23,87 ( itt )   | 1                   | bernard hinault     | bernard hinault   |
|   1971 |      15 | bagnères-de-luchon | 19.6            | 1                   | josé-manuel fuente  | eddy merckx       |
|   1962 |      13 | bagnères-de-luchon | 18.25 ( itt )   | 1                   | federico bahamontes | joseph planckaert |
|   1961 |      16 | toulouse           | 208             | 1                   | imerio massignan    | jacques anquetil  |

Question: What year was yellow jersey of Jacques Anquetil?

table_id: 2-18391739-1
label: SELECT MIN("Year") FROM "table" WHERE "Yellow jersey" = "jacques anquetil"
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 | Pass Rate   | % 'A' Aggregates   | % 'B' Aggregates   | % 'A' or 'B' Aggregates   |   Average A's per learner |
|-------:|:------------|:-------------------|:-------------------|:--------------------------|--------------------------:|
|   2007 | 100%        | 56%                | 28%                | 84%                       |                      3.28 |
|   2008 | 100%        | 48%                | 25%                | 73%                       |                      3.37 |
|   2009 | 100%        | 41%                | 34%                | 75%                       |                      3.8  |
|   2010 | 100%        | 45%                | 25%                | 73%                       |                      4.07 |
|   2011 | 100%        | 47%                | 34%                | 75%                       |                      4.2  |

Question: Which Year has an Average A's per learner larger than 3.37, and a % 'A' or 'B' Aggregates of 73%?

table_id: 2-15910236-1
label: SELECT "Year" FROM "table" WHERE "Average A''s per learner" > 3.37 AND "% ''A'' or ''B'' Aggregates" = "73%"
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 |   April | Opponent              | Score   | Record   |
|-------:|--------:|:----------------------|:--------|:---------|
|     75 |       1 | @ atlanta flames      | 6 - 0   | 29-33-13 |
|     76 |       2 | @ boston bruins       | 8 - 3   | 29-34-13 |
|     77 |       5 | atlanta flames        | 4 - 2   | 29-35-13 |
|     78 |       6 | @ philadelphia flyers | 3 - 0   | 29-36-13 |
|     79 |       8 | @ new york islanders  | 7 - 2   | 29-37-13 |
|     80 |       9 | chicago black hawks   | 3 - 2   | 30-37-13 |

Question: Who is the opponent in a game higher than 76 on April 6?

table_id: 2-17310913-8
label: SELECT "Opponent" FROM "table" WHERE "Game" > 76 AND "April" = 6
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   Place | Team                  |   Played |   Draw |   Lost |   Goals Scored |   Goals Conceded |   Points |
|--------:|:----------------------|---------:|-------:|-------:|---------------:|-----------------:|---------:|
|       1 | c.d. águila           |       18 |      5 |      2 |             47 |               20 |       38 |
|       2 | alianza f.c.          |       18 |      3 |      6 |             38 |               24 |       30 |
|       3 | c.d. municipal limeño |       18 |      6 |      4 |             24 |               16 |       30 |
|       4 | a.d. isidro metapán   |       18 |      5 |      5 |             30 |               16 |       29 |
|       5 | c.d. fas              |       18 |      8 |      3 |             29 |               18 |       29 |
|       6 | c.d. luis ángel firpo |       18 |      5 |      5 |             22 |               22 |       29 |
|       7 | c.d. atlético balboa  |       18 |      7 |      6 |             19 |               24 |       22 |
|       8 | san salvador f.c.     |       18 |      5 |     10 |             23 |               37 |       14 |
|       9 | c.d. dragón           |       18 |      3 |     12 |             22 |               44 |       12 |
|      10 | atlético marte        |       18 |      5 |     11 |             13 |               45 |        7 |

Question: What is the mean played number where the goals conceded is less than 16?

table_id: 2-15873969-1
label: SELECT AVG("Played") FROM "table" WHERE "Goals Conceded" < 16
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 | united states  |     26 |       21 |       24 |      71 |
|      2 | norway         |     10 |        1 |        2 |      13 |
|      3 | east germany   |      9 |        8 |        2 |      19 |
|      4 | austria        |      7 |       17 |       12 |      36 |
|      5 | japan          |      7 |        3 |        6 |      16 |
|      6 | hungary        |      7 |        1 |        3 |      11 |
|      7 | great britain  |      6 |        9 |        7 |      22 |
|      8 | canada         |      4 |        5 |        4 |      13 |
|      9 | netherlands    |      4 |        1 |        3 |       8 |
|     10 | russia         |      3 |        5 |        4 |      12 |
|     11 | south korea    |      2 |        2 |        2 |       6 |
|     12 | czechoslovakia |      2 |        0 |        3 |       5 |
|     13 | germany        |      1 |        8 |        4 |      13 |
|     14 | france         |      1 |        4 |        2 |       7 |
|     15 | italy          |      1 |        2 |        3 |       6 |
|     16 | china          |      1 |        1 |        2 |       4 |
|     17 | switzerland    |      1 |        0 |        0 |       1 |
|     17 | ukraine        |      1 |        0 |        0 |       1 |
|     19 | sweden         |      0 |        2 |        5 |       7 |
|     20 | soviet union   |      0 |        2 |        1 |       3 |
|     21 | finland        |      0 |        0 |        1 |       1 |

Question: What is the sum of Bronze when the rank is 7, and the total is more than 22?

table_id: 2-15409776-2
label: SELECT SUM("Bronze") FROM "table" WHERE "Rank" = 7 AND "Total" > 22
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Team               | Stadium                   |   Capacity |   Highest |   Lowest |   Average |
|:-------------------|:--------------------------|-----------:|----------:|---------:|----------:|
| east fife          | bayview stadium           |       2000 |      1300 |      540 |       769 |
| arbroath           | gayfield park             |       6488 |       959 |      421 |       611 |
| montrose           | links park                |       3292 |      1470 |      321 |       597 |
| dumbarton          | strathclyde homes stadium |       2025 |       907 |      258 |       559 |
| elgin city         | borough briggs            |       3927 |       624 |      301 |       471 |
| stenhousemuir      | ochilview park            |       3776 |       755 |      212 |       414 |
| forfar athletic    | station park              |       5177 |       615 |      270 |       410 |
| east stirlingshire | firs park                 |       1800 |       791 |      235 |       377 |
| albion rovers      | cliftonhill               |       1249 |       512 |      186 |       307 |

Question: The gayfield park stadium had a highest attendance of what?

table_id: 1-11206916-1
label: SELECT MAX("Highest") FROM "table" WHERE "Stadium" = "Gayfield Park"
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 | 17.12 (114)       | st kilda    | 8.14 (62)         | arden street oval     |    6500 | 7 june 1941 |
| footscray       | 20.12 (132)       | melbourne   | 14.20 (104)       | western oval          |   16000 | 7 june 1941 |
| fitzroy         | 17.14 (116)       | geelong     | 10.15 (75)        | brunswick street oval |    7000 | 7 june 1941 |
| carlton         | 13.21 (99)        | collingwood | 11.16 (82)        | princes park          |   18500 | 7 june 1941 |
| richmond        | 17.15 (117)       | hawthorn    | 8.14 (62)         | punt road oval        |    8500 | 7 june 1941 |
| south melbourne | 8.13 (61)         | essendon    | 13.18 (96)        | lake oval             |   15000 | 7 june 1941 |

Question: Name the away team for home team of fitzroy

table_id: 2-10807673-6
label: SELECT "Away team" FROM "table" WHERE "Home team" = "fitzroy"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Name            | Position       | Number   | School/Club Team   | Season    | Acquisition via   |
|:----------------|:---------------|:---------|:-------------------|:----------|:------------------|
| manny ramos     | forward        | 6        | la salle           | 2007      | trade             |
| neil rañeses    | forward        | 9        | visayas            | 2005-2006 | rookie draft      |
| rafi reavis     | center/forward | 4        | coppin state       | 2002-2006 | rookie draft      |
| jai reyes       | guard          | 15       | ateneo             | 2010-2011 | rookie draft      |
| rob reyes       | forward/center | 22       | flagler            | 2010-2011 | free agency       |
| jaja richards   | forward/center | 00       | loyola             | 2004      | import            |
| renren ritualo  | guard          | 14       | la salle           | 2010-2011 | free agency       |
| r.j rizada      | guard          | 8, 5     | far eastern        | 2006-2011 | far eastern       |
| larry rodriguez | forward        | 17       | pmi                | 2009-2010 | trade             |

Question: Name the name for visayas

table_id: 1-15463188-16
label: SELECT "Name" FROM "table" WHERE "School/Club Team" = "Visayas"
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:
| Rider            | Manufacturer   |   Laps | Time/Retired   |   Grid |
|:-----------------|:---------------|-------:|:---------------|-------:|
| casey stoner     | ducati         |     27 | 41:12.244      |      3 |
| loris capirossi  | ducati         |     27 | +6.763         |      5 |
| valentino rossi  | yamaha         |     27 | +10.038        |      2 |
| dani pedrosa     | honda          |     27 | +11.663        |      1 |
| alex barros      | ducati         |     27 | +19.475        |      7 |
| randy de puniet  | kawasaki       |     27 | +27.313        |      6 |
| john hopkins     | suzuki         |     27 | +29.243        |     14 |
| chris vermeulen  | suzuki         |     27 | +34.833        |     16 |
| colin edwards    | yamaha         |     27 | +35.073        |     11 |
| marco melandri   | honda          |     27 | +36.971        |     12 |
| carlos checa     | honda          |     27 | +37.721        |     13 |
| anthony west     | kawasaki       |     27 | +38.426        |     10 |
| shinya nakano    | honda          |     27 | +47.430        |      8 |
| sylvain guintoli | yamaha         |     27 | +54.324        |      9 |
| toni elías       | honda          |     27 | +1:10.471      |     18 |
| makoto tamada    | yamaha         |     27 | +1:12.904      |     15 |
| kurtis roberts   | kr212v         |     27 | +1:13.020      |     19 |
| nicky hayden     | honda          |      8 | retirement     |      4 |
| chaz davies      | ducati         |      8 | retirement     |     17 |

Question: What is the average grid with a number of laps smaller than 8?

table_id: 2-13719531-1
label: SELECT AVG("Grid") FROM "table" WHERE "Laps" < 8
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      | 2000   | 2001   | 2002   | 2005   | 2006   | 2007   | 2008   | 2009   | 2010   | 2011   | 2012   | 2013   | Win %   |
|:----------------|:-------|:-------|:-------|:-------|:-------|:-------|:-------|:-------|:-------|:-------|:-------|:-------|:--------|
| australian open | a      | lq     | a      | 3r     | 1r     | 4r     | 3r     | a      | sf     | f      | 4r     | f      | 77%     |
| french open     | a      | a      | a      | a      | 3r     | 3r     | a      | 4r     | 3r     | w      | 4r     | 2r     | 77%     |
| wimbledon       | a      | lq     | a      | a      | qf     | a      | 2r     | 3r     | qf     | 2r     | 2r     | qf     | 71%     |
| us open         | lq     | a      | a      | 1r     | 4r     | a      | 4r     | qf     | 1r     | 1r     | 3r     | sf     | 68%     |
| win-loss        | 0–0    | 0–0    | 0–0    | 2–2    | 9–4    | 5–2    | 6–3    | 9–3    | 11–4   | 14–3   | 9–4    | 16–4   | 74%     |

Question: What is the 2005 figure when 2002 is A and 2010 is 3R?

table_id: 2-1800772-3
label: SELECT "2005" FROM "table" WHERE "2002" = "a" AND "2010" = "3r"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Region   | Date              | Label             | Format         | Catalog    |
|:---------|:------------------|:------------------|:---------------|:-----------|
| japan    | march 21, 1982    | alfa records      | stereo lp      | alr-20002  |
| japan    | december 21, 1983 | alfa records      | cd             | 38xa-5     |
| japan    | january 25, 1987  | alfa records      | cd             | 32xa-112   |
| japan    | march 21, 1992    | alfa records      | cd             | alca-277   |
| japan    | july 27, 1994     | alfa records      | cd             | alca-9007  |
| japan    | july 23, 1998     | alfa records      | cd             | alca-9202  |
| japan    | january 23, 2002  | village records   | ed remaster cd | vrcl-2207  |
| japan    | february 14, 2002 | village records   | ed remaster cd | vrcl-2227  |
| japan    | may 27, 2009      | sony music direct | ed remaster cd | mhcl-20009 |

Question: What was the date for a catalog formatted in stereo LP?

table_id: 2-12703558-2
label: SELECT "Date" FROM "table" WHERE "Format" = "stereo lp"
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:
| City              | System                   | Category          |   Daily ridership | As of   |   Opened | Stations   |
|:------------------|:-------------------------|:------------------|------------------:|:--------|---------:|:-----------|
| vancouver, bc     | skytrain (vancouver)     | icts              |            354000 | 2009    |     1985 | 47         |
| toronto , ontario | toronto streetcar system | streetcar         |            275200 | 4q2009  |     1861 | n/a        |
| calgary, alberta  | c-train                  | light rail        |            269600 | 2012    |     1981 | 44         |
| edmonton, alberta | edmonton lrt             | light rail        |             93600 | 2010    |     1978 | 15         |
| toronto , ontario | scarborough rt           | icts              |             42250 | 2009    |     1985 | 6          |
| ottawa, ontario   | o-train                  | diesel light rail |             12200 | 4q2009  |     2001 | 5          |

Question: Which Stations are in vancouver, bc?

table_id: 2-18567686-1
label: SELECT "Stations" FROM "table" WHERE "City" = "vancouver, bc"