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 id for the trips that lasted at least as long as the average duration of trips in zip code 94103. | SELECT id FROM trip WHERE duration >= (SELECT AVG(duration) FROM trip WHERE zip_code = 94103) | CREATE TABLE trip (id VARCHAR(255), duration INTEGER, zip_code VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 107
} |
What are the dates in which the mean sea level pressure was between 30.3 and 31? | SELECT date FROM weather WHERE mean_sea_level_pressure_inches BETWEEN 30.3 AND 31 | CREATE TABLE weather (date VARCHAR(255), mean_sea_level_pressure_inches INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 108
} |
Find the day in which the difference between the max temperature and min temperature was the smallest. Also report the difference. | SELECT date, max_temperature_f - min_temperature_f FROM weather ORDER BY max_temperature_f - min_temperature_f LIMIT 1 | CREATE TABLE weather (date VARCHAR(255), max_temperature_f VARCHAR(255), min_temperature_f VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 109
} |
How many books are there? | SELECT COUNT(*) FROM book | CREATE TABLE book (Id VARCHAR(255), Title VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 115
} |
List the writers of the books in ascending alphabetical order. | SELECT Writer FROM book ORDER BY Writer | CREATE TABLE book (Writer VARCHAR(255), Title VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 116
} |
List the titles of the books in ascending order of issues. | SELECT Title FROM book ORDER BY Issues | CREATE TABLE book (Title VARCHAR(255), Issues VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 117
} |
What are the titles of the books whose writer is not "Elaine Lee"? | SELECT Title FROM book WHERE Writer <> 'Elaine Lee' | CREATE TABLE book (Title VARCHAR(255), Writer VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 118
} |
What are the title and issues of the books? | SELECT Title, Issues FROM book | CREATE TABLE book (Title VARCHAR(255), Issues VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 119
} |
What are the dates of publications in descending order of price? | SELECT Publication_Date FROM publication ORDER BY Price DESC | CREATE TABLE publication (Publication_Date VARCHAR(255), Price VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 120
} |
What are the distinct publishers of publications with price higher than 5000000? | SELECT DISTINCT Publisher FROM publication WHERE Price > 5000000 | CREATE TABLE publication (Publisher VARCHAR(255), Price INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 121
} |
List the publisher of the publication with the highest price. | SELECT Publisher FROM publication ORDER BY Price DESC LIMIT 1 | CREATE TABLE publication (Publisher VARCHAR(255), Price VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 122
} |
List the publication dates of publications with 3 lowest prices. | SELECT Publication_Date FROM publication ORDER BY Price LIMIT 3 | CREATE TABLE publication (Publication_Date VARCHAR(255), Price VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 123
} |
Show the title and publication dates of books. | SELECT T1.Title, T2.Publication_Date FROM book AS T1 JOIN publication AS T2 ON T1.Book_ID = T2.Book_ID | CREATE TABLE book (Title VARCHAR(255), Book_ID VARCHAR(255)); CREATE TABLE publication (Publication_Date VARCHAR(255), Book_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 124
} |
Show writers who have published a book with price more than 4000000. | SELECT T1.Writer FROM book AS T1 JOIN publication AS T2 ON T1.Book_ID = T2.Book_ID WHERE T2.Price > 4000000 | CREATE TABLE publication (Book_ID VARCHAR(255), Price INTEGER); CREATE TABLE book (Writer VARCHAR(255), Book_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 125
} |
Show the titles of books in descending order of publication price. | SELECT T1.Title FROM book AS T1 JOIN publication AS T2 ON T1.Book_ID = T2.Book_ID ORDER BY T2.Price DESC | CREATE TABLE publication (Book_ID VARCHAR(255), Price VARCHAR(255)); CREATE TABLE book (Title VARCHAR(255), Book_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 126
} |
Show publishers that have more than one publication. | SELECT Publisher FROM publication GROUP BY Publisher HAVING COUNT(*) > 1 | CREATE TABLE publication (Publisher 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": 127
} |
Show different publishers together with the number of publications they have. | SELECT Publisher, COUNT(*) FROM publication GROUP BY Publisher | CREATE TABLE publication (Publisher 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": 128
} |
Please show the most common publication date. | SELECT Publication_Date FROM publication GROUP BY Publication_Date ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE publication (Publication_Date 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": 129
} |
List the writers who have written more than one book. | SELECT Writer FROM book GROUP BY Writer HAVING COUNT(*) > 1 | CREATE TABLE book (Writer 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": 130
} |
List the titles of books that are not published. | SELECT Title FROM book WHERE NOT Book_ID IN (SELECT Book_ID FROM publication) | CREATE TABLE book (Title VARCHAR(255), Book_ID VARCHAR(255)); CREATE TABLE publication (Title VARCHAR(255), Book_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 131
} |
Show the publishers that have publications with price higher than 10000000 and publications with price lower than 5000000. | SELECT Publisher FROM publication WHERE Price > 10000000 INTERSECT SELECT Publisher FROM publication WHERE Price < 5000000 | CREATE TABLE publication (Publisher VARCHAR(255), Price INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 132
} |
What is the number of distinct publication dates? | SELECT COUNT(DISTINCT Publication_Date) FROM publication | CREATE TABLE publication (Publication_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": 133
} |
Show the prices of publications whose publisher is either "Person" or "Wiley" | SELECT Price FROM publication WHERE Publisher = 'Person' OR Publisher = 'Wiley' | CREATE TABLE publication (Price VARCHAR(255), Publisher 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": 134
} |
How many actors are there? | SELECT COUNT(*) FROM actor | CREATE TABLE actor (Id VARCHAR(255), Name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 135
} |
List the name of actors in ascending alphabetical order. | SELECT Name FROM actor ORDER BY Name | CREATE TABLE actor (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": 136
} |
What are the characters and duration of actors? | SELECT Character, Duration FROM actor | CREATE TABLE actor (Character VARCHAR(255), Duration 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": 137
} |
List the name of actors whose age is not 20. | SELECT Name FROM actor WHERE Age <> 20 | CREATE TABLE actor (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": 138
} |
What are the characters of actors in descending order of age? | SELECT Character FROM actor ORDER BY age DESC | CREATE TABLE actor (Character 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": 139
} |
What is the duration of the oldest actor? | SELECT Duration FROM actor ORDER BY Age DESC LIMIT 1 | CREATE TABLE actor (Duration 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": 140
} |
What are the names of musicals with nominee "Bob Fosse"? | SELECT Name FROM musical WHERE Nominee = 'Bob Fosse' | CREATE TABLE musical (Name VARCHAR(255), Nominee 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": 141
} |
What are the distinct nominees of the musicals with the award that is not "Tony Award"? | SELECT DISTINCT Nominee FROM musical WHERE Award <> 'Tony Award' | CREATE TABLE musical (Nominee VARCHAR(255), Award 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": 142
} |
Show names of actors and names of musicals they are in. | SELECT T1.Name, T2.Name FROM actor AS T1 JOIN musical AS T2 ON T1.Musical_ID = T2.Musical_ID | CREATE TABLE actor (Name VARCHAR(255), Musical_ID VARCHAR(255)); CREATE TABLE musical (Name VARCHAR(255), Musical_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 143
} |
Show names of actors that have appeared in musical with name "The Phantom of the Opera". | SELECT T1.Name FROM actor AS T1 JOIN musical AS T2 ON T1.Musical_ID = T2.Musical_ID WHERE T2.Name = 'The Phantom of the Opera' | CREATE TABLE actor (Name VARCHAR(255), Musical_ID VARCHAR(255)); CREATE TABLE musical (Musical_ID VARCHAR(255), Name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 144
} |
Show names of actors in descending order of the year their musical is awarded. | SELECT T1.Name FROM actor AS T1 JOIN musical AS T2 ON T1.Musical_ID = T2.Musical_ID ORDER BY T2.Year DESC | CREATE TABLE musical (Musical_ID VARCHAR(255), Year VARCHAR(255)); CREATE TABLE actor (Name VARCHAR(255), Musical_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 145
} |
Show names of musicals and the number of actors who have appeared in the musicals. | SELECT T2.Name, COUNT(*) FROM actor AS T1 JOIN musical AS T2 ON T1.Musical_ID = T2.Musical_ID GROUP BY T1.Musical_ID | CREATE TABLE actor (Musical_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE musical (Name VARCHAR(255), Musical_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 146
} |
Show names of musicals which have at least three actors. | SELECT T2.Name FROM actor AS T1 JOIN musical AS T2 ON T1.Musical_ID = T2.Musical_ID GROUP BY T1.Musical_ID HAVING COUNT(*) >= 3 | CREATE TABLE actor (Musical_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE musical (Name VARCHAR(255), Musical_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 147
} |
Show different nominees and the number of musicals they have been nominated. | SELECT Nominee, COUNT(*) FROM musical GROUP BY Nominee | CREATE TABLE musical (Nominee 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": 148
} |
Please show the nominee who has been nominated the greatest number of times. | SELECT Nominee FROM musical GROUP BY Nominee ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE musical (Nominee 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": 149
} |
List the most common result of the musicals. | SELECT RESULT FROM musical GROUP BY RESULT ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE musical (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": 150
} |
List the nominees that have been nominated more than two musicals. | SELECT Nominee FROM musical GROUP BY Nominee HAVING COUNT(*) > 2 | CREATE TABLE musical (Nominee 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": 151
} |
List the name of musicals that do not have actors. | SELECT Name FROM musical WHERE NOT Musical_ID IN (SELECT Musical_ID FROM actor) | CREATE TABLE actor (Name VARCHAR(255), Musical_ID VARCHAR(255)); CREATE TABLE musical (Name VARCHAR(255), Musical_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 152
} |
Show the nominees that have nominated musicals for both "Tony Award" and "Drama Desk Award". | SELECT Nominee FROM musical WHERE Award = 'Tony Award' INTERSECT SELECT Nominee FROM musical WHERE Award = 'Drama Desk Award' | CREATE TABLE musical (Nominee VARCHAR(255), Award VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 153
} |
Show the musical nominee with award "Bob Fosse" or "Cleavant Derricks". | SELECT Nominee FROM musical WHERE Award = 'Tony Award' OR Award = 'Cleavant Derricks' | CREATE TABLE musical (Nominee VARCHAR(255), Award VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 154
} |
Find the emails of the user named "Mary". | SELECT email FROM user_profiles WHERE name = 'Mary' | CREATE TABLE user_profiles (email VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 155
} |
What is the partition id of the user named "Iron Man". | SELECT partitionid FROM user_profiles WHERE name = 'Iron Man' | CREATE TABLE user_profiles (partitionid VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 156
} |
How many users are there? | SELECT COUNT(*) FROM user_profiles | CREATE TABLE user_profiles (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 157
} |
How many followers does each user have? | SELECT COUNT(*) FROM follows | CREATE TABLE follows (Id VARCHAR(255), user_id VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 158
} |
Find the number of followers for each user. | SELECT COUNT(*) FROM follows GROUP BY f1 | CREATE TABLE follows (f1 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": 159
} |
Find the number of tweets in record. | SELECT COUNT(*) FROM tweets | CREATE TABLE tweets (Id VARCHAR(255), content VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 160
} |
Find the number of users who posted some tweets. | SELECT COUNT(DISTINCT UID) FROM tweets | CREATE TABLE tweets (UID VARCHAR(255), tweet_text VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 161
} |
Find the name and email of the user whose name contains the word ‘Swift’. | SELECT name, email FROM user_profiles WHERE name LIKE '%Swift%' | CREATE TABLE user_profiles (name VARCHAR(255), email VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 162
} |
Find the names of users whose emails contain ‘superstar’ or ‘edu’. | SELECT name FROM user_profiles WHERE email LIKE '%superstar%' OR email LIKE '%edu%' | CREATE TABLE user_profiles (name VARCHAR(255), email VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 163
} |
Return the text of tweets about the topic 'intern'. | SELECT text FROM tweets WHERE text LIKE '%intern%' | CREATE TABLE tweets (text 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": 164
} |
Find the name and email of the users who have more than 1000 followers. | SELECT name, email FROM user_profiles WHERE followers > 1000 | CREATE TABLE user_profiles (name VARCHAR(255), email VARCHAR(255), followers INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 165
} |
Find the names of the users whose number of followers is greater than that of the user named "Tyler Swift". | SELECT T1.name FROM user_profiles AS T1 JOIN follows AS T2 ON T1.uid = T2.f1 GROUP BY T2.f1 HAVING COUNT(*) > (SELECT COUNT(*) FROM user_profiles AS T1 JOIN follows AS T2 ON T1.uid = T2.f1 WHERE T1.name = 'Tyler Swift') | CREATE TABLE follows (f1 VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE user_profiles (name VARCHAR(255), uid VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 166
} |
Find the name and email for the users who have more than one follower. | SELECT T1.name, T1.email FROM user_profiles AS T1 JOIN follows AS T2 ON T1.uid = T2.f1 GROUP BY T2.f1 HAVING COUNT(*) > 1 | CREATE TABLE follows (f1 VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE user_profiles (name VARCHAR(255), email VARCHAR(255), uid VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 167
} |
Find the names of users who have more than one tweet. | SELECT T1.name FROM user_profiles AS T1 JOIN tweets AS T2 ON T1.uid = T2.uid GROUP BY T2.uid HAVING COUNT(*) > 1 | CREATE TABLE tweets (uid VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE user_profiles (name VARCHAR(255), uid VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 168
} |
Find the id of users who are followed by Mary and Susan. | SELECT T2.f1 FROM user_profiles AS T1 JOIN follows AS T2 ON T1.uid = T2.f2 WHERE T1.name = 'Mary' INTERSECT SELECT T2.f1 FROM user_profiles AS T1 JOIN follows AS T2 ON T1.uid = T2.f2 WHERE T1.name = 'Susan' | CREATE TABLE follows (f1 VARCHAR(255), f2 VARCHAR(255)); CREATE TABLE user_profiles (uid VARCHAR(255), name VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 169
} |
Find the id of users who are followed by Mary or Susan. | SELECT T2.f1 FROM user_profiles AS T1 JOIN follows AS T2 ON T1.uid = T2.f2 WHERE T1.name = 'Mary' OR T1.name = 'Susan' | CREATE TABLE follows (f1 VARCHAR(255), f2 VARCHAR(255)); CREATE TABLE user_profiles (uid VARCHAR(255), name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 170
} |
Find the name of the user who has the largest number of followers. | SELECT name FROM user_profiles ORDER BY followers DESC LIMIT 1 | CREATE TABLE user_profiles (name VARCHAR(255), followers 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": 171
} |
Find the name and email of the user followed by the least number of people. | SELECT name, email FROM user_profiles ORDER BY followers LIMIT 1 | CREATE TABLE user_profiles (name VARCHAR(255), email VARCHAR(255), followers 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": 172
} |
List the name and number of followers for each user, and sort the results by the number of followers in descending order. | SELECT name, followers FROM user_profiles ORDER BY followers DESC | CREATE TABLE user_profiles (name VARCHAR(255), followers 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": 173
} |
List the names of 5 users followed by the largest number of other users. | SELECT name FROM user_profiles ORDER BY followers DESC LIMIT 5 | CREATE TABLE user_profiles (name VARCHAR(255), followers 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": 174
} |
List the text of all tweets in the order of date. | SELECT text FROM tweets ORDER BY createdate | CREATE TABLE tweets (text VARCHAR(255), createdate VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 175
} |
Find the name of each user and number of tweets tweeted by each of them. | SELECT T1.name, COUNT(*) FROM user_profiles AS T1 JOIN tweets AS T2 ON T1.uid = T2.uid GROUP BY T2.uid | CREATE TABLE tweets (uid VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE user_profiles (name VARCHAR(255), uid VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 176
} |
Find the name and partition id for users who tweeted less than twice. | SELECT T1.name, T1.partitionid FROM user_profiles AS T1 JOIN tweets AS T2 ON T1.uid = T2.uid GROUP BY T2.uid HAVING COUNT(*) < 2 | CREATE TABLE user_profiles (name VARCHAR(255), partitionid VARCHAR(255), uid VARCHAR(255)); CREATE TABLE tweets (uid VARCHAR(255), tweet_text VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 177
} |
Find the name of the user who tweeted more than once, and number of tweets tweeted by them. | SELECT T1.name, COUNT(*) FROM user_profiles AS T1 JOIN tweets AS T2 ON T1.uid = T2.uid GROUP BY T2.uid HAVING COUNT(*) > 1 | CREATE TABLE tweets (uid VARCHAR(255), tweet_text VARCHAR(255)); CREATE TABLE user_profiles (name VARCHAR(255), uid VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 178
} |
Find the average number of followers for the users who do not have any tweet. | SELECT AVG(followers) FROM user_profiles WHERE NOT UID IN (SELECT UID FROM tweets) | CREATE TABLE user_profiles (followers INTEGER, UID VARCHAR(255)); CREATE TABLE tweets (followers INTEGER, UID VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 179
} |
Find the average number of followers for the users who had some tweets. | SELECT AVG(followers) FROM user_profiles WHERE UID IN (SELECT UID FROM tweets) | CREATE TABLE user_profiles (followers INTEGER, UID VARCHAR(255)); CREATE TABLE tweets (followers INTEGER, UID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 180
} |
Find the maximum and total number of followers of all users. | SELECT MAX(followers), SUM(followers) FROM user_profiles | CREATE TABLE user_profiles (followers 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": 181
} |
Find the names of all the catalog entries. | SELECT DISTINCT (catalog_entry_name) FROM catalog_contents | CREATE TABLE catalog_contents (catalog_entry_name 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": 182
} |
Find the list of attribute data types possessed by more than 3 attribute definitions. | SELECT attribute_data_type FROM Attribute_Definitions GROUP BY attribute_data_type HAVING COUNT(*) > 3 | CREATE TABLE Attribute_Definitions (attribute_data_type 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": 183
} |
What is the attribute data type of the attribute with name "Green"? | SELECT attribute_data_type FROM Attribute_Definitions WHERE attribute_name = 'Green' | CREATE TABLE Attribute_Definitions (attribute_data_type VARCHAR(255), attribute_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 184
} |
Find the name and level of catalog structure with level between 5 and 10. | SELECT catalog_level_name, catalog_level_number FROM Catalog_Structure WHERE catalog_level_number BETWEEN 5 AND 10 | CREATE TABLE Catalog_Structure (catalog_level_name VARCHAR(255), catalog_level_number INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 185
} |
Find all the catalog publishers whose name contains "Murray" | SELECT DISTINCT (catalog_publisher) FROM catalogs WHERE catalog_publisher LIKE '%Murray%' | CREATE TABLE catalogs (catalog_publisher 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": 186
} |
Which catalog publisher has published the most catalogs? | SELECT catalog_publisher FROM catalogs GROUP BY catalog_publisher ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE catalogs (catalog_publisher 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": 187
} |
What is the entry name of the most expensive catalog (in USD)? | SELECT catalog_entry_name FROM catalog_contents ORDER BY price_in_dollars DESC LIMIT 1 | CREATE TABLE catalog_contents (catalog_entry_name VARCHAR(255), price_in_dollars VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 190
} |
What is the level name of the cheapest catalog (in USD)? | SELECT t2.catalog_level_name FROM catalog_contents AS t1 JOIN catalog_structure AS t2 ON t1.catalog_level_number = t2.catalog_level_number ORDER BY t1.price_in_dollars LIMIT 1 | CREATE TABLE catalog_structure (catalog_level_name VARCHAR(255), catalog_level_number VARCHAR(255)); CREATE TABLE catalog_contents (catalog_level_number VARCHAR(255), price_in_dollars VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 191
} |
What are the average and minimum price (in Euro) of all products? | SELECT AVG(price_in_euros), MIN(price_in_euros) FROM catalog_contents | CREATE TABLE catalog_contents (price_in_euros 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": 192
} |
What is the product with the highest height? Give me the catalog entry name. | SELECT catalog_entry_name FROM catalog_contents ORDER BY height DESC LIMIT 1 | CREATE TABLE catalog_contents (catalog_entry_name VARCHAR(255), height VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 193
} |
Find the name of the product that has the smallest capacity. | SELECT catalog_entry_name FROM catalog_contents ORDER BY capacity LIMIT 1 | CREATE TABLE catalog_contents (catalog_entry_name VARCHAR(255), capacity VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 194
} |
Find the names of all the products whose stock number starts with "2". | SELECT catalog_entry_name FROM catalog_contents WHERE product_stock_number LIKE '2%' | CREATE TABLE catalog_contents (catalog_entry_name VARCHAR(255), product_stock_number VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 195
} |
Find the names of catalog entries with level number 8. | SELECT t1.catalog_entry_name FROM Catalog_Contents AS t1 JOIN Catalog_Contents_Additional_Attributes AS t2 ON t1.catalog_entry_id = t2.catalog_entry_id WHERE t2.catalog_level_number = '8' | CREATE TABLE Catalog_Contents_Additional_Attributes (catalog_entry_id VARCHAR(255), catalog_level_number VARCHAR(255)); CREATE TABLE Catalog_Contents (catalog_entry_name VARCHAR(255), catalog_entry_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 196
} |
Find the names of the products with length smaller than 3 or height greater than 5. | SELECT catalog_entry_name FROM catalog_contents WHERE LENGTH < 3 OR width > 5 | CREATE TABLE catalog_contents (catalog_entry_name VARCHAR(255), LENGTH VARCHAR(255), width VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 197
} |
Find the name and attribute ID of the attribute definitions with attribute value 0. | SELECT t1.attribute_name, t1.attribute_id FROM Attribute_Definitions AS t1 JOIN Catalog_Contents_Additional_Attributes AS t2 ON t1.attribute_id = t2.attribute_id WHERE t2.attribute_value = 0 | CREATE TABLE Catalog_Contents_Additional_Attributes (attribute_id VARCHAR(255), attribute_value VARCHAR(255)); CREATE TABLE Attribute_Definitions (attribute_name VARCHAR(255), attribute_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 198
} |
Find the name and capacity of products with price greater than 700 (in USD). | SELECT catalog_entry_name, capacity FROM Catalog_Contents WHERE price_in_dollars > 700 | CREATE TABLE Catalog_Contents (catalog_entry_name VARCHAR(255), capacity VARCHAR(255), price_in_dollars INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 199
} |
Find the dates on which more than one revisions were made. | SELECT date_of_latest_revision FROM Catalogs GROUP BY date_of_latest_revision HAVING COUNT(*) > 1 | CREATE TABLE Catalogs (date_of_latest_revision 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": 200
} |
How many products are there in the records? | SELECT COUNT(*) FROM catalog_contents | CREATE TABLE catalog_contents (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 201
} |
Name all the products with next entry ID greater than 8. | SELECT catalog_entry_name FROM catalog_contents WHERE next_entry_id > 8 | CREATE TABLE catalog_contents (catalog_entry_name VARCHAR(255), next_entry_id INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 202
} |
How many aircrafts do we have? | SELECT COUNT(*) FROM Aircraft | CREATE TABLE Aircraft (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 203
} |
Show name and distance for all aircrafts. | SELECT name, distance FROM Aircraft | CREATE TABLE Aircraft (name VARCHAR(255), distance VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 204
} |
Show ids for all aircrafts with more than 1000 distance. | SELECT aid FROM Aircraft WHERE distance > 1000 | CREATE TABLE Aircraft (aid VARCHAR(255), distance INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 205
} |
How many aircrafts have distance between 1000 and 5000? | SELECT COUNT(*) FROM Aircraft WHERE distance BETWEEN 1000 AND 5000 | CREATE TABLE Aircraft (distance INTEGER, aid VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 206
} |
What is the name and distance for aircraft with id 12? | SELECT name, distance FROM Aircraft WHERE aid = 12 | CREATE TABLE Aircraft (name VARCHAR(255), distance VARCHAR(255), aid VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 207
} |
What is the minimum, average, and maximum distance of all aircrafts. | SELECT MIN(distance), AVG(distance), MAX(distance) FROM Aircraft | CREATE TABLE Aircraft (distance INTEGER, aid VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 2 | {
"split": "train",
"row_index": 208
} |
Show the id and name of the aircraft with the maximum distance. | SELECT aid, name FROM Aircraft ORDER BY distance DESC LIMIT 1 | CREATE TABLE Aircraft (aid VARCHAR(255), name VARCHAR(255), distance VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 209
} |
Show the name of aircrafts with top three lowest distances. | SELECT name FROM Aircraft ORDER BY distance LIMIT 3 | CREATE TABLE Aircraft (name VARCHAR(255), distance VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 210
} |
Show names for all aircrafts with distances more than the average. | SELECT name FROM Aircraft WHERE distance > (SELECT AVG(distance) FROM Aircraft) | CREATE TABLE Aircraft (name VARCHAR(255), distance INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 211
} |
How many employees do we have? | SELECT COUNT(*) FROM Employee | CREATE TABLE Employee (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 212
} |
Show name and salary for all employees sorted by salary. | SELECT name, salary FROM Employee ORDER BY salary | CREATE TABLE Employee (name VARCHAR(255), salary VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 213
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.