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:
| Week #            | Theme                  | Song choice             | Original artist    | Order #   | Result   |
|:------------------|:-----------------------|:------------------------|:-------------------|:----------|:---------|
| audition          | auditioner's choice    | unaired                 | unaired            | n/a       | advanced |
| hollywood         | first solo             | unaired                 | unaired            | n/a       | advanced |
| hollywood         | group performance      | " bad romance "         | lady gaga          | n/a       | advanced |
| hollywood         | second solo            | " living for the city " | stevie wonder      | n/a       | advanced |
| top 24 (12 women) | billboard hot 100 hits | " all right now "       | free               | 1         | safe     |
| top 20 (10 women) | billboard hot 100 hits | " walk away "           | kelly clarkson     | 9         | safe     |
| top 16 (8 women)  | billboard hot 100 hits | " smile "               | nat king cole      | 6         | safe     |
| top 12            | the rolling stones     | " honky tonk women "    | the rolling stones | 10        | bottom 3 |

Question: Who was the original artist for First Solo?

table_id: 1-26250176-1
label: SELECT "Original artist" FROM "table" WHERE "Theme" = "First Solo"
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                    | Score   | Result   | Competition   |
|:--------------|:-------------------------|:--------|:---------|:--------------|
| 27 march 1880 | hampden park , glasgow   | 3-0     | 5-1      | friendly      |
| 29 march 1884 | cathkin park , glasgow   | 1-1     | 4-1      | bhc           |
| 21 march 1885 | kennington oval , london | 1-0     | 1-1      | bhc           |
| 23 march 1885 | acton park , wrexham     | 4-1     | 8-1      | bhc           |
| 23 march 1885 | acton park , wrexham     | 7-1     | 8-1      | bhc           |
| 23 march 1885 | acton park , wrexham     | 8-1     | 8-1      | bhc           |

Question: When was there a score of 7-1?

table_id: 2-12738226-1
label: SELECT "Date" FROM "table" WHERE "Score" = "7-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:
| Outcome   | Date             | Surface   | Partner             | Opponents                           | Score                   |
|:----------|:-----------------|:----------|:--------------------|:------------------------------------|:------------------------|
| runner-up | 6 november 2005  | hard (i)  | ashley harkleroad   | anastasia rodionova elena vesnina   | 6–7 (4–7) , 6–4, 6–2    |
| runner-up | 13 january 2006  | hard      | claire curran       | marta domachowska roberta vinci     | 7–6 (7–5) , 6–3         |
| winner    | 17 february 2008 | clay      | alicja rosolska     | mariya koryttseva julia schruff     | 7–5, 6–3                |
| runner-up | 20 june 2008     | grass     | angelique kerber    | marina erakovic michaëlla krajicek  | 6–3, 6–2                |
| runner-up | 19 april 2009    | clay      | patty schnyder      | bethanie mattek-sands nadia petrova | 6–7 (5–7) , 6–2, [11–9] |
| runner-up | 15 january 2011  | hard      | kateryna bondarenko | sara errani roberta vinci           | 6–3, 7–5                |
| runner-up | 25 august 2012   | hard      | irina falconi       | marina erakovic heather watson      | 6–3, 6–0                |

Question: What was the Outcome of the match played on Hard (i) Surface?

table_id: 2-15852178-2
label: SELECT "Outcome" FROM "table" WHERE "Surface" = "hard (i)"
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 | Player         | Country       |   Earnings ( $ ) |   Events |   Wins |
|-------:|:---------------|:--------------|-----------------:|---------:|-------:|
|      1 | larry nelson   | united states |          2708005 |       30 |      6 |
|      2 | bruce fleisher | united states |          2373977 |       30 |      4 |
|      3 | hale irwin     | united states |          2128968 |       24 |      4 |
|      4 | gil morgan     | united states |          1873216 |       23 |      3 |
|      5 | dana quigley   | united states |          1802063 |       39 |      1 |

Question: What is the highest rank of the player who played 30 events and made less than $2,708,005?

