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:
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 warehouse location, what is the value of the most expensive box?

db_id: warehouse_1
tables: name: Warehouses
data: Warehouses.csv
name: Boxes
data: Boxes.csv
label: SELECT max(T1.value) ,  T2.location FROM boxes AS T1 JOIN warehouses AS T2 ON T1.warehouse  =  T2.code GROUP BY T2.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:
boat_1

Tables:

Table: Sailors
|   sid | name   |   rating |   age |
|------:|:-------|---------:|------:|
|     1 | Eugene |        7 |    22 |
|     2 | Luis   |        2 |    39 |
|     3 | Ken    |        8 |    27 |


Table: Boats
|   bid | name   | color   |
|------:|:-------|:--------|
|   101 | Legacy | red     |
|   102 | Melon  | blue    |
|   103 | Mars   | red     |


Table: Reserves
|   sid |   bid | day   |
|------:|------:|:------|
|     1 |   102 | 9/12  |
|     2 |   102 | 9/13  |
|     2 |   103 | 9/14  |
|     2 |   103 | 9/15  |


Question: What is the maximum rating for sailors?

db_id: boat_1
tables: name: Sailors
data: Sailors.csv
name: Boats
data: Boats.csv
name: Reserves
data: Reserves.csv
label: SELECT max(rating) FROM Sailors
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/boat_1/boat_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:
pilot_1

Tables:

Table: PilotSkills
| pilot_name   | plane_name   |   age |
|:-------------|:-------------|------:|
| Celko        | Piper Cub    |    23 |
| Higgins      | B-52 Bomber  |    34 |
| Higgins      | F-14 Fighter |    50 |
| Higgins      | Piper Cub    |    30 |
| Jones        | B-52 Bomber  |    24 |
| Jones        | F-14 Fighter |    32 |
| Smith        | B-1 Bomber   |    41 |
| Smith        | B-52 Bomber  |    26 |
| Smith        | F-14 Fighter |    45 |
| Wilson       | B-1 Bomber   |    52 |


Table: Hangar
| plane_name   | location   |
|:-------------|:-----------|
| B-1 Bomber   | Chicago    |
| B-52 Bomber  | Austin     |
| F-14 Fighter | Boston     |
| Piper Cub    | Seattle    |


Question: Find all different planes whose names contain substring 'Bomber'.

db_id: pilot_1
tables: name: PilotSkills
data: PilotSkills.csv
name: Hangar
data: Hangar.csv
label: SELECT DISTINCT plane_name FROM pilotskills WHERE plane_name LIKE '%Bomber%'
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/pilot_1/pilot_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:
boat_1

Tables:

Table: Sailors
|   sid | name   |   rating |   age |
|------:|:-------|---------:|------:|
|     1 | Eugene |        7 |    22 |
|     2 | Luis   |        2 |    39 |
|     3 | Ken    |        8 |    27 |


Table: Boats
|   bid | name   | color   |
|------:|:-------|:--------|
|   101 | Legacy | red     |
|   102 | Melon  | blue    |
|   103 | Mars   | red     |


Table: Reserves
|   sid |   bid | day   |
|------:|------:|:------|
|     1 |   102 | 9/12  |
|     2 |   102 | 9/13  |
|     2 |   103 | 9/14  |
|     2 |   103 | 9/15  |


Question: Find the name and id of the sailors who reserved at least one boat?

db_id: boat_1
tables: name: Sailors
data: Sailors.csv
name: Boats
data: Boats.csv
name: Reserves
data: Reserves.csv
label: SELECT DISTINCT T1.name ,  T1.sid FROM Sailors AS T1 JOIN Reserves AS T2 ON T1.sid  =  T2.sid
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/boat_1/boat_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:
pilot_1

Tables:

