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:
|   Year | Conventional plans   | HMOs   | PPOs   | POS plans   |
|-------:|:---------------------|:-------|:-------|:------------|
|   1998 | 14%                  | 27%    | 35%    | 24%         |
|   1999 | 10%                  | 28%    | 39%    | 24%         |
|   2000 | 8%                   | 29%    | 42%    | 21%         |
|   2001 | 7%                   | 24%    | 46%    | 23%         |
|   2002 | 4%                   | 27%    | 52%    | 18%         |
|   2003 | 5%                   | 24%    | 54%    | 17%         |
|   2004 | 5%                   | 25%    | 55%    | 15%         |
|   2005 | 3%                   | 21%    | 61%    | 15%         |
|   2006 | 3%                   | 20%    | 60%    | 13%         |
|   2007 | 3%                   | 21%    | 57%    | 15%         |
|   2008 | 2%                   | 20%    | 58%    | 12%         |

Question: Which HMO has a conventional plan of 3% in 2005?

table_id: 2-15343730-1
label: SELECT "HMOs" FROM "table" WHERE "Conventional plans" = "3%" AND "Year" = 2005
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                   | Country   | Role       | Period                          | Teams                                            |
|:-----------------------|:----------|:-----------|:--------------------------------|:-------------------------------------------------|
| radhouane abbes        | algeria   | defender   | 1987-1988 & 1989-1990           | montpellier hsc                                  |
| djamel abdoun          | algeria   | midfielder | 2003-2006 2008-2009             | ac ajaccio fc nantes                             |
| boumediene abderahmane | algeria   | defender   | 1945-1949 & 1953-1954 1949-1952 | fc sète olympique de marseille                   |
| madjid adjaoud         | algeria   | midfielder | 1999-2003                       | cs sedan                                         |
| nassim akrour          | algeria   | forward    | 2002-2003 2008-2010             | troyes ac grenoble foot                          |
| ridha ali messaoud     | algeria   | forward    | 1976-1977                       | paris sg                                         |
| said amara             | algeria   | midfielder | 1956-1957 1957-1958 1962-1964   | rc strasbourg béziers girondins de bordeaux      |
| salim arrache          | algeria   | midfielder | 2003-2006 2006-2008 2008        | rc strasbourg olympique de marseille toulouse fc |

Question: What is the team with the name Boumediene Abderahmane?

table_id: 2-17546250-2
label: SELECT "Teams" FROM "table" WHERE "Name" = "boumediene abderahmane"
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:
| Quartier       | % 0-19 years   | % 20-39 years   | % 40-59 years   | % 60-74 years   | % 75 years and +   |
|:---------------|:---------------|:----------------|:----------------|:----------------|:-------------------|
| la capelette   | 20,32%         | 33,86%          | 24,64%          | 13,62%          | 7,56%              |
| menpenti       | 16,22%         | 34,11%          | 24,37%          | 15,67%          | 9,62%              |
| pont-de-vivaux | 23,74%         | 24,94%          | 24,43%          | 16,27%          | 10,63%             |
| saint-loup     | 25,21%         | 25,02%          | 27,05%          | 15,16%          | 7,55%              |
| saint-tronc    | 24,36%         | 25,88%          | 25,31%          | 16,37%          | 8,08%              |
| la timone      | 21,39%         | 35,24%          | 24,97%          | 11,31%          | 7,09%              |
| arrondissement | 23,16%         | 28,24%          | 25,58%          | 15,00%          | 8,02%              |

Question: How many o-19% are where the quartier is in saint-loup?

table_id: 1-29615165-5
label: SELECT "% 0-19 years" FROM "table" WHERE "Quartier" = "Saint-Loup"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Place   | Player            | Country       | Score        | To par   |
|:--------|:------------------|:--------------|:-------------|:---------|
| 1       | ben hogan         | united states | 67-72-73=212 | –4       |
| 2       | sam snead         | united states | 72-69-72=213 | –3       |
| t3      | jimmy demaret     | united states | 71-76-71=218 | +2       |
| t3      | george fazio      | united states | 70-71-77=218 | +2       |
| t3      | jay hebert        | united states | 72-72-74=218 | +2       |
| t6      | fred haas         | united states | 74-73-72=219 | +3       |
| t6      | dick metz         | united states | 75-70-74=219 | +3       |
| t8      | jack burke, jr.   | united states | 76-73-72=221 | +5       |
| t8      | ted kroll         | united states | 76-71-74=221 | +5       |
| t10     | dutch harrison    | united states | 77-75-70=222 | +6       |
| t10     | bobby locke       | south africa  | 78-70-74=222 | +6       |
| t10     | frank souchak (a) | united states | 70-76-76=222 | +6       |

