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:
| Date        | Visitor     | Score   | Home        | Decision   |   Attendance | Record   |
|:------------|:------------|:--------|:------------|:-----------|-------------:|:---------|
| december 1  | colorado    | 5 – 2   | los angeles | labarbera  |        17297 | 10–14–1  |
| december 3  | edmonton    | 4 – 3   | los angeles | aubin      |        14193 | 10–14–2  |
| december 5  | los angeles | 1 – 4   | phoenix     | aubin      |        11401 | 10–15–2  |
| december 6  | buffalo     | 2 – 8   | los angeles | quick      |        15980 | 11–15–2  |
| december 8  | phoenix     | 4 – 2   | los angeles | aubin      |        16053 | 11–16–2  |
| december 10 | vancouver   | 2 – 4   | los angeles | aubin      |        15087 | 12–16–2  |
| december 12 | los angeles | 3 – 6   | chicago     | quick      |        12534 | 12–17–2  |
| december 13 | los angeles | 1 – 4   | dallas      | quick      |        17913 | 12–18–2  |
| december 15 | minnesota   | 2 – 1   | los angeles | aubin      |        16648 | 12–19–2  |
| december 17 | colorado    | 4 – 2   | los angeles | labarbera  |        16647 | 12–20–2  |
| december 19 | los angeles | 2 – 6   | detroit     | labarbera  |        19516 | 12–21–2  |
| december 21 | los angeles | 1 – 2   | columbus    | labarbera  |        14034 | 12–22–2  |
| december 22 | los angeles | 3 – 4   | nashville   | labarbera  |        15698 | 12–23–2  |
| december 26 | san jose    | 3 – 2   | los angeles | labarbera  |        18118 | 12–24–2  |
| december 29 | los angeles | 3 – 1   | colorado    | aubin      |        17256 | 13–24–2  |
| december 30 | los angeles | 3 – 2   | chicago     | labarbera  |        21715 | 14–24–2  |

Question: Who did team phoenix visit in their home?

table_id: 2-11821711-6
label: SELECT "Home" FROM "table" WHERE "Visitor" = "phoenix"
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 venue that had 5000 m after 2009?

table_id: 2-18354377-1
label: SELECT "Venue" FROM "table" WHERE "Year" > 2009 AND "Notes" = "5000 m"
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 |   Time | Athlete        | Nation   | Date             | Location               |
|-------:|-------:|:---------------|:---------|:-----------------|:-----------------------|
|      1 |   9.58 | usain bolt     | jamaica  | 16 august 2009   | berlin , germany       |
|      2 |   9.69 | yohan blake    | jamaica  | 23 august 2012   | lausanne , switzerland |
|      3 |   9.72 | asafa powell   | jamaica  | 2 september 2008 | lausanne , switzerland |
|      4 |   9.78 | nesta carter   | jamaica  | 29 august 2010   | rieti , italy          |
|      5 |   9.8  | steve mullings | jamaica  | 4 june 2011      | eugene , usa           |

Question: What is the Athlete of the race with a Time of 9.78?

table_id: 2-15166232-2
label: SELECT "Athlete" FROM "table" WHERE "Time" = 9.78
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Place   | Player           | Country       | Score        | To par   |
|:--------|:-----------------|:--------------|:-------------|:---------|
| 1       | tom watson       | united states | 72-65-71=208 | –2       |
| t2      | keith clearwater | united states | 74-71-64=209 | –1       |
| t2      | scott simpson    | united states | 71-68-70=209 | –1       |
| 4       | lennie clements  | united states | 70-70-70=210 | e        |
| t5      | seve ballesteros | spain         | 68-75-68=211 | +1       |
| t5      | ben crenshaw     | united states | 67-72-72=211 | +1       |
| t5      | bernhard langer  | west germany  | 69-69-73=211 | +1       |
| t5      | john mahaffey    | united states | 72-72-67=211 | +1       |
| t5      | larry mize       | united states | 71-68-72=211 | +1       |
| t5      | jim thorpe       | united states | 70-68-73=211 | +1       |

Question: What was the nationality of the player with a score of 72-72-67=211?

