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:
|   Rank | Player                |   Points |   Points defending |   Points won |   New points | Withdrew due to     |
|-------:|:----------------------|---------:|-------------------:|-------------:|-------------:|:--------------------|
|      5 | juan martín del potro |     5115 |                720 |            0 |         4395 | right wrist surgery |
|      6 | nikolay davydenko     |     5145 |                360 |            0 |         4785 | broken wrist        |
|     20 | radek štěpánek        |     1705 |                 90 |            0 |         1615 | fatigue             |
|     23 | tommy haas            |     1660 |                180 |            0 |         1480 | right hip surgery   |
|     32 | gilles simon          |     1395 |                 90 |            0 |         1305 | right knee injury   |
|     36 | ivo karlović          |     1295 |                 10 |            0 |         1285 | right foot injury   |

Question: List the players with 1285 new points?

table_id: 1-24431264-18
label: SELECT "Player" FROM "table" WHERE "New points" = 1285
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    | may 25, 1979      | alfa records      | stereo lp      | alr-6017   |
| japan    | december 21, 1986 | alfa records      | cd             | 32xa-104   |
| japan    | march 21, 1992    | alfa records      | cd             | alca-271   |
| japan    | june 29, 1994     | alfa records      | cd             | alca-9001  |
| japan    | july 23, 1998     | alfa records      | cd             | alca-9196  |
| japan    | may 31, 2000      | toshiba emi       | ed remaster cd | toct-24364 |
| japan    | december 19, 2001 | village records   | ed remaster cd | vrcl-2201  |
| japan    | january 17, 2002  | village records   | ed remaster cd | vrcl-2221  |
| japan    | may 27, 2009      | sony music direct | ed remaster cd | mhcl-20003 |

Question: When did sony music direct a label?

table_id: 2-12694743-1
label: SELECT "Date" FROM "table" WHERE "Label" = "sony music direct"
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:
| Class           | Type     |   Sailors |   Trapeze |   First OG |   Olympics so far |
|:----------------|:---------|----------:|----------:|-----------:|------------------:|
| finn            | dinghy   |         1 |         0 |       1952 |                 5 |
| flying dutchman | dinghy   |         2 |         1 |       1960 |                 3 |
| star            | keelboat |         2 |         0 |       1932 |                 8 |
| dragon          | keelboat |         3 |         0 |       1948 |                 6 |
| 5.5 metre       | keelboat |         3 |         0 |       1952 |                 5 |

Question: What is the lowest value for Olympics, when Sailors is greater than 1, when First OG is after 1948, and when Class is "Flying Dutchman"?

table_id: 2-1806946-2
label: SELECT MIN("Olympics so far") FROM "table" WHERE "Sailors" > 1 AND "First OG" > 1948 AND "Class" = "flying dutchman"
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 | mayra gonzález   | cuba        | 8:02.10 | fc      |
|      2 | nuria domínguez  | spain       | 8:03.61 | fc      |
|      3 | gabriela best    | argentina   | 8:09.61 | fc      |
|      4 | fabiana beltrame | brazil      | 8:13.01 | fd      |
|      5 | shin yeong-eun   | south korea | 8:23.62 | fd      |
|      6 | elana hill       | zimbabwe    | 8:34.27 | fe      |

Question: What are the notes for Zimbabwe?

table_id: 2-18662695-12
label: SELECT "Notes" FROM "table" WHERE "Country" = "zimbabwe"
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 Player of bernard thompson?

table_id: 2-17116053-1
label: SELECT "Position" FROM "table" WHERE "Player" = "bernard thompson"
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 | Competition                             | Venue                    | Position   | Notes       |
|-------:|:----------------------------------------|:-------------------------|:-----------|:------------|
|   2007 | world cross country championships       | mombasa , kenya          | 4th        | junior race |
|   2007 | world youth championships in athletics  | ostrava , czech republic | 3rd        | 3000 m      |
|   2008 | world junior championships in athletics | bydgoszcz , poland       | 1st        | 5000 m      |
|   2009 | world cross country championships       | amman , jordan           | 6th        | junior race |
|   2011 | all-africa games                        | maputo , mozambique      | 1st        | 5000 m      |
|   2011 | all-africa games                        | maputo , mozambique      | 1st        | 10,000 m    |

