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:
| Model number   | sSpec number   | Frequency   | GPU frequency   | L2 cache   | I/O bus   | Memory                    | Voltage    | Socket     | Release date      | Part number(s)   |
|:---------------|:---------------|:------------|:----------------|:-----------|:----------|:--------------------------|:-----------|:-----------|:------------------|:-----------------|
| atom n435      | slc4c(a0)      | 1.33 ghz    | 200 mhz         | 512 kb     | dmi       | 1 × ddr2-667 1 × ddr3-800 | 0.8–1.175v | fc-bga 559 | june 2011         | au80610007533aa  |
| atom n450      | slbmg(a0)      | 1.67 ghz    | 200 mhz         | 512 kb     | dmi       | 1 × ddr2-667              | 0.8–1.175v | fc-bga 559 | december 21, 2009 | au80610004653aa  |
| atom n455      | slbx9(a0)      | 1.67 ghz    | 200 mhz         | 512 kb     | dmi       | 1 × ddr2-800 1 × ddr3-800 | 0.8–1.175v | fc-bga 559 | june 1, 2010      | au80610006237aa  |
| atom n470      | slbmf(a0)      | 1.83 ghz    | 200 mhz         | 512 kb     | dmi       | 1 × ddr2-667              | 0.8–1.175v | fc-bga 559 | march 1, 2010     | au80610003495aa  |
| atom n475      | slbx5(a0)      | 1.83 ghz    | 200 mhz         | 512 kb     | dmi       | 1 × ddr2-800 1 × ddr3-800 | 0.8–1.175v | fc-bga 559 | june 1, 2010      | au80610006240aa  |

Question: What is Socket, when Part Number(s) is au80610003495aa?

table_id: 2-16729930-7
label: SELECT "Socket" FROM "table" WHERE "Part number(s)" = "au80610003495aa"
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 | Pick   | Player                                    | Position   | Country   | Previous team (League)          |
|-------:|:-------|:------------------------------------------|:-----------|:----------|:--------------------------------|
|   1977 | 2      | barry beck category:articles with hcards  | defense    | canada    | new westminster bruins ( wchl ) |
|   1978 | 5      | mike gillis category:articles with hcards | left wing  | canada    | kingston canadians ( oha )      |
|   1979 | 1*     | rob ramage category:articles with hcards  | defense    | canada    | birmingham bulls ( wha )        |
|   1980 | 19     | paul gagne category:articles with hcards  | forward    | canada    | windsor spitfires ( oha )       |
|   1981 | 5      | joe cirella category:articles with hcards | defense    | canada    | oshawa generals ( ohl )         |

Question: What was the position in 1981?

table_id: 2-18255134-2
label: SELECT "Position" FROM "table" WHERE "Year" = 1981
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:
| Character              | Original Berkeley Cast   | Original Broadway Cast   | Original 1st US Tour Cast   | Original UK Cast   | Original Tokyo / Seoul Tour Cast   | Original 3rd US Tour Cast   |
|:-----------------------|:-------------------------|:-------------------------|:----------------------------|:-------------------|:-----------------------------------|:----------------------------|
| johnny                 | john gallagher, jr.      | john gallagher, jr.      | van hughes                  | alex nee           | sean michael murray                | jared nepute                |
| will                   | michael esper            | michael esper            | jake epstein                | casey o'farrell    | casey o'farrell                    | casey o'farrell             |
| tunny                  | matt caplan              | stark sands              | scott j. campbell           | thomas hettrick    | thomas hettrick                    | dan tracy                   |
| whatsername            | rebecca naomi jones      | rebecca naomi jones      | gabrielle mcclinton         | alyssa dipalma     | alyssa dipalma                     | olivia puckett              |
| heather                | mary faber               | mary faber               | leslie mcdonel              | kennedy caughell   | mariah macfarlane                  | mariah macfarlane           |
| the extraordinary girl | christina sajous         | christina sajous         | nicci claspell              | jenna rubaii       | jenna rubaii                       | taylor jones                |

Question: While the original 1st us tour cast included nicci claspell, who was in the original tokyo/seoul tour cast?

