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:
| Name                                           | Appointed/Elected   | Term expires      | Appointing Governor   | Governor's Party Affiliation   |
|:-----------------------------------------------|:--------------------|:------------------|:----------------------|:-------------------------------|
| chief justice mark cady                        | 1998                | december 31, 2016 | terry branstad        | republican                     |
| david wiggins                                  | 2003                | december 31, 2020 | tom vilsack           | democratic                     |
| daryl hecht                                    | 2006                | december 31, 2016 | tom vilsack           | democratic                     |
| brent r. appel                                 | 2006                | december 31, 2016 | tom vilsack           | democratic                     |
| bruce b. zager                                 | february 2011       | december 31, 2020 | terry branstad        | republican                     |
| edward mansfield category:articles with hcards | february 2011       | december 31, 2020 | terry branstad        | republican                     |
| thomas d. waterman                             | february 2011       | december 31, 2020 | terry branstad        | republican                     |

Question: Which person has an expiring term of December 31, 2020, and has Terry Branstad as the appointing governor?

table_id: 2-1189288-1
label: SELECT "Name" FROM "table" WHERE "Term expires" = "december 31, 2020" AND "Appointing Governor" = "terry branstad"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Season   |   Tier | League       |   Pos. | Postseason   | European competitions   |
|:---------|-------:|:-------------|-------:|:-------------|:------------------------|
| 2007–08  |      4 | regionalliga |      3 | –            | –                       |
| 2008–09  |      4 | regionalliga |      1 | promoted     | –                       |
| 2009–10  |      3 | prob         |      3 | promoted     | –                       |
| 2010–11  |      2 | proa         |      2 | promoted     | –                       |
| 2011–12  |      1 | bundesliga   |      4 | semifinalist | –                       |
| 2012–13  |      1 | bundesliga   |      9 | –            | eurocup regular season  |

Question: What is the total number of tiers for the postseason of semifinalist?

table_id: 2-15113793-1
label: SELECT SUM("Tier") FROM "table" WHERE "Postseason" = "semifinalist"
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   |
|--------:|---------:|----------:|:--------------------|:--------------|:----------|
|       1 |        8 |         8 | derrick harvey      | defensive end | florida   |
|       2 |       21 |        52 | quentin groves      | defensive end | auburn    |
|       5 |       20 |       155 | thomas williams     | linebacker    | usc       |
|       5 |       24 |       159 | trae williams       | cornerback    | usf       |
|       7 |        6 |       213 | chauncey washington | running back  | usc       |

Question: What is the sum of the pick numbers where the player was picked in round 5 and overall pick number was greater than 159?

table_id: 2-15028555-1
label: SELECT SUM("Pick #") FROM "table" WHERE "Round" = 5 AND "Overall" > 159
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:
| 7:00 PM           | 8:00 PM                 | 8:30 PM                 | 9:00 PM                               | 9:30 PM                               | 10:00 PM       |
|:------------------|:------------------------|:------------------------|:--------------------------------------|:--------------------------------------|:---------------|
| découverte        | tout le monde en parle  | tout le monde en parle  | tout le monde en parle                | tout le monde en parle                | le téléjournal |
| virginie          | l'auberge du chien noir | l'auberge du chien noir | les hauts et les bas de sophie paquin | les hauts et les bas de sophie paquin | le téléjournal |
| virginie          | providence              | providence              | roxy                                  | les boys                              | le téléjournal |
| virginie          | le match des étoiles    | le match des étoiles    | une heure sur terre                   | une heure sur terre                   | le téléjournal |
| virginie          | les parent              | les étoiles filantes    | enquête                               | enquête                               | le téléjournal |
| virginie          | paquet voleur           | paquet voleur           | specials                              | specials                              | le téléjournal |
| grands rires 2007 | le moment de vérité     | le moment de vérité     | dre. grey, leçons d'anatomie          | dre. grey, leçons d'anatomie          | le téléjournal |

Question: What shows for 10:00 PM when the 8:00 PM is tout le monde en parle?