Table: PilotSkills
| pilot_name   | plane_name   |   age |
|:-------------|:-------------|------:|
| Celko        | Piper Cub    |    23 |
| Higgins      | B-52 Bomber  |    34 |
| Higgins      | F-14 Fighter |    50 |
| Higgins      | Piper Cub    |    30 |
| Jones        | B-52 Bomber  |    24 |
| Jones        | F-14 Fighter |    32 |
| Smith        | B-1 Bomber   |    41 |
| Smith        | B-52 Bomber  |    26 |
| Smith        | F-14 Fighter |    45 |
| Wilson       | B-1 Bomber   |    52 |


Table: Hangar
| plane_name   | location   |
|:-------------|:-----------|
| B-1 Bomber   | Chicago    |
| B-52 Bomber  | Austin     |
| F-14 Fighter | Boston     |
| Piper Cub    | Seattle    |


Question: List all distinct types of planes owned by all pilots in alphabetic order?

db_id: pilot_1
tables: name: PilotSkills
data: PilotSkills.csv
name: Hangar
data: Hangar.csv
label: SELECT DISTINCT plane_name FROM pilotskills ORDER BY plane_name
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/pilot_1/pilot_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:
boat_1

Tables:

Table: Sailors
|   sid | name   |   rating |   age |
|------:|:-------|---------:|------:|
|     1 | Eugene |        7 |    22 |
|     2 | Luis   |        2 |    39 |
|     3 | Ken    |        8 |    27 |


Table: Boats
|   bid | name   | color   |
|------:|:-------|:--------|
|   101 | Legacy | red     |
|   102 | Melon  | blue    |
|   103 | Mars   | red     |


Table: Reserves
|   sid |   bid | day   |
|------:|------:|:------|
|     1 |   102 | 9/12  |
|     2 |   102 | 9/13  |
|     2 |   103 | 9/14  |
|     2 |   103 | 9/15  |


Question: How many sailors whose name starts with letter D exist ?

db_id: boat_1
tables: name: Sailors
data: Sailors.csv
name: Boats
data: Boats.csv
name: Reserves
data: Reserves.csv
label: select count(*) from sailors where name like 'd%'
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/boat_1/boat_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 all movies that are not played in 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:
pilot_1

Tables:

Table: PilotSkills
| pilot_name   | plane_name   |   age |
|:-------------|:-------------|------:|
| Celko        | Piper Cub    |    23 |
| Higgins      | B-52 Bomber  |    34 |
| Higgins      | F-14 Fighter |    50 |
| Higgins      | Piper Cub    |    30 |
| Jones        | B-52 Bomber  |    24 |
| Jones        | F-14 Fighter |    32 |
| Smith        | B-1 Bomber   |    41 |
| Smith        | B-52 Bomber  |    26 |
| Smith        | F-14 Fighter |    45 |
| Wilson       | B-1 Bomber   |    52 |


Table: Hangar
| plane_name   | location   |
|:-------------|:-----------|
| B-1 Bomber   | Chicago    |
| B-52 Bomber  | Austin     |
| F-14 Fighter | Boston     |
| Piper Cub    | Seattle    |


Question: Return the name of the youngest pilot to fly Piper Cub.

db_id: pilot_1
tables: name: PilotSkills
data: PilotSkills.csv
name: Hangar
data: Hangar.csv
label: SELECT pilot_name FROM pilotskills WHERE plane_name  =  'Piper Cub' ORDER BY age LIMIT 1
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/pilot_1/pilot_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:
boat_1

Tables:

Table: Sailors
|   sid | name   |   rating |   age |
|------:|:-------|---------:|------:|
|     1 | Eugene |        7 |    22 |
|     2 | Luis   |        2 |    39 |
|     3 | Ken    |        8 |    27 |


Table: Boats
|   bid | name   | color   |
|------:|:-------|:--------|
|   101 | Legacy | red     |
|   102 | Melon  | blue    |
|   103 | Mars   | red     |


Table: Reserves
|   sid |   bid | day   |
|------:|------:|:------|
|     1 |   102 | 9/12  |
|     2 |   102 | 9/13  |
|     2 |   103 | 9/14  |
|     2 |   103 | 9/15  |


Question: Find the number of reservations for each boat.