table_id: 1-24353141-1
label: SELECT "Original Tokyo / Seoul Tour Cast" FROM "table" WHERE "Original 1st US Tour Cast" = "Nicci Claspell"
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:
| Source         | Date   | GERB   | Attack   | Blue Coalition   |
|:---------------|:-------|:-------|:---------|:-----------------|
| alpha research | march  | 19,2%  | 6,8%     | 4,9%             |
| alpha research | april  | 24%    | 8%       | 7%               |
| nciom          | 19 may | 32,4%  | 11%      | 6,2%             |
| skala          | 28 may | 31,99% | 9,70%    | 10,21%           |
| mbmd           | 31 may | 30,00% | 8,10%    | 6,07%            |
| skala          | 1 june | 30,30% | 9,77%    | 8,94%            |
| skala          | 2 june | 31,15% | 9,46%    | 8,80%            |
| barometar info | 3 june | 26,07% | 8,53%    | 9,24%            |
| skala          | 4 june | 29,50% | 10,30%   | 8,22%            |

Question: What GERB has an 11% Attack?

table_id: 2-15125012-1
label: SELECT "GERB" FROM "table" WHERE "Attack" = "11%"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   Game |   February | Opponent              | Score   | Record   |
|-------:|-----------:|:----------------------|:--------|:---------|
|     50 |          1 | new york islanders    | 7 - 6   | 16-25-9  |
|     51 |          4 | @ st. louis blues     | 2 - 2   | 16-25-10 |
|     52 |          5 | colorado rockies      | 6 - 3   | 17-25-10 |
|     53 |          8 | minnesota north stars | 3 - 0   | 18-25-10 |
|     54 |          9 | @ buffalo sabres      | 2 - 0   | 18-26-10 |
|     55 |         11 | @ toronto maple leafs | 3 - 2   | 18-27-10 |
|     56 |         12 | montreal canadiens    | 5 - 3   | 18-28-10 |
|     57 |         15 | vancouver canucks     | 6 - 3   | 19-28-10 |
|     58 |         19 | colorado rockies      | 4 - 4   | 19-28-11 |
|     59 |         22 | @ chicago black hawks | 3 - 2   | 19-29-11 |
|     60 |         23 | chicago black hawks   | 6 - 2   | 20-29-11 |
|     61 |         25 | @ montreal canadiens  | 6 - 3   | 21-29-11 |
|     62 |         27 | atlanta flames        | 5 - 3   | 21-30-11 |

Question: What is Score, when Game is less than 61, when February is less than 11, and when Opponent is "@ Buffalo Sabres"?

table_id: 2-17310913-6
label: SELECT "Score" FROM "table" WHERE "Game" < 61 AND "February" < 11 AND "Opponent" = "@ buffalo sabres"
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             |
|:------------|:------------------|:----------------|:------------------|:----------------------|--------:|:-----------------|
| geelong     | 21.22 (148)       | hawthorn        | 9.15 (69)         | corio oval            |    6000 | 5 september 1936 |
| footscray   | 14.8 (92)         | north melbourne | 12.10 (82)        | western oval          |   11000 | 5 september 1936 |
| fitzroy     | 11.13 (79)        | south melbourne | 11.14 (80)        | brunswick street oval |   11000 | 5 september 1936 |
| essendon    | 14.8 (92)         | richmond        | 11.10 (76)        | windy hill            |    8000 | 5 september 1936 |
| melbourne   | 9.13 (67)         | collingwood     | 11.18 (84)        | mcg                   |   21648 | 5 september 1936 |
| st kilda    | 16.10 (106)       | carlton         | 15.15 (105)       | junction oval         |   18000 | 5 september 1936 |

Question: What was Home team Footscray's score?

table_id: 2-10790804-18
label: SELECT "Home team score" FROM "table" WHERE "Home team" = "footscray"
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 12, 1976 | at new orleans saints       | w 40-9       |        58156 |
|      2 | september 19, 1976 | los angeles rams            | t 10-10 (ot) |        47310 |
|      3 | september 26, 1976 | at detroit lions            | w 10-9       |        77292 |
|      4 | october 4, 1976    | pittsburgh steelers         | w 17-6       |        47809 |
|      5 | october 10, 1976   | chicago bears               | w 20-19      |        47614 |
|      6 | october 17, 1976   | new york giants             | w 24-7       |        46508 |
|      7 | october 24, 1976   | at philadelphia eagles      | w 31-12      |        56233 |
|      8 | october 31, 1976   | at chicago bears            | l 14-13      |        53602 |
|      9 | november 7, 1976   | detroit lions               | w 31-23      |        46735 |
|     10 | november 14, 1976  | seattle seahawks            | w 27-21      |        45087 |
|     11 | november 21, 1976  | at green bay packers (milw) | w 17-10      |        53104 |
|     12 | november 29, 1976  | at san francisco 49ers      | l 20-16      |        56775 |
|     13 | december 5, 1976   | green bay packers           | w 20-9       |        43700 |
|     14 | december 11, 1976  | at miami dolphins           | w 29-7       |        46543 |