Question: What was the latest year with a position of 1st at Maputo, Mozambique?

table_id: 2-18354377-1
label: SELECT MAX("Year") FROM "table" WHERE "Position" = "1st" AND "Venue" = "maputo, mozambique"
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                    | Nickname        |   Founded | Type                           |   Enrollment |   Joined |
|:-----------------------|:----------------------------|:----------------|----------:|:-------------------------------|-------------:|---------:|
| albright college       | reading, pennsylvania       | lions           |      1856 | private/methodist              |         2401 |     1999 |
| alvernia university    | reading, pennsylvania       | crusaders       |      1958 | private/catholic               |         2906 |     2009 |
| arcadia university     | glenside, pennsylvania      | knights         |      1853 | private/presbyterian           |         4078 |     2008 |
| elizabethtown college  | elizabethtown, pennsylvania | blue jays       |      1899 | private/church of the brethren |         2416 |     1999 |
| hood college           | frederick, maryland         | blazers         |      1893 | private/reformed               |         2435 |     2012 |
| lebanon valley college | annville, pennsylvania      | flying dutchmen |      1866 | private/methodist              |         2102 |     1999 |
| lycoming college       | williamsport, pennsylvania  | warriors        |      1812 | private/methodist              |         1321 |     2007 |
| messiah college        | grantham, pennsylvania      | falcons         |      1909 | private/christian              |         2976 |     1999 |
| stevenson university   | stevenson, maryland         | mustangs        |      1947 | private/catholic               |         3941 |     2012 |

Question: what type is the institute that enrolled 2102

table_id: 1-1974632-1
label: SELECT "Type" FROM "table" WHERE "Enrollment" = 2102
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 3, 2000  | jacksonville jaguars    | l 27–7   | 72,418       |
|      2 | september 10, 2000 | at cincinnati bengals   | w 24–7   | 64,006       |
|      3 | september 17, 2000 | pittsburgh steelers     | w 23–20  | 73,018       |
|      4 | september 24, 2000 | at oakland raiders      | l 36–10  | 45,702       |
|      5 | october 1, 2000    | baltimore ravens        | l 12–0   | 73,018       |
|      6 | october 8, 2000    | at arizona cardinals    | l 29–21  | 39,148       |
|      7 | october 15, 2000   | at denver broncos       | l 44–10  | 75,811       |
|      8 | october 22, 2000   | at pittsburgh steelers  | l 22–0   | 57,659       |
|      9 | october 29, 2000   | cincinnati bengals      | l 12–3   | 73,118       |
|     10 | november 5, 2000   | new york giants         | l 24–3   | 72,718       |
|     11 | november 12, 2000  | new england patriots    | w 19–11  | 72,618       |
|     12 | november 19, 2000  | at tennessee titans     | l 24–10  | 68,498       |
|     13 | november 26, 2000  | at baltimore ravens     | l 44–7   | 68,361       |
|     14 | december 3, 2000   | at jacksonville jaguars | l 48–0   | 51,262       |
|     15 | december 10, 2000  | philadelphia eagles     | l 35–24  | 72,318       |
|     16 | december 17, 2000  | tennessee titans        | l 24–0   | 72,318       |
|     17 | bye                | bye                     | bye      | bye          |

Question: What week did they have a bye?