table_id: 2-11603398-3
label: SELECT MAX("Rank") FROM "table" WHERE "Earnings ( $ )" < 2708005 AND "Events" = 30
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 | Title                        | Studio                | Director          | Gross rental                  |
|-------:|:-----------------------------|:----------------------|:------------------|:------------------------------|
|      1 | south pacific                | 20th century fox      | joshua logan      | $16,300,000                   |
|      2 | auntie mame                  | warner bros. pictures | morton dacosta    | $9,100,000                    |
|      3 | cat on a hot tin roof        | metro-goldwyn-mayer   | richard brooks    | $7,800,000                    |
|      4 | no time for sergeants        | warner bros. pictures | mervyn leroy      | $7,500,000                    |
|      5 | gigi                         | metro-goldwyn-mayer   | vincente minnelli | $6,700,000                    |
|      6 | the vikings                  | united artists        | richard fleischer | $6,000,000                    |
|      7 | vertigo                      | paramount pictures    | alfred hitchcock  | $5,306,000[ citation needed ] |
|      8 | the young lions              | 20th century fox      | edward dmytryk    | $4,480,000[ citation needed ] |
|      9 | some came running            | metro-goldwyn-mayer   | vincente minnelli | $4,442,000[ citation needed ] |
|     10 | the sheriff of fractured jaw | 20th century fox      | raoul walsh       | $4,410,000[ citation needed ] |

Question: What is the Studio of the Film with a Gross rental of $7,500,000?

table_id: 2-172085-1
label: SELECT "Studio" FROM "table" WHERE "Gross rental" = "$7,500,000"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   Year | Entrant              | Chassis    | Engine       |   Points |
|-------:|:---------------------|:-----------|:-------------|---------:|
|   1963 | scuderia centro sud  | brm p57    | brm v8       |        0 |
|   1964 | team lotus           | lotus 33   | climax v8    |        0 |
|   1965 | team lotus           | lotus 25   | climax v8    |        0 |
|   1966 | cooper car company   | cooper t81 | maserati v12 |        0 |
|   1967 | team lotus           | lotus 49   | cosworth v8  |        0 |
|   1968 | gold leaf team lotus | lotus 49b  | cosworth v8  |        0 |

Question: What engine did the Team Lotus have after 1965?

table_id: 2-1235121-1
label: SELECT "Engine" FROM "table" WHERE "Entrant" = "team lotus" AND "Year" > 1965
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:
| Route Name   | Direction   | Termini                                   | Junctions    | Length     | Population Area   | Remarks                |
|:-------------|:------------|:------------------------------------------|:-------------|:-----------|:------------------|:-----------------------|
| sh 2         | south north | laredo, texas la salle county             | none         | miles (km) | laredo webb       | replaced by us 81      |
| sh 4         | south north | zapata county dimmit county               | none         | miles (km) | laredo webb       | replaced by us 83      |
| us 81        | south north | laredo, texas la salle county             | none         | miles (km) | laredo webb       | replaced by i-35       |
| us 83 bus.   | south north | gateway to the americas int'l bridge i-35 | i-35 us 83   | miles (km) | laredo            | replaced by bsi-35     |
| sh 96        | east west   | duval county laredo                       | none         | miles (km) | las lomas laredo  | replaced by us 59      |
| sh 202       | east west   | duval county laredo                       | none         | miles (km) | las lomas laredo  | replaced by us 96      |
| lp 420       | south north | gateway to the americas int'l bridge i-35 | i-35 us 83   | miles (km) | laredo            | replaced by us 83 bus. |
| fm 863       | east west   | duval county us 83                        | us 83        | miles (km) | none              | replaced by sh 44      |
| fm 3464      | east west   | i-35 ur 1472                              | i-35 ur 1472 | miles (km) | laredo            | replaced by lp 20      |

Question: What is the length of the highway with the route name sh 2?