table_id: 2-11672472-1
label: SELECT "10:00 PM" FROM "table" WHERE "8:00 PM" = "tout le monde en parle"
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                            | Tenure    | Courtesy title           | Court Rank           | Revenues    | Lineage                           |
|:--------------------------------|:----------|:-------------------------|:---------------------|:------------|:----------------------------------|
| ōoka tadasuke (大岡忠相)        | 1748–1751 | echizen-no-kami (越前守) | lower 5th (従五位下) | 10,000 koku | 4th son of hatamoto ōoka tadataka |
| ōoka tadayoshi (大岡忠宜)       | 1755–1766 | echizen-no-kami (越前守) | lower 5th (従五位下) | 10,000 koku | 2nd son of tadasuke               |
| ōoka tadatsune (大岡忠恒)       | 1766–1784 | echizen-no-kami (越前守) | lower 5th (従五位下) | 10,000 koku | 2nd son of tadayoshi              |
| ōoka tadatomo (大岡忠與)        | 1784–1786 | echizen-no-kami (越前守) | lower 5th (従五位下) | 13,000 koku | 3rd son of ogasawara nagamichi    |
| ōoka tadayori (大岡忠移)        | 1786–1828 | echizen-no-kami (越前守) | lower 5th (従五位下) | 10,000 koku | 3rd son of tadatsune              |
| ōoka tadayoshi (2nd) (大岡忠愛) | 1828–1857 | echizen-no-kami (越前守) | lower 5th (従五位下) | 10,000 koku | son of tadayori                   |
| ōoka tadataka (大岡忠敬)        | 1857–1871 | echizen-no-kami (越前守) | lower 5th (従五位下) | 10,000 koku | 5th son of tadayori               |

Question: What are the revenues for ōoka tadayoshi (2nd) (大岡忠愛)?

table_id: 2-12803263-1
label: SELECT "Revenues" FROM "table" WHERE "Name" = "ōoka tadayoshi (2nd) (大岡忠愛)"
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 december 2002  | cavaliers   | 93–125  | knicks    | dajuan wagner (25)      | 2–17     |
| 4 december 2002  | bulls       | 101–111 | cavaliers | dajuan wagner (29)      | 3–17     |
| 7 december 2002  | cavaliers   | 104–112 | bulls     | zydrunas ilgauskas (28) | 3–18     |
| 9 december 2002  | bucks       | 140–133 | cavaliers | ricky davis (45)        | 3–19     |
| 11 december 2002 | raptors     | 83–96   | cavaliers | dajuan wagner (33)      | 4–19     |
| 13 december 2002 | cavaliers   | 100–115 | celtics   | ricky davis (42)        | 4–20     |
| 14 december 2002 | nuggets     | 104–111 | cavaliers | two-way tie (29)        | 5–20     |
| 16 december 2002 | supersonics | 111–98  | cavaliers | ricky davis (20)        | 5–21     |
| 18 december 2002 | pistons     | 111–106 | cavaliers | zydrunas ilgauskas (29) | 5–22     |
| 20 december 2002 | cavaliers   | 107–109 | pistons   | ricky davis (42)        | 5–23     |
| 21 december 2002 | celtics     | 89–82   | cavaliers | dajuan wagner (25)      | 5–24     |
| 23 december 2002 | heat        | 72–74   | cavaliers | ricky davis (33)        | 6–24     |
| 27 december 2002 | pacers      | 113–89  | cavaliers | zydrunas ilgauskas (21) | 6–25     |
| 29 december 2002 | suns        | 103–84  | cavaliers | ricky davis (15)        | 6–26     |
| 30 december 2002 | cavaliers   | 88–102  | nets      | ricky davis (24)        | 6–27     |

Question: Whose Visitor has a Record of 3–18?

table_id: 2-16140345-5
label: SELECT "Visitor" FROM "table" WHERE "Record" = "3–18"
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        | Score   | Away           |   Attendance |
|:------------------|:------------|:--------|:---------------|-------------:|
| 13 september 2008 | real espana | 2:0     | deportes savio |         2114 |
| 13 september 2008 | vida        | 1:2     | real juventud  |          831 |
| 14 september 2008 | hispano     | 3:1     | olimpia        |         1881 |
| 14 september 2008 | motagua     | 0:4     | victoria       |         1330 |
| 14 september 2008 | platense    | 1:2     | marathon       |         2584 |

Question: Which Away has a Date of 14 september 2008, and an Attendance larger than 1881?