table_id: 2-10652292-2
label: SELECT "Week" FROM "table" WHERE "Opponent" = "bye"
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 # |   Production Count | Original Airdate   | Prod. Code   | Title                   |   Viewing figures millions |
|------------:|-------------------:|:-------------------|:-------------|:------------------------|---------------------------:|
|           1 |                 24 | 8 august 2003      | icec483x     | "a sporting chance"     |                       5.19 |
|           2 |                 25 | 15 august 2003     | icec481j     | "the living dead"       |                       6.26 |
|           3 |                 26 | 22 august 2003     | icec490f     | "taking the credit"     |                       6.4  |
|           4 |                 27 | 29 august 2003     | icec485k     | "it’s all in the mind"  |                       6.19 |
|           5 |                 28 | 5 september 2003   | icec486e     | "space virus"           |                       6.49 |
|           6 |                 29 | 12 september 2003  | icec482d     | "the mayor of northolt" |                       6.32 |
|           7 |                 30 | 19 september 2003  | icec487y     | "big"                   |                       6.19 |
|           8 |                 31 | 26 september 2003  | icec484r     | "the consultant"        |                       6.21 |
|           9 |                 32 | 3 october 2003     | icec489l     | "the family way"        |                       6.51 |

Question: What is the lowest episode number?

table_id: 1-2501754-4
label: SELECT MIN("Episode #") FROM "table"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   Played |   Drawn |   Lost |   Against |   % Won |
|---------:|--------:|-------:|----------:|--------:|
|        2 |       0 |      0 |        29 |   100   |
|        5 |       0 |      2 |        80 |    60   |
|        1 |       0 |      0 |        24 |   100   |
|        5 |       0 |      2 |        64 |    60   |
|        2 |       0 |      0 |        16 |   100   |
|        3 |       0 |      0 |        33 |   100   |
|        1 |       0 |      0 |         7 |   100   |
|        3 |       0 |      3 |        93 |     0   |
|        1 |       0 |      0 |         3 |   100   |
|        3 |       0 |      0 |        66 |   100   |
|        2 |       0 |      0 |        18 |   100   |
|        4 |       0 |      3 |        95 |    25   |
|        2 |       0 |      0 |        30 |   100   |
|        3 |       0 |      0 |        25 |   100   |
|        1 |       0 |      0 |        13 |   100   |
|        2 |       0 |      1 |        33 |    50   |
|       40 |       0 |     11 |       633 |    72.5 |

Question: What is the smallest Against with Lost larger than 0, % Won larger than 50, and Played smaller than 5?

table_id: 2-18243389-9
label: SELECT MIN("Against") FROM "table" WHERE "Lost" > 0 AND "% Won" > 50 AND "Played" < 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:
| Position           | 2014              | 2013              | 2012            | 2011           |
|:-------------------|:------------------|:------------------|:----------------|:---------------|
| president          | kevan leonard     | danielle button   | josh biggs      | pete mcevoy    |
| vice-president     | michael cooper    | william hextall   | elsa bland      | mardi rohden   |
| social convenor    | jerry rockner     | freddie dunham    | garion weller   | kate stevenson |
| communications rep | jamie graham      | claire milligan   | olivia congdon  | kirsten heslop |
| cultural rep       | elissa davies     | jess melvin       | nicola dobson   | n/a            |
| male sports rep    | matty moir        | jarrah rubinstein | matt barwick    | liam dolbey    |
| female sports rep  | stephanie lockett | stephanie warren  | winston johnson | claire turnor  |

Question: Who held the same position in 2014 that Danielle Button held in 2013?

table_id: 2-1596425-2
label: SELECT "2014" FROM "table" WHERE "2013" = "danielle button"
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 | singapore   |     11 |        9 |        6 |      26 |
|      2 | philippines |      8 |        3 |        7 |      18 |
|      3 | malaysia    |      7 |        8 |        8 |      23 |
|      4 | thailand    |      5 |        7 |        8 |      20 |
|      5 | vietnam     |      1 |        0 |        1 |       2 |
|      6 | indonesia   |      0 |        5 |        2 |       7 |