table_id: 2-17231211-6
label: SELECT "Country" FROM "table" WHERE "Score" = "72-72-67=211"
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             |
| chris ross      | guard          | 1        | marshall           | 2009-2010 | trade             |

Question: What is the number for the forward position from the school/club team La Salle?

table_id: 2-15463188-16
label: SELECT "Number" FROM "table" WHERE "Position" = "forward" AND "School/Club Team" = "la salle"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Date             | Visitor   | Score   | Home      | Leading scorer        | Record   |
|:-----------------|:----------|:--------|:----------|:----------------------|:---------|
| 2 november 2007  | bucks     | 99–102  | bobcats   | michael redd (21)     | 0–2      |
| 3 november 2007  | bulls     | 72–78   | bucks     | michael redd (27)     | 1–2      |
| 6 november 2007  | raptors   | 85–112  | bucks     | desmond mason (21)    | 2–2      |
| 9 november 2007  | bucks     | 88–104  | rockets   | michael redd (26)     | 2–3      |
| 11 november 2007 | bucks     | 88–113  | spurs     | maurice williams (17) | 2–4      |
| 14 november 2007 | grizzlies | 99–102  | bucks     | michael redd (31)     | 3–4      |
| 17 november 2007 | hawks     | 96–105  | bucks     | two-way tie (21)      | 4–4      |
| 20 november 2007 | bucks     | 111–107 | cavaliers | michael redd (34)     | 5–4      |
| 21 november 2007 | lakers    | 103–110 | bucks     | michael redd (26)     | 6–4      |
| 24 november 2007 | mavericks | 95–97   | bucks     | michael redd (27)     | 7–4      |
| 27 november 2007 | sixers    | 114–99  | bucks     | michael redd (17)     | 7–5      |
| 28 november 2007 | bucks     | 80–96   | hawks     | michael redd (24)     | 7–6      |
| 30 november 2007 | bucks     | 88–91   | knicks    | michael redd (27)     | 7–7      |

Question: Name the record with home of bucks on 24 november 2007

table_id: 2-11961176-4
label: SELECT "Record" FROM "table" WHERE "Home" = "bucks" AND "Date" = "24 november 2007"
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                         | Bullet        | Case Length   | Base         | Neck         |
|:-----------------------------|:--------------|:--------------|:-------------|:-------------|
| .401 winchester self-loading | 10.34 (.4065) | 38.1 (1.5)    | 11.68 (.490) | 10.99 (.432) |
| .44 wcf                      | 10.85 (.427)  | 33.27 (1.310) | 11.96 (.471) | 11.25 (.443) |
| .408 chey tac                | 10.4 (.408)   | 77 (3.04)     | 16.2 (.637)  | 11.1 (.438)  |
| .416 barrett                 | 10.57 (.416)  | 83.058 (3.27) | 20.2 (.797)  | 11.8 (.465)  |
| .416 remington magnum        | 10.566 (.416) | 72.39 (2.850) | 13.03 (.513) | 11.35 (.447) |
| .416 rigby                   | 10.57 (.416)  | 73.66 (2.90)  | 14.96 (.589) | 11.33 (.446) |
| .416 weatherby magnum        | 10.566 (.416) | 73.99 (2.913) | 14.78 (.582) | 11.28 (.444) |
| .404 jeffery                 | 10.75 (.422)  | 72.64 (2.86)  | 13.82 (.544) | 11.43 (.450) |
| .405 winchester              | 10.45 (0.411) | 65.6 (2.583)  | 11.7 (0.461) | 11.1 (0.436) |
| .444 marlin                  | 10.922 (.430) | 56.51 (2.225) | 11.96 (.471) | 11.51 (.453) |

Question: Which Base has a Name of .44 wcf?

