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:
| Position   | Player                   | Loaned to       | Date             | Loan expires                    |
|:-----------|:-------------------------|:----------------|:-----------------|:--------------------------------|
| df         | juan                     | millwall        | 1 august 2003    | 24 september 2003               |
| df         | sebastian svärd          | copenhagen      | 3 august 2003    | 20 december 2003                |
| df         | moritz volz              | fulham          | 7 august 2003    | end of the season               |
| df         | igors stepanovs          | beveren         | 14 august 2003   | end of the season               |
| mf         | jermaine pennant         | leeds united    | 20 august 2003   | 15 may 2004                     |
| mf         | giovanni van bronckhorst | barcelona       | 26 august 2003   | end of the season               |
| fw         | francis jeffers          | everton         | 1 september 2003 | end of the season               |
| df         | sebastian svärd          | stoke city      | 29 december 2003 | 10 may 2004                     |
| gk         | rami shaaban             | west ham united | 16 january 2004  | week beginning 16 february 2004 |

Question: What player loaned to of Leeds United?

table_id: 2-18424300-5
label: SELECT "Player" FROM "table" WHERE "Loaned to" = "leeds united"
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:
| Wrestler      |   Reign | Date             | Days held   | Location          | Event                                   |   Successful defenses |
|:--------------|--------:|:-----------------|:------------|:------------------|:----------------------------------------|----------------------:|
| erick stevens |       1 | march 10, 2007   | 244         | crystal river, fl | battle for the belts                    |                    12 |
| sal rinauro   |       1 | november 9, 2007 | 337         | crystal river, fl | unstoppable 2007                        |                     4 |
| chris jones   |       1 | october 11, 2008 | 168         | crystal river, fl | impact of honor 2                       |                     2 |
| rhett titus   |       1 | march 28, 2009   | 188         | crystal river, fl | live event                              |                     2 |
| brad allen    |       1 | october 3, 2009  | 301         | crystal river, fl | fallout                                 |                     0 |
| jake manning  |       1 | july 31, 2010    | 455         | crystal river, fl | cage of pain iii                        |                     0 |
| uhaa nation   |       1 | october 29, 2011 | 650         | crystal river, fl | jeff peterson memorial cup 2011 - tag 2 |                     1 |
| gran akuma    |       1 | august 9, 2013   | 176+        | tampa, fl         | headstroke                              |                     2 |

Question: What's the highest reign on march 10, 2007?

table_id: 2-16899750-1
label: SELECT MAX("Reign") FROM "table" WHERE "Date" = "march 10, 2007"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Tournament             | 2006                   | 2007                   | 2008                   | 2009                   | 2011                   | 2012                   |
|:-----------------------|:-----------------------|:-----------------------|:-----------------------|:-----------------------|:-----------------------|:-----------------------|
| grand slam tournaments | grand slam tournaments | grand slam tournaments | grand slam tournaments | grand slam tournaments | grand slam tournaments | grand slam tournaments |
| australian open        | a                      | a                      | a                      | a                      | 1r                     | a                      |
| french open            | a                      | a                      | a                      | a                      | a                      | a                      |
| wimbledon              | 1r                     | a                      | 3r                     | a                      | a                      | a                      |
| us open                | a                      | a                      | a                      | a                      | a                      | a                      |
| win–loss               | 0–1                    | 0–0                    | 2–1                    | 0–0                    | 0–1                    | 0–0                    |

Question: For the Australian Open, in 2007 the result was A, but what was the result in 2012?

table_id: 2-18085907-4
label: SELECT "2012" FROM "table" WHERE "2007" = "a" AND "Tournament" = "australian open"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Home team       | Home team score   | Away team       | Away team score   | Venue          |   Crowd | Date           |
|:----------------|:------------------|:----------------|:------------------|:---------------|--------:|:---------------|
| hawthorn        | 16.14 (110)       | melbourne       | 14.15 (99)        | princes park   |    8850 | 20 august 1977 |
| essendon        | 10.13 (73)        | fitzroy         | 20.17 (137)       | windy hill     |   10180 | 20 august 1977 |
| st kilda        | 11.12 (78)        | north melbourne | 15.16 (106)       | moorabbin oval |   11506 | 20 august 1977 |
| south melbourne | 8.9 (57)          | collingwood     | 12.17 (89)        | lake oval      |   29186 | 20 august 1977 |
| richmond        | 15.13 (103)       | carlton         | 14.16 (100)       | mcg            |   49134 | 20 august 1977 |
| footscray       | 11.19 (85)        | geelong         | 10.8 (68)         | vfl park       |   11010 | 20 august 1977 |