table_id: 2-11336756-6
label: SELECT "Length" FROM "table" WHERE "Route Name" = "sh 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:
|   Game | Date       | Opponent            | Score      | Location             |   Attendance | Record   |   Points |
|-------:|:-----------|:--------------------|:-----------|:---------------------|-------------:|:---------|---------:|
|      1 | october 3  | atlanta thrashers   | 6 – 3      | philips arena        |        18545 | 0–1–0    |        0 |
|      2 | october 6  | carolina hurricanes | 2 – 1 (so) | rbc center           |        16186 | 0–1–1    |        1 |
|      3 | october 8  | new jersey devils   | 4 – 3 (so) | st. pete times forum |        17454 | 0–1–2    |        2 |
|      4 | october 10 | carolina hurricanes | 5 – 2      | st. pete times forum |        14212 | 1–1–2    |        4 |
|      5 | october 12 | florida panthers    | 3 – 2      | st. pete times forum |        14126 | 2–1–2    |        6 |
|      6 | october 15 | ottawa senators     | 7 – 1      | scotiabank place     |        17732 | 2–2–2    |        6 |
|      7 | october 17 | pittsburgh penguins | 4 – 1      | mellon arena         |        17132 | 2–3–2    |        6 |
|      8 | october 22 | san jose sharks     | 5 – 2      | st. pete times forum |        13343 | 3–3–2    |        8 |
|      9 | october 24 | buffalo sabres      | 3 – 2 (so) | st. pete times forum |        15804 | 3–3–3    |        9 |
|     10 | october 29 | ottawa senators     | 5 – 2      | st. pete times forum |        13213 | 4–3–3    |       11 |

Question: What date did they play the Florida Panthers?

table_id: 1-23486853-3
label: SELECT "Date" FROM "table" WHERE "Opponent" = "Florida Panthers"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   Pick # | CFL Team                          | Player                | Position   | College           |
|---------:|:----------------------------------|:----------------------|:-----------|:------------------|
|       26 | edmonton eskimos (via hamilton)   | andrew brown          | lb         | lafayette college |
|       27 | calgary stampeders (via winnipeg) | riley clayton         | ol         | manitoba          |
|       28 | hamilton tiger-cats (via ottawa)  | chris sutherland      | ol         | saskatchewan      |
|       29 | saskatchewan roughriders          | peter hogarth         | ol         | mcmaster          |
|       30 | calgary stampeders                | gerald commissiong    | rb         | stanford          |
|       31 | toronto argonauts                 | obed cétoute          | wr         | central michigan  |
|       32 | montreal alouettes (via bc)       | ivan birungi          | wr         | acadia            |
|       33 | montreal alouettes                | adrian davis          | dl         | marshall          |
|       34 | edmonton eskimos                  | jean phillipe abraham | lb         | laval             |

Question: which college has a player called Riley Clayton?

table_id: 2-10812938-4
label: SELECT "College" FROM "table" WHERE "Player" = "riley clayton"
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:
| South or west terminus   | North or east terminus   |   First year |   Final year | Notes                                      |
|:-------------------------|:-------------------------|-------------:|-------------:|:-------------------------------------------|
| muskegon                 | detroit                  |         1926 |         1962 | replaced by i-96                           |
| erie                     | port austin              |         1926 |         1973 | replaced by i-75 and m-25                  |
| coldwater                | mackinaw city            |         1926 |         2002 | replaced by i-69 and us127                 |
| niles                    | hagar shores             |         1937 |         1998 | replaced by us31 and m-63                  |
| crystal falls            | covington                |         1926 |         1928 | replaced by us 141                         |
| new buffalo              | detroit                  |         1926 |         1961 | replaced by us 12 when i-94 replaced us 12 |
| indiana state line       | union                    |         1926 |         1935 | replaced by m-205 , now a county road      |

Question: What is the most minimal Final year that has a North or east end of covington?

table_id: 2-16304749-2
label: SELECT MIN("Final year") FROM "table" WHERE "North or east terminus" = "covington"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Player           | Nationality   | Position               | Years for Grizzlies   | School/Club Team        |
|:-----------------|:--------------|:-----------------------|:----------------------|:------------------------|
| hasheem thabeet  | tanzania      | center                 | 2009-2011             | connecticut             |
| john thomas      | united states | forward                | 2005-2006             | minnesota               |
| otis thorpe      | united states | power forward / center | 1997-1998             | providence              |
| cezary trybański | poland        | center                 | 2002-2003             | mks pruszkow ( poland ) |
| jake tsakalidis  | greece        | center                 | 2003-2007             | aek athens ( greece )   |

Question: Which player played for the Grizzlies from 1997-1998?