table_id: 2-1057183-3
label: SELECT "Base" FROM "table" WHERE "Name" = ".44 wcf"
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   | Date of Birth (Age)   |   Caps | Club/province     |
|:---------------------|:-----------|:----------------------|-------:|:------------------|
| mark crick           | hooker     | 27 january 1975       |      3 | pac               |
| mike french          | prop       | 19 november 1975      |      8 | ombac             |
| brian lemay          | prop       | 26 may 1983           |      0 | boston            |
| chris moreno         | prop       | 23 april 1978         |      0 | denver barbarians |
| john van der giessen | lock       | 6 may 1982            |      0 | denver barbarians |
| tyson meek           | scrum-half | 21 april 1980         |      4 | denver barbarians |
| andrew osborne       | fullback   | 4 march 1981          |      1 | ombac             |

Question: When was brian lemay born?

table_id: 2-11783766-6
label: SELECT "Date of Birth (Age)" FROM "table" WHERE "Player" = "brian lemay"
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         | Team      |   Matches |   Wickets |   Average | Best Bowling   |
|:---------------|:----------|----------:|----------:|----------:|:---------------|
| ray lindwall   | australia |         5 |        27 |     19.62 | 6/20           |
| norman yardley | england   |         5 |         9 |     22.66 | 2/32           |
| keith miller   | australia |         5 |        13 |     23.15 | 4/125          |
| bill johnston  | australia |         5 |        27 |     23.33 | 5/36           |
| ernie toshack  | australia |         4 |        11 |     33.09 | 5/40           |
| alec bedser    | england   |         5 |        18 |     38.22 | 4/81           |
| jim laker      | england   |         3 |         9 |     52.44 | 4/138          |

Question: what is the highest wickets when the best bowling is 2/32 and matches is less than 5?

table_id: 2-16570286-4
label: SELECT MAX("Wickets") FROM "table" WHERE "Best Bowling" = "2/32" AND "Matches" < 5
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   Year | Competition                          | Venue                                           | Position   | Notes   |
|-------:|:-------------------------------------|:------------------------------------------------|:-----------|:--------|
|   1985 | central american and caribbean games | nassau, bahamas                                 | 2nd        | 1.81m   |
|   1986 | central american and caribbean games | santiago de los caballeros , dominican republic | 2nd        | 1.81m   |
|   1988 | olympic games                        | seoul, south korea                              | 20th       | 1.84m   |
|   1990 | central american and caribbean games | mexico city, mexico                             | 3rd        | 1.79m   |
|   1991 | central american and caribbean games | xalapa, veracruz , mexico                       | 1st        | 1.86m   |
|   1992 | olympic games                        | barcelona, spain                                | dnq        | 1.83m   |

Question: In what year is the notes distance 1.83m?

table_id: 2-14617261-1
label: SELECT "Year" FROM "table" WHERE "Notes" = "1.83m"
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:
| Constituency number   | Name       | Reserved for ( SC / ST /None)   | District   |   Number of electorates (2009) |
|:----------------------|:-----------|:--------------------------------|:-----------|-------------------------------:|
| 174                   | bagali     | st                              | dewas      |                         163233 |
| 175                   | mandhata   | none                            | khandwa    |                         146012 |
| 177                   | khandwa    | sc                              | khandwa    |                         188799 |
| 178                   | pandhana   | st                              | khandwa    |                         178625 |
| 179                   | nepanagar  | st                              | burhanpur  |                         159916 |
| 180                   | burhanpur  | none                            | burhanpur  |                         220057 |
| 181                   | bikhangaon | st                              | khargone   |                         144997 |
| 182                   | badwah     | none                            | khargone   |                         153550 |
| total:                | total:     | total:                          | total:     |                        1355189 |

Question: What is the Constituency number for Bikhangaon with a Reserved for ( SC / ST /None) of st?

table_id: 2-18517491-1
label: SELECT "Constituency number" FROM "table" WHERE "Reserved for ( SC / ST /None)" = "st" AND "Name" = "bikhangaon"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   Round |   Pick # |   Overall | Name             | Position         | College                 |
|--------:|---------:|----------:|:-----------------|:-----------------|:------------------------|
|       2 |       23 |        55 | bryan scott      | safety           | penn state              |
|       4 |       24 |       121 | justin griffith  | fullback         | mississippi state       |
|       5 |       24 |       159 | jon olinger      | wide receiver    | cincinnati              |
|       6 |       23 |       196 | latarence dunbar | wide receiver    | tcu                     |
|       6 |       29 |       202 | waine bacon      | cornerback       | alabama                 |
|       7 |       24 |       238 | demetrin veal    | defensive tackle | university of tennessee |

