MMTU-benchmark/MMTU huggingface dataset:
Task: NL2SQL (source dataset: Spider)

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.

Database:
movie_2

Tables:

Table: Movies
|   Code | Title                   | Rating   |
|-------:|:------------------------|:---------|
|      1 | Citizen Kane            | PG       |
|      2 | Singin' in the Rain     | G        |
|      3 | The Wizard of Oz        | G        |
|      4 | The Quiet Man           |          |
|      5 | North by Northwest      |          |
|      6 | The Last Tango in Paris | NC-17    |
|      7 | Some Like it Hot        | PG-13    |
|      8 | A Night at the Opera    |          |


Table: MovieTheaters
|   Code | Name        | Movie   |
|-------:|:------------|:--------|
|      1 | Odeon       | 5.0     |
|      2 | Imperial    | 1.0     |
|      3 | Majestic    |         |
|      4 | Royale      | 6.0     |
|      5 | Paraiso     | 3.0     |
|      6 | Nickelodeon |         |


Question: What are the names of every movie that is not playing at the Odeon theater?

db_id: movie_2
tables: name: Movies
data: Movies.csv
name: MovieTheaters
data: MovieTheaters.csv
label: SELECT title FROM movies EXCEPT SELECT T1.title FROM movies AS T1 JOIN movietheaters AS T2 ON T1.code  =  T2.movie WHERE T2.name  =  'Odeon'
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/movie_2/movie_2.sqlite
Task: NL2SQL (source dataset: Spider)

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.

Database:
movie_2

Tables:

Table: Movies
|   Code | Title                   | Rating   |
|-------:|:------------------------|:---------|
|      1 | Citizen Kane            | PG       |
|      2 | Singin' in the Rain     | G        |
|      3 | The Wizard of Oz        | G        |
|      4 | The Quiet Man           |          |
|      5 | North by Northwest      |          |
|      6 | The Last Tango in Paris | NC-17    |
|      7 | Some Like it Hot        | PG-13    |
|      8 | A Night at the Opera    |          |


Table: MovieTheaters
|   Code | Name        | Movie   |
|-------:|:------------|:--------|
|      1 | Odeon       | 5.0     |
|      2 | Imperial    | 1.0     |
|      3 | Majestic    |         |
|      4 | Royale      | 6.0     |
|      5 | Paraiso     | 3.0     |
|      6 | Nickelodeon |         |


Question: What are the movie names sorted by rating?

db_id: movie_2
tables: name: Movies
data: Movies.csv
name: MovieTheaters
data: MovieTheaters.csv
label: SELECT title FROM movies ORDER BY rating
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/movie_2/movie_2.sqlite
Task: NL2SQL (source dataset: Spider)

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.

Database:
warehouse_1

Tables:

Table: Warehouses
|   Code | Location      |   Capacity |
|-------:|:--------------|-----------:|
|      1 | Chicago       |          3 |
|      2 | Chicago       |          4 |
|      3 | New York      |          7 |
|      4 | Los Angeles   |          2 |
|      5 | San Francisco |          8 |


Table: Boxes
| Code   | Contents   |   Value |   Warehouse |
|:-------|:-----------|--------:|------------:|
| 0MN7   | Rocks      |     180 |           3 |
| 4H8P   | Rocks      |     250 |           1 |
| 4RT3   | Scissors   |     190 |           4 |
| 7G3H   | Rocks      |     200 |           1 |
| 8JN6   | Papers     |      75 |           1 |
| 8Y6U   | Papers     |      50 |           3 |
| 9J6F   | Papers     |     175 |           2 |
| LL08   | Rocks      |     140 |           4 |
| P0H6   | Scissors   |     125 |           1 |
| P2T6   | Scissors   |     150 |           2 |


Question: For each location, what are the total, average, and maximum capacities of warehouses?

db_id: warehouse_1
tables: name: Warehouses
data: Warehouses.csv
name: Boxes
data: Boxes.csv
label: SELECT sum(capacity) ,  avg(capacity) ,  max(capacity) ,  LOCATION FROM warehouses GROUP BY LOCATION
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/warehouse_1/warehouse_1.sqlite
Task: NL2SQL (source dataset: Spider)

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.