Question: What Player has a +3 To par?

table_id: 2-17290169-3
label: SELECT "Player" FROM "table" WHERE "To par" = "+3"
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:
|   Draw | Artist       | Song                          |   Points |   Place |
|-------:|:-------------|:------------------------------|---------:|--------:|
|      1 | all mixed up | "forever night and day"       |       32 |       8 |
|      2 | tamara       | "coming home"                 |       83 |       4 |
|      3 | colors       | "positivity"                  |       68 |       6 |
|      4 | jane         | "dreams"                      |       96 |       3 |
|      5 | all of us    | "maybe love"                  |       30 |       9 |
|      6 | donya        | "before the clock strikes 12" |       55 |       7 |
|      7 | double date  | "e-mail to berlin"            |       19 |      10 |
|      8 | roger happel | "where is the time"           |       82 |       5 |
|      9 | deante       | "we don't live too long"      |      103 |       2 |
|     10 | marlayne     | " one good reason "           |      248 |       1 |

Question: How many points does Draw 5 have?

table_id: 2-11467154-1
label: SELECT "Points" FROM "table" WHERE "Draw" = 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:
| Home team       | Home team score   | Away team       | Away team score   | Venue             |   Crowd | Date          |
|:----------------|:------------------|:----------------|:------------------|:------------------|--------:|:--------------|
| fitzroy         | 9.13 (67)         | richmond        | 15.26 (116)       | junction oval     |   17040 | 13 april 1974 |
| hawthorn        | 6.12 (48)         | collingwood     | 10.11 (71)        | princes park      |   28689 | 13 april 1974 |
| geelong         | 15.7 (97)         | carlton         | 12.16 (88)        | kardinia park     |   21043 | 13 april 1974 |
| melbourne       | 11.20 (86)        | st kilda        | 14.16 (100)       | mcg               |   36708 | 15 april 1974 |
| essendon        | 21.24 (150)       | south melbourne | 10.18 (78)        | windy hill        |   25348 | 15 april 1974 |
| north melbourne | 20.12 (132)       | footscray       | 11.9 (75)         | arden street oval |   21358 | 15 april 1974 |

Question: What was the away score at the game at MCG?

table_id: 2-10869646-2
label: SELECT "Away team score" FROM "table" WHERE "Venue" = "mcg"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   Week | Date               | Opponent                | Result       | Attendance   |
|-------:|:-------------------|:------------------------|:-------------|:-------------|
|      1 | september 3, 2000  | at new england patriots | w 21-16      | 60,292       |
|      2 | september 10, 2000 | chicago bears           | w 41-0       | 65,569       |
|      3 | september 17, 2000 | at detroit lions        | w 31-10      | 76,928       |
|      4 | september 24, 2000 | new york jets           | l 21-17      | 65,619       |
|      5 | october 1, 2000    | at washington redskins  | l 20-17 (ot) | 83,532       |
|      6 | october 9, 2000    | at minnesota vikings    | l 30-23      | 64,162       |
|      7 | bye                | bye                     | bye          | bye          |
|      8 | october 19, 2000   | detroit lions           | l 28-14      | 65,557       |
|      9 | october 29, 2000   | minnesota vikings       | w 41-13      | 65,589       |
|     10 | november 5, 2000   | at atlanta falcons      | w 27-14      | 70,097       |
|     11 | november 12, 2000  | green bay packers       | w 20-15      | 65,621       |
|     12 | november 19, 2000  | at chicago bears        | l 13-10      | 66,944       |
|     13 | november 26, 2000  | buffalo bills           | w 31-17      | 65,546       |
|     14 | december 3, 2000   | dallas cowboys          | w 27-7       | 65,621       |
|     15 | december 10, 2000  | at miami dolphins       | w 16-13      | 74,307       |
|     16 | december 18, 2000  | st. louis rams          | w 38-35      | 65,653       |
|     17 | december 24, 2000  | at green bay packers    | l 17-14 (ot) | 59,692       |

Question: Who was the opponent on the game with a 65,569 attendance before week 12?

table_id: 2-11364413-1
label: SELECT "Opponent" FROM "table" WHERE "Week" < 12 AND "Attendance" = "65,569"
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       | Venue                       | Opponent   | Result   | Competition        |
|:-----------|:----------------------------|:-----------|:---------|:-------------------|
| 10-05-2012 | milano arena , kumanovo     | macedonia  | 0-1      | euro u21 qualifier |
| 15-08-2012 | tatabanya                   | hungary    | 2-3      | friendly           |
| 07-09-2012 | the oval , belfast          | macedonia  | 1-3      | euro u21 qualifier |
| 10-09-2012 | aalborg stadium , aalborg   | denmark    | 0-3      | euro u21 qualifier |
| 13-11-2012 | bloomfield road , blackpool | england    | 0-2      | friendly           |