Question: Before round 7, what is the greatest Pick # for a player that plays defensive tackle?

table_id: 2-15198842-38
label: SELECT MAX("Pick #") FROM "table" WHERE "Position" = "defensive tackle" AND "Round" < 7
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 Player has a Pick larger than 20?

table_id: 2-17116053-1
label: SELECT "Player" FROM "table" WHERE "Pick" > 20
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:
|   L&CR No. | Type   | Manufacturer               | Delivered   | Name       |   Jt. Cttee No. | 1845 disposal   |
|-----------:|:-------|:---------------------------|:------------|:-----------|----------------:|:----------------|
|          1 | 2-2-2  | sharp, roberts and company | 1838/07     | surrey     |               1 | l&br            |
|          2 | 2-2-2  | g. and j. rennie           | 1838/08     | croydon    |               2 | ser             |
|          3 | 2-2-2  | sharp, roberts and company | 1838/09     | sussex     |               3 | l&br            |
|          4 | 2-2-2  | sharp, roberts and company | 1839/02     | kent       |               4 | l&br            |
|          5 | 2-2-2  | sharp, roberts and company | 1839/03     | london     |               5 | ser             |
|          6 | 2-2-2  | g. and j. rennie           | 1839/07     | archimedes |               6 | ser             |
|          7 | 0-4-2  | sharp, roberts and company | 1839/07     | hercules   |               7 | ser             |

Question: What was the type of sussex?

table_id: 1-1184344-1
label: SELECT "Type" FROM "table" WHERE "Name" = "Sussex"
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:
| Time      | 00:00 AM    | 01:00 AM                  | 02:00 AM   | 05:00 AM             |
|:----------|:------------|:--------------------------|:-----------|:---------------------|
| monday    | double shot | melosamosorn (vj woonsen) | [v] tunes  | asian hero (vj mike) |
| tuesday   | double shot | melosamosorn (vj woonsen) | [v] tunes  | asian hero (vj mike) |
| wednesday | double shot | melosamosorn (vj woonsen) | [v] tunes  | asian hero (vj mike) |
| thursday  | double shot | melosamosorn (vj woonsen) | [v] tunes  | asian hero (vj mike) |
| friday    | double shot | melosamosorn (vj woonsen) | [v] tunes  | asian hero (vj mike) |
| saturday  | double shot | melosamosorn (vj woonsen) | [v] tunes  | asian hero (vj mike) |
| sunday    | double shot | melosamosorn (vj woonsen) | [v] tunes  | asian hero (vj mike) |

Question: Which show runs on Friday at 05:00 AM?

table_id: 2-15535243-1
label: SELECT "05:00 AM" FROM "table" WHERE "Time" = "friday"
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:
| Driver             | Seasons                   |   Entries |   Poles | Percentage   |
|:-------------------|:--------------------------|----------:|--------:|:-------------|
| michael schumacher | 1991 – 2006 , 2010 – 2012 |       308 |      68 | 22.08%       |
| ayrton senna       | 1984 – 1994               |       162 |      65 | 40.12%       |
| sebastian vettel   | 2007 – 2013               |       118 |      43 | 36.44%       |
| jim clark          | 1960 – 1968               |        73 |      33 | 45.21%       |
| alain prost        | 1980 – 1991 , 1993        |       202 |      33 | 16.34%       |
| nigel mansell      | 1980 – 1992 , 1994 – 1995 |       191 |      32 | 16.75%       |
| lewis hamilton     | 2007 – 2013               |       127 |      31 | 24.41%       |
| juan manuel fangio | 1950 – 1951 , 1953 – 1958 |        52 |      29 | 55.77%       |
| mika häkkinen      | 1991 – 2001               |       165 |      26 | 15.76%       |
| niki lauda         | 1971 – 1979 , 1982 – 1985 |       177 |      24 | 13.56%       |
| nelson piquet      | 1978 – 1991               |       207 |      24 | 11.59%       |