Database:
movie_2

Tables:

Table: Movies
|   Code | Title                   | Rating   |
|-------:|:------------------------|:---------|
|      1 | Citizen Kane            | PG       |
|      2 | Singin' in the Rain     | G        |
|      3 | The Wizard of Oz        | G        |
|      4 | The Quiet Man           |          |
|      5 | North by Northwest      |          |
|      6 | The Last Tango in Paris | NC-17    |
|      7 | Some Like it Hot        | PG-13    |
|      8 | A Night at the Opera    |          |


Table: MovieTheaters
|   Code | Name        | Movie   |
|-------:|:------------|:--------|
|      1 | Odeon       | 5.0     |
|      2 | Imperial    | 1.0     |
|      3 | Majestic    |         |
|      4 | Royale      | 6.0     |
|      5 | Paraiso     | 3.0     |
|      6 | Nickelodeon |         |


Question: Find the name of the movie that is played in the most number of theaters.

db_id: movie_2
tables: name: Movies
data: Movies.csv
name: MovieTheaters
data: MovieTheaters.csv
label: SELECT T1.title FROM movies AS T1 JOIN movietheaters AS T2 ON T1.code  =  T2.movie GROUP BY T1.title ORDER BY count(*) DESC LIMIT 1
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/movie_2/movie_2.sqlite
Task: NL2SQL (source dataset: Spider)

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.

Database:
book_review

Tables:

Table: book
|   Book_ID | Title                | Type   |   Pages |   Chapters | Audio   | Release       |
|----------:|:---------------------|:-------|--------:|-----------:|:--------|:--------------|
|         1 | A Game of Thrones    | Novel  |     704 |         73 | 33h 53m | August 1996   |
|         2 | A Clash of Kings     | Novel  |     768 |         70 | 37h 17m | February 1999 |
|         3 | A Storm of Swords    | Novel  |     992 |         82 | 47h 37m | November 2000 |
|         4 | A Feast for Crows    | Novel  |     753 |         46 | 31h 10m | November 2005 |
|         5 | A Dance with Dragons | Poet   |    1056 |         73 | 48h 56m | July 2011     |


Table: review
|   Review_ID |   Book_ID |   Rating |   Readers_in_Million |   Rank |
|------------:|----------:|---------:|---------------------:|-------:|
|           1 |         1 |      6.6 |                  3.3 |     16 |
|           2 |         3 |      5.7 |                  2.8 |     25 |
|           3 |         4 |      5.8 |                  2.6 |     26 |
|           4 |         5 |      5.6 |                  2.4 |     35 |


Question: What is the rating of the book with the largest number of chapters?

db_id: book_review
tables: name: book
data: book.csv
name: review
data: review.csv
label: SELECT T2.Rating FROM book AS T1 JOIN review AS T2 ON T1.Book_ID  =  T2.Book_ID ORDER BY T1.Chapters DESC LIMIT 1
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/book_review/book_review.sqlite
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                                         |
|:-----------------|:-----------------|:-----------|----------------:|:-----------|:---------------------------------------------------|
| massachusetts 2  | edward boland    | democratic |            1952 | re-elected | edward boland (d) unopposed                        |
| massachusetts 3  | philip philbin   | democratic |            1942 | re-elected | philip philbin (d) unopposed                       |
| massachusetts 6  | william h. bates | republican |            1950 | re-elected | william h. bates (r) unopposed                     |
| massachusetts 7  | thomas j. lane   | democratic |            1941 | re-elected | thomas j. lane (d) 75.6% robert t. breed (r) 24.4% |
| massachusetts 11 | tip o'neill      | democratic |            1952 | re-elected | tip o'neill (d) 80.4% elliott h. stone (r) 19.6%   |

Question: What is the last year that someone is first elected in this table?