table_id: 2-17026847-12
label: SELECT "Away" FROM "table" WHERE "Date" = "14 september 2008" AND "Attendance" > 1881
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-25 |   Events |   Cuts made |
|:----------------------|-------:|--------:|---------:|---------:|------------:|
| masters tournament    |      0 |       0 |        1 |        4 |           3 |
| u.s. open             |      0 |       1 |        1 |        3 |           1 |
| the open championship |      0 |       0 |        1 |        6 |           4 |
| pga championship      |      0 |       0 |        1 |        4 |           2 |
| totals                |      0 |       1 |        4 |       17 |          10 |

Question: what is the lowest top-25 when the events is less than 17 and top-5 is more than 0?

table_id: 2-12962193-3
label: SELECT MIN("Top-25") FROM "table" WHERE "Events" < 17 AND "Top-5" > 0
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:
| Perfect stem   | Future stem   | Imperfect stem   | Short stem   | Meaning             |
|:---------------|:--------------|:-----------------|:-------------|:--------------------|
| hartu          | hartuko       | hartzen          | har          | 'take'              |
| garbitu        | garbituko     | garbitzen        | garbi        | 'clean'             |
| kendu          | kenduko       | kentzen          | ken          | 'take away, remove' |
| poztu          | poztuko       | pozten           | poz          | 'be/become happy'   |
| ibili          | ibiliko       | ibiltzen         | ibil         | 'go about'          |
| ikusi          | ikusiko       | ikusten          | ikus         | 'see'               |
| iritsi         | iritsiko      | iristen          | irits        | 'arrive'            |
| ireki          | irekiko       | irekitzen        | ireki        | 'open'              |
| bete           | beteko        | betetzen         | bete         | 'fill'              |
| jo             | joko          | jotzen           | jo           | 'strike'            |
| hil            | hilko         | hiltzen          | hil          | 'die, kill'         |
| egin           | egingo        | egiten           | egin         | 'make, do'          |
| eman           | emango        | ematen           | eman         | 'give'              |
| esan           | esango        | esaten           | esan         | 'say'               |

Question: What is the short stem for the word that has a perfect stem of poztu?

table_id: 2-12784134-24
label: SELECT "Short stem" FROM "table" WHERE "Perfect stem" = "poztu"
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         | Opponent   | City        | Result   | Score   |
|:-------------|:-----------|:------------|:---------|:--------|
| september 18 | illinois   | champaign   | win      | 32-18   |
| september 25 | ohio state | columbus    | win      | 28-13   |
| october 2    | iowa state | ames        | win      | 33-13   |
| october 9    | iowa       | iowa city   | win      | 25-0    |
| october 16   | missouri   | kansas city | win      | 21-6    |
| october 30   | fort riley | iowa city   | win      | 19-2    |
| november 7   | marquette  | milwaukee   | win      | 46-19   |
| november 13  | camp grant | iowa city   | win      | 28-13   |
| november 20  | notre dame | south bend  | loss     | 13-14   |
| november 27  | minnesota  | minneapolis | win      | 32-0    |

Question: What team was the opponent when the score was 25-0?

table_id: 2-12261783-2
label: SELECT "Opponent" FROM "table" WHERE "Score" = "25-0"
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                         | Winning score         | Margin of victory   | Runner(s)-up                               |
|:------------|:-----------------------------------|:----------------------|:--------------------|:-------------------------------------------|
| 16 apr 1989 | credit lyonnais cannes open        | –9 (65-70-72=207)     | 1 stroke            | jimmy heggarty , brett ogle , peter senior |
| 11 aug 1991 | european pro-celebrity             | –16 (67-70-69-66=272) | 7 strokes           | ronan rafferty                             |
| 9 may 1993  | benson & hedges international open | –12 (69-69-67-71=276) | 1 stroke            | mark james , josé maría olazábal           |
| 25 jun 1995 | peugeot open de france             | –14 (67-75-69-63=274) | 8 strokes           | neal briggs                                |
| 3 apr 2005  | portuguese open                    | –13 (68-66-70-67=271) | 1 stroke            | paul lawrie                                |
| 2 apr 2006  | portuguese open                    | –17 (64-69-71-67=271) | 1 stroke            | anthony wall                               |

Question: Who was the runner-up with the margin of victory of 8 strokes?