Question: Where was the game played that had an away team score of 20.17 (137)?

table_id: 2-10887379-21
label: SELECT "Venue" FROM "table" WHERE "Away team score" = "20.17 (137)"
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:
| Episode   | First broadcast   | Davids team                         | Lees team                                   | Scores   |
|:----------|:------------------|:------------------------------------|:--------------------------------------------|:---------|
| 4x01      | 23 july 2010      | fern britton and richard e. grant   | sanjeev bhaskar and martin clunes           | 5–6      |
| 4x02      | 30 july 2010      | ruth jones and jason manford        | jack dee and peter serafinowicz             | 8–3      |
| 4x03      | 6 august 2010     | keeley hawes and stephen mangan     | kevin bridges and professor brian cox       | 7–4      |
| 4x04      | 13 august 2010    | ben fogle and craig revel horwood   | hugh dennis and kate silverton              | 3–8      |
| 4x06      | 27 august 2010    | rhod gilbert and miranda hart       | hugh fearnley-whittingstall and rufus hound | 4–5      |
| 4x07      | 3 september 2010  | bernard cribbins and patrick kielty | deborah meaden and mark watson              | 7–5      |

Question: Who is on the David's Team for the episode with the Lees Team of Jack Dee and Peter Serafinowicz

table_id: 1-23575917-4
label: SELECT "Davids team" FROM "table" WHERE "Lees team" = "Jack Dee and Peter Serafinowicz"
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 28, 1951 | new york yanks         | w 54-14  |        30315 |
|      2 | october 7, 1951    | cleveland browns       | l 38-23  |        67186 |
|      3 | october 14, 1951   | at detroit lions       | w 27-21  |        50567 |
|      4 | october 21, 1951   | at green bay packers   | w 28-0   |        21393 |
|      5 | october 28, 1951   | at san francisco 49ers | l 44-17  |        49538 |
|      6 | november 4, 1951   | san francisco 49ers    | w 23-16  |        54346 |
|      7 | november 11, 1951  | chicago cardinals      | w 45-21  |        29995 |
|      8 | november 18, 1951  | new york yanks         | w 48-21  |        34717 |
|      9 | november 25, 1951  | at washington redskins | l 31-21  |        26307 |
|     10 | december 2, 1951   | at chicago bears       | w 42-17  |        50286 |
|     11 | december 9, 1951   | detroit lions          | l 24-22  |        52937 |
|     12 | december 16, 1951  | green bay packers      | w 42-14  |        23698 |

Question: Which Attendance has a Date of november 18, 1951?

table_id: 2-11172634-1
label: SELECT "Attendance" FROM "table" WHERE "Date" = "november 18, 1951"
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:
|   Goal | Date              | Venue                           | Score   | Result   | Competition                    |
|-------:|:------------------|:--------------------------------|:--------|:---------|:-------------------------------|
|      1 | 11 september 2008 | hongkou stadium , shanghai      | 1 – 1   | 1–1      | 2010 fifa world cup qualifiers |
|      2 | 11 october 2008   | suwon world cup stadium , suwon | 1 – 0   | 3–0      | friendly international         |
|      3 | 6 june 2009       | al-maktoum stadium , dubai      | 2 – 0   | 2–0      | 2010 fifa world cup qualifiers |
|      4 | 14 october 2009   | seoul world cup stadium , seoul | 1 – 0   | 2–0      | friendly international         |
|      5 | 25 january 2011   | al-gharafa stadium , doha       | 1 – 0   | 2–2      | 2011 afc asian cup             |

Question: Which Venue has a Goal larger than 3, and a Competition of 2011 afc asian cup?

table_id: 2-13182410-1
label: SELECT "Venue" FROM "table" WHERE "Goal" > 3 AND "Competition" = "2011 afc asian cup"
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                                       | Height   | Weight   | Spike   | 2008 club           |
|:-------------------------------------------|:---------|:---------|:--------|:--------------------|
| bruno category:articles with hcards        | m ()     | kg (lb)  | cm (in) | cimed               |
| marcelinho category:articles with hcards   | m ()     | kg (lb)  | cm (in) | panathinaikos vc    |
| andré heller category:articles with hcards | m ()     | kg (lb)  | cm (in) | pallavolo modena    |
| samuel fuchs category:articles with hcards | m ()     | kg (lb)  | cm (in) | lokomotiv belgorod  |
| giba category:articles with hcards         | m ()     | kg (lb)  | cm (in) | iskra odintsovo     |
| murilo category:articles with hcards       | m ()     | kg (lb)  | cm (in) | pallavolo modena    |
| andré category:articles with hcards        | m ()     | kg (lb)  | cm (in) | pallavolo modena    |
| sérgio category:articles with hcards       | m ()     | kg (lb)  | cm (in) | copra nordmeccanica |
| anderson category:articles with hcards     | m ()     | kg (lb)  | cm (in) | sport club ulbra    |
| gustavo category:articles with hcards      | m ()     | kg (lb)  | cm (in) | sisley treviso      |
| rodrigão category:articles with hcards     | m ()     | kg (lb)  | cm (in) | lube banca marche   |
| dante category:articles with hcards        | m ()     | kg (lb)  | cm (in) | panathinaikos vc    |