Question: How many poles has a percentage of 22.08%?

table_id: 2-13599687-24
label: SELECT SUM("Poles") FROM "table" WHERE "Percentage" = "22.08%"
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 | 7.8 (50)          | st kilda    | 11.15 (81)        | arden street oval     |    4000 | 29 august 1931 |
| footscray       | 10.12 (72)        | melbourne   | 5.8 (38)          | western oval          |   12000 | 29 august 1931 |
| fitzroy         | 9.8 (62)          | geelong     | 9.22 (76)         | brunswick street oval |    8000 | 29 august 1931 |
| south melbourne | 12.18 (90)        | hawthorn    | 9.5 (59)          | lake oval             |    4500 | 29 august 1931 |
| richmond        | 23.14 (152)       | essendon    | 15.11 (101)       | punt road oval        |   16000 | 29 august 1931 |
| collingwood     | 20.15 (135)       | carlton     | 10.14 (74)        | victoria park         |   20000 | 29 august 1931 |

Question: Which Away team has a Home team score of 7.8 (50)?

table_id: 2-10789881-16
label: SELECT "Away team" FROM "table" WHERE "Home team score" = "7.8 (50)"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   Round |   Pick | Player           | Position   | School              |
|--------:|-------:|:-----------------|:-----------|:--------------------|
|       1 |     14 | renaldo turnbull | de         | west virginia       |
|       2 |     44 | vince buck       | db         | central state       |
|       3 |     71 | joel smeenge     | de         | western michigan    |
|       4 |     98 | demond winston   | lb         | vanderbilt          |
|       5 |    125 | charles arbuckle | te         | ucla                |
|       6 |    156 | mike buck        | qb         | maine               |
|       6 |    158 | james williams   | lb         | mississippi state   |
|       7 |    183 | scott hough      | g          | maine               |
|       8 |    207 | gerry gdowski    | qb         | nebraska            |
|       8 |    210 | derrick carr     | de         | bowling green       |
|       9 |    233 | broderick graves | rb         | winston-salem state |
|       9 |    236 | lonnie brockman  | lb         | west virginia       |
|      10 |    260 | gary cooper      | wr         | clemson             |
|      10 |    267 | ernest spears    | db         | usc                 |
|      11 |    287 | webbie burnett   | dt         | western kentucky    |
|      12 |    320 | chris port       | g          | duke                |

Question: What was the highest Pick for Lonnie Brockman before round 9?

table_id: 2-16712710-1
label: SELECT MAX("Pick") FROM "table" WHERE "Player" = "lonnie brockman" AND "Round" < 9
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   Week | Date               | Opponent               | Result   | Attendance   |
|-------:|:-------------------|:-----------------------|:---------|:-------------|
|      1 | september 25, 1960 | at san francisco 49ers | w 21–19  | 44,598       |
|      2 | october 2, 1960    | at st. louis cardinals | w 35–14  | 26,089       |
|      3 | october 9, 1960    | at pittsburgh steelers | w 19–17  | 40,323       |
|      4 | october 16, 1960   | washington redskins    | t 24–24  | 60,625       |
|      5 | bye                | bye                    | bye      | bye          |
|      6 | october 30, 1960   | st. louis cardinals    | l 20–13  | 58,516       |
|      7 | november 6, 1960   | at cleveland browns    | w 17–13  | 82,872       |
|      8 | november 13, 1960  | pittsburgh steelers    | w 27–24  | 63,321       |
|      9 | november 20, 1960  | philadelphia eagles    | l 17–10  | 63,571       |
|     10 | november 27, 1960  | at philadelphia eagles | l 31–23  | 60,547       |
|     11 | december 4, 1960   | dallas cowboys         | t 31–31  | 55,033       |
|     12 | december 11, 1960  | at washington redskins | w 17–3   | 14,077       |
|     13 | december 18, 1960  | cleveland browns       | l 48–34  | 56,517       |

Question: What was the Opponent in Week 9?

table_id: 2-16660922-1
label: SELECT "Opponent" FROM "table" WHERE "Week" = 9