table_id: 2-1688190-1
label: SELECT "Runner(s)-up" FROM "table" WHERE "Margin of victory" = "8 strokes"
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   | Partnering      | Opponents in the final            | Score         |
|:------------------|:----------------------------|:----------|:----------------|:----------------------------------|:--------------|
| august 4, 1991    | kitzbühel , austria         | clay      | tomás carbonell | pablo arraya dimitri poliakov     | 6–7, 6–2, 6–4 |
| november 15, 1992 | são paulo , brazil          | clay      | diego pérez     | christer allgardh carl limberger  | 6–2, 7–6      |
| october 11, 1992  | athens , greece             | clay      | tomás carbonell | marcelo filippini mark koevermans | 6–3, 6–4      |
| august 28, 1994   | umag , croatia              | clay      | diego pérez     | karol kučera paul wekesa          | 6–2, 6–4      |
| march 28, 1995    | casablanca , morocco        | clay      | tomás carbonell | emanuel couto joão cunha e silva  | 6–4, 6–1      |
| june 16, 1995     | oporto , portugal           | clay      | tomás carbonell | jordi arrese àlex corretja        | 6–3, 7–6      |
| july 23, 1995     | stuttgart outdoor , germany | clay      | tomás carbonell | ellis ferreira jan siemerink      | 3–6, 6–3, 6–4 |
| october 8, 1995   | valencia , spain            | clay      | tomás carbonell | tom kempers jack waite            | 7–5, 6–3      |
| april 14, 1996    | estoril , portugal          | clay      | tomás carbonell | tom nijssen greg van emburgh      | 6–3, 6–2      |

Question: What is the Score of an Opponent\ in the final of jordi arrese àlex corretja?

table_id: 2-13831441-2
label: SELECT "Score" FROM "table" WHERE "Opponents in the final" = "jordi arrese àlex corretja"
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 | Name              | Position       | School/College    |
|--------:|-------:|:------------------|:---------------|:------------------|
|       2 |     43 | isaac davis       | guard          | arkansas          |
|       2 |     63 | vaughn parker     | guard          | ucla              |
|       3 |     70 | andre coleman     | wide receiver  | kansas state      |
|       3 |     82 | willie clark      | defensive back | jackson state     |
|       5 |    137 | aaron laing       | tight end      | new mexico state  |
|       5 |    145 | rodney harrison p | safety         | western illinois  |
|       5 |    150 | darren krein      | defensive end  | miami ( fl )      |
|       5 |    160 | tony vinson       | running back   | towson university |
|       7 |    207 | zane beehn        | linebacker     | kentucky          |

Question: Average round for rodney harrison p before 145?

table_id: 2-15345341-1
label: SELECT AVG("Round") FROM "table" WHERE "Name" = "rodney harrison p" AND "Pick" < 145
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                 | Country of origin*   | PBA team                     | College                |
|-------:|:-----------------------|:---------------------|:-----------------------------|:-----------------------|
|      1 | manuel luis locsin     | philippines          | tondena 65 rhum              | de la salle university |
|      2 | reynaldo evangelista   | philippines          | coney island ice cream stars | santo tomas            |
|      3 | emmanuel victoria, jr. | philippines          | swift mighty meaties         | san beda               |
|      4 | richard ticzon         | philippines          | pepsi mega hotshots          | ateneo de manila       |
|      5 | edward juinio          | philippines          | alaska milkmen               | up-diliman             |
|      6 | merwin castelo         | philippines          | alaska milkmen               | san beda               |
|      7 | expedito falcasantos   | philippines          | sta. lucia realtors          | ateneo de manila       |
|      8 | vicente hizon          | philippines          | coney island ice cream stars | ateneo de manila       |

Question: What is the country of origin for the player who plays on Tondena 65 Rhum?

table_id: 2-18771646-1
label: SELECT "Country of origin*" FROM "table" WHERE "PBA team" = "tondena 65 rhum"
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:
| Celebrity        | Famous for                                        | Entered   | Exited   | Finished   |
|:-----------------|:--------------------------------------------------|:----------|:---------|:-----------|
| matt willis      | ex busted member and tv presenter                 | day 1     | day 19   | 1st        |
| myleene klass    | tv presenter, singer, model                       | day 1     | day 19   | 2nd        |
| jason donovan    | australian actor, singer                          | day 1     | day 19   | 3rd        |
| david gest       | american tv producer                              | day 1     | day 18   | 4th        |
| dean gaffney     | actor (played robbie jackson in eastenders )      | day 5     | day 18   | 5th        |
| jan leeming      | newsreader                                        | day 1     | day 17   | 6th        |
| malandra burrows | actress (played kathy glover in emmerdale )       | day 6     | day 16   | 7th        |
| phina oruche     | actress                                           | day 1     | day 15   | 8th        |
| lauren booth     | model, journalist, younger sister of cherie booth | day 1     | day 14   | 9th        |
| faith brown      | impressionist, comedian                           | day 1     | day 13   | 10th       |
| scott henshall   | fashion model, designer                           | day 1     | day 12   | 11th       |
| toby anstis      | radio host                                        | day 1     | day 11   | 12th       |