table_id: 1-1341930-21
label: SELECT MAX("First elected") FROM "table"
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 | Name                   |   Played |   Drawn |   Lost |   Points |
|-----------:|:-----------------------|---------:|--------:|-------:|---------:|
|          1 | ehc bayreuth (n)       |       14 |       2 |      1 |       24 |
|          2 | esv würzburg           |       14 |       3 |      1 |       23 |
|          3 | erc ingolstadt ii      |       14 |       3 |      3 |       19 |
|          4 | ec amberg (n)          |       14 |       2 |      4 |       18 |
|          5 | ehc regensburg         |       14 |       2 |      7 |       12 |
|          6 | ec erkersreuth (r)     |       14 |       2 |      7 |       12 |
|          7 | deggendorfer sc ii     |       14 |       1 |     12 |        3 |
|          8 | ec pfaffenhofen ii (n) |       14 |       1 |     13 |        0 |

Question: What is the whole of Drawn that has a Lost of 4?

table_id: 2-16566850-25
label: SELECT SUM("Drawn") FROM "table" WHERE "Lost" = 4
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 # | US air date              | Rating   | Share   | Rating/Share (18–49)   |   Viewers (millions) |
|------------:|:-------------------------|:---------|:--------|:-----------------------|---------------------:|
|           1 | thursday, april 9, 2009  | 6.5      | 11      | 2.6/8                  |                10.21 |
|           2 | thursday, april 16, 2009 | 5.1      | 9       | 2.2/6                  |                 7.82 |
|           3 | thursday, april 23, 2009 | 4.7      | 9       | 1.9/5                  |                 7.02 |
|           4 | saturday, may 2, 2009    | 3.1      | 6       | 1.0/3                  |                 4.61 |
|           5 | saturday, may 9, 2009    | 3.1      | 6       | 1.1/3                  |                 4.6  |
|           6 | saturday, may 23, 2009   | 2.5      | 5       | 1.0/4                  |                 3.85 |
|           7 | saturday, may 30, 2009   | 2.4      | 5       | 0.9/3                  |                 3.62 |
|           8 | saturday, june 6, 2009   | 2.4      | 5       | 0.9/3                  |                 3.56 |
|           9 | saturday, june 13, 2009  | 2.0      | 4       | 0.8/3                  |                 3.2  |
|          10 | saturday, june 20, 2009  | tba      | tba     | 0.9/4                  |                 3.79 |
|          11 | saturday, june 27, 2009  | 2.4      | 5       | 0.8/3                  |                 3.53 |
|          12 | saturday, july 11, 2009  | 2.4      | 5       | 0.8/3                  |                 3.63 |

Question: What is the rating of the episode with a rating/share of 0.9/4?

table_id: 1-17525955-2
label: SELECT "Rating" FROM "table" WHERE "Rating/Share (18–49)" = "0.9/4"
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:
|   Track no. | Track                    | Original Artist   | Soloist(s)                                   | Vocal Percussionist             | Arranger(s)    |
|------------:|:-------------------------|:------------------|:---------------------------------------------|:--------------------------------|:---------------|
|           1 | does your mother know    | abba              | nick barstow                                 | danny swift                     | alexei kalveks |
|           2 | in my head               | jason_derülo      | ollie stephenson, chris bland                | alexei kalveks                  | alexei kalveks |
|           3 | beautiful day / firework | u2 / katy perry   | dave brennan, james kay, laurie cottam       | alexei kalveks and dave brennan | nick barstow   |
|           4 | no diggity               | blackstreet       | nick fletcher, selali fiamanya, dave brennan | samuel swinnterton              | ben woodgates  |
|           5 | mustang sally            | wilson pickett    | danny swift                                  | ollie stephenson                | ben woodgates  |
|           6 | she's always a woman     | billy joel        | alexei kalveks                               | unknown                         | alexei kalveks |

Question: What is the original artist when the vocal percussionist is Alexei Kalveks?

table_id: 1-28715942-5
label: SELECT "Original Artist" FROM "table" WHERE "Vocal Percussionist" = "Alexei Kalveks"
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:
| Couple             |   Week 1 |   Week 2 |   Week 3 | Week 4     | Week 5     | Week 6       | Week 7       | Week 8 Final       |
|:-------------------|---------:|---------:|---------:|:-----------|:-----------|:-------------|:-------------|:-------------------|
| mikk & olga        |       22 |       27 |       32 | 36         | 32         | 36 + 36 = 72 | 40 + 40 = 80 | 37 + 39 + 40 = 116 |
| gerli & martin     |       19 |       28 |       34 | 32         | 38         | 38 + 38 = 76 | 40 + 37 = 77 | 36 + 39 + 40 = 115 |
| erki & ave         |       17 |       20 |       28 | 29         | 30         | 28 + 36 = 64 | 37 + 38 = 75 | eliminated         |
| aivar & kristina   |       12 |       16 |       26 | 24         | 20         | 28 + 27 = 55 | eliminated   | eliminated         |
| vilja & veiko      |       20 |       15 |       22 | 26         | 21         | eliminated   | eliminated   | eliminated         |
| ingrid & aleksandr |       19 |       23 |       28 | 26         | eliminated | eliminated   | eliminated   | eliminated         |
| reet & eduard      |       13 |       19 |       26 | eliminated | eliminated | eliminated   | eliminated   | eliminated         |

Question: Which couple had a week 2 score of exactly 23?

table_id: 1-28946565-2
label: SELECT "Couple" FROM "table" WHERE "Week 2" = 23
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
| Place   | Player              | Country          |   Score | To par   |
|:--------|:--------------------|:-----------------|--------:|:---------|
| 1       | justin rose         | england          |      67 | –5       |
| t2      | chris dimarco       | united states    |      69 | –3       |
| t2      | jay haas            | united states    |      69 | –3       |
| t4      | ernie els           | south africa     |      70 | –2       |
| t4      | alex čejka          | germany          |      70 | –2       |
| t4      | chris riley         | united states    |      70 | –2       |
| t4      | darren clarke       | northern ireland |      70 | –2       |
| t8      | k. j. choi          | south korea      |      71 | –1       |
| t8      | charles howell iii  | united states    |      71 | –1       |
| t8      | bernhard langer     | germany          |      71 | –1       |
| t8      | colin montgomerie   | scotland         |      71 | –1       |
| t8      | josé maría olazábal | spain            |      71 | –1       |
| t8      | phillip price       | wales            |      71 | –1       |
| t8      | kirk triplett       | united states    |      71 | –1       |

Question: What's k. j. choi's to par?

table_id: 2-16457250-4
label: SELECT "To par" FROM "table" WHERE "Player" = "k. j. choi"
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:
| Tone               | Standard Thai   | Phonemic   | Phonetic   | Example meaning in English   |
|:-------------------|:----------------|:-----------|:-----------|:-----------------------------|
| high               | ผ่า              | /pʰáː/     | [pʰaː˥˥]   | to split                     |
| mid rising-falling | ปลา             | /plâː/     | [plaː˧˦˧]  | fish                         |
| low-rising         | ถ้า              | /tʰǎː/     | [tʰaː˩˦]   | landing                      |
| mid-high           | ห้า              | /haː/      | [haː˦˦]    | five                         |
| low                | ค้า              | /kʰàː/     | [kʰaː˩˩]   | to trade                     |

Question: Which tone has a Standard Thai at ปลา?

table_id: 2-1517041-1
label: SELECT "Tone" FROM "table" WHERE "Standard Thai" = "ปลา"
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:
| Coach            | Years            |   Seasons | Record   |   Winning % |
|:-----------------|:-----------------|----------:|:---------|------------:|
| frank haith      | 2011–present     |         2 | 52-14    |       0.788 |
| mike anderson    | 2006-11          |         5 | 111-57   |       0.661 |
| melvin watkins * | 2005–06          |         1 | 2–5      |       0.286 |
| quin snyder      | 1999–2005        |         6 | 126–91   |       0.58  |
| norm stewart     | 1967–99          |        32 | 634–333  |       0.656 |
| bob vanatta      | 1962–67          |         5 | 42–80    |       0.344 |
| wilbur stalcup   | 1946–62          |        16 | 195–179  |       0.521 |
| george edwards   | 1926–46          |        20 | 181–172  |       0.513 |
| george bond      | 1922–26          |         4 | 34–38    |       0.472 |
| craig ruby       | 1920–22          |         2 | 33–2     |       0.933 |
| walter meanwell  | 1917–18, 1919–20 |         2 | 34–2     |       0.944 |
| john miller      | 1916–17, 1918–19 |         2 | 26–7     |       0.788 |
| eugene van gent  | 1914–16          |         2 | 21–9     |       0.7   |
| osmond f. field  | 1911–14          |         3 | 22–27    |       0.449 |
| chester brewer   | 1910–11          |         1 | 5–7      |       0.417 |
| guy lowman       | 1908–10          |         2 | 19–15    |       0.559 |
| a. m. ebright    | 1907–08          |         1 | 8–10     |       0.444 |
| isadore anderson | 1906–07          |         1 | 10–6     |       0.625 |

Question: what is the winning % for the years 2006-11?

table_id: 2-16201038-1
label: SELECT "Winning %" FROM "table" WHERE "Years" = "2006-11"
Task: NL2SQL (source dataset: WikiSQL)

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

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

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

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

Table:
|   Episode # | US air date              | Rating   | Share   | Rating/Share (18–49)   |   Viewers (millions) |
|------------:|:-------------------------|:---------|:--------|:-----------------------|---------------------:|
|           1 | thursday, april 9, 2009  | 6.5      | 11      | 2.6/8                  |                10.21 |
|           2 | thursday, april 16, 2009 | 5.1      | 9       | 2.2/6                  |                 7.82 |
|           3 | thursday, april 23, 2009 | 4.7      | 9       | 1.9/5                  |                 7.02 |
|           4 | saturday, may 2, 2009    | 3.1      | 6       | 1.0/3                  |                 4.61 |
|           5 | saturday, may 9, 2009    | 3.1      | 6       | 1.1/3                  |                 4.6  |
|           6 | saturday, may 23, 2009   | 2.5      | 5       | 1.0/4                  |                 3.85 |
|           7 | saturday, may 30, 2009   | 2.4      | 5       | 0.9/3                  |                 3.62 |
|           8 | saturday, june 6, 2009   | 2.4      | 5       | 0.9/3                  |                 3.56 |
|           9 | saturday, june 13, 2009  | 2.0      | 4       | 0.8/3                  |                 3.2  |
|          10 | saturday, june 20, 2009  | tba      | tba     | 0.9/4                  |                 3.79 |
|          11 | saturday, june 27, 2009  | 2.4      | 5       | 0.8/3                  |                 3.53 |
|          12 | saturday, july 11, 2009  | 2.4      | 5       | 0.8/3                  |                 3.63 |

Question: How many episodes aired Saturday, July 11, 2009

table_id: 1-17525955-2
label: SELECT COUNT("Episode #") FROM "table" WHERE "US air date" = "Saturday, July 11, 2009"
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:
| Rider              | Bike                |   Laps | Time       |   Grid |
|:-------------------|:--------------------|-------:|:-----------|-------:|
| noriyuki haga      | yamaha yzf-r1       |     23 | 38:35.353  |      4 |
| max biaggi         | suzuki gsx-r1000 k7 |     23 | +3.518     |      6 |
| fonsi nieto        | kawasaki zx-10r     |     23 | +9.142     |      9 |
| troy corser        | yamaha yzf-r1       |     23 | +9.257     |      3 |
| troy bayliss       | ducati 999 f07      |     23 | +12.825    |      7 |
| james toseland     | honda cbr1000rr     |     23 | +19.316    |      1 |
| roberto rolfo      | honda cbr1000rr     |     23 | +20.994    |     11 |
| régis laconi       | kawasaki zx-10r     |     23 | +22.452    |      8 |
| michel fabrizio    | honda cbr1000rr     |     23 | +22.505    |     12 |
| ruben xaus         | ducati 999 f06      |     23 | +28.352    |     10 |
| karl muggeridge    | honda cbr1000rr     |     23 | +44.333    |     16 |
| yoann tiberio      | honda cbr1000rr     |     23 | +48.077    |     14 |
| guillaume dietrich | suzuki gsx-r1000 k6 |     23 | +1:23.307  |     18 |
| luca morelli       | honda cbr1000rr     |     23 | +1:23.826  |     19 |
| dean ellison       | ducati 999rs        |     23 | +1:37.631  |     20 |
| max neukirchner    | suzuki gsx-r1000 k7 |      6 | retirement |      2 |
| shinichi nakatomi  | yamaha yzf-r1       |      5 | retirement |     17 |
| steve martin       | suzuki gsx-r1000 k6 |      1 | retirement |     13 |
| jakub smrž         | ducati 999 f05      |      0 | retirement |     15 |

Question: What is the average lap for suzuki gsx-r1000 k7 and at grid 6?

table_id: 2-13648477-2
label: SELECT AVG("Laps") FROM "table" WHERE "Bike" = "suzuki gsx-r1000 k7" AND "Grid" = 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:
| Religious group   | Population % 1961   | Population % 1971   | Population % 1981   | Population % 1991   | Population % 2001   |
|:------------------|:--------------------|:--------------------|:--------------------|:--------------------|:--------------------|
| hindu             | 83.45%              | 82.73%              | 82.30%              | 81.53%              | 80.46%              |
| muslim            | 10.69%              | 11.21%              | 11.75%              | 12.61%              | 13.43%              |
| christian         | 2.44%               | 2.60%               | 2.44%               | 2.32%               | 2.34%               |
| sikh              | 1.79%               | 1.89%               | 1.92%               | 1.94%               | 1.87%               |
| buddhist          | 0.74%               | 0.70%               | 0.70%               | 0.77%               | 0.77%               |
| animist , others  | 0.43%               | 0.41%               | 0.42%               | 0.44%               | 0.72%               |

Question: What religious groups made up 0.72% of the Indian population in 2001?

table_id: 1-10710364-1
label: SELECT "Religious group" FROM "table" WHERE "Population % 2001" = "0.72%"
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           | Result   |   Boilermakers points |   Opponents | Record   |
|-------:|:---------|:-------------------|:---------|----------------------:|------------:|:---------|
|      1 | sept 17  | ohio               | win      |                    42 |           3 | 1-0      |
|      2 | sept. 24 | @ notre dame       | loss     |                    14 |          26 | 1-1      |
|      3 | oct. 1   | southern methodist | win      |                    35 |          23 | 2-1      |
|      4 | oct 8    | iowa               | win      |                    35 |           0 | 3-1      |
|      5 | oct 15   | @ michigan         | win      |                    22 |          21 | 4-1      |
|      6 | oct 22   | @ michigan state   | loss     |                    20 |          41 | 4-2      |
|      7 | oct 29   | illinois           | win      |                    25 |          21 | 5-2      |
|      8 | nov 5    | @ wisconsin        | win      |                    23 |           0 | 6-2      |
|      9 | nov 12   | @ minnesota        | win      |                    16 |           0 | 7-2      |
|     10 | nov 19   | indiana            | win      |                    51 |           6 | 8-2      |

Question: How many games were there in the 1966 season?

table_id: 1-20849830-1
label: SELECT MAX("Game") FROM "table"
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            | Record   |
|-------:|:-------------|:----------------------|:-------------|:--------------------|:---------|
|     74 | wed. apr. 1  | washington bullets    | 103-86       | boston garden       | 54-20    |
|     75 | fri. apr. 3  | detroit pistons       | 119-115 (ot) | boston garden       | 55-20    |
|     76 | sun. apr. 5  | @ philadelphia 76ers  | 104-106 (ot) | the spectrum        | 55-21    |
|     77 | tue. apr. 7  | @ cleveland cavaliers | 83-107       | richfield coliseum  | 55-22    |
|     78 | fri. apr. 10 | @ new jersey nets     | 108-117      | brendan byrne arena | 55-23    |
|     79 | sun. apr. 12 | new york knicks       | 119-107      | boston garden       | 56-23    |
|     80 | wed. apr. 15 | @ indiana pacers      | 108-85       | market square arena | 57-23    |
|     81 | fri. apr. 17 | chicago bulls         | 108-105      | boston garden       | 58-23    |
|     82 | sun. apr. 19 | atlanta hawks         | 118-107      | boston garden       | 59-23    |

Question: Opponent of chicago bulls had what location?

table_id: 2-13821868-9
label: SELECT "Location" FROM "table" WHERE "Opponent" = "chicago bulls"