Question: What is the average week on November 7, 1976 with an attendance less than 46,735?

table_id: 2-10361570-2
label: SELECT AVG("Week") FROM "table" WHERE "Date" = "november 7, 1976" AND "Attendance" < 46735
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 |
|:-------------|:---------------|:--------|:------------|-------------:|
| 26 july 2008 | marathon       | 2:1     | platense    |         2116 |
| 26 july 2008 | victoria       | 0:4     | motagua     |         3355 |
| 27 july 2008 | deportes savio | 0:1     | real espana |         1500 |
| 27 july 2008 | real juventud  | 0:1     | vida        |         1920 |
| 27 july 2008 | olimpia        | 0:0     | hispano     |         2167 |

Question: What is the Home team when the Attendance was 1920?

table_id: 2-17026847-3
label: SELECT "Home" FROM "table" WHERE "Attendance" = 1920
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 | 9.8 (62)          | st kilda    | 20.12 (132)       | arden street oval     |    9000 | 17 august 1929 |
| hawthorn        | 8.10 (58)         | richmond    | 11.14 (80)        | glenferrie oval       |   12500 | 17 august 1929 |
| melbourne       | 11.16 (82)        | footscray   | 6.5 (41)          | mcg                   |   13891 | 17 august 1929 |
| south melbourne | 14.10 (94)        | essendon    | 13.10 (88)        | lake oval             |   15000 | 17 august 1929 |
| fitzroy         | 8.7 (55)          | collingwood | 16.15 (111)       | brunswick street oval |   13000 | 17 august 1929 |
| geelong         | 2.13 (25)         | carlton     | 5.9 (39)          | corio oval            |   10000 | 17 august 1929 |

Question: What is the name of the away team with glenferrie oval venue?

table_id: 2-10767118-16
label: SELECT "Away team" 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         | Record   |
|:-----------|:-------------|:--------|:-------------|:---------|
| october 5  | pittsburgh   | 3 - 3   | new jersey   | 0-0-1    |
| october 8  | ny rangers   | 2 - 3   | new jersey   | 1-0-1    |
| october 9  | new jersey   | 5 - 5   | toronto      | 1-0-2    |
| october 12 | boston       | 2 - 2   | new jersey   | 1-0-3    |
| october 14 | montreal     | 5 - 3   | new jersey   | 1-1-3    |
| october 16 | new jersey   | 6 - 5   | pittsburgh   | 2-1-3    |
| october 18 | philadelphia | 1 - 3   | new jersey   | 3-1-3    |
| october 20 | new jersey   | 4 - 7   | los angeles  | 3-2-3    |
| october 22 | new jersey   | 1 - 3   | winnipeg     | 3-3-3    |
| october 26 | minnesota    | 5 - 3   | new jersey   | 3-4-3    |
| october 28 | ny islanders | 4 - 2   | new jersey   | 3-5-3    |
| october 30 | new jersey   | 5 - 8   | ny islanders | 3-6-3    |

Question: When was the game played against a visiting team from Philadelphia?

table_id: 2-12019734-3
label: SELECT "Date" FROM "table" WHERE "Visitor" = "philadelphia"
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                | Number   | Builder              | Date built   | Wheel arrangement   | Driving wheels   | Cylinders   | Boiler pressure   | Notes                  |
|:--------------------|:---------|:---------------------|:-------------|:--------------------|:-----------------|:------------|:------------------|:-----------------------|
| selsey              | 2        | peckett and sons     | 1897         | 2-4-2 t             | 2ft 9in          | 10" x 15"   | 140 psi           | new                    |
| sidlesham           | 3 or 2   | manning wardle       | 1861         | 0-6-0 st            | 3ft 2in          | 11" x 17"   | 120 psi           | ex- industrial         |
| hesperus            | 4 or 2   | neilson and company  | 1871 or 1872 | 0-4-2 st            | 3ft 1in          | 10" x 18"   | 90 psi            | ex- pdswjr             |
| ringing rock        | 5 or 2   | manning wardle       | 1883         | 0-6-0 st            | 3ft 2in          | 12" x 17"   | 120 psi           | ex-industrial          |
| chichester (first)  | 1 or 3   | longbottom, barnsley | 1847         | 0-4-2t              | 3ft 6in          | 11" x 18"   | 120 psi           | built for gwr as 0-6-0 |
| chichester (second) | 6 or 4   | hudswell clarke      | 1903         | 0-6-0 st            | 3ft 1in          | 12" x 18"   | 120 psi           | ex-industrial          |
| morous              | 7 or 4   | manning wardle       | 1866         | 0-6-0 st            | 3ft 2in          | 11" x 17"   | 120 psi           | ex- smr                |