Question: What was the venue for the game on 10-09-2012?

table_id: 2-10814520-2
label: SELECT "Venue" FROM "table" WHERE "Date" = "10-09-2012"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Place   | Player            | Country       | Score     | To par   |
|:--------|:------------------|:--------------|:----------|:---------|
| 1       | tom lehman        | united states | 67-70=137 | –3       |
| t2      | stewart cink      | united states | 71-67=138 | –2       |
| t2      | ernie els         | south africa  | 71-67=138 | –2       |
| t4      | scott hoch        | united states | 71-68=139 | –1       |
| t4      | jeff maggert      | united states | 73-66=139 | –1       |
| t4      | david ogrin       | united states | 70-69=139 | –1       |
| t4      | hal sutton        | united states | 66-73=139 | –1       |
| 8       | mark mcnulty      | zimbabwe      | 67-73=140 | e        |
| t9      | scott dunlap      | united states | 75-66=141 | +1       |
| t9      | kelly gibson      | united states | 72-69=141 | +1       |
| t9      | hideki kase       | japan         | 68-73=141 | +1       |
| t9      | justin leonard    | united states | 69-72=141 | +1       |
| t9      | colin montgomerie | scotland      | 65-76=141 | +1       |
| t9      | loren roberts     | united states | 72-69=141 | +1       |
| t9      | dave schreyer     | united states | 68-73=141 | +1       |
| t9      | jeff sluman       | united states | 69-72=141 | +1       |
| t9      | tommy tolles      | united states | 74-67=141 | +1       |
| t9      | tiger woods       | united states | 74-67=141 | +1       |

Question: What is Place, when Player is "Justin Leonard"?

table_id: 2-17162179-4
label: SELECT "Place" FROM "table" WHERE "Player" = "justin leonard"
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:
| Shekhina:   | Reason            | Mind            | Intelligence    | Thought          | Understanding    |
|:------------|:------------------|:----------------|:----------------|:-----------------|:-----------------|
| syriac      | ܗܘܢܐ haunâ        | ܡܕܥܐ madde´â    | ܪܥܝܢܐ reyana    | ܡܚܫܒܬܐ mahšabtâ  | ܬܪܥܝܬܐ tar´îtâ   |
| parthian    | bâm               | manohmêd        | uš              | andêšišn         | parmânag         |
| chinese     | 相 xiāng, "phase" | 心 xīn, "heart" | 念 niàn, "idea" | 思 sī, "thought" | 意 yì, "meaning" |
| turkish     | qut               | ög              | köngül          | saqinç           | tuimaq           |
| greek       | νοῦς nous         | εννοια          | φρονησις        | ενθυμησις        | λογισμος         |

Question: What is the mind of the one that has qut reason?

table_id: 1-19760-1
label: SELECT "Mind" FROM "table" WHERE "Reason" = "qut"
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 |
|-------:|:----------------------|:---------------|:-------------|---------:|
|   1978 | elf team tyrrell      | tyrrell 008    | cosworth v8  |        7 |
|   1979 | team tyrrell          | tyrrell 009    | cosworth v8  |       14 |
|   1979 | candy tyrrell team    | tyrrell 009    | cosworth v8  |       14 |
|   1980 | equipe ligier gitanes | ligier js11/15 | cosworth v8  |       32 |
|   1981 | scuderia ferrari      | ferrari 126ck  | ferrari v6 t |        9 |
|   1982 | scuderia ferrari      | ferrari 126c2  | ferrari v6 t |       39 |

Question: What is the highest year team tyrrell earned more than 14 points?

table_id: 2-1219767-1
label: SELECT MAX("Year") FROM "table" WHERE "Entrant" = "team tyrrell" AND "Points" > 14
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   Rank | Nation         |   Gold |   Silver |   Bronze |   Total |
|-------:|:---------------|-------:|---------:|---------:|--------:|
|      1 | east germany   |      1 |        2 |        0 |       3 |
|      2 | soviet union   |      0 |        1 |        2 |       3 |
|      3 | italy          |      1 |        0 |        0 |       1 |
|      4 | west germany   |      1 |        0 |        0 |       1 |
|      5 | czechoslovakia |      0 |        0 |        1 |       1 |