table_id: 2-16494599-19
label: SELECT "Player" FROM "table" WHERE "Years for Grizzlies" = "1997-1998"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   Round |   Pick # |   Overall | Name               | Position      | College        |
|--------:|---------:|----------:|:-------------------|:--------------|:---------------|
|       1 |       28 |        28 | marcedes lewis     | tight end     | ucla           |
|       2 |       28 |        60 | maurice jones-drew | running back  | ucla           |
|       3 |       16 |        80 | clint ingram       | linebacker    | oklahoma       |
|       5 |       28 |       160 | brent hawkins      | defensive end | illinois state |
|       7 |        5 |       213 | james wyche        | defensive end | syracuse       |
|       7 |       28 |       236 | dee webb           | cornerback    | florida        |

Question: Name the sum of pick # for round less than 1

table_id: 2-15100419-12
label: SELECT SUM("Pick #") FROM "table" WHERE "Round" < 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:
|   Year | Tournament            | Venue                 | Result   | Extra         |
|-------:|:----------------------|:----------------------|:---------|:--------------|
|   2006 | commonwealth games    | melbourne , australia | 2nd      | 4x400 m relay |
|   2006 | african championships | bambous , mauritius   | 5th      | 400 m         |
|   2006 | world cup             | athens , greece       | 6th      | 4x400 m relay |
|   2007 | all-africa games      | algiers , algeria     | 5th      | 400 m         |
|   2007 | all-africa games      | algiers , algeria     | 1st      | 4x400 m relay |

Question: What was the extra info for the Commonwealth Games?

table_id: 2-12954757-1
label: SELECT "Extra" FROM "table" WHERE "Tournament" = "commonwealth games"
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 8, 1985  | at buffalo bills       | w 14–9   |        67597 |
|      2 | september 15, 1985 | seattle seahawks       | l 49–35  |        54420 |
|      3 | september 22, 1985 | at cincinnati bengals  | w 44–41  |        52270 |
|      4 | september 29, 1985 | cleveland browns       | l 21–7   |        52107 |
|      5 | october 6, 1985    | at seattle seahawks    | l 26–21  |        61300 |
|      6 | october 13, 1985   | kansas city chiefs     | w 31–20  |        50067 |
|      7 | october 20, 1985   | at minnesota vikings   | l 21–17  |        61670 |
|      8 | october 28, 1985   | at los angeles raiders | l 34–21  |        69297 |
|      9 | november 3, 1985   | denver broncos         | w 30–10  |        57312 |
|     10 | november 10, 1985  | los angeles raiders    | w 40–34  |        58566 |
|     11 | november 17, 1985  | at denver broncos      | l 30–24  |        74376 |
|     12 | november 24, 1985  | at houston oilers      | l 37–35  |        34336 |
|     13 | december 1, 1985   | buffalo bills          | w 40–7   |        45487 |
|     14 | december 8, 1985   | pittsburgh steelers    | w 54–44  |        52098 |
|     15 | december 15, 1985  | philadelphia eagles    | w 20–14  |        45569 |
|     16 | december 22, 1985  | at kansas city chiefs  | l 38–34  |        18178 |

Question: Can you tell me the lowest Week that has the Attendance smaller than 34,336?

table_id: 2-15378653-1
label: SELECT MIN("Week") FROM "table" WHERE "Attendance" < 34336
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    | League   | Season   | Play-Off   | Baltic        | Events   | European   |
|:--------|:---------|:---------|:-----------|:--------------|:---------|:-----------|
| 2005–06 | nkl      | a-6      | 1/8        | –             | –        | –          |
| 2006–07 | nkl      | b-1      | 1/4        | –             | –        | –          |
| 2007–08 | lkl      | 4        | 4th        | challenge cup | 8th      | –          |
| 2008–09 | lkl      | 9th      | –          | challenge cup | 9th      | –          |
| 2009–10 | lkl      | 11th     | –          | challenge cup | 12th     | –          |
| 2010–11 | lkl      | 13th     | relegated  | challenge cup | 6th      | –          |

Question: Which Play-Off has Events of –, and a Season of a-6?

