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:
| Tournament   | Surface    | Week       | Winner                                | Finalist          | Semi finalists                    |
|:-------------|:-----------|:-----------|:--------------------------------------|:------------------|:----------------------------------|
| tokyo        | carpet (i) | january 31 | martina hingis 6–3, 7–5               | sandrine testud   | chanda rubin katarina srebotnik   |
| indian wells | hard       | march 6    | lindsay davenport 4–6, 6–4, 6–0       | martina hingis    | mary pierce elena dementieva      |
| miami        | hard       | march 20   | martina hingis 6–3, 6–2               | lindsay davenport | monica seles sandrine testud      |
| hilton head  | clay       | april 17   | mary pierce 6–1, 6–0                  | arantxa sánchez   | monica seles conchita martínez    |
| berlin       | clay       | may 8      | conchita martínez 6–1, 6–2            | amanda coetzer    | martina hingis joannette kruger   |
| rome         | clay       | may 15     | monica seles 6–2, 7–6(4)              | amélie mauresmo   | corina morariu fabiola zuluaga    |
| montréal     | hard       | august 14  | martina hingis 0–6, 6–3, 3–0, retired | serena williams   | conchita martínez arantxa sánchez |
| zurich       | carpet (i) | october 9  | martina hingis 6–4, 4–6, 7–5          | lindsay davenport | jennifer capriati barbara schett  |
| moscow       | carpet (i) | october 23 | martina hingis 6–3, 6–1               | anna kournikova   | amélie mauresmo nathalie tauziat  |

Question: Which Finalist has a Semi finalists of monica seles conchita martínez?

table_id: 2-16871290-1
label: SELECT "Finalist" FROM "table" WHERE "Semi finalists" = "monica seles conchita martínez"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Tournament            |   Wins |   Top-5 |   Top-10 |   Top-25 |   Events |   Cuts made |
|:----------------------|-------:|--------:|---------:|---------:|---------:|------------:|
| masters tournament    |      1 |       5 |       11 |       22 |       45 |          27 |
| u.s. open             |      1 |       1 |        5 |       16 |       31 |          26 |
| the open championship |      0 |       3 |        4 |       10 |       20 |          16 |
| pga championship      |      2 |       4 |        8 |       17 |       31 |          27 |
| totals                |      4 |      13 |       28 |       65 |      127 |          96 |

Question: Which Events is the highest one that has a Top-5 larger than 5, and a Top-10 larger than 28?

table_id: 2-1520225-6
label: SELECT MAX("Events") FROM "table" WHERE "Top-5" > 5 AND "Top-10" > 28
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:
| State          |   Interview |   Swimsuit |   Evening Gown |   Average |
|:---------------|------------:|-----------:|---------------:|----------:|
| kansas         |       9.357 |      9.084 |          9.45  |     9.297 |
| new jersey     |       9.464 |      8.896 |          9.243 |     9.201 |
| california     |       9.284 |      8.943 |          9.436 |     9.221 |
| north carolina |       9.214 |      8.829 |          9.257 |     9.1   |
| oklahoma       |       9.241 |      8.83  |          9.214 |     9.095 |
| illinois       |       9.271 |      8.733 |          9.243 |     9.082 |
| new york       |       9.15  |      8.586 |          9.433 |     9.056 |
| alabama        |       9.121 |      8.8   |          9.236 |     9.052 |
| hawaii         |       8.929 |      8.874 |          9.314 |     9.039 |
| arizona        |       8.808 |      8.714 |          9.243 |     8.921 |
| oregon         |       8.686 |      8.9   |          9.143 |     8.909 |

Question: What is the number for swimsuit when the interview number is less than 8.808?

table_id: 2-12050358-2
label: SELECT "Swimsuit" FROM "table" WHERE "Interview" < 8.808
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                     |   Bodyweight |   Snatch |   Clean & jerk |   Total (kg) |
|:-------------------------|-------------:|---------:|---------------:|-------------:|
| carlos hernández ( cub ) |        92.14 |      175 |          207.5 |        382.5 |
| darío lecman ( arg )     |        92.92 |      175 |          205   |        380   |
| julio césar luña ( ven ) |        93.62 |      165 |          195   |        360   |
| peter kelley ( usa )     |        93.86 |      150 |          180   |        330   |
| javier otoya ( ecu )     |        89.64 |      140 |          180   |        320   |
| carlos holguín ( dom )   |        93.13 |      140 |          170   |        310   |

Question: Which name had a bodyweight bigger than 89.64, a total (kg) bigger than 310, a clean and jerk less than 207.5, and a snatch that is bigger than 165?