Question: What is the highest silver total for nations with 3 total and over 2 bronze?

table_id: 2-11238355-4
label: SELECT MAX("Silver") FROM "table" WHERE "Total" = 3 AND "Bronze" > 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:
| District       | Armenian        |   Population (2001) |   Area (km²) | Neighborhoods                    |
|:---------------|:----------------|--------------------:|-------------:|:---------------------------------|
| avan           | ավան            |               50400 |         8.37 | avan, avan- arinj , aghi hank    |
| davtashen      | դավթաշեն        |               50500 |         6.71 | davtashen blocks, huysi avan     |
| kanaker-zeytun | քանաքեր-զեյթուն |              102700 |         8.1  | kanaker , nor zeytun , mounument |
| nork-marash    | նորք-մարաշ      |               14600 |         4.6  | nork , nor marash                |
| nor nork       | նոր նորք        |              132100 |        14.47 | nor nork, bagrevand              |

Question: What is the Armenian name of the district that is 8.37 km² large?

table_id: 1-27366772-3
label: SELECT "Armenian" FROM "table" WHERE "Area (km²)" = "8.37"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Home team       | Home team score   | Away team       | Away team score   | Venue             |   Crowd | Date           |
|:----------------|:------------------|:----------------|:------------------|:------------------|--------:|:---------------|
| north melbourne | 14.14 (98)        | richmond        | 15.19 (109)       | arden street oval |   23682 | 23 august 1980 |
| fitzroy         | 16.21 (117)       | geelong         | 20.12 (132)       | junction oval     |   12004 | 23 august 1980 |
| collingwood     | 19.16 (130)       | footscray       | 13.14 (92)        | victoria park     |   23472 | 23 august 1980 |
| melbourne       | 14.17 (101)       | essendon        | 18.14 (122)       | mcg               |   23530 | 23 august 1980 |
| st kilda        | 13.9 (87)         | carlton         | 20.16 (136)       | moorabbin oval    |   21258 | 23 august 1980 |
| hawthorn        | 16.17 (113)       | south melbourne | 12.11 (83)        | vfl park          |   19882 | 23 august 1980 |

Question: Which away team has Away team score of 20.12 (132)?

table_id: 2-10809823-21
label: SELECT "Away team" FROM "table" WHERE "Away team score" = "20.12 (132)"
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:
| Club                             | League                                 | Sport               | Established   |   Championships |
|:---------------------------------|:---------------------------------------|:--------------------|:--------------|----------------:|
| guelph storm                     | ontario hockey league                  | hockey              | 1991          |               2 |
| guelph royals                    | intercounty baseball league            | baseball            | 1919          |               8 |
| guelph gryphons                  | canadian interuniversity sport         | university          | 1874          |               0 |
| guelph regals                    | ontario lacrosse association           | lacrosse            | 1992          |               1 |
| guelph rangers                   | kitchener district soccer league       | soccer              | circa 1985    |               3 |
| guelph underdogs sc              | conestoga college indoor soccer league | soccer              | 2004          |               0 |
| guelph hurricanes                | greater ontario junior hockey league   | hockey              | 1963          |               0 |
| guelph bears                     | ontario football conference            | football            | 1997          |               0 |
| guelph gargoyles                 | ontario australian football league     | australian football | 2001          |               0 |
| speed river track and field club | athletics canada                       | athletics           | 1997          |              10 |

Question: Which Established has a League of ontario australian football league?

table_id: 2-178833-4
label: SELECT "Established" FROM "table" WHERE "League" = "ontario australian football league"
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   | Partner           | Opponent in the final          | Score in the final   |
|-------:|:---------------------------------------|:----------|:------------------|:-------------------------------|:---------------------|
|   1988 | gstaad , switzerland                   | clay      | milan šrejber     | andrés gómez emilio sánchez    | 7–6, 7–6             |
|   1988 | prague , czechoslovakia                | clay      | jaroslav navrátil | thomas muster horst skoff      | 7–5, 7–6             |
|   1989 | stuttgart , germany                    | clay      | tomáš šmíd        | florin segărceanu cyril suk    | 6–7, 6–3, 6–1        |
|   1990 | monte carlo , monaco                   | clay      | tomáš šmíd        | andrés gómez javier sánchez    | 6–2, 6–1             |
|   1991 | new haven , usa                        | hard      | wally masur       | jeff brown scott melville      | w/o                  |
|   1991 | berlin , germany                       | carpet    | karel nováček     | jan siemerink daniel vacek     | 3–6, 7–5, 7–5        |
|   1993 | monte carlo, monaco                    | clay      | stefan edberg     | paul haarhuis mark koevermans  | 6–2, 2–6, 7–5        |
|   1993 | halle , germany                        | grass     | cyril suk         | mike bauer marc-kevin goellner | 7–6, 5–7, 6–3        |
|   1993 | cincinnati , usa                       | hard      | andre agassi      | stefan edberg henrik holm      | 6–4, 7–6             |
|   1996 | australian open, melbourne , australia | hard      | stefan edberg     | sébastien lareau alex o'brien  | 7–5, 7–5, 4–6, 6–1   |

