question string | answer string | context string | dialect string | spider_hardness string | extended_hardness string | classification_status string | syntax_status string | ddl_syntax_status string | schema_status string | syntax_errors list | ddl_syntax_errors list | schema_errors list | classification_errors list | status_history list | correction_status string | component1 int64 | component2 int64 | others int64 | validation_source dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Find the name and active date of the customer that use email as the contact channel. | SELECT t1.customer_name, t2.active_from_date FROM customers AS t1 JOIN customer_contact_channels AS t2 ON t1.customer_id = t2.customer_id WHERE t2.channel_code = 'Email' | CREATE TABLE customers (customer_name VARCHAR(255), customer_id VARCHAR(255)); CREATE TABLE customer_contact_channels (active_from_date VARCHAR(255), customer_id VARCHAR(255), channel_code VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3471
} |
What is the name of the customer that has purchased the most items? | SELECT t1.customer_name FROM customers AS t1 JOIN customer_orders AS t2 ON t1.customer_id = t2.customer_id JOIN order_items AS t3 ON t2.order_id = t3.order_id GROUP BY t1.customer_name ORDER BY SUM(t3.order_quantity) DESC LIMIT 1 | CREATE TABLE order_items (order_id VARCHAR(255), order_quantity INTEGER); CREATE TABLE customers (customer_name VARCHAR(255), customer_id VARCHAR(255)); CREATE TABLE customer_orders (customer_id VARCHAR(255), order_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 5 | 0 | 0 | {
"split": "train",
"row_index": 3473
} |
How many types of products have Rodrick Heaney bought in total? | SELECT COUNT(DISTINCT t3.product_id) FROM customers AS t1 JOIN customer_orders AS t2 ON t1.customer_id = t2.customer_id JOIN order_items AS t3 ON t2.order_id = t3.order_id WHERE t1.customer_name = 'Rodrick Heaney' | CREATE TABLE customers (customer_id VARCHAR(255), customer_name VARCHAR(255)); CREATE TABLE order_items (product_id VARCHAR(255), order_id VARCHAR(255)); CREATE TABLE customer_orders (customer_id VARCHAR(255), order_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 3475
} |
What is the total quantity of products purchased by "Rodrick Heaney"? | SELECT SUM(t3.order_quantity) FROM customers AS t1 JOIN customer_orders AS t2 ON t1.customer_id = t2.customer_id JOIN order_items AS t3 ON t2.order_id = t3.order_id WHERE t1.customer_name = 'Rodrick Heaney' | CREATE TABLE customers (customer_id VARCHAR(255), customer_name VARCHAR(255)); CREATE TABLE order_items (order_quantity INTEGER, order_id VARCHAR(255)); CREATE TABLE customer_orders (customer_id VARCHAR(255), order_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 3476
} |
How many customers have at least one order with status "Cancelled"? | SELECT COUNT(DISTINCT customer_id) FROM customer_orders WHERE order_status = 'Cancelled' | CREATE TABLE customer_orders (customer_id VARCHAR(255), order_status VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3477
} |
How many orders have detail "Second time"? | SELECT COUNT(*) FROM customer_orders WHERE order_details = 'Second time' | CREATE TABLE customer_orders (order_details VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3478
} |
What is the total number of products that are in orders with status "Cancelled"? | SELECT SUM(t2.order_quantity) FROM customer_orders AS t1 JOIN order_items AS t2 ON t1.order_id = t2.order_id WHERE t1.order_status = 'Cancelled' | CREATE TABLE customer_orders (order_id VARCHAR(255), order_status VARCHAR(255)); CREATE TABLE order_items (order_quantity INTEGER, order_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3480
} |
Find the total amount of products ordered before 2018-03-17 07:13:53. | SELECT SUM(t2.order_quantity) FROM customer_orders AS t1 JOIN order_items AS t2 ON t1.order_id = t2.order_id WHERE t1.order_date < '2018-03-17 07:13:53' | CREATE TABLE customer_orders (order_id VARCHAR(255), order_date INTEGER); CREATE TABLE order_items (order_quantity INTEGER, order_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3481
} |
Who made the latest order? | SELECT t1.customer_name FROM customers AS t1 JOIN customer_orders AS t2 ON t1.customer_id = t2.customer_id ORDER BY t2.order_date DESC LIMIT 1 | CREATE TABLE customer_orders (customer_id VARCHAR(255), order_date VARCHAR(255)); CREATE TABLE customers (customer_name VARCHAR(255), customer_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 3482
} |
Which product has been ordered most number of times? | SELECT t2.product_details FROM order_items AS t1 JOIN products AS t2 ON t1.product_id = t2.product_id GROUP BY t1.product_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE products (product_details VARCHAR(255), product_id VARCHAR(255)); CREATE TABLE order_items (product_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 3483
} |
Find the name and ID of the product whose total order quantity is the largest. | SELECT t2.product_details, t2.product_id FROM order_items AS t1 JOIN products AS t2 ON t1.product_id = t2.product_id GROUP BY t1.product_id ORDER BY SUM(t1.order_quantity) LIMIT 1 | CREATE TABLE order_items (product_id VARCHAR(255), order_quantity INTEGER); CREATE TABLE products (product_details VARCHAR(255), product_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 3484
} |
Find all the addresses in East Julianaside, Texas or in Gleasonmouth, Arizona. | SELECT address_content FROM addresses WHERE city = 'East Julianaside' AND state_province_county = 'Texas' UNION SELECT address_content FROM addresses WHERE city = 'Gleasonmouth' AND state_province_county = 'Arizona' | CREATE TABLE addresses (address_content VARCHAR(255), city VARCHAR(255), state_province_county VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 3485
} |
Find the name of customers who did not pay with Cash. | SELECT customer_name FROM customers WHERE payment_method <> 'Cash' | CREATE TABLE customers (customer_name VARCHAR(255), payment_method VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3486
} |
Find the names of customers who ordered both products Latte and Americano. | SELECT t1.customer_name FROM customers AS t1 JOIN customer_orders AS t2 ON t1.customer_id = t2.customer_id JOIN order_items AS t3 ON t2.order_id = t3.order_id JOIN products AS t4 ON t3.product_id = t4.product_id WHERE t4.product_details = 'Latte' INTERSECT SELECT t1.customer_name FROM customers AS t1 JOIN customer_orde... | CREATE TABLE products (product_id VARCHAR(255), product_details VARCHAR(255)); CREATE TABLE order_items (order_id VARCHAR(255), product_id VARCHAR(255)); CREATE TABLE customers (customer_name VARCHAR(255), customer_id VARCHAR(255)); CREATE TABLE customer_orders (customer_id VARCHAR(255), order_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 1 | 0 | {
"split": "train",
"row_index": 3489
} |
List the age of all music artists. | SELECT Age FROM artist | CREATE TABLE artist (Age VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3490
} |
What is the average age of all artists? | SELECT AVG(Age) FROM artist | CREATE TABLE artist (Age INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3491
} |
What are the famous titles of the artist "Triumfall"? | SELECT Famous_Title FROM artist WHERE Artist = 'Triumfall' | CREATE TABLE artist (Famous_Title VARCHAR(255), Artist VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3492
} |
What are the distinct Famous release dates? | SELECT DISTINCT (Famous_Release_date) FROM artist | CREATE TABLE artist (Famous_Release_date VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3493
} |
Return the dates of ceremony and the results of all music festivals | SELECT Date_of_ceremony, RESULT FROM music_festival | CREATE TABLE music_festival (Date_of_ceremony VARCHAR(255), RESULT VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 3494
} |
What are the category of music festivals with result "Awarded"? | SELECT Category FROM music_festival WHERE RESULT = 'Awarded' | CREATE TABLE music_festival (Category VARCHAR(255), RESULT VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3495
} |
What are the maximum and minimum week on top of all volumes? | SELECT MAX(Weeks_on_Top), MIN(Weeks_on_Top) FROM volume | CREATE TABLE volume (Weeks_on_Top INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 2 | {
"split": "train",
"row_index": 3496
} |
What are the songs in volumes with more than 1 week on top? | SELECT Song FROM volume WHERE Weeks_on_Top > 1 | CREATE TABLE volume (Song VARCHAR(255), Weeks_on_Top INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3497
} |
Please list all songs in volumes in ascending alphabetical order. | SELECT Song FROM volume ORDER BY Song | CREATE TABLE volume (Song VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3498
} |
How many distinct artists do the volumes associate to? | SELECT COUNT(DISTINCT Artist_ID) FROM volume | CREATE TABLE volume (Artist_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3499
} |
Please show the date of ceremony of the volumes that last more than 2 weeks on top. | SELECT T1.Date_of_ceremony FROM music_festival AS T1 JOIN volume AS T2 ON T1.Volume = T2.Volume_ID WHERE T2.Weeks_on_Top > 2 | CREATE TABLE music_festival (Date_of_ceremony VARCHAR(255), Volume VARCHAR(255)); CREATE TABLE volume (Volume_ID VARCHAR(255), Weeks_on_Top INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3500
} |
Please show the songs that have result "nominated" at music festivals. | SELECT T2.Song FROM music_festival AS T1 JOIN volume AS T2 ON T1.Volume = T2.Volume_ID WHERE T1.Result = 'Nominated' | CREATE TABLE volume (Song VARCHAR(255), Volume_ID VARCHAR(255)); CREATE TABLE music_festival (Volume VARCHAR(255), Result VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3501
} |
What are the issue dates of volumes associated with the artist "Gorgoroth"? | SELECT T2.Issue_Date FROM artist AS T1 JOIN volume AS T2 ON T1.Artist_ID = T2.Artist_ID WHERE T1.Artist = 'Gorgoroth' | CREATE TABLE artist (Artist_ID VARCHAR(255), Artist VARCHAR(255)); CREATE TABLE volume (Issue_Date VARCHAR(255), Artist_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3502
} |
What are the songs in volumes associated with the artist aged 32 or older? | SELECT T2.Song FROM artist AS T1 JOIN volume AS T2 ON T1.Artist_ID = T2.Artist_ID WHERE T1.age >= 32 | CREATE TABLE volume (Song VARCHAR(255), Artist_ID VARCHAR(255)); CREATE TABLE artist (Artist_ID VARCHAR(255), age VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3503
} |
What is the average weeks on top of volumes associated with the artist aged 25 or younger? | SELECT AVG(T2.Weeks_on_Top) FROM artist AS T1 JOIN volume AS T2 ON T1.Artist_ID = T2.Artist_ID WHERE T1.age <= 25 | CREATE TABLE volume (Weeks_on_Top INTEGER, Artist_ID VARCHAR(255)); CREATE TABLE artist (Artist_ID VARCHAR(255), age VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3504
} |
What are the famous title of the artists associated with volumes with more than 2 weeks on top? | SELECT T1.Famous_Title FROM artist AS T1 JOIN volume AS T2 ON T1.Artist_ID = T2.Artist_ID WHERE T2.Weeks_on_Top > 2 | CREATE TABLE artist (Famous_Title VARCHAR(255), Artist_ID VARCHAR(255)); CREATE TABLE volume (Artist_ID VARCHAR(255), Weeks_on_Top INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3505
} |
Please list the age and famous title of artists in descending order of age. | SELECT Famous_Title, Age FROM artist ORDER BY Age DESC | CREATE TABLE artist (Famous_Title VARCHAR(255), Age VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3506
} |
What is the famous release date of the artist with the oldest age? | SELECT Famous_Release_date FROM artist ORDER BY Age DESC LIMIT 1 | CREATE TABLE artist (Famous_Release_date VARCHAR(255), Age VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3507
} |
Please show the categories of the music festivals and the count. | SELECT Category, COUNT(*) FROM music_festival GROUP BY Category | CREATE TABLE music_festival (Category VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3508
} |
What is the most common result of the music festival? | SELECT RESULT FROM music_festival GROUP BY RESULT ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE music_festival (RESULT VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 3509
} |
Please show the categories of the music festivals with count more than 1. | SELECT Category FROM music_festival GROUP BY Category HAVING COUNT(*) > 1 | CREATE TABLE music_festival (Category VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3510
} |
What is the song in the volume with the maximum weeks on top? | SELECT Song FROM volume ORDER BY Weeks_on_Top DESC LIMIT 1 | CREATE TABLE volume (Song VARCHAR(255), Weeks_on_Top VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3511
} |
Find the famous titles of artists that do not have any volume. | SELECT Famous_Title FROM artist WHERE NOT Artist_ID IN (SELECT Artist_ID FROM volume) | CREATE TABLE volume (Famous_Title VARCHAR(255), Artist_ID VARCHAR(255)); CREATE TABLE artist (Famous_Title VARCHAR(255), Artist_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 3512
} |
Show the famous titles of the artists with both volumes that lasted more than 2 weeks on top and volumes that lasted less than 2 weeks on top. | SELECT T1.Famous_Title FROM artist AS T1 JOIN volume AS T2 ON T1.Artist_ID = T2.Artist_ID WHERE T2.Weeks_on_Top > 2 INTERSECT SELECT T1.Famous_Title FROM artist AS T1 JOIN volume AS T2 ON T1.Artist_ID = T2.Artist_ID WHERE T2.Weeks_on_Top < 2 | CREATE TABLE artist (Famous_Title VARCHAR(255), Artist_ID VARCHAR(255)); CREATE TABLE volume (Artist_ID VARCHAR(255), Weeks_on_Top INTEGER) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 3513
} |
What are the date of ceremony of music festivals with category "Best Song" and result "Awarded"? | SELECT Date_of_ceremony FROM music_festival WHERE Category = 'Best Song' AND RESULT = 'Awarded' | CREATE TABLE music_festival (Date_of_ceremony VARCHAR(255), Category VARCHAR(255), RESULT VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3514
} |
What is the issue date of the volume with the minimum weeks on top? | SELECT Issue_Date FROM volume ORDER BY Weeks_on_Top LIMIT 1 | CREATE TABLE volume (Issue_Date VARCHAR(255), Weeks_on_Top VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3515
} |
Please show the results of music festivals and the number of music festivals that have had each, ordered by this count. | SELECT RESULT, COUNT(*) FROM music_festival GROUP BY RESULT ORDER BY COUNT(*) DESC | CREATE TABLE music_festival (RESULT VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 2 | {
"split": "train",
"row_index": 3516
} |
How many roller coasters are there? | SELECT COUNT(*) FROM roller_coaster | CREATE TABLE roller_coaster (Id VARCHAR(255), Name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3518
} |
List the names of roller coasters by ascending order of length. | SELECT Name FROM roller_coaster ORDER BY LENGTH | CREATE TABLE roller_coaster (Name VARCHAR(255), LENGTH VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3519
} |
What are the lengths and heights of roller coasters? | SELECT LENGTH, Height FROM roller_coaster | CREATE TABLE roller_coaster (LENGTH VARCHAR(255), Height VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 3520
} |
List the names of countries whose language is not "German". | SELECT Name FROM country WHERE Languages <> 'German' | CREATE TABLE country (Name VARCHAR(255), Languages VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3521
} |
Show the statuses of roller coasters longer than 3300 or higher than 100. | SELECT Status FROM roller_coaster WHERE LENGTH > 3300 OR Height > 100 | CREATE TABLE roller_coaster (Status VARCHAR(255), LENGTH VARCHAR(255), Height VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3522
} |
What are the speeds of the longest roller coaster? | SELECT Speed FROM roller_coaster ORDER BY LENGTH DESC LIMIT 1 | CREATE TABLE roller_coaster (Speed VARCHAR(255), LENGTH VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3523
} |
What is the average speed of roller coasters? | SELECT AVG(Speed) FROM roller_coaster | CREATE TABLE roller_coaster (Speed INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3524
} |
Show the different statuses and the numbers of roller coasters for each status. | SELECT Status, COUNT(*) FROM roller_coaster GROUP BY Status | CREATE TABLE roller_coaster (Status VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3525
} |
Please show the most common status of roller coasters. | SELECT Status FROM roller_coaster GROUP BY Status ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE roller_coaster (Status VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 3526
} |
List the status shared by more than two roller coaster. | SELECT Status FROM roller_coaster GROUP BY Status HAVING COUNT(*) > 2 | CREATE TABLE roller_coaster (Status VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3527
} |
Show the park of the roller coaster with the highest speed. | SELECT Park FROM roller_coaster ORDER BY Speed DESC LIMIT 1 | CREATE TABLE roller_coaster (Park VARCHAR(255), Speed VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3528
} |
Show the names of roller coasters and names of country they are in. | SELECT T2.Name, T1.Name FROM country AS T1 JOIN roller_coaster AS T2 ON T1.Country_ID = T2.Country_ID | CREATE TABLE country (Name VARCHAR(255), Country_ID VARCHAR(255)); CREATE TABLE roller_coaster (Name VARCHAR(255), Country_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3529
} |
Show the names of countries that have more than one roller coaster. | SELECT T1.Name FROM country AS T1 JOIN roller_coaster AS T2 ON T1.Country_ID = T2.Country_ID GROUP BY T1.Name HAVING COUNT(*) > 1 | CREATE TABLE roller_coaster (Country_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE country (Name VARCHAR(255), Country_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3530
} |
Show the name and population of the country that has the highest roller coaster. | SELECT T1.Name, T1.population FROM country AS T1 JOIN roller_coaster AS T2 ON T1.Country_ID = T2.Country_ID ORDER BY T2.Height DESC LIMIT 1 | CREATE TABLE roller_coaster (Country_ID VARCHAR(255), Height VARCHAR(255)); CREATE TABLE country (Name VARCHAR(255), population VARCHAR(255), Country_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 3531
} |
Show the names of countries and the average speed of roller coasters from each country. | SELECT T1.Name, AVG(T2.Speed) FROM country AS T1 JOIN roller_coaster AS T2 ON T1.Country_ID = T2.Country_ID GROUP BY T1.Name | CREATE TABLE roller_coaster (Speed INTEGER, Country_ID VARCHAR(255)); CREATE TABLE country (Name VARCHAR(255), Country_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3532
} |
How many countries do not have an roller coaster longer than 3000? | SELECT COUNT(*) FROM country WHERE NOT country_id IN (SELECT country_id FROM roller_coaster WHERE LENGTH > 3000) | CREATE TABLE country (country_id VARCHAR(255), LENGTH INTEGER); CREATE TABLE roller_coaster (country_id VARCHAR(255), LENGTH INTEGER) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 3533
} |
What are the country names, area and population which has both roller coasters with speed higher | SELECT T1.name, T1.area, T1.population FROM country AS T1 JOIN roller_coaster AS T2 ON T1.Country_ID = T2.Country_ID WHERE T2.speed > 60 INTERSECT SELECT T1.name, T1.area, T1.population FROM country AS T1 JOIN roller_coaster AS T2 ON T1.Country_ID = T2.Country_ID WHERE T2.speed < 55 | CREATE TABLE country (name VARCHAR(255), area VARCHAR(255), population VARCHAR(255), Country_ID VARCHAR(255)); CREATE TABLE roller_coaster (Country_ID VARCHAR(255), speed INTEGER) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 1 | {
"split": "train",
"row_index": 3534
} |
How many different captain ranks are there? | SELECT COUNT(DISTINCT rank) FROM captain | CREATE TABLE captain (rank VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3535
} |
How many captains are in each rank? | SELECT COUNT(*), rank FROM captain GROUP BY rank | CREATE TABLE captain (rank VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3536
} |
How many captains with younger than 50 are in each rank? | SELECT COUNT(*), rank FROM captain WHERE age < 50 GROUP BY rank | CREATE TABLE captain (rank VARCHAR(255), age INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3537
} |
Sort all captain names by their ages from old to young. | SELECT name FROM captain ORDER BY age DESC | CREATE TABLE captain (name VARCHAR(255), age VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3538
} |
Find the name, class and rank of all captains. | SELECT name, CLASS, rank FROM captain | CREATE TABLE captain (name VARCHAR(255), CLASS VARCHAR(255), rank VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 3539
} |
Which rank is the most common among captains? | SELECT rank FROM captain GROUP BY rank ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE captain (rank VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 3540
} |
Which classes have more than two captains? | SELECT CLASS FROM captain GROUP BY CLASS HAVING COUNT(*) > 2 | CREATE TABLE captain (CLASS VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3541
} |
Find the name of captains whose rank are either Midshipman or Lieutenant. | SELECT name FROM captain WHERE rank = 'Midshipman' OR rank = 'Lieutenant' | CREATE TABLE captain (name VARCHAR(255), rank VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3542
} |
What are the average and minimum age of captains in different class? | SELECT AVG(age), MIN(age), CLASS FROM captain GROUP BY CLASS | CREATE TABLE captain (CLASS VARCHAR(255), age INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 3543
} |
Find the captain rank that has some captains in both Cutter and Armed schooner classes. | SELECT rank FROM captain WHERE CLASS = 'Cutter' INTERSECT SELECT rank FROM captain WHERE CLASS = 'Armed schooner' | CREATE TABLE captain (rank VARCHAR(255), CLASS VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 3544
} |
Find the captain rank that has no captain in Third-rate ship of the line class. | SELECT rank FROM captain EXCEPT SELECT rank FROM captain WHERE CLASS = 'Third-rate ship of the line' | CREATE TABLE captain (rank VARCHAR(255), CLASS VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 3545
} |
What is the name of the youngest captain? | SELECT name FROM captain ORDER BY age LIMIT 1 | CREATE TABLE captain (name VARCHAR(255), age VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3546
} |
Find the name, type, and flag of the ship that is built in the most recent year. | SELECT name, TYPE, flag FROM ship ORDER BY built_year DESC LIMIT 1 | CREATE TABLE ship (name VARCHAR(255), TYPE VARCHAR(255), flag VARCHAR(255), built_year VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3547
} |
Group by ships by flag, and return number of ships that have each flag. | SELECT COUNT(*), flag FROM ship GROUP BY flag | CREATE TABLE ship (flag VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT, name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3548
} |
Which flag is most widely used among all ships? | SELECT flag FROM ship GROUP BY flag ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE ship (flag VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT, name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 3549
} |
List all ship names in the order of built year and class. | SELECT name FROM ship ORDER BY built_year, CLASS | CREATE TABLE ship (name VARCHAR(255), built_year VARCHAR(255), CLASS VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3550
} |
Find the ship type that are used by both ships with Panama and Malta flags. | SELECT TYPE FROM ship WHERE flag = 'Panama' INTERSECT SELECT TYPE FROM ship WHERE flag = 'Malta' | CREATE TABLE ship (TYPE VARCHAR(255), flag VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 3551
} |
In which year were most of ships built? | SELECT built_year FROM ship GROUP BY built_year ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE ship (built_year VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT, name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 3552
} |
Find the name of the ships that have more than one captain. | SELECT t1.name FROM ship AS t1 JOIN captain AS t2 ON t1.ship_id = t2.ship_id GROUP BY t2.ship_id HAVING COUNT(*) > 1 | CREATE TABLE captain (ship_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT, name VARCHAR(255)); CREATE TABLE ship (name VARCHAR(255), ship_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3553
} |
what are the names and classes of the ships that do not have any captain yet? | SELECT name, CLASS FROM ship WHERE NOT ship_id IN (SELECT ship_id FROM captain) | CREATE TABLE ship (name VARCHAR(255), CLASS VARCHAR(255), ship_id VARCHAR(255)); CREATE TABLE captain (name VARCHAR(255), CLASS VARCHAR(255), ship_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 3554
} |
Find the name of the ship that is steered by the youngest captain. | SELECT t1.name FROM ship AS t1 JOIN captain AS t2 ON t1.ship_id = t2.ship_id ORDER BY t2.age LIMIT 1 | CREATE TABLE ship (name VARCHAR(255), ship_id VARCHAR(255)); CREATE TABLE captain (ship_id VARCHAR(255), age VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 3555
} |
Find the name and flag of ships that are not steered by any captain with Midshipman rank. | SELECT name, flag FROM ship WHERE NOT ship_id IN (SELECT ship_id FROM captain WHERE rank = 'Midshipman') | CREATE TABLE captain (name VARCHAR(255), flag VARCHAR(255), ship_id VARCHAR(255), rank VARCHAR(255)); CREATE TABLE ship (name VARCHAR(255), flag VARCHAR(255), ship_id VARCHAR(255), rank VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 3556
} |
Find the name of the ships that are steered by both a captain with Midshipman rank and a captain with Lieutenant rank. | SELECT t1.name FROM ship AS t1 JOIN captain AS t2 ON t1.ship_id = t2.ship_id WHERE t2.rank = 'Midshipman' INTERSECT SELECT t1.name FROM ship AS t1 JOIN captain AS t2 ON t1.ship_id = t2.ship_id WHERE t2.rank = 'Lieutenant' | CREATE TABLE ship (name VARCHAR(255), ship_id VARCHAR(255)); CREATE TABLE captain (ship_id VARCHAR(255), rank VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 3557
} |
What is id of the city that hosted events in the most recent year? | SELECT host_city FROM hosting_city ORDER BY YEAR DESC LIMIT 1 | CREATE TABLE hosting_city (host_city VARCHAR(255), YEAR VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3558
} |
Find the match ids of the cities that hosted competition "1994 FIFA World Cup qualification"? | SELECT match_id FROM MATCH WHERE competition = '1994 FIFA World Cup qualification' | CREATE TABLE MATCH (match_id VARCHAR(255), competition VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3559
} |
Find the cities which were once a host city after 2010? | SELECT T1.city FROM city AS T1 JOIN hosting_city AS T2 ON T1.city_id = T2.host_city WHERE T2.year > 2010 | CREATE TABLE city (city VARCHAR(255), city_id VARCHAR(255)); CREATE TABLE hosting_city (host_city VARCHAR(255), year INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3560
} |
Which city has hosted the most events? | SELECT T1.city FROM city AS T1 JOIN hosting_city AS T2 ON T1.city_id = T2.host_city GROUP BY T2.host_city ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE city (city VARCHAR(255), city_id VARCHAR(255)); CREATE TABLE hosting_city (host_city VARCHAR(255), year INTEGER) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 3561
} |
What is the venue of the competition "1994 FIFA World Cup qualification" hosted by "Nanjing ( Jiangsu )"? | SELECT T3.venue FROM city AS T1 JOIN hosting_city AS T2 ON T1.city_id = T2.host_city JOIN MATCH AS T3 ON T2.match_id = T3.match_id WHERE T1.city = 'Nanjing ( Jiangsu )' AND T3.competition = '1994 FIFA World Cup qualification' | CREATE TABLE city (city_id VARCHAR(255), city VARCHAR(255)); CREATE TABLE MATCH (venue VARCHAR(255), match_id VARCHAR(255), competition VARCHAR(255)); CREATE TABLE hosting_city (host_city VARCHAR(255), match_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 3562
} |
Give me the temperature of Shanghai in January. | SELECT T2.Jan FROM city AS T1 JOIN temperature AS T2 ON T1.city_id = T2.city_id WHERE T1.city = 'Shanghai' | CREATE TABLE city (city_id VARCHAR(255), city VARCHAR(255)); CREATE TABLE temperature (Jan VARCHAR(255), city_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3563
} |
What is the host year of city "Taizhou ( Zhejiang )"? | SELECT T2.year FROM city AS T1 JOIN hosting_city AS T2 ON T1.city_id = T2.host_city WHERE T1.city = 'Taizhou ( Zhejiang )' | CREATE TABLE city (city_id VARCHAR(255), city VARCHAR(255)); CREATE TABLE hosting_city (year VARCHAR(255), host_city VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3564
} |
Which three cities have the largest regional population? | SELECT city FROM city ORDER BY regional_population DESC LIMIT 3 | CREATE TABLE city (city VARCHAR(255), regional_population VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3565
} |
Which city has the lowest GDP? Please list the city name and its GDP. | SELECT city, GDP FROM city ORDER BY GDP LIMIT 1 | CREATE TABLE city (city VARCHAR(255), GDP VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3566
} |
Which city has the highest temperature in February? | SELECT T1.city FROM city AS T1 JOIN temperature AS T2 ON T1.city_id = T2.city_id ORDER BY T2.Feb DESC LIMIT 1 | CREATE TABLE city (city VARCHAR(255), city_id VARCHAR(255)); CREATE TABLE temperature (city_id VARCHAR(255), Feb VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 3567
} |
Give me a list of cities whose temperature in March is lower than that in July or higher than that in Oct? | SELECT T1.city FROM city AS T1 JOIN temperature AS T2 ON T1.city_id = T2.city_id WHERE T2.Mar < T2.Jul OR T2.Mar > T2.Oct | CREATE TABLE city (city VARCHAR(255), city_id VARCHAR(255)); CREATE TABLE temperature (city_id VARCHAR(255), Mar VARCHAR(255), Jul VARCHAR(255), Oct VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 3568
} |
Give me a list of cities whose temperature in Mar is lower than that in July and which have also served as host cities? | SELECT T1.city FROM city AS T1 JOIN temperature AS T2 ON T1.city_id = T2.city_id WHERE T2.Mar < T2.Jul INTERSECT SELECT T3.city FROM city AS T3 JOIN hosting_city AS T4 ON T3.city_id = T4.host_city | CREATE TABLE city (city VARCHAR(255), city_id VARCHAR(255)); CREATE TABLE hosting_city (host_city VARCHAR(255), year INTEGER); CREATE TABLE temperature (city_id VARCHAR(255), Mar INTEGER, Jul VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 3569
} |
Give me a list of cities whose temperature in Mar is lower than that in Dec and which have never been host cities. | SELECT T1.city FROM city AS T1 JOIN temperature AS T2 ON T1.city_id = T2.city_id WHERE T2.Mar < T2.Dec EXCEPT SELECT T3.city FROM city AS T3 JOIN hosting_city AS T4 ON T3.city_id = T4.host_city | CREATE TABLE city (city VARCHAR(255), city_id VARCHAR(255)); CREATE TABLE hosting_city (host_city VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE temperature (city_id VARCHAR(255), Mar INTEGER, Dec VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 3570
} |
Give me a list of cities whose temperature in Feb is higher than that in Jun or cities that were once host cities? | SELECT T1.city FROM city AS T1 JOIN temperature AS T2 ON T1.city_id = T2.city_id WHERE T2.Feb > T2.Jun UNION SELECT T3.city FROM city AS T3 JOIN hosting_city AS T4 ON T3.city_id = T4.host_city | CREATE TABLE city (city VARCHAR(255), city_id VARCHAR(255)); CREATE TABLE hosting_city (host_city VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE temperature (city_id VARCHAR(255), Feb INTEGER, Jun VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 3571
} |
Please give me a list of cities whose regional population is over 10000000. | SELECT city FROM city WHERE regional_population > 10000000 | CREATE TABLE city (city VARCHAR(255), regional_population INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3572
} |
Please give me a list of cities whose regional population is over 8000000 or under 5000000. | SELECT city FROM city WHERE regional_population > 10000000 UNION SELECT city FROM city WHERE regional_population < 5000000 | CREATE TABLE city (city VARCHAR(255), regional_population INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 3573
} |
Find the number of matches in different competitions. | SELECT COUNT(*), Competition FROM MATCH GROUP BY Competition | CREATE TABLE MATCH (Competition VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3574
} |
List venues of all matches in the order of their dates starting from the most recent one. | SELECT venue FROM MATCH ORDER BY date DESC | CREATE TABLE MATCH (venue VARCHAR(255), date VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3575
} |
what is the GDP of the city with the largest population. | SELECT gdp FROM city ORDER BY Regional_Population DESC LIMIT 1 | CREATE TABLE city (gdp VARCHAR(255), Regional_Population VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3576
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.