table_id: 2-14941366-1
label: SELECT "Play-Off" FROM "table" WHERE "Events" = "–" AND "Season" = "a-6"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| School           | Base   | Bask   | Golf   | Soccer   | Swimming   | Tennis   | Indoor track   |
|:-----------------|:-------|:-------|:-------|:---------|:-----------|:---------|:---------------|
| cleveland state  | no     | yes    | yes    | yes      | yes        | yes      | no             |
| detroit          | no     | yes    | yes    | yes      | no         | yes      | yes            |
| green bay        | no     | yes    | yes    | yes      | yes        | yes      | no             |
| milwaukee        | yes    | yes    | no     | yes      | yes        | no       | yes            |
| oakland          | yes    | yes    | yes    | yes      | yes        | no       | yes            |
| uic              | yes    | yes    | no     | yes      | yes        | yes      | yes            |
| valparaiso       | yes    | yes    | yes    | yes      | yes        | yes      | yes            |
| wright state     | yes    | yes    | yes    | yes      | yes        | yes      | yes            |
| youngstown state | yes    | yes    | yes    | no       | no         | yes      | yes            |

Question: What is the basketball status for Valparaiso who has an indoor track status of yes?

table_id: 2-16645083-1
label: SELECT "Bask" FROM "table" WHERE "Indoor track" = "yes" AND "School" = "valparaiso"
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   |   Cores | Frequency   | Turbo    | L2 cache   | L3 cache   | GPU model        | GPU frequency   | Socket    | I/O bus   | Release date   | Part number(s)                 | Release price ( USD )   |
|:---------------|:---------------|--------:|:------------|:---------|:-----------|:-----------|:-----------------|:----------------|:----------|:----------|:---------------|:-------------------------------|:------------------------|
| core i7-4700mq | sr15h(c0)      |       4 | 2.4 ghz     | 8/8/9/10 | 4 × 256 kb | 6 mb       | hd graphics 4600 | 400–1150 mhz    | socket g3 | dmi 2.0   | june 2013      | cw8064701470702                | $383                    |
| core i7-4702mq | sr15j(c0)      |       4 | 2.2 ghz     | 7/7/9/10 | 4 × 256 kb | 6 mb       | hd graphics 4600 | 400–1150 mhz    | socket g3 | dmi 2.0   | june 2013      | cw8064701470802                | $383                    |
| core i7-4800mq | sr15l(c0)      |       4 | 2.7 ghz     | 8/8/9/10 | 4 × 256 kb | 6 mb       | hd graphics 4600 | 400–1300 mhz    | socket g3 | dmi 2.0   | june 2013      | cw8064701471001bx80647i74800mq | $378                    |
| core i7-4900mq | sr15k(c0)      |       4 | 2.8 ghz     | 8/8/9/10 | 4 × 256 kb | 8 mb       | hd graphics 4600 | 400–1300 mhz    | socket g3 | dmi 2.0   | june 2013      | cw8064701470901bx80647i74900mq | $568                    |
| core i7-4930mx | sr15m(c0)      |       4 | 3 ghz       | 7/7/8/9  | 4 × 256 kb | 8 mb       | hd graphics 4600 | 400–1350 mhz    | socket g3 | dmi 2.0   | june 2013      | cw8064701471101                | $1096                   |

Question: what is the sspec number when the part number is cw8064701470802?

table_id: 2-18823880-18
label: SELECT "sSpec number" FROM "table" WHERE "Part number(s)" = "cw8064701470802"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   Year | Competition Description   | Location   | Apparatus   | Rank-Final   |   Score-Final | Rank-Qualifying   |   Score-Qualifying |
|-------:|:--------------------------|:-----------|:------------|:-------------|--------------:|:------------------|-------------------:|
|   2012 | olympics                  | london     | all-around  | 1st          |        116.9  | 1st               |            116     |
|   2012 | olympics                  | london     | ball        | 1st          |         29.2  | 1st               |             29.525 |
|   2012 | olympics                  | london     | ribbon      | 2nd          |         28.9  | 1st               |             29.4   |
|   2012 | olympics                  | london     | hoop        | 1st          |         29.35 | 2nd               |             28.1   |
|   2012 | olympics                  | london     | clubs       | 1st          |         29.45 | 1st               |             28.975 |

Question: What competition had a Rank-Qualifying of 1st and a ball apparatus?

table_id: 2-18385965-2
label: SELECT "Competition Description" FROM "table" WHERE "Rank-Qualifying" = "1st" AND "Apparatus" = "ball"