Question: Which Tournament has a Partner of karel nováček?

table_id: 2-1439769-6
label: SELECT "Tournament" FROM "table" WHERE "Partner" = "karel nováček"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Home team   | Home team score   | Away team       | Away team score   | Venue           |   Crowd | Date         |
|:------------|:------------------|:----------------|:------------------|:----------------|--------:|:-------------|
| hawthorn    | 7.13 (55)         | richmond        | 12.21 (93)        | glenferrie oval |   21000 | 10 june 1939 |
| st kilda    | 18.12 (120)       | north melbourne | 16.10 (106)       | junction oval   |   17000 | 10 june 1939 |
| collingwood | 18.15 (123)       | carlton         | 12.12 (84)        | victoria park   |   36000 | 10 june 1939 |
| essendon    | 9.16 (70)         | south melbourne | 13.13 (91)        | windy hill      |   18000 | 12 june 1939 |
| melbourne   | 18.14 (122)       | footscray       | 15.13 (103)       | mcg             |   22016 | 12 june 1939 |
| geelong     | 21.17 (143)       | fitzroy         | 14.12 (96)        | corio oval      |    9000 | 12 june 1939 |

Question: In the venue of Glenferrie Oval, what is the home team score?

table_id: 2-10806852-8
label: SELECT "Home team score" FROM "table" WHERE "Venue" = "glenferrie oval"
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 march 2003  | magic     | 102–76  | cavaliers | two-way tie (14)        | 11–48    |
| 4 march 2003  | cavaliers | 80–89   | knicks    | ricky davis (24)        | 11–49    |
| 5 march 2003  | hawks     | 111–105 | cavaliers | zydrunas ilgauskas (27) | 11–50    |
| 7 march 2003  | cavaliers | 76–102  | hornets   | carlos boozer (16)      | 11–51    |
| 8 march 2003  | grizzlies | 115–89  | cavaliers | ricky davis (18)        | 11–52    |
| 11 march 2003 | heat      | 77–75   | cavaliers | ricky davis (19)        | 11–53    |
| 16 march 2003 | jazz      | 95–122  | cavaliers | ricky davis (28)        | 12–53    |
| 18 march 2003 | cavaliers | 93–114  | mavericks | zydrunas ilgauskas (30) | 12–54    |
| 19 march 2003 | cavaliers | 101–128 | grizzlies | carlos boozer (27)      | 12–55    |
| 21 march 2003 | cavaliers | 85–109  | magic     | milt palacio (15)       | 12–56    |
| 23 march 2003 | nets      | 88–93   | cavaliers | zydrunas ilgauskas (29) | 13–56    |
| 25 march 2003 | warriors  | 103–124 | cavaliers | ricky davis (28)        | 14–56    |
| 26 march 2003 | cavaliers | 83–89   | raptors   | zydrunas ilgauskas (25) | 14–57    |
| 28 march 2003 | cavaliers | 95–104  | celtics   | ricky davis (31)        | 14–58    |
| 29 march 2003 | celtics   | 110–106 | cavaliers | ricky davis (38)        | 14–59    |

Question: Which team was the visitor when Milt Palacio (15) was the leading scorer?

table_id: 2-16140345-8
label: SELECT "Visitor" FROM "table" WHERE "Leading scorer" = "milt palacio (15)"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Region         | Date         | Label      | Format         | Catalog    |
|:---------------|:-------------|:-----------|:---------------|:-----------|
| united kingdom | february1972 | a&m        | stereo lp      | amlh 66078 |
| united states  | february1972 | a&m        | stereo lp      | sp 4344    |
| japan          | 1987         | a&m/canyon | cd             | d32y3578   |
| south korea    | 1997         | si-wan     | cd             | srmc 0075  |
| worldwide      | 1998         | a&m        | ed remaster cd | 540,934-2  |

Question: What is the date on Catalog 540,934-2?

table_id: 2-13076312-2
label: SELECT "Date" FROM "table" WHERE "Catalog" = "540,934-2"