Question: What is the largest bronze with a Rank of 2, and a Gold smaller than 8?

table_id: 2-14639905-3
label: SELECT MAX("Bronze") FROM "table" WHERE "Rank" = 2 AND "Gold" < 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:
|   Pick # | CFL Team              | Player                | Position   | College      |
|---------:|:----------------------|:----------------------|:-----------|:-------------|
|       33 | hamilton tiger-cats   | laurent lavigne masse | rec        | laval        |
|       34 | edmonton eskimos      | dante luciani         | rec        | laurier      |
|       35 | calgary stampeders    | jon gott              | ol         | boise state  |
|       36 | montreal alouettes    | paul woldu            | db         | saskatchewan |
|       37 | toronto argonauts     | richard zulys         | ol         | western      |
|       38 | bc lions              | brady browne          | db         | manitoba     |
|       39 | winnipeg blue bombers | don oramasionwu       | dl         | manitoba     |

Question: What position is the player drafted with pick 34?

table_id: 1-16575609-5
label: SELECT "Position" FROM "table" WHERE "Pick #" = 34
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Date       | City               | Opponent   | Results¹   | Type of game   |
|:-----------|:-------------------|:-----------|:-----------|:---------------|
| january 16 | cairo , egypt      | egypt      | 3:1        | friendly       |
| may 9      | belgrade           | greece     | 1:0        | 1954 wcq       |
| may 14     | brussels , belgium | belgium    | 3:1        | friendly       |
| may 21     | belgrade           | wales      | 5:2        | friendly       |
| june 5     | zagreb             | turkey     | 2:2        | friendly       |
| october 18 | zagreb             | france     | 3:1        | friendly       |
| november 8 | skoplje            | israel     | 1:0        | 1954 wcq       |

Question: Who was the opponent in Belgrade and had a result of 5:2?

table_id: 2-14305653-31
label: SELECT "Opponent" FROM "table" WHERE "City" = "belgrade" AND "Results¹" = "5:2"
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:
| Couple            | Score        | Dance   | Music                              | Result     |
|:------------------|:-------------|:--------|:-----------------------------------|:-----------|
| evander & edyta   | 13 (5, 4, 4) | jive    | " reet petite "— jackie wilson     | eliminated |
| rachel & jonathan | 26 (8, 9, 9) | tango   | " toxic "— britney spears          | safe       |
| kelly & alec      | 21 (6, 7, 8) | jive    | " footloose "— kenny loggins       | safe       |
| john & charlotte  | 24 (9, 8, 7) | tango   | " dance with me "— debelah morgan  | safe       |
| joey & ashly      | 22 (7, 7, 8) | jive    | " i'm still standing "— elton john | bottom two |

Question: What was the music for the team who earned a score of 13 (5, 4, 4)?

table_id: 2-10535354-8
label: SELECT "Music" FROM "table" WHERE "Score" = "13 (5, 4, 4)"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Place   | Player        | Country       | Score           | To par   | Money ( $ )   |
|:--------|:--------------|:--------------|:----------------|:---------|:--------------|
| t1      | jack nicklaus | united states | 72-70-72-69=283 | –1       | playoff       |
| t1      | arnold palmer | united states | 71-68-73-71=283 | –1       | playoff       |
| t3      | bobby nichols | united states | 70-72-70-73=285 | +1       | 5,500         |
| t3      | phil rodgers  | united states | 74-70-69-72=285 | +1       | 5,500         |
| 5       | gay brewer    | united states | 73-72-73-69=287 | +3       | 4,000         |
| t6      | tommy jacobs  | united states | 74-71-73-70=288 | +4       | 2,750         |
| t6      | gary player   | south africa  | 71-71-72-74=288 | +4       | 2,750         |
| t8      | doug ford     | united states | 74-75-71-70=290 | +6       | 1,767         |
| t8      | gene littler  | united states | 69-74-72-75=290 | +6       | 1,767         |
| t8      | billy maxwell | united states | 71-70-75-74=290 | +6       | 1,767         |