Question: What is the boiler pressure for the Hesperus model?

table_id: 2-1157867-2
label: SELECT "Boiler pressure" FROM "table" WHERE "Name" = "hesperus"
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:
| Non-dictatorship   | Pareto efficiency   | Majority   | Monotone   | Consistency & Participation   | Condorcet   | Condorcet loser   | Clone independence   | Reversal symmetry   |
|:-------------------|:--------------------|:-----------|:-----------|:------------------------------|:------------|:------------------|:---------------------|:--------------------|
| no                 | no                  | no         | yes        | yes                           | no          | no                | yes                  | yes                 |
| yes                | yes                 | no         | yes        | yes                           | no          | no                | no                   | yes                 |
| yes                | yes                 | no         | yes        | no                            | no          | no                | no                   | yes                 |
| yes                | yes                 | yes        | yes        | no                            | yes         | no                | yes                  | yes                 |
| no                 | yes                 | yes        | yes        | yes                           | yes         | yes               | yes                  | yes                 |

Question: what is the monotone when pareto efficiency is yes, non-dictatorship is yes, and clone independence is yes?

table_id: 2-1857-3
label: SELECT "Monotone" FROM "table" WHERE "Pareto efficiency" = "yes" AND "Non-dictatorship" = "yes" AND "Clone independence" = "yes"
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 | Álbum                  | Charts              |   Sales | Certification   |
|-------:|:-----------------------|:--------------------|--------:|:----------------|
|   1990 | xuxa 1                 | no. 1 latin charts  | 2500000 | 1x diamond      |
|   1991 | xuxa 2                 | no. 1 latin charts  | 1650000 | 2x platinum     |
|   1992 | xuxa 3                 | no. 7 latin charts  |  750000 | 2x platinum     |
|   1993 | todos sús exitos       | no. 1 latin charts  | 1500000 | 1x diamond      |
|   1994 | el pequeño mundo       | no. 49 latin        |  300000 | 1x platinum     |
|   1996 | xuxa dance             | no. 10 latin charts |  300000 | 1x platinum     |
|   1999 | el mundo és de los dos | no. 40 latin charts |  150000 | 1x gold         |
|   2005 | solamente para bajitos | –                   |  200000 | 1x gold         |

Question: What were the number of sales before 1991?

table_id: 2-12937449-3
label: SELECT "Sales" FROM "table" WHERE "Year" < 1991
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:
| Mininera DFL         |   Wins |   Byes |   Losses |   Draws |   Against |
|:---------------------|-------:|-------:|---------:|--------:|----------:|
| glenthompson-dunkeld |     16 |      0 |        2 |       0 |       882 |
| tatyoon              |     16 |      0 |        2 |       0 |       924 |
| moyston-willaura     |     15 |      0 |        3 |       0 |      1190 |
| lismore-derrinallum  |     10 |      0 |        8 |       0 |      1128 |
| penshurst            |     10 |      0 |        8 |       0 |      1405 |
| wickliffe-lake bolac |      7 |      0 |       11 |       0 |      1465 |
| smw rovers           |      6 |      0 |       11 |       1 |      1357 |
| hawkesdale-macarthur |      6 |      0 |       12 |       0 |      1707 |
| caramut              |      2 |      0 |       15 |       1 |      1868 |
| woorndoo-mortlake    |      1 |      0 |       17 |       0 |      2010 |

Question: WHAT IS THE HIGHEST AGAINST WITH LOSSES SMALLER THAN 17, DRAWS LARGER THAN 1?

table_id: 2-17732555-7
label: SELECT MAX("Against") FROM "table" WHERE "Losses" < 17 AND "Draws" > 1
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   | Ground           |   Crowd | Date                  |
|:---------------|:------------------|:-----------------|:------------------|:-----------------|--------:|:----------------------|
| st kilda       | 16.13 (109)       | melbourne        | 5.11 (41)         | colonial stadium |   13814 | friday, 15 february   |
| fremantle      | 13.9 (87)         | western bulldogs | 10.8 (68)         | subiaco oval     |   13304 | friday, 15 february   |
| geelong        | 12.7 (79)         | richmond         | 7.13 (55)         | baytec stadium   |   11531 | saturday, 16 february |
| carlton        | 12.9 (81)         | west coast       | 17.14 (116)       | optus oval       |    5217 | saturday, 16 february |
| brisbane lions | 14.7 (91)         | adelaide         | 14.9 (93)         | gabba            |   17236 | saturday, 16 february |
| hawthorn       | 13.10 (88)        | kangaroos        | 11.10 (76)        | york park        |   12861 | sunday, 17 february   |
| sydney         | 18.11 (119)       | collingwood      | 5.9 (39)          | manuka oval      |    7826 | sunday, 17 february   |
| port adelaide  | 13.8 (86)         | essendon         | 8.10 (58)         | football park    |   15576 | sunday, 17 february   |