Question: What is the Weight of the Player with Copra Nordmeccanica 2008 Club?

table_id: 2-18499677-7
label: SELECT "Weight" FROM "table" WHERE "2008 club" = "copra nordmeccanica"
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 | Team                      |   Men's |   Women's |   Total |
|-------:|:--------------------------|--------:|----------:|--------:|
|      1 | ust growling tigers       |     165 |       140 |     305 |
|      2 | de la salle green archers |     113 |       139 |     252 |
|      3 | feu tamaraws              |     109 |       120 |     229 |
|      4 | ateneo blue eagles        |     113 |       109 |     222 |
|      5 | up fighting maroons       |     109 |       110 |     219 |
|      6 | ue red warriors           |     106 |        75 |     181 |
|      7 | adamson falcons           |      39 |        62 |     101 |
|      8 | nu bulldogs               |      25 |        19 |      44 |

Question: How many times is the team nu bulldogs and the women's is less than 19?

table_id: 2-18434466-26
label: SELECT COUNT("Rank") FROM "table" WHERE "Team" = "nu bulldogs" AND "Women''s" < 19
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   | Competition            | Round   | Opponent            | Home   | Away   | Agg.      |
|:---------|:-----------------------|:--------|:--------------------|:-------|:-------|:----------|
| 1964–65  | inter-cities fairs cup | r1      | gak                 | 3–2    | 6–0    | 9–2       |
| 1964–65  | inter-cities fairs cup | r2      | roma                | 1–1    | 0–1    | 1–2       |
| 1965–66  | inter-cities fairs cup | r1      | rfc liège           | 2–0    | 0–1    | 2–1       |
| 1965–66  | inter-cities fairs cup | r2      | steagul roşu braşov | 2–2    | 0–1    | 2–3       |
| 1969–70  | inter-cities fairs cup | r1      | charleroi           | 1–3    | 1–2    | 2–5       |
| 1995–96  | intertoto cup          | group 6 | lask linz           | 0–0    | –      | –         |
| 1995–96  | intertoto cup          | group 6 | keflavík            | –      | 0–0    | –         |
| 1995–96  | intertoto cup          | group 6 | metz                | 0–1    | –      | –         |
| 1995–96  | intertoto cup          | group 6 | partick thistle     | –      | 2–1    | –         |
| 1997–98  | cup winners' cup       | qr      | sloga jugomagnat    | 2–0    | 2–1    | 4–1       |
| 1997–98  | cup winners' cup       | r1      | tromsø              | 3–2    | 2–4    | 5–6       |
| 2001–02  | intertoto cup          | r1      | pobeda              | 1–2    | 1–1    | 2–3       |
| 2002–03  | champions league       | qr2     | zalaegerszeg        | 2–1    | 0–1    | 2–2 ( a ) |
| 2003–04  | intertoto cup          | r1      | koper               | 2–2    | 0–1    | 2–3       |
| 2007–08  | intertoto cup          | r1      | vllaznia shkodër    | 2–1    | 0–1    | 2–2 ( a ) |

Question: What was the aggregate total for the match against Koper?

table_id: 2-1609836-3
label: SELECT "Agg." FROM "table" WHERE "Opponent" = "koper"
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:
| Institution                          | Main Campus Location   |   Founded | Mascot      | School Colors          |
|:-------------------------------------|:-----------------------|----------:|:------------|:-----------------------|
| allen community college              | iola                   |      1923 | red devils  | scarlet & black        |
| coffeyville community college        | coffeyville            |      1923 | red ravens  | red & white            |
| cowley college                       | arkansas city          |      1922 | tigers      | orange & black         |
| fort scott community college         | fort scott             |      1919 | greyhounds  | maroon & grey          |
| highland community college           | highland               |      1858 | scotties    | navy & gold            |
| independence community college       | independence           |      1925 | pirates     | navy blue & vegas gold |
| johnson county community college     | overland park          |      1967 | cavaliers   | maroon & gold          |
| kansas city kansas community college | kansas city            |      1923 | blue devils | blue, red & white      |
| labette community college            | parsons                |      1923 | cardinals   | red & white            |