table_id: 2-11279593-6
label: SELECT "Name" FROM "table" WHERE "Bodyweight" > 89.64 AND "Total (kg)" > 310 AND "Clean & jerk" < 207.5 AND "Snatch" > 165
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       | Home team             | Score   | Away team            | Venue                           | Box Score   | Report   |
|:-----------|:----------------------|:--------|:---------------------|:--------------------------------|:------------|:---------|
| 29 october | wollongong hawks      | 101-93  | cairns taipans       | win entertainment centre        | box score   | report   |
| 30 october | new zealand breakers  | 103-99  | perth wildcats       | north shore events centre       | box score   | report   |
| 1 november | cairns taipans        | 87-89   | wollongong hawks     | cairns convention centre        | box score   | report   |
| 1 november | melbourne tigers      | 123-111 | gold coast blaze     | state netball and hockey centre | box score   | report   |
| 1 november | south dragons         | 96-87   | sydney spirit        | hisense arena                   | box score   | report   |
| 1 november | townsville crocodiles | 97-106  | new zealand breakers | townsville entertainment centre | box score   | report   |
| 2 november | adelaide 36ers        | 108-76  | sydney spirit        | distinctive homes dome          | box score   | report   |

Question: What was the score for the Perth Wildcats as away team?

table_id: 2-16653153-14
label: SELECT "Score" FROM "table" WHERE "Away team" = "perth wildcats"
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                        |   Nanquan |   Nangun |   Total |
|-------:|:-------------------------------|----------:|---------:|--------:|
|      1 | willy wang ( phi )             |      9.74 |     9.7  |   19.44 |
|      2 | peng wei-chua ( tpe )          |      9.7  |     9.69 |   19.39 |
|      3 | pui fook chien ( mas )         |      9.72 |     9.62 |   19.34 |
|      4 | koki nakata ( jpn )            |      9.72 |     9.5  |   19.22 |
|      5 | farshad arabi ( iri )          |      9.71 |     9.44 |   19.15 |
|      6 | stanislav galkin ( rus )       |      9.35 |     9.48 |   18.83 |
|      7 | michele giordano ( ita )       |      8.99 |     9.37 |   18.36 |
|      8 | hani el-sayed ( egy )          |      8.65 |     9.2  |   17.85 |
|      9 | adriano silva ( bra )          |      8.31 |     9.4  |   17.71 |
|     10 | prabhath mudiyanselage ( sri ) |      8.47 |     8.85 |   17.32 |
|     11 | maximiliano rodriguez ( arg )  |      7.94 |     9.12 |   17.06 |

Question: WHAT IS THE TOTAL WITH A NANQUAN OF 9.72, RANK BIGGER THAN 3, NANGUN SMALLER THAN 9.5?

table_id: 2-17660359-6
label: SELECT MIN("Total") FROM "table" WHERE "Nanquan" = 9.72 AND "Rank" > 3 AND "Nangun" < 9.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:
| State      | Type      | Name        | Title   | Royal house   | From   |
|:-----------|:----------|:------------|:--------|:--------------|:-------|
| cai        | sovereign | zhao        | marquis | ji            | 518 bc |
| cao        | sovereign | cao bo yang | duke    | —             | 501 bc |
| chen       | sovereign | min         | duke    | —             | 501 bc |
| chu        | sovereign | zhao        | king    | mi            | 515 bc |
| jin        | sovereign | ding        | duke    | ji            | 511 bc |
| lu         | sovereign | ding        | duke    | ji            | 509 bc |
| qi         | sovereign | jing        | duke    | jiang         | 547 bc |
| qi (henan) | sovereign | li          | duke    | —             | 505 bc |
| qin        | sovereign | hui i       | duke    | ying          | 500 bc |
| song       | sovereign | jing        | duke    | —             | 516 bc |
| teng       | sovereign | qing        | duke    | —             | 512 bc |
| wey        | sovereign | ling        | duke    | —             | 534 bc |
| wu         | sovereign | helü        | king    | zhou          | 514 bc |
| yan        | sovereign | jian i      | duke    | —             | 504 bc |
| yue        | sovereign | yun chang   | marquis | —             | 538 bc |
| zheng      | sovereign | sheng       | duke    | —             | 500 bc |

Question: Which state has a royal house of Jiang?