Question: What is the average Crowd for Away team with a score of 17.14 (116)?

table_id: 2-16388478-2
label: SELECT AVG("Crowd") FROM "table" WHERE "Away team score" = "17.14 (116)"
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         |
|:----------------|:------------------|:----------------|:------------------|:---------------|--------:|:-------------|
| footscray       | 16.14 (110)       | geelong         | 9.11 (65)         | western oval   |   15204 | 6 april 1974 |
| collingwood     | 17.15 (117)       | essendon        | 15.10 (100)       | victoria park  |   30493 | 6 april 1974 |
| carlton         | 14.13 (97)        | melbourne       | 6.12 (48)         | princes park   |   16562 | 6 april 1974 |
| south melbourne | 15.10 (100)       | north melbourne | 11.14 (80)        | lake oval      |   10744 | 6 april 1974 |
| richmond        | 12.16 (88)        | hawthorn        | 15.14 (104)       | mcg            |   38735 | 6 april 1974 |
| st kilda        | 11.17 (83)        | fitzroy         | 6.7 (43)          | moorabbin oval |   17286 | 6 april 1974 |

Question: What is the score for the away team at Victoria Park?

table_id: 2-10869646-1
label: SELECT "Away team score" FROM "table" WHERE "Venue" = "victoria park"
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   | Winner             | Prize    | Runner-Up       | 3rd place           |
|:---------|:-------------------|:---------|:----------------|:--------------------|
| 1        | dave ulliott       | £40,000  | peter evans     | dave welch          |
| 2        | simon trumper      | £40,000  | ross boatman    | ram vaswani         |
| 3        | phil hellmuth, jr. | £45,000  | adam heller     | paul alterman       |
| 4        | hemish shah        | £50,000  | simon trumper   | barny boatman       |
| 5        | padraig parkinson  | £50,000  | korosh nejad    | joe beevers         |
| 6        | peter costa        | £60,000  | jin cai lin     | lucy rokach         |
| ace 1    | john shaw          | £50,000  | hung luc        | miles adam          |
| ace 2    | raul mestre        | $50,000  | simon ehne      | michiel van woerden |
| masters  | david tighe        | $100,000 | simon ehne      | barny boatman       |
| 7        | andreas jorbeck    | $125,000 | roland de wolfe | andy black          |
| 8        | huck seed          | $200,000 | gus hansen      | annette obrestad    |
| 9        | john duthie        | $200,000 | phil ivey       | carlos mortensen    |
| 10       | sam holden         | $150,000 | luke schwartz   | rob okell           |

Question: What is Winner, when Prize is "£50,000", and when Runner-Up is "Korosh Nejad"?

table_id: 2-1718446-1
label: SELECT "Winner" FROM "table" WHERE "Prize" = "£50,000" AND "Runner-Up" = "korosh nejad"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| State         |   Interview |   Swimsuit |   Evening Gown |   Average |
|:--------------|------------:|-----------:|---------------:|----------:|
| new york      |       9.155 |      9.394 |          9.494 |     9.347 |
| illinois      |       9.238 |      9.283 |          9.3   |     9.273 |
| louisiana     |       9.205 |      9.131 |          8.961 |     9.099 |
| alabama       |       8.842 |      9.072 |          9.348 |     9.087 |
| oregon        |       9.072 |      9.027 |          9.122 |     9.073 |
| texas         |       9.133 |      8.916 |          9.072 |     9.04  |
| new jersey    |       9.016 |      9.033 |          8.822 |     9.029 |
| new mexico    |       8.872 |      9.013 |          8.822 |     9.013 |
| mississippi   |       8.872 |      8.966 |          8.794 |     8.877 |
| west virginia |       8.516 |      8.838 |          8.711 |     8.688 |

Question: What is the lowest average that has a swimsuit less than 8.966, for west virginia and an evening gown less than 8.711?

table_id: 2-12079804-1
label: SELECT MIN("Average") FROM "table" WHERE "Swimsuit" < 8.966 AND "State" = "west virginia" AND "Evening Gown" < 8.711