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 titles of all movies directed by steven spielberg. | SELECT title FROM Movie WHERE director = 'Steven Spielberg' | CREATE TABLE Movie (title VARCHAR(255), director 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": 1454
} |
What is the name of the movie produced after 2000 and directed by James Cameron? | SELECT title FROM Movie WHERE director = 'James Cameron' AND YEAR > 2000 | CREATE TABLE Movie (title VARCHAR(255), director VARCHAR(255), YEAR 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": 1455
} |
How many movies were made before 2000? | SELECT COUNT(*) FROM Movie WHERE YEAR < 2000 | CREATE TABLE Movie (YEAR INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1456
} |
Who is the director of movie Avatar? | SELECT director FROM Movie WHERE title = 'Avatar' | CREATE TABLE Movie (director VARCHAR(255), title 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": 1457
} |
How many reviewers listed? | SELECT COUNT(*) FROM Reviewer | CREATE TABLE Reviewer (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 1458
} |
What is the id of the reviewer whose name has substring “Mike”? | SELECT rID FROM Reviewer WHERE name LIKE '%Mike%' | CREATE TABLE Reviewer (rID VARCHAR(255), name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1459
} |
What is the reviewer id of Daniel Lewis? | SELECT rID FROM Reviewer WHERE name = 'Daniel Lewis' | CREATE TABLE Reviewer (rID VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1460
} |
What is the total number of ratings that has more than 3 stars? | SELECT COUNT(*) FROM Rating WHERE stars > 3 | CREATE TABLE Rating (stars INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1461
} |
What is the lowest and highest rating star? | SELECT MAX(stars), MIN(stars) FROM Rating | CREATE TABLE Rating (stars 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": 1462
} |
Find all years that have a movie that received a rating of 4 or 5, and sort them in increasing order of year. | SELECT DISTINCT YEAR FROM Movie AS T1 JOIN Rating AS T2 ON T1.mID = T2.mID WHERE T2.stars >= 4 ORDER BY T1.year | CREATE TABLE Movie (mID VARCHAR(255), year VARCHAR(255)); CREATE TABLE Rating (mID VARCHAR(255), stars VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 1463
} |
What are the names of directors who directed movies with 5 star rating? Also return the title of these movies. | SELECT T1.director, T1.title FROM Movie AS T1 JOIN Rating AS T2 ON T1.mID = T2.mID WHERE T2.stars = 5 | CREATE TABLE Movie (director VARCHAR(255), title VARCHAR(255), mID VARCHAR(255)); CREATE TABLE Rating (mID VARCHAR(255), stars VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1464
} |
What is the average rating star for each reviewer? | SELECT T2.name, AVG(T1.stars) FROM Rating AS T1 JOIN Reviewer AS T2 ON T1.rID = T2.rID GROUP BY T2.name | CREATE TABLE Reviewer (name VARCHAR(255), rID VARCHAR(255)); CREATE TABLE Rating (stars INTEGER, rID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1465
} |
Find the titles of all movies that have no ratings. | SELECT title FROM Movie WHERE NOT mID IN (SELECT mID FROM Rating) | CREATE TABLE Rating (title VARCHAR(255), mID VARCHAR(255)); CREATE TABLE Movie (title VARCHAR(255), mID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 1466
} |
What is the name of the most recent movie? | SELECT title FROM Movie WHERE YEAR = (SELECT MAX(YEAR) FROM Movie) | CREATE TABLE Movie (title VARCHAR(255), YEAR INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 1469
} |
What is the names of movies whose created year is after all movies directed by Steven Spielberg? | SELECT title FROM Movie WHERE YEAR > (SELECT MAX(YEAR) FROM Movie WHERE director = 'Steven Spielberg') | CREATE TABLE Movie (title VARCHAR(255), YEAR INTEGER, director VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 1471
} |
What are the titles and directors of the movies whose star is greater than the average stars of the movies directed by James Cameron? | SELECT T2.title, T2.director FROM Rating AS T1 JOIN Movie AS T2 ON T1.mID = T2.mID WHERE T1.stars > (SELECT AVG(T1.stars) FROM Rating AS T1 JOIN Movie AS T2 ON T1.mID = T2.mID WHERE T2.director = 'James Cameron') | CREATE TABLE Rating (mID VARCHAR(255), stars INTEGER); CREATE TABLE Movie (title VARCHAR(255), director VARCHAR(255), mID VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 1 | {
"split": "train",
"row_index": 1472
} |
Return reviewer name, movie title, stars, and ratingDate. And sort the data first by reviewer name, then by movie title, and lastly by number of stars. | SELECT T3.name, T2.title, T1.stars, T1.ratingDate FROM Rating AS T1 JOIN Movie AS T2 ON T1.mID = T2.mID JOIN Reviewer AS T3 ON T1.rID = T3.rID ORDER BY T3.name, T2.title, T1.stars | CREATE TABLE Rating (stars VARCHAR(255), ratingDate VARCHAR(255), mID VARCHAR(255), rID VARCHAR(255)); CREATE TABLE Reviewer (name VARCHAR(255), rID VARCHAR(255)); CREATE TABLE Movie (title VARCHAR(255), mID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 1473
} |
Find the names of all reviewers who have contributed three or more ratings. | SELECT T2.name FROM Rating AS T1 JOIN Reviewer AS T2 ON T1.rID = T2.rID GROUP BY T1.rID HAVING COUNT(*) >= 3 | CREATE TABLE Reviewer (name VARCHAR(255), rID VARCHAR(255)); CREATE TABLE Rating (rID 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": 1474
} |
Find the names of all reviewers who rated Gone with the Wind. | SELECT DISTINCT T3.name FROM Rating AS T1 JOIN Movie AS T2 ON T1.mID = T2.mID JOIN Reviewer AS T3 ON T1.rID = T3.rID WHERE T2.title = 'Gone with the Wind' | CREATE TABLE Movie (mID VARCHAR(255), title VARCHAR(255)); CREATE TABLE Reviewer (name VARCHAR(255), rID VARCHAR(255)); CREATE TABLE Rating (mID VARCHAR(255), rID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 1475
} |
Find the names of all directors whose movies are rated by Sarah Martinez. | SELECT DISTINCT T2.director FROM Rating AS T1 JOIN Movie AS T2 ON T1.mID = T2.mID JOIN Reviewer AS T3 ON T1.rID = T3.rID WHERE T3.name = 'Sarah Martinez' | CREATE TABLE Reviewer (rID VARCHAR(255), name VARCHAR(255)); CREATE TABLE Movie (director VARCHAR(255), mID VARCHAR(255)); CREATE TABLE Rating (mID VARCHAR(255), rID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 1476
} |
For any rating where the name of reviewer is the same as the director of the movie, return the reviewer name, movie title, and number of stars. | SELECT DISTINCT T3.name, T2.title, T1.stars FROM Rating AS T1 JOIN Movie AS T2 ON T1.mID = T2.mID JOIN Reviewer AS T3 ON T1.rID = T3.rID WHERE T2.director = T3.name | CREATE TABLE Rating (stars VARCHAR(255), mID VARCHAR(255), rID VARCHAR(255)); CREATE TABLE Reviewer (name VARCHAR(255), rID VARCHAR(255)); CREATE TABLE Movie (title VARCHAR(255), mID VARCHAR(255), director VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 1477
} |
Return all reviewer names and movie names together in a single list. | SELECT name FROM Reviewer UNION SELECT title FROM Movie | CREATE TABLE Reviewer (name VARCHAR(255), title VARCHAR(255)); CREATE TABLE Movie (name VARCHAR(255), title VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 1478
} |
What are the names of the directors who made exactly one movie? | SELECT director FROM Movie GROUP BY director HAVING COUNT(*) = 1 | CREATE TABLE Movie (director 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": 1482
} |
What are the names of the directors who made exactly one movie excluding director NULL? | SELECT director FROM Movie WHERE director <> 'null' GROUP BY director HAVING COUNT(*) = 1 | CREATE TABLE Movie (director 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": 1483
} |
How many movie reviews does each director get? | SELECT COUNT(*), T1.director FROM Movie AS T1 JOIN Rating AS T2 ON T1.mID = T2.mID GROUP BY T1.director | CREATE TABLE Rating (mID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Movie (director VARCHAR(255), mID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1484
} |
Find the movies with the highest average rating. Return the movie titles and average rating. | SELECT T2.title, AVG(T1.stars) FROM Rating AS T1 JOIN Movie AS T2 ON T1.mID = T2.mID GROUP BY T1.mID ORDER BY AVG(T1.stars) DESC LIMIT 1 | CREATE TABLE Rating (stars INTEGER, mID VARCHAR(255)); CREATE TABLE Movie (title VARCHAR(255), mID VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 2 | {
"split": "train",
"row_index": 1485
} |
What are the movie titles and average rating of the movies with the lowest average rating? | SELECT T2.title, AVG(T1.stars) FROM Rating AS T1 JOIN Movie AS T2 ON T1.mID = T2.mID GROUP BY T1.mID ORDER BY AVG(T1.stars) LIMIT 1 | CREATE TABLE Rating (stars INTEGER, mID VARCHAR(255)); CREATE TABLE Movie (title VARCHAR(255), mID VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 2 | {
"split": "train",
"row_index": 1486
} |
What are the names and years of the movies that has the top 3 highest rating star? | SELECT T2.title, T2.year FROM Rating AS T1 JOIN Movie AS T2 ON T1.mID = T2.mID ORDER BY T1.stars DESC LIMIT 3 | CREATE TABLE Rating (mID VARCHAR(255), stars VARCHAR(255)); CREATE TABLE Movie (title VARCHAR(255), year VARCHAR(255), mID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 1487
} |
For each director, return the director's name together with the title of the movie they directed that received the highest rating among all of their movies, and the value of that rating. Ignore movies whose director is NULL. | SELECT T2.title, T1.stars, T2.director, MAX(T1.stars) FROM Rating AS T1 JOIN Movie AS T2 ON T1.mID = T2.mID WHERE director <> 'null' GROUP BY director | CREATE TABLE Rating (stars INTEGER, mID VARCHAR(255)); CREATE TABLE Movie (title VARCHAR(255), director VARCHAR(255), mID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 1488
} |
Find the title and star rating of the movie that got the least rating star for each reviewer. | SELECT T2.title, T1.rID, T1.stars, MIN(T1.stars) FROM Rating AS T1 JOIN Movie AS T2 ON T1.mID = T2.mID GROUP BY T1.rID | CREATE TABLE Rating (rID VARCHAR(255), stars INTEGER, mID VARCHAR(255)); CREATE TABLE Movie (title VARCHAR(255), mID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1489
} |
Find the title and score of the movie with the lowest rating among all movies directed by each director. | SELECT T2.title, T1.stars, T2.director, MIN(T1.stars) FROM Rating AS T1 JOIN Movie AS T2 ON T1.mID = T2.mID GROUP BY T2.director | CREATE TABLE Rating (stars INTEGER, mID VARCHAR(255)); CREATE TABLE Movie (title VARCHAR(255), director VARCHAR(255), mID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1490
} |
What is the name of the movie that is rated by most of times? | SELECT T2.title, T1.mID FROM Rating AS T1 JOIN Movie AS T2 ON T1.mID = T2.mID GROUP BY T1.mID ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Rating (mID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Movie (title VARCHAR(255), mID VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 1491
} |
What are the titles of all movies that have rating star is between 3 and 5? | SELECT T2.title FROM Rating AS T1 JOIN Movie AS T2 ON T1.mID = T2.mID WHERE T1.stars BETWEEN 3 AND 5 | CREATE TABLE Rating (mID VARCHAR(255), stars INTEGER); CREATE TABLE Movie (title VARCHAR(255), mID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1492
} |
Find the names of reviewers who had given higher than 3 star ratings. | SELECT T2.name FROM Rating AS T1 JOIN Reviewer AS T2 ON T1.rID = T2.rID WHERE T1.stars > 3 | CREATE TABLE Reviewer (name VARCHAR(255), rID VARCHAR(255)); CREATE TABLE Rating (rID VARCHAR(255), stars INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1493
} |
Find the average rating star for each movie that received at least 2 ratings. | SELECT mID, AVG(stars) FROM Rating GROUP BY mID HAVING COUNT(*) >= 2 | CREATE TABLE Rating (mID VARCHAR(255), stars INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1496
} |
find the ids of reviewers who did not give 4 star. | SELECT rID FROM Rating EXCEPT SELECT rID FROM Rating WHERE stars = 4 | CREATE TABLE Rating (rID VARCHAR(255), stars VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 1497
} |
Find the ids of reviewers who didn't only give 4 star. | SELECT rID FROM Rating WHERE stars <> 4 | CREATE TABLE Rating (rID VARCHAR(255), stars VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1498
} |
What are names of the movies that are either made after 2000 or reviewed by Brittany Harris? | SELECT DISTINCT T2.title FROM Rating AS T1 JOIN Movie AS T2 ON T1.mID = T2.mID JOIN Reviewer AS T3 ON T1.rID = T3.rID WHERE T3.name = 'Brittany Harris' OR T2.year > 2000 | CREATE TABLE Reviewer (rID VARCHAR(255), name VARCHAR(255)); CREATE TABLE Movie (title VARCHAR(255), mID VARCHAR(255), year VARCHAR(255)); CREATE TABLE Rating (mID VARCHAR(255), rID VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 1499
} |
What are names of the movies that are either made before 1980 or directed by James Cameron? | SELECT title FROM Movie WHERE director = 'James Cameron' OR YEAR < 1980 | CREATE TABLE Movie (title VARCHAR(255), director VARCHAR(255), YEAR VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1500
} |
What are the names of reviewers who had rated 3 star and 4 star? | SELECT T2.name FROM Rating AS T1 JOIN Reviewer AS T2 ON T1.rID = T2.rID WHERE T1.stars = 3 INTERSECT SELECT T2.name FROM Rating AS T1 JOIN Reviewer AS T2 ON T1.rID = T2.rID WHERE T1.stars = 4 | CREATE TABLE Reviewer (name VARCHAR(255), rID VARCHAR(255)); CREATE TABLE Rating (rID VARCHAR(255), stars VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 1501
} |
What are the names of movies that get 3 star and 4 star? | SELECT T2.title FROM Rating AS T1 JOIN Movie AS T2 ON T1.mID = T2.mID WHERE T1.stars = 3 INTERSECT SELECT T2.title FROM Rating AS T1 JOIN Movie AS T2 ON T1.mID = T2.mID WHERE T1.stars = 4 | CREATE TABLE Rating (mID VARCHAR(255), stars VARCHAR(255)); CREATE TABLE Movie (title VARCHAR(255), mID VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 1502
} |
How many counties are there? | SELECT COUNT(*) FROM county_public_safety | CREATE TABLE county_public_safety (Id VARCHAR(255), Name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 1503
} |
List the names of counties in descending order of population. | SELECT Name FROM county_public_safety ORDER BY Population DESC | CREATE TABLE county_public_safety (Name VARCHAR(255), Population VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1504
} |
List the distinct police forces of counties whose location is not on east side. | SELECT DISTINCT Police_force FROM county_public_safety WHERE LOCATION <> 'East' | CREATE TABLE county_public_safety (Police_force VARCHAR(255), LOCATION VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1505
} |
What are the minimum and maximum crime rate of counties? | SELECT MIN(Crime_rate), MAX(Crime_rate) FROM county_public_safety | CREATE TABLE county_public_safety (Crime_rate 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": 1506
} |
Show the crime rates of counties in ascending order of number of police officers. | SELECT Crime_rate FROM county_public_safety ORDER BY Police_officers | CREATE TABLE county_public_safety (Crime_rate VARCHAR(255), Police_officers 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": 1507
} |
What are the names of cities in ascending alphabetical order? | SELECT Name FROM city ORDER BY Name | CREATE TABLE city (Name 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": 1508
} |
What are the percentage of hispanics in cities with the black percentage higher than 10? | SELECT Hispanic FROM city WHERE Black > 10 | CREATE TABLE city (Hispanic VARCHAR(255), Black INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1509
} |
List the name of the county with the largest population. | SELECT Name FROM county_public_safety ORDER BY Population DESC LIMIT 1 | CREATE TABLE county_public_safety (Name VARCHAR(255), 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": 1510
} |
List the names of the city with the top 5 white percentages. | SELECT Name FROM city ORDER BY White DESC LIMIT 5 | CREATE TABLE city (Name VARCHAR(255), White 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": 1511
} |
Show names of cities and names of counties they are in. | SELECT T1.Name, T2.Name FROM city AS T1 JOIN county_public_safety AS T2 ON T1.County_ID = T2.County_ID | CREATE TABLE city (Name VARCHAR(255), County_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE county_public_safety (Name VARCHAR(255), County_ID 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": 1512
} |
Show white percentages of cities and the crime rates of counties they are in. | SELECT T1.White, T2.Crime_rate FROM city AS T1 JOIN county_public_safety AS T2 ON T1.County_ID = T2.County_ID | CREATE TABLE city (White VARCHAR(255), County_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE county_public_safety (Crime_rate VARCHAR(255), County_ID 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": 1513
} |
Show the name of cities in the county that has the largest number of police officers. | SELECT name FROM city WHERE county_ID = (SELECT county_ID FROM county_public_safety ORDER BY Police_officers DESC LIMIT 1) | CREATE TABLE city (name VARCHAR(255), county_ID VARCHAR(255), Police_officers VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE county_public_safety (name VARCHAR(255), county_ID VARCHAR(255), Police_officers 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": 1514
} |
Show the number of cities in counties that have a population more than 20000. | SELECT COUNT(*) FROM city WHERE county_ID IN (SELECT county_ID FROM county_public_safety WHERE population > 20000) | CREATE TABLE county_public_safety (county_ID VARCHAR(255), population INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE city (county_ID VARCHAR(255), population INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 1515
} |
Show the crime rate of counties with a city having white percentage more than 90. | SELECT T2.Crime_rate FROM city AS T1 JOIN county_public_safety AS T2 ON T1.County_ID = T2.County_ID WHERE T1.White > 90 | CREATE TABLE county_public_safety (Crime_rate VARCHAR(255), County_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE city (County_ID VARCHAR(255), White 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": 1516
} |
Please show the police forces and the number of counties with each police force. | SELECT Police_force, COUNT(*) FROM county_public_safety GROUP BY Police_force | CREATE TABLE county_public_safety (Police_force 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": 1517
} |
What is the location shared by most counties? | SELECT LOCATION FROM county_public_safety GROUP BY LOCATION ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE county_public_safety (LOCATION 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": 1518
} |
List the names of counties that do not have any cities. | SELECT Name FROM county_public_safety WHERE NOT County_ID IN (SELECT County_ID FROM city) | CREATE TABLE city (Name VARCHAR(255), County_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE county_public_safety (Name VARCHAR(255), County_ID 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": 1519
} |
Show the police force shared by counties with location on the east and west. | SELECT Police_force FROM county_public_safety WHERE LOCATION = 'East' INTERSECT SELECT Police_force FROM county_public_safety WHERE LOCATION = 'West' | CREATE TABLE county_public_safety (Police_force VARCHAR(255), LOCATION 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": 1520
} |
Show the names of cities in counties that have a crime rate less than 100. | SELECT name FROM city WHERE county_id IN (SELECT county_id FROM county_public_safety WHERE Crime_rate < 100) | CREATE TABLE county_public_safety (name VARCHAR(255), county_id VARCHAR(255), Crime_rate INTEGER); CREATE TABLE city (name VARCHAR(255), county_id VARCHAR(255), Crime_rate INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 1521
} |
Show the case burden of counties in descending order of population. | SELECT Case_burden FROM county_public_safety ORDER BY Population DESC | CREATE TABLE county_public_safety (Case_burden VARCHAR(255), Population VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1522
} |
Find the names of all modern rooms with a base price below $160 and two beds. | SELECT roomName FROM Rooms WHERE basePrice < 160 AND beds = 2 AND decor = 'modern' | CREATE TABLE Rooms (roomName VARCHAR(255), decor VARCHAR(255), basePrice VARCHAR(255), beds VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1523
} |
Find all the rooms that have a price higher than 160 and can accommodate more than 2 people. Report room names and ids. | SELECT roomName, RoomId FROM Rooms WHERE basePrice > 160 AND maxOccupancy > 2 | CREATE TABLE Rooms (roomName VARCHAR(255), RoomId VARCHAR(255), basePrice VARCHAR(255), maxOccupancy VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 1524
} |
Find the most popular room in the hotel. The most popular room is the room that had seen the largest number of reservations. | SELECT T2.roomName FROM Reservations AS T1 JOIN Rooms AS T2 ON T1.Room = T2.RoomId GROUP BY T1.Room ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Reservations (Room VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Rooms (roomName VARCHAR(255), RoomId VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 1525
} |
How many kids stay in the rooms reserved by ROY SWEAZY? | SELECT kids FROM Reservations WHERE FirstName = 'ROY' AND LastName = 'SWEAZY' | CREATE TABLE Reservations (kids VARCHAR(255), FirstName VARCHAR(255), LastName VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1526
} |
How many times does ROY SWEAZY has reserved a room. | SELECT COUNT(*) FROM Reservations WHERE FirstName = 'ROY' AND LastName = 'SWEAZY' | CREATE TABLE Reservations (FirstName VARCHAR(255), LastName VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1527
} |
Which room has the highest rate? List the room's full name, rate, check in and check out date. | SELECT T2.roomName, T1.Rate, T1.CheckIn, T1.CheckOut FROM Reservations AS T1 JOIN Rooms AS T2 ON T1.Room = T2.RoomId GROUP BY T1.Room ORDER BY T1.Rate DESC LIMIT 1 | CREATE TABLE Rooms (roomName VARCHAR(255), RoomId VARCHAR(255)); CREATE TABLE Reservations (Rate VARCHAR(255), CheckIn VARCHAR(255), CheckOut VARCHAR(255), Room VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 1528
} |
How many adults stay in the room CONRAD SELBIG checked in on Oct 23, 2010? | SELECT Adults FROM Reservations WHERE CheckIn = '2010-10-23' AND FirstName = 'CONRAD' AND LastName = 'SELBIG' | CREATE TABLE Reservations (Adults VARCHAR(255), LastName VARCHAR(255), CheckIn VARCHAR(255), FirstName VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1529
} |
How many kids stay in the room DAMIEN TRACHSEL checked in on Sep 21, 2010? | SELECT Kids FROM Reservations WHERE CheckIn = '2010-09-21' AND FirstName = 'DAMIEN' AND LastName = 'TRACHSEL' | CREATE TABLE Reservations (Kids VARCHAR(255), LastName VARCHAR(255), CheckIn VARCHAR(255), FirstName VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1530
} |
How many king beds are there? | SELECT SUM(beds) FROM Rooms WHERE bedtype = 'King' | CREATE TABLE Rooms (beds INTEGER, bedtype VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1531
} |
List the names and decor of rooms that have a king bed. Sort the list by their price. | SELECT roomName, decor FROM Rooms WHERE bedtype = 'King' ORDER BY basePrice | CREATE TABLE Rooms (roomName VARCHAR(255), decor VARCHAR(255), bedtype VARCHAR(255), basePrice VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1532
} |
Which room has cheapest base price? List the room's name and the base price. | SELECT roomName, basePrice FROM Rooms ORDER BY basePrice LIMIT 1 | CREATE TABLE Rooms (roomName VARCHAR(255), basePrice VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1533
} |
What is the decor of room Recluse and defiance? | SELECT decor FROM Rooms WHERE roomName = 'Recluse and defiance' | CREATE TABLE Rooms (decor VARCHAR(255), roomName VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1534
} |
What is the average base price of different bed type? List bed type and average base price. | SELECT bedType, AVG(basePrice) FROM Rooms GROUP BY bedType | CREATE TABLE Rooms (bedType VARCHAR(255), basePrice INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1535
} |
What is the total number of people who could stay in the modern rooms in this inn? | SELECT SUM(maxOccupancy) FROM Rooms WHERE decor = 'modern' | CREATE TABLE Rooms (maxOccupancy INTEGER, decor VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1536
} |
What kind of decor has the least number of reservations? | SELECT T2.decor FROM Reservations AS T1 JOIN Rooms AS T2 ON T1.Room = T2.RoomId GROUP BY T2.decor ORDER BY COUNT(T2.decor) LIMIT 1 | CREATE TABLE Reservations (Room VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Rooms (decor VARCHAR(255), RoomId VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 1537
} |
List how many times the number of people in the room reached the maximum occupancy of the room. The number of people include adults and kids. | SELECT COUNT(*) FROM Reservations AS T1 JOIN Rooms AS T2 ON T1.Room = T2.RoomId WHERE T2.maxOccupancy = T1.Adults + T1.Kids | CREATE TABLE Rooms (RoomId VARCHAR(255), maxOccupancy VARCHAR(255)); CREATE TABLE Reservations (Room VARCHAR(255), Adults VARCHAR(255), Kids VARCHAR(255)) | generic | null | medium | extended | valid | valid | valid | [] | [] | [] | [
"Unsupported column expression: T1.Adults + T1.Kids"
] | [
"validated",
"extended",
"extended"
] | null | null | null | null | {
"split": "train",
"row_index": 1538
} |
Find the first and last names of people who payed more than the rooms' base prices. | SELECT T1.firstname, T1.lastname FROM Reservations AS T1 JOIN Rooms AS T2 ON T1.Room = T2.RoomId WHERE T1.Rate - T2.basePrice > 0 | CREATE TABLE Reservations (firstname VARCHAR(255), lastname VARCHAR(255), Room VARCHAR(255), Rate VARCHAR(255)); CREATE TABLE Rooms (RoomId VARCHAR(255), basePrice VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1539
} |
How many rooms are there? | SELECT COUNT(*) FROM Rooms | CREATE TABLE Rooms (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 1540
} |
Find the number of rooms with a king bed. | SELECT COUNT(*) FROM Rooms WHERE bedType = 'King' | CREATE TABLE Rooms (bedType 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": 1541
} |
Find the number of rooms for each bed type. | SELECT bedType, COUNT(*) FROM Rooms GROUP BY bedType | CREATE TABLE Rooms (bedType 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": 1542
} |
Find the name of the room with the maximum occupancy. | SELECT roomName FROM Rooms ORDER BY maxOccupancy DESC LIMIT 1 | CREATE TABLE Rooms (roomName VARCHAR(255), maxOccupancy VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1543
} |
Find the id and name of the most expensive base price room. | SELECT RoomId, roomName FROM Rooms ORDER BY basePrice DESC LIMIT 1 | CREATE TABLE Rooms (RoomId VARCHAR(255), roomName VARCHAR(255), basePrice VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1544
} |
List the type of bed and name of all traditional rooms. | SELECT roomName, bedType FROM Rooms WHERE decor = 'traditional' | CREATE TABLE Rooms (roomName VARCHAR(255), bedType VARCHAR(255), decor VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1545
} |
Find the number of rooms with king bed for each decor type. | SELECT decor, COUNT(*) FROM Rooms WHERE bedType = 'King' GROUP BY decor | CREATE TABLE Rooms (decor VARCHAR(255), bedType VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1546
} |
Find the average and minimum price of the rooms in different decor. | SELECT decor, AVG(basePrice), MIN(basePrice) FROM Rooms GROUP BY decor | CREATE TABLE Rooms (decor VARCHAR(255), basePrice INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 1547
} |
List the name of all rooms sorted by their prices. | SELECT roomName FROM Rooms ORDER BY basePrice | CREATE TABLE Rooms (roomName VARCHAR(255), basePrice VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1548
} |
Find the number of rooms with price higher than 120 for different decor. | SELECT decor, COUNT(*) FROM Rooms WHERE basePrice > 120 GROUP BY decor | CREATE TABLE Rooms (decor VARCHAR(255), basePrice INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1549
} |
List the name of rooms with king or queen bed. | SELECT roomName FROM Rooms WHERE bedType = 'King' OR bedType = 'Queen' | CREATE TABLE Rooms (roomName VARCHAR(255), bedType VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1550
} |
How many different types of beds are there? | SELECT COUNT(DISTINCT bedType) FROM Rooms | CREATE TABLE Rooms (bedType 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": 1551
} |
Find the name and id of the top 3 expensive rooms. | SELECT RoomId, roomName FROM Rooms ORDER BY basePrice DESC LIMIT 3 | CREATE TABLE Rooms (RoomId VARCHAR(255), roomName VARCHAR(255), basePrice VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1552
} |
Find the name of rooms whose price is higher than the average price. | SELECT roomName FROM Rooms WHERE basePrice > (SELECT AVG(basePrice) FROM Rooms) | CREATE TABLE Rooms (roomName VARCHAR(255), basePrice INTEGER, id INTEGER PRIMARY KEY) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 1553
} |
Find the number of rooms that do not have any reservation. | SELECT COUNT(*) FROM rooms WHERE NOT roomid IN (SELECT DISTINCT room FROM reservations) | CREATE TABLE rooms (roomid VARCHAR(255), room VARCHAR(255)); CREATE TABLE reservations (roomid VARCHAR(255), room VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 1554
} |
Return the name and number of reservations made for each of the rooms. | SELECT T2.roomName, COUNT(*), T1.Room FROM Reservations AS T1 JOIN Rooms AS T2 ON T1.Room = T2.RoomId GROUP BY T1.Room | CREATE TABLE Reservations (Room VARCHAR(255), id INTEGER PRIMARY KEY); CREATE TABLE Rooms (roomName VARCHAR(255), RoomId VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1555
} |
Find the names of rooms that have been reserved for more than 60 times. | SELECT T2.roomName FROM Reservations AS T1 JOIN Rooms AS T2 ON T1.Room = T2.RoomId GROUP BY T1.Room HAVING COUNT(*) > 60 | CREATE TABLE Reservations (Room VARCHAR(255), id INTEGER PRIMARY KEY); CREATE TABLE Rooms (roomName VARCHAR(255), RoomId VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1556
} |
Find the name of rooms whose base price is between 120 and 150. | SELECT roomname FROM rooms WHERE baseprice BETWEEN 120 AND 150 | CREATE TABLE rooms (roomname VARCHAR(255), baseprice INTEGER, id INTEGER PRIMARY KEY) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1557
} |
what are the details of the cmi masters that have the cross reference code 'Tax'? | SELECT T1.cmi_details FROM Customer_Master_Index AS T1 JOIN CMI_Cross_References AS T2 ON T1.master_customer_id = T2.master_customer_id WHERE T2.source_system_code = 'Tax' | CREATE TABLE CMI_Cross_References (master_customer_id VARCHAR(255), source_system_code VARCHAR(255)); CREATE TABLE Customer_Master_Index (cmi_details VARCHAR(255), master_customer_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1559
} |
What is the cmi cross reference id that is related to at least one council tax entry? List the cross reference id and source system code. | SELECT T1.cmi_cross_ref_id, T1.source_system_code FROM CMI_Cross_References AS T1 JOIN Council_Tax AS T2 ON T1.cmi_cross_ref_id = T2.cmi_cross_ref_id GROUP BY T1.cmi_cross_ref_id HAVING COUNT(*) >= 1 | CREATE TABLE Council_Tax (cmi_cross_ref_id VARCHAR(255), id INTEGER PRIMARY KEY); CREATE TABLE CMI_Cross_References (cmi_cross_ref_id VARCHAR(255), source_system_code VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1560
} |
How many business rates are related to each cmi cross reference? List cross reference id, master customer id and the n | SELECT T2.cmi_cross_ref_id, T2.master_customer_id, COUNT(*) FROM Business_Rates AS T1 JOIN CMI_Cross_References AS T2 ON T1.cmi_cross_ref_id = T2.cmi_cross_ref_id GROUP BY T2.cmi_cross_ref_id | CREATE TABLE Business_Rates (cmi_cross_ref_id VARCHAR(255), id INTEGER PRIMARY KEY); CREATE TABLE CMI_Cross_References (cmi_cross_ref_id VARCHAR(255), master_customer_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1561
} |
What is the tax source system code related to the benefits and overpayments? List the code and the benifit id, order by benifit id. | SELECT T1.source_system_code, T2.council_tax_id FROM CMI_Cross_References AS T1 JOIN Benefits_Overpayments AS T2 ON T1.cmi_cross_ref_id = T2.cmi_cross_ref_id ORDER BY T2.council_tax_id | CREATE TABLE CMI_Cross_References (source_system_code VARCHAR(255), cmi_cross_ref_id VARCHAR(255)); CREATE TABLE Benefits_Overpayments (council_tax_id VARCHAR(255), cmi_cross_ref_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1562
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.