Question: What Country is Gene Littler from?

table_id: 2-17277219-7
label: SELECT "Country" FROM "table" WHERE "Player" = "gene littler"
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 # | CFL Team                                        | Player             | Position   | College            |
|---------:|:------------------------------------------------|:-------------------|:-----------|:-------------------|
|       25 | hamilton tiger-cats (via montreal via hamilton) | robert pavlovic    | te         | south carolina     |
|       26 | edmonton eskimos                                | micheal jean-louis | dl         | laval              |
|       27 | edmonton eskimos (via winnipeg)                 | calvin mccarty     | rb         | western washington |
|       28 | saskatchewan roughriders                        | ryan ackerman      | ol         | regina             |
|       29 | toronto argonauts                               | eric maranda       | lb         | laval              |
|       30 | toronto argonauts (via calgary)                 | steve schmidt      | te         | san diego state    |
|       31 | montreal alouettes                              | james judges       | de         | buffalo            |

Question: What college had a LB in the draft?

table_id: 1-10812403-4
label: SELECT "College" FROM "table" WHERE "Position" = "LB"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Place   | Player        | Country       | Score           | To par   | Money ( $ )   |
|:--------|:--------------|:--------------|:----------------|:---------|:--------------|
| t1      | jack nicklaus | united states | 72-70-72-69=283 | –1       | playoff       |
| t1      | arnold palmer | united states | 71-68-73-71=283 | –1       | playoff       |
| t3      | bobby nichols | united states | 70-72-70-73=285 | +1       | 5,500         |
| t3      | phil rodgers  | united states | 74-70-69-72=285 | +1       | 5,500         |
| 5       | gay brewer    | united states | 73-72-73-69=287 | +3       | 4,000         |
| t6      | tommy jacobs  | united states | 74-71-73-70=288 | +4       | 2,750         |
| t6      | gary player   | south africa  | 71-71-72-74=288 | +4       | 2,750         |
| t8      | doug ford     | united states | 74-75-71-70=290 | +6       | 1,767         |
| t8      | gene littler  | united states | 69-74-72-75=290 | +6       | 1,767         |
| t8      | billy maxwell | united states | 71-70-75-74=290 | +6       | 1,767         |

Question: What is the Country of the Player with a Score of 70-72-70-73=285 and Money ( $ ) of 5,500?

table_id: 2-17277219-7
label: SELECT "Country" FROM "table" WHERE "Money ( $ )" = "5,500" AND "Score" = "70-72-70-73=285"
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          | Position   | School                            | Hometown             | MLB Draft                                         |
|:----------------|:-----------|:----------------------------------|:---------------------|:--------------------------------------------------|
| clayton kershaw | pitcher    | highland park high school         | dallas, tx           | 1st round - 7th pick of 2006 draft ( dodgers )    |
| hank conger     | catcher    | huntington beach high school      | huntington beach, ca | 1st round - 25th pick of 2006 draft ( angels )    |
| chris marrero   | infielder  | monsignor pace high school        | opa-locka, fl        | 1st round - 15th pick of 2006 draft ( nationals ) |
| billy rowell    | infielder  | bishop eustace preparatory school | pennsauken, nj       | 1st round - 9th pick of 2006 draft ( orioles )    |
| chris parmelee  | outfielder | chino hills high school           | chino hills, ca      | 1st round - 20th pick of 2006 draft ( twins )     |
| jason place     | outfielder | wren high school                  | piedmont, sc         | 1st round - 27th pick of 2006 draft ( red sox )   |
| travis snider   | outfielder | jackson high school               | mill creek, wa       | 1st round - 14th pick of 2006 draft ( blue jays ) |

Question: What is the hometown of player Jason Place?

table_id: 1-11677100-12
label: SELECT "Hometown" FROM "table" WHERE "Player" = "Jason Place"