Question: What is the name of the institution with the mascot of blue devils?

table_id: 1-12434380-1
label: SELECT "Institution" FROM "table" WHERE "Mascot" = "Blue Devils"
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 | Team                        |   Wins |   Points | Championship Finish   |
|-------:|:----------------------------|-------:|---------:|:----------------------|
|   1985 | dick simon racing           |      0 |       10 | 30th                  |
|   1986 | dick simon racing           |      0 |       54 | 13th                  |
|   1987 | granatelli                  |      0 |        8 | 27th                  |
|   1988 | shierson racing             |      0 |       89 | 8th                   |
|   1989 | shierson racing             |      0 |       68 | 11th                  |
|   1990 | truesports                  |      0 |       42 | 12th                  |
|   1992 | dick simon racing           |      0 |       80 | 9th                   |
|   1993 | dick simon racing           |      0 |      132 | 5th                   |
|   1994 | dick simon racing           |      0 |       90 | 7th                   |
|   1995 | rahal-hogan racing          |      0 |       48 | 16th                  |
|   1996 | team green                  |      0 |       17 | 22nd                  |
|   1997 | patrick racing              |      0 |       91 | 10th                  |
|   1999 | green / all american racers |      0 |        1 | 32nd                  |

Question: What is the lowest win number of the competitor who had 90 points before 1994?

table_id: 2-1226543-3
label: SELECT MIN("Wins") FROM "table" WHERE "Points" = 90 AND "Year" < 1994
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 (class)     | Vacator                  | Reason for change                  | Successor                  | Date of successors formal installation   |
|:------------------|:-------------------------|:-----------------------------------|:---------------------------|:-----------------------------------------|
| new hampshire (2) | styles bridges (r)       | died november 26, 1961             | maurice j. murphy, jr. (r) | january 10, 1962                         |
| kansas (2)        | andrew f. schoeppel (r)  | died january 21, 1962              | james b. pearson (r)       | january 31, 1962                         |
| south dakota (3)  | francis h. case (r)      | died june 23, 1962                 | joseph h. bottum (r)       | july 9, 1962                             |
| idaho (2)         | henry dworshak (r)       | died july 23, 1962                 | leonard b. jordan (r)      | august 6, 1962                           |
| massachusetts (1) | benjamin a. smith ii (d) | successor elected november 6, 1962 | ted kennedy (d)            | november 7, 1962                         |
| new mexico (1)    | dennis chavez (d)        | died november 18, 1962             | edwin l. mechem (r)        | november 30, 1962                        |

Question: How many total reason for change are listed corresponding to the successor Leonard B. Jordan (r)?

table_id: 1-1802522-3
label: SELECT COUNT("Reason for change") FROM "table" WHERE "Successor" = "Leonard B. Jordan (R)"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| District        | Incumbent       | Party           | First elected         | Result                           | Candidates                                         |
|:----------------|:----------------|:----------------|:----------------------|:---------------------------------|:---------------------------------------------------|
| pennsylvania 2  | john sergeant   | anti-jacksonian | 1816 1827 ( special ) | lost re-election jacksonian gain | joseph hemphill (j) 54.2% john sergeant (aj) 45.8% |
| pennsylvania 6  | innis green     | jacksonian      | 1826                  | re-elected                       | innis green (j) 72.0% valentine hummel (aj) 28.0%  |
| pennsylvania 10 | adam king       | jacksonian      | 1826                  | re-elected                       | adam king (j) 63.2% william mcilvine (aj) 36.8%    |
| pennsylvania 14 | andrew stewart  | anti-jacksonian | 1820                  | lost re-election jacksonian gain | thomas irwin (j) 56.3% andrew stewart (aj) 43.7%   |
| pennsylvania 17 | richard coulter | jacksonian      | 1826                  | re-elected                       | richard coulter (j) 100%                           |

Question:  What party was represented by incumbent Richard Coulter ? 