table_id: 2-17938457-8
label: SELECT "State" FROM "table" WHERE "Royal house" = "jiang"
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 |   Result | Athlete                 | Date             | Location     |
|-------:|---------:|:------------------------|:-----------------|:-------------|
|      1 |    21.87 | merlene ottey           | 13 february 1993 | lievin       |
|      2 |    22.1  | irina privalova         | 19 february 1995 | toronto      |
|      3 |    22.27 | heike drechsler         | 7 march 1987     | indianapolis |
|      4 |    22.33 | gwen torrence           | 3 february 1996  | atlanta      |
|      5 |    22.38 | veronica campbell-brown | 18 february 2005 | birmingham   |
|      6 |    22.39 | marita koch             | 5 march 1983     | budapest     |
|      6 |    22.39 | ionela tirlea           | 6 march 1999     | maebashi     |
|      8 |    22.4  | bianca knight           | 14 march 2008    | fayetteville |
|      9 |    22.41 | galina malchugina       | 13 march 1994    | paris        |
|     10 |    22.43 | svetlana goncharenko    | 22 february 1998 | lievin       |

Question: What Date has a Rank of 2?

table_id: 2-1833981-4
label: SELECT "Date" FROM "table" WHERE "Rank" = 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:
| Week #            | Theme               | Song choice                           | Original artist   |   Order # | Result   |
|:------------------|:--------------------|:--------------------------------------|:------------------|----------:|:---------|
| top 24 (12 women) | 1960s               | " rescue me "                         | fontella bass     |         1 | safe     |
| top 20 (10 women) | 1970s               | " you're no good "                    | betty everett     |         5 | safe     |
| top 16 (8 women)  | 1980s               | " faithfully "                        | journey           |         5 | safe     |
| top 12            | lennon–mccartney    | " eight days a week "                 | the beatles       |        11 | bottom 2 |
| top 11            | the beatles         | " you've got to hide your love away " | the beatles       |         2 | bottom 2 |
| top 10            | year they were born | " god bless the usa "                 | lee greenwood     |         9 | safe     |
| top 9             | dolly parton        | " coat of many colors "               | dolly parton      |         7 | bottom 2 |
| top 8             | inspirational       | " anyway "                            | martina mcbride   |         4 | safe     |

Question: WHAT IS THE RESULT FOR THE SONG WHERE THE ORIGINAL ARTIST IS BETTY EVERETT?

table_id: 1-15778392-1
label: SELECT "Result" FROM "table" WHERE "Original artist" = "Betty Everett"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   Game | Date     | Opponent           | Score   | Series           |
|-------:|:---------|:-------------------|:--------|:-----------------|
|      1 | april 9  | new york rangers   | 2–6     | rangers lead 1–0 |
|      2 | april 10 | new york rangers   | 2–1     | series tied 1–1  |
|      3 | april 12 | @ new york rangers | 2–5     | rangers lead 2–1 |
|      4 | april 14 | @ new york rangers | 7–1     | series tied 2–2  |
|      5 | april 15 | new york rangers   | 2–5     | rangers win 3–2  |

Question: What opponent has april 10 as the date?

table_id: 2-14320222-9
label: SELECT "Opponent" FROM "table" WHERE "Date" = "april 10"
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 | Overall               | Player              | Position   | Nationality   | Club team                    |
|--------:|:----------------------|:--------------------|:-----------|:--------------|:-----------------------------|
|       1 | 6                     | mika zibanejad      | centre     | sweden        | djurgårdens if hockey (sel)  |
|       1 | 21 (from nashville)   | stefan noesen       | right wing | united states | plymouth whalers (ohl)       |
|       1 | 24 (from detroit)     | matthew puempel     | left wing  | canada        | peterborough petes (ohl)     |
|       2 | 61 (from boston)      | shane prince        | left wing  | united states | ottawa 67's (ohl)            |
|       4 | 96                    | jean-gabriel pageau | centre     | canada        | gatineau olympiques (qmjhl)  |
|       5 | 126                   | fredrik claesson    | defense    | sweden        | djurgårdens if hockey (sel)  |
|       6 | 156                   | darren kramer       | centre     | canada        | spokane chiefs (whl)         |
|       6 | 171 (from phoenix)    | max mccormick       | left wing  | united states | sioux city musketeers (ushl) |
|       7 | 186                   | jordan fransoo      | defense    | canada        | brandon wheat kings (whl)    |
|       7 | 204 (from pittsburgh) | ryan dzingel        | centre     | united states | lincoln stars (ushl)         |

Question: Which Player has an Overall of 126?

table_id: 2-11803648-20
label: SELECT "Player" FROM "table" WHERE "Overall" = "126"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Release       | Oricon Albums Chart          |   Peak Position |   Debut Sales (copies) |   Sales Total (copies) | Chart Run   |
|:--------------|:-----------------------------|----------------:|-----------------------:|-----------------------:|:------------|
| june 10, 2009 | daily charts                 |               1 |                 101976 |                1005874 | 34 weeks    |
| june 10, 2009 | weekly charts                |               1 |                 452258 |                1005874 | 34 weeks    |
| june 10, 2009 | monthly charts (june 2009)   |               1 |                 625507 |                1005874 | 34 weeks    |
| june 10, 2009 | monthly charts (july 2009)   |               3 |                 245877 |                1005874 | 34 weeks    |
| june 10, 2009 | monthly charts (august 2009) |               8 |                  85671 |                1005874 | 34 weeks    |

Question: Which charts had debut sales of 101976?

table_id: 1-23180638-1
label: SELECT "Oricon Albums Chart" FROM "table" WHERE "Debut Sales (copies)" = 101976
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          |   Touchdowns |   Extra points |   Field goals |   Points |
|:----------------|-------------:|---------------:|--------------:|---------:|
| tom hammond     |           15 |             63 |             5 |      163 |
| herb graver     |           15 |              1 |             0 |       76 |
| willie heston   |           14 |              0 |             0 |       70 |
| joe curtis      |            8 |             13 |             0 |       53 |
| joe maddock     |           10 |              0 |             0 |       50 |
| duncan thompson |           10 |              0 |             0 |       50 |
| fred norcross   |            9 |              0 |             0 |       45 |

Question: How many points did Duncan Thompson score?

table_id: 1-14342480-15
label: SELECT MAX("Points") FROM "table" WHERE "Player" = "Duncan 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:
| Tournament   | Surface    | Week       | Winner and score                           | Finalist           | Semifinalists                   |
|:-------------|:-----------|:-----------|:-------------------------------------------|:-------------------|:--------------------------------|
| indian wells | hard       | march 8    | mark philippoussis 5-7, 6-4, 6-4, 4-6, 6-2 | carlos moyá        | chris woodruff gustavo kuerten  |
| key biscane  | hard       | march 18   | richard krajicek 4-6, 6-1, 6-2, 7-5        | sébastien grosjean | francisco clavet thomas enqvist |
| monte carlo  | clay       | april 19   | gustavo kuerten 6-4, 2-1 ret.              | marcelo ríos       | jérôme golmard félix mantilla   |
| hamburg      | clay       | may 3      | marcelo ríos 6-7(5), 7-5, 5-7, 7-6(5), 6-2 | mariano zabaleta   | nicolás lapentti carlos moyá    |
| rome         | clay       | may 10     | gustavo kuerten 6-4, 7-5, 7-6(6)           | patrick rafter     | àlex corretja félix mantilla    |
| montréal     | hard       | august 2   | thomas johansson 1-6, 6-3, 6-3             | yevgeny kafelnikov | nicolas kiefer andre agassi     |
| cincinnati   | hard       | august 9   | pete sampras 7-6(7), 6-3                   | patrick rafter     | andre agassi yevgeny kafelnikov |
| stuttgart    | hard (i)   | october 25 | thomas enqvist 6-1, 6-4, 5-7, 7-5          | richard krajicek   | andre agassi greg rusedski      |
| paris        | carpet (i) | november 1 | andre agassi 7-6(1), 6-2, 4-6, 6-4         | marat safin        | nicolás lapentti michael chang  |

Question: what is the surface when the winner and score is gustavo kuerten 6-4, 7-5, 7-6(6)?

table_id: 2-16779952-1
label: SELECT "Surface" FROM "table" WHERE "Winner and score" = "gustavo kuerten 6-4, 7-5, 7-6(6)"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Date              | Tournament         | Surface   | Opponent in the final   | Score         |
|:------------------|:-------------------|:----------|:------------------------|:--------------|
| 18 june 2007      | ireland f1         | carpet    | colin ebelthite         | 2–6, 3–6      |
| 27 august 2007    | great britain f16  | hard      | satoshi iwabuchi        | 3–6, 2–6      |
| 22 september 2008 | sweden f2          | hard      | michael ryderstedt      | 1–6, 4–6      |
| 29 august 2010    | poznań, poland f6  | clay      | marcin gawron           | 3–6, 4–6      |
| 20 october 2012   | annaba, algeria f2 | clay      | steven diez             | 6–4, 4–6, 1–6 |

Question: What date was the game played on the hard surface at the Tournament of Sweden f2?

table_id: 2-18089112-3
label: SELECT "Date" FROM "table" WHERE "Surface" = "hard" AND "Tournament" = "sweden f2"
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 | Name               |   Played |   Drawn |   Lost |   Points |
|-----------:|:-------------------|---------:|--------:|-------:|---------:|
|          1 | esc kempten (n)    |       16 |       0 |      0 |       32 |
|          2 | vfl denklingen     |       16 |       1 |      4 |       23 |
|          3 | esv bad bayersoien |       16 |       2 |      5 |       20 |
|          4 | sv hohenfurch      |       16 |       3 |      5 |       19 |
|          5 | sv apfeldorf       |       16 |       2 |      6 |       18 |
|          6 | eg wood augsburg   |       16 |       2 |     10 |       10 |
|          7 | 1. ec senden       |       16 |       1 |     11 |        9 |
|          8 | ec oberstdorf      |       16 |       3 |     11 |        7 |
|          9 | esv buchloe ii (n) |       16 |       2 |     12 |        6 |

Question: what is the lowest played when the position is more than 9?

table_id: 2-16501954-23
label: SELECT MIN("Played") FROM "table" WHERE "Position" > 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:
| Outcome   | Date              | Tournament                 | Surface   | Partner            | Opponents                              | Score                    |
|:----------|:------------------|:---------------------------|:----------|:-------------------|:---------------------------------------|:-------------------------|
| runner-up | 5 august 2006     | saransk , russia           | clay      | dekel valtzer      | alexey kedriouk orest tereshchuk       | 4–6, 7–5, [5–10]         |
| runner-up | 10 september 2006 | brașov , romania           | clay      | michal navratil    | lazar magdincev predrag rusevski       | 4–6, 6–7 (9–11)          |
| winner    | 4 november 2006   | louisville , united states | hard      | igor sijsling      | amer delic robert kendrick             | w/o                      |
| runner-up | 28 january 2007   | wrexham , great britain    | hard      | richard bloomfield | thomas oger nicolas tourte             | 7–6 (7–4) , 5–7, [10–12] |
| winner    | 1 august 2010     | cordenons , italy          | clay      | rogier wassen      | james cerretani adil shamasdin         | 7–6 (16–14) , 7–5        |
| winner    | 28 august 2010    | manerbio , italy           | clay      | thomas schoorel    | diego junqueira gabriel trujillo-soler | 6–4, 6–4                 |

Question: What is Diego Junqueira Gabriel Trujillo-Soler's opponent's score?

table_id: 2-12397961-13
label: SELECT "Score" FROM "table" WHERE "Opponents" = "diego junqueira gabriel trujillo-soler"
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               | Date of Birth   |   Height |   Weight |   Spike |   Block |
|:-------------------|:----------------|---------:|---------:|--------:|--------:|
| marcos milinkovic  | 22.12.1971      |      205 |      100 |     355 |     338 |
| jorge elgueta      | 21.11.1969      |      196 |       95 |     353 |     333 |
| gustavo porporatto | 07.05.1981      |      199 |       91 |     353 |     323 |
| diego gutiérrez    | 27.05.1976      |      186 |       85 |     330 |     315 |
| hernán ferraro     | 13.05.1968      |      170 |       74 |     300 |     300 |
| alejandro spajic   | 07.05.1976      |      204 |       95 |     360 |     340 |
| jerónimo bidegain  | 16.01.1977      |      200 |       93 |     352 |     335 |
| pablo peralta      | 09.12.1979      |      204 |      100 |     350 |     330 |
| santiago darraidou | 24.11.1980      |      194 |       95 |     345 |     335 |
| leonardo patti     | 06.07.1978      |      188 |       88 |     340 |     320 |
| pablo meana        | 10.06.1975      |      187 |       86 |     325 |     315 |
| gastón giani       | 26.04.1979      |      194 |       86 |     345 |     330 |

Question: What is the smallest Weight, when Spike is less than 330, when Block is 315, and when Height is greater than 187?

table_id: 2-15859432-1
label: SELECT MIN("Weight") FROM "table" WHERE "Spike" < 330 AND "Block" = 315 AND "Height" > 187
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 | Entrant                 | Chassis         | Engine              |   Points |
|-------:|:------------------------|:----------------|:--------------------|---------:|
|   1963 | ecurie maarsbergen      | porsche 718     | porsche flat-4      |        3 |
|   1964 | team lotus              | lotus 25        | climax v8           |        0 |
|   1965 | team lotus              | lotus 25        | climax v8           |        0 |
|   1966 | ron harris / team lotus | lotus 44 f2     | cosworth straight-4 |        0 |
|   1967 | gerhard mitter          | brabham bt23 f2 | cosworth straight-4 |        0 |
|   1969 | bmw                     | bmw 269 f2      | bmw straight-4      |        0 |

Question: What engine was in the lotus 44 f2 Chassis?

table_id: 2-1228404-1
label: SELECT "Engine" FROM "table" WHERE "Chassis" = "lotus 44 f2"