Question: What celebrity finished 6th?

table_id: 2-14345690-7
label: SELECT "Celebrity" FROM "table" WHERE "Finished" = "6th"
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:
| Helium     | Neon       | Argon      | Krypton   | Xenon     | Radon   |
|:-----------|:-----------|:-----------|:----------|:----------|:--------|
| 0.1786     | 0.9002     | 1.7818     | 3.708     | 5.851     | 9.97    |
| 0.1418     | 0.0461     | 0.0169     | 0.00874   | 0.00506   | 0.0036  |
| 192.66     | 135.36     | 68.33      | 52.34     | 37.88     | –       |
| 8.61       | 10.5       | 33.6       | 59.4      | 108.1     | 230     |
| −0.0000019 | −0.0000072 | −0.0000194 | −0.000028 | −0.000043 | –       |
| 20.78      | 20.79      | 20.85      | 20.95     | 21.01     | 21      |
| 973        | 433        | 307.8      | 213       | 168       | –       |
| 141.84     | 46.07      | 16.94      | 8.74      | 5.06      | 3.6     |
| 0.521      | 1.004      | 4.203      | 6.397     | 10.435    | –       |
| 1.0000684  | 1.000545   | 1.000127   | –         | –         | –       |
| 0.03412    | 0.2107     | 1.345      | 2.318     | 4.194     | –       |
| 0.02370    | 0.01709    | 0.03219    | 0.03978   | 0.05105   | –       |

Question: What neon has an Argon of 4.203?

table_id: 2-18225689-3
label: SELECT "Neon" FROM "table" WHERE "Argon" = "4.203"
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      | Date        | Opposition   | Game                      |   Début |
|:--------------------|:----------|:------------|:-------------|:--------------------------|--------:|
| colin lynch         | clare     | july 27     | cork         | all-ireland quarter-final |    1997 |
| frank lohan         | clare     | july 27     | cork         | all-ireland quarter-final |    1995 |
| joe deane           | cork      | august 10   | kilkenny     | all-ireland semi-final    |    1996 |
| brian murphy        | cork      | august 10   | kilkenny     | all-ireland semi-final    |    2004 |
| diarmuid o'sullivan | cork      | august 10   | kilkenny     | all-ireland semi-final    |    1997 |
| éamonn corcoran     | tipperary | august 17   | waterford    | all-ireland semi-final    |    1999 |
| dave bennett        | waterford | september 7 | kilkenny     | all-ireland final         |    1997 |
| tom feeney          | waterford | september 7 | kilkenny     | all-ireland final         |    1995 |
| paul flynn          | waterford | september 7 | kilkenny     | all-ireland final         |    1993 |
| james mcgarry       | kilkenny  | september 7 | waterford    | all-ireland final         |    1999 |

Question: Who is the opponent when the team is Cork?

table_id: 2-11190568-3
label: SELECT "Opposition" FROM "table" WHERE "Team" = "cork"
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       | Opponent   | Score      | Loss              |   Attendance | Series   |
|:-----------|:-----------|:-----------|:------------------|-------------:|:---------|
| october 8  | @ twins    | 5 - 4      | candiotti (0-1)   |        54766 | 0-1      |
| october 9  | @ twins    | 5 - 2      | tapani (0-1)      |        54816 | 1-1      |
| october 11 | twins      | 3 - 2 (10) | timlin (0-1)      |        51454 | 1-2      |
| october 12 | twins      | 9 - 3      | stottlemyre (0-1) |        51526 | 1-3      |
| october 13 | twins      | 8 - 5      | ward (0-1)        |        51425 | 1-4      |

Question: Who was the opponent when the series was at 1-3?

table_id: 2-12206617-9
label: SELECT "Opponent" FROM "table" WHERE "Series" = "1-3"