table_id: 1-2668243-20
label: SELECT "Party" FROM "table" WHERE "Incumbent" = "Richard Coulter"
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:
| Tie no   | Home team           | Score   | Away team            | Date             |
|:---------|:--------------------|:--------|:---------------------|:-----------------|
| 1        | middlesbrough       | 2–0     | bolton wanderers     | 27 february 1978 |
| 2        | derby county        | 2–3     | west bromwich albion | 22 february 1978 |
| 3        | wrexham             | 1–1     | blyth spartans       | 18 february 1978 |
| replay   | blyth spartans      | 1–2     | wrexham              | 27 february 1978 |
| 4        | queens park rangers | 1–1     | nottingham forest    | 18 february 1978 |
| replay   | nottingham forest   | 1–1     | queens park rangers  | 27 february 1978 |
| replay   | nottingham forest   | 3–1     | queens park rangers  | 2 march 1978     |
| 5        | bristol rovers      | 2–2     | ipswich town         | 18 february 1978 |
| replay   | ipswich town        | 3–0     | bristol rovers       | 28 february 1978 |
| 6        | millwall            | 2–1     | notts county         | 18 february 1978 |
| 7        | arsenal             | 4–1     | walsall              | 18 february 1978 |
| 8        | orient              | 0–0     | chelsea              | 18 february 1978 |
| replay   | chelsea             | 1–2     | orient               | 27 february 1978 |

Question: What home team has 6 as the tie no.?

table_id: 2-18675114-5
label: SELECT "Home team" FROM "table" WHERE "Tie no" = "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:
| Home team   | Home team score   | Away team       | Away team score   | Venue          |   Crowd | Date          |
|:------------|:------------------|:----------------|:------------------|:---------------|--------:|:--------------|
| geelong     | 19.15 (129)       | hawthorn        | 12.12 (84)        | kardinia park  |   13000 | 19 april 1947 |
| essendon    | 16.23 (119)       | south melbourne | 10.8 (68)         | windy hill     |   19000 | 19 april 1947 |
| collingwood | 20.18 (138)       | fitzroy         | 14.8 (92)         | victoria park  |   24000 | 19 april 1947 |
| carlton     | 17.20 (122)       | melbourne       | 16.13 (109)       | princes park   |   24000 | 19 april 1947 |
| richmond    | 18.27 (135)       | north melbourne | 15.14 (104)       | punt road oval |   20000 | 19 april 1947 |
| st kilda    | 12.16 (88)        | footscray       | 22.17 (149)       | junction oval  |   14000 | 19 april 1947 |

Question: What is the size of the biggest crowd for a game where Fitzroy was the away team?

table_id: 2-10809444-1
label: SELECT MAX("Crowd") FROM "table" WHERE "Away team" = "fitzroy"
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:
| Distance            | Time                | Date                | Location            | Notes                       |
|:--------------------|:--------------------|:--------------------|:--------------------|:----------------------------|
| men's speed skating | men's speed skating | men's speed skating | men's speed skating | men's speed skating         |
| distance            | time                | date                | location            | notes                       |
| 500 m               | 45.7                | 1931-02-01          | davos               | davos eisstadion            |
| 1,000 m             | 1:35.6              | 1930-01-11          | davos               | eisstadion                  |
| 1,500 m             | 2:27.9              | 1928-02-14          | st. moritz          | st. moritz olympic ice rink |
| 3,000 m             | 5:51.2              | 1932-01-08          | davos               | eisstadion                  |
| 5,000 m             | 9:04.3              | 1931-02-02          | davos               | eisstadion                  |
| 10,000 m            | 19:10.2             | 1928-02-05          | davos               | eisstadion                  |

Question: Which Date has a Location of davos, and a Time of 45.7?

table_id: 2-17520230-1
label: SELECT "Date" FROM "table" WHERE "Location" = "davos" AND "Time" = "45.7"
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           | Location       | Mascot    |   Enrollment | IHSAA Class   | County        |   Year Joined |
|:-----------------|:---------------|:----------|-------------:|:--------------|:--------------|--------------:|
| crawfordsville   | crawfordsville | athenians |          726 | aaa           | 54 montgomery |          1967 |
| danville         | danville       | warriors  |          811 | aaaa          | 32 hendricks  |          1999 |
| frankfort        | frankfort      | hot dogs  |         1006 | aaaa          | 12 clinton    |          1967 |
| lebanon          | lebanon        | tigers    |         1043 | aaaa          | 06 boone      |          1967 |
| north montgomery | linden         | chargers  |          684 | aaa           | 54 montgomery |          1974 |
| south montgomery | crafordsville  | mounties  |          625 | aaa           | 54 montgomery |          1985 |
| tri-west         | lizton         | bruins    |          604 | aaa           | 32 hendricks  |          1999 |
| western boone    | thorntown      | stars     |          902 | aaa           | 06 boone      |          1983 |

Question: When did crawfordsville join?

table_id: 2-18926196-1
label: SELECT MAX("Year Joined") FROM "table" WHERE "Location" = "crawfordsville"