db_id: boat_1
tables: name: Sailors
data: Sailors.csv
name: Boats
data: Boats.csv
name: Reserves
data: Reserves.csv
label: SELECT bid ,  count(*) FROM Reserves GROUP BY bid
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/boat_1/boat_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:
pilot_1

Tables:

Table: PilotSkills
| pilot_name   | plane_name   |   age |
|:-------------|:-------------|------:|
| Celko        | Piper Cub    |    23 |
| Higgins      | B-52 Bomber  |    34 |
| Higgins      | F-14 Fighter |    50 |
| Higgins      | Piper Cub    |    30 |
| Jones        | B-52 Bomber  |    24 |
| Jones        | F-14 Fighter |    32 |
| Smith        | B-1 Bomber   |    41 |
| Smith        | B-52 Bomber  |    26 |
| Smith        | F-14 Fighter |    45 |
| Wilson       | B-1 Bomber   |    52 |


Table: Hangar
| plane_name   | location   |
|:-------------|:-----------|
| B-1 Bomber   | Chicago    |
| B-52 Bomber  | Austin     |
| F-14 Fighter | Boston     |
| Piper Cub    | Seattle    |


Question: Find the names of all pilots who have a plane named Piper Cub and is under 35.

db_id: pilot_1
tables: name: PilotSkills
data: PilotSkills.csv
name: Hangar
data: Hangar.csv
label: SELECT pilot_name FROM PilotSkills WHERE age  <  35 AND plane_name  =  'Piper Cub'
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/pilot_1/pilot_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:
boat_1

Tables:

Table: Sailors
|   sid | name   |   rating |   age |
|------:|:-------|---------:|------:|
|     1 | Eugene |        7 |    22 |
|     2 | Luis   |        2 |    39 |
|     3 | Ken    |        8 |    27 |


Table: Boats
|   bid | name   | color   |
|------:|:-------|:--------|
|   101 | Legacy | red     |
|   102 | Melon  | blue    |
|   103 | Mars   | red     |


Table: Reserves
|   sid |   bid | day   |
|------:|------:|:------|
|     1 |   102 | 9/12  |
|     2 |   102 | 9/13  |
|     2 |   103 | 9/14  |
|     2 |   103 | 9/15  |


Question: What are the names of sailors who reserved a boat with the name Melon?

db_id: boat_1
tables: name: Sailors
data: Sailors.csv
name: Boats
data: Boats.csv
name: Reserves
data: Reserves.csv
label: SELECT T1.name FROM Sailors AS T1 JOIN Reserves AS T2 ON T1.sid  =  T2.sid JOIN Boats AS T3 ON T3.bid  =  T2.bid WHERE T3.name  =  'Melon'
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/boat_1/boat_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:
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: How many books do not have reviews?

db_id: book_review
tables: name: book
data: book.csv
name: review
data: review.csv
label: SELECT count(*) FROM book WHERE Book_ID NOT IN (SELECT Book_ID FROM review)
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/book_review/book_review.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 number of movies whose rating is ‘G’.

db_id: movie_2
tables: name: Movies
data: Movies.csv
name: MovieTheaters
data: MovieTheaters.csv
label: SELECT count(*) FROM movies WHERE rating  =  'G'
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 are the types and release dates of books?

db_id: book_review
tables: name: book
data: book.csv
name: review
data: review.csv
label: SELECT TYPE ,  Release FROM book
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/book_review/book_review.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: What are the codes of warehouses that have more boxes than their capacity?

db_id: warehouse_1
tables: name: Warehouses
data: Warehouses.csv
name: Boxes
data: Boxes.csv
label: SELECT T2.code FROM boxes AS T1 JOIN Warehouses AS T2 ON T1.warehouse  =  T2.code GROUP BY T2.code HAVING count(*)  >  T2.capacity
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:
pilot_1

Tables:

Table: PilotSkills
| pilot_name   | plane_name   |   age |
|:-------------|:-------------|------:|
| Celko        | Piper Cub    |    23 |
| Higgins      | B-52 Bomber  |    34 |
| Higgins      | F-14 Fighter |    50 |
| Higgins      | Piper Cub    |    30 |
| Jones        | B-52 Bomber  |    24 |
| Jones        | F-14 Fighter |    32 |
| Smith        | B-1 Bomber   |    41 |
| Smith        | B-52 Bomber  |    26 |
| Smith        | F-14 Fighter |    45 |
| Wilson       | B-1 Bomber   |    52 |


Table: Hangar
| plane_name   | location   |
|:-------------|:-----------|
| B-1 Bomber   | Chicago    |
| B-52 Bomber  | Austin     |
| F-14 Fighter | Boston     |
| Piper Cub    | Seattle    |


Question: Find the names of all pilots with age between 30 and 40 sorted by their ages in ascending order.

db_id: pilot_1
tables: name: PilotSkills
data: PilotSkills.csv
name: Hangar
data: Hangar.csv
label: SELECT pilot_name FROM pilotskills WHERE age BETWEEN 30 AND 40 ORDER BY age
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/pilot_1/pilot_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:
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: Find the unique contents of all boxes whose value is higher than the average value of all boxes.

db_id: warehouse_1
tables: name: Warehouses
data: Warehouses.csv
name: Boxes
data: Boxes.csv
label: SELECT DISTINCT CONTENTS FROM boxes WHERE value  >  (SELECT avg(value) FROM boxes)
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:
boat_1

Tables:

Table: Sailors
|   sid | name   |   rating |   age |
|------:|:-------|---------:|------:|
|     1 | Eugene |        7 |    22 |
|     2 | Luis   |        2 |    39 |
|     3 | Ken    |        8 |    27 |


Table: Boats
|   bid | name   | color   |
|------:|:-------|:--------|
|   101 | Legacy | red     |
|   102 | Melon  | blue    |
|   103 | Mars   | red     |


Table: Reserves
|   sid |   bid | day   |
|------:|------:|:------|
|     1 |   102 | 9/12  |
|     2 |   102 | 9/13  |
|     2 |   103 | 9/14  |
|     2 |   103 | 9/15  |


Question: What are the different names of sailors who are older than some other sailor with a rating larger than 7?

db_id: boat_1
tables: name: Sailors
data: Sailors.csv
name: Boats
data: Boats.csv
name: Reserves
data: Reserves.csv
label: SELECT DISTINCT name FROM Sailors WHERE age  >  (SELECT min(age) FROM Sailors WHERE rating  >  7);
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/boat_1/boat_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:
pilot_1

Tables:

Table: PilotSkills
| pilot_name   | plane_name   |   age |
|:-------------|:-------------|------:|
| Celko        | Piper Cub    |    23 |
| Higgins      | B-52 Bomber  |    34 |
| Higgins      | F-14 Fighter |    50 |
| Higgins      | Piper Cub    |    30 |
| Jones        | B-52 Bomber  |    24 |
| Jones        | F-14 Fighter |    32 |
| Smith        | B-1 Bomber   |    41 |
| Smith        | B-52 Bomber  |    26 |
| Smith        | F-14 Fighter |    45 |
| Wilson       | B-1 Bomber   |    52 |


Table: Hangar
| plane_name   | location   |
|:-------------|:-----------|
| B-1 Bomber   | Chicago    |
| B-52 Bomber  | Austin     |
| F-14 Fighter | Boston     |
| Piper Cub    | Seattle    |


Question: Where is the plane F-14 Fighter located?

db_id: pilot_1
tables: name: PilotSkills
data: PilotSkills.csv
name: Hangar
data: Hangar.csv
label: SELECT LOCATION FROM hangar WHERE plane_name  =  'F-14 Fighter'
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/pilot_1/pilot_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:
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: List all different types of contents ordered by contents.

db_id: warehouse_1
tables: name: Warehouses
data: Warehouses.csv
name: Boxes
data: Boxes.csv
label: SELECT DISTINCT CONTENTS FROM boxes ORDER BY CONTENTS
sqlite_path: $MMTU_HOME/data_sqlite/spider/spider_data/test_database/warehouse_1/warehouse_1.sqlite