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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Show ids for all employees with at least 100000 salary. | SELECT eid FROM Employee WHERE salary > 100000 | CREATE TABLE Employee (eid VARCHAR(255), salary INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 214
} |
How many employees have salary between 100000 and 200000? | SELECT COUNT(*) FROM Employee WHERE salary BETWEEN 100000 AND 200000 | CREATE TABLE Employee (salary 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": 215
} |
What is the name and salary for employee with id 242518965? | SELECT name, salary FROM Employee WHERE eid = 242518965 | CREATE TABLE Employee (name VARCHAR(255), salary VARCHAR(255), eid VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 216
} |
What is average and maximum salary of all employees. | SELECT AVG(salary), MAX(salary) FROM Employee | CREATE TABLE Employee (salary 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": 217
} |
Show the id and name of the employee with maximum salary. | SELECT eid, name FROM Employee ORDER BY salary DESC LIMIT 1 | CREATE TABLE Employee (eid VARCHAR(255), name VARCHAR(255), salary VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 218
} |
Show the name of employees with three lowest salaries. | SELECT name FROM Employee ORDER BY salary LIMIT 3 | CREATE TABLE Employee (name VARCHAR(255), salary VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 219
} |
Show names for all employees with salary more than the average. | SELECT name FROM Employee WHERE salary > (SELECT AVG(salary) FROM Employee) | CREATE TABLE Employee (name VARCHAR(255), salary INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 220
} |
Show the id and salary of Mark Young. | SELECT eid, salary FROM Employee WHERE name = 'Mark Young' | CREATE TABLE Employee (eid VARCHAR(255), salary VARCHAR(255), name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 221
} |
How many flights do we have? | SELECT COUNT(*) FROM Flight | CREATE TABLE Flight (Id VARCHAR(255), departure_date VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 222
} |
Show flight number, origin, destination of all flights in the alphabetical order of the departure cities. | SELECT flno, origin, destination FROM Flight ORDER BY origin | CREATE TABLE Flight (flno VARCHAR(255), origin VARCHAR(255), destination VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 223
} |
Show all flight number from Los Angeles. | SELECT flno FROM Flight WHERE origin = 'Los Angeles' | CREATE TABLE Flight (flno VARCHAR(255), origin VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 224
} |
Show origins of all flights with destination Honolulu. | SELECT origin FROM Flight WHERE destination = 'Honolulu' | CREATE TABLE Flight (origin VARCHAR(255), destination VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 225
} |
Show me the departure date and arrival date for all flights from Los Angeles to Honolulu. | SELECT departure_date, arrival_date FROM Flight WHERE origin = 'Los Angeles' AND destination = 'Honolulu' | CREATE TABLE Flight (departure_date VARCHAR(255), arrival_date VARCHAR(255), origin VARCHAR(255), destination VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 226
} |
Show flight number for all flights with more than 2000 distance. | SELECT flno FROM Flight WHERE distance > 2000 | CREATE TABLE Flight (flno VARCHAR(255), distance INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 227
} |
What is the average price for flights from Los Angeles to Honolulu. | SELECT AVG(price) FROM Flight WHERE origin = 'Los Angeles' AND destination = 'Honolulu' | CREATE TABLE Flight (price INTEGER, origin VARCHAR(255), destination VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 228
} |
Show origin and destination for flights with price higher than 300. | SELECT origin, destination FROM Flight WHERE price > 300 | CREATE TABLE Flight (origin VARCHAR(255), destination VARCHAR(255), price INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 229
} |
Show the flight number and distance of the flight with maximum price. | SELECT flno, distance FROM Flight ORDER BY price DESC LIMIT 1 | CREATE TABLE Flight (flno VARCHAR(255), distance VARCHAR(255), price VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 230
} |
Show the flight number of flights with three lowest distances. | SELECT flno FROM Flight ORDER BY distance LIMIT 3 | CREATE TABLE Flight (flno VARCHAR(255), distance VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 231
} |
What is the average distance and average price for flights from Los Angeles. | SELECT AVG(distance), AVG(price) FROM Flight WHERE origin = 'Los Angeles' | CREATE TABLE Flight (distance INTEGER, price INTEGER, origin VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 232
} |
Show all origins and the number of flights from each origin. | SELECT origin, COUNT(*) FROM Flight GROUP BY origin | CREATE TABLE Flight (origin 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": 233
} |
Show all destinations and the number of flights to each destination. | SELECT destination, COUNT(*) FROM Flight GROUP BY destination | CREATE TABLE Flight (destination 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": 234
} |
Which origin has most number of flights? | SELECT origin FROM Flight GROUP BY origin ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Flight (origin 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": 235
} |
Which destination has least number of flights? | SELECT destination FROM Flight GROUP BY destination ORDER BY COUNT(*) LIMIT 1 | CREATE TABLE Flight (destination 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": 236
} |
What is the aircraft name for the flight with number 99 | SELECT T2.name FROM Flight AS T1 JOIN Aircraft AS T2 ON T1.aid = T2.aid WHERE T1.flno = 99 | CREATE TABLE Flight (aid VARCHAR(255), flno VARCHAR(255)); CREATE TABLE Aircraft (name VARCHAR(255), aid VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 237
} |
Show all flight numbers with aircraft Airbus A340-300. | SELECT T1.flno FROM Flight AS T1 JOIN Aircraft AS T2 ON T1.aid = T2.aid WHERE T2.name = 'Airbus A340-300' | CREATE TABLE Flight (flno VARCHAR(255), aid VARCHAR(255)); CREATE TABLE Aircraft (aid VARCHAR(255), name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 238
} |
Show aircraft names and number of flights for each aircraft. | SELECT T2.name, COUNT(*) FROM Flight AS T1 JOIN Aircraft AS T2 ON T1.aid = T2.aid GROUP BY T1.aid | CREATE TABLE Aircraft (name VARCHAR(255), aid VARCHAR(255)); CREATE TABLE Flight (aid 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": 239
} |
Show names for all aircraft with at least two flights. | SELECT T2.name FROM Flight AS T1 JOIN Aircraft AS T2 ON T1.aid = T2.aid GROUP BY T1.aid HAVING COUNT(*) >= 2 | CREATE TABLE Aircraft (name VARCHAR(255), aid VARCHAR(255)); CREATE TABLE Flight (aid VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 240
} |
How many employees have certificate. | SELECT COUNT(DISTINCT eid) FROM Certificate | CREATE TABLE Certificate (eid 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": 241
} |
Show ids for all employees who don't have a certificate. | SELECT eid FROM Employee EXCEPT SELECT eid FROM Certificate | CREATE TABLE Employee (eid VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Certificate (eid VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 242
} |
Show names for all aircrafts of which John Williams has certificates. | SELECT T3.name FROM Employee AS T1 JOIN Certificate AS T2 ON T1.eid = T2.eid JOIN Aircraft AS T3 ON T3.aid = T2.aid WHERE T1.name = 'John Williams' | CREATE TABLE Aircraft (name VARCHAR(255), aid VARCHAR(255)); CREATE TABLE Employee (eid VARCHAR(255), name VARCHAR(255)); CREATE TABLE Certificate (eid VARCHAR(255), aid VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 243
} |
Show names for all employees who have certificate of Boeing 737-800. | SELECT T1.name FROM Employee AS T1 JOIN Certificate AS T2 ON T1.eid = T2.eid JOIN Aircraft AS T3 ON T3.aid = T2.aid WHERE T3.name = 'Boeing 737-800' | CREATE TABLE Employee (name VARCHAR(255), eid VARCHAR(255)); CREATE TABLE Certificate (eid VARCHAR(255), aid VARCHAR(255)); CREATE TABLE Aircraft (aid VARCHAR(255), name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 244
} |
Show names for all employees who have certificates on both Boeing 737-800 and Airbus A340-300. | SELECT T1.name FROM Employee AS T1 JOIN Certificate AS T2 ON T1.eid = T2.eid JOIN Aircraft AS T3 ON T3.aid = T2.aid WHERE T3.name = 'Boeing 737-800' INTERSECT SELECT T1.name FROM Employee AS T1 JOIN Certificate AS T2 ON T1.eid = T2.eid JOIN Aircraft AS T3 ON T3.aid = T2.aid WHERE T3.name = 'Airbus A340-300' | CREATE TABLE Employee (name VARCHAR(255), eid VARCHAR(255)); CREATE TABLE Certificate (eid VARCHAR(255), aid VARCHAR(255)); CREATE TABLE Aircraft (aid VARCHAR(255), name VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 1 | 0 | {
"split": "train",
"row_index": 245
} |
Show the name of aircraft which fewest people have its certificate. | SELECT T2.name FROM Certificate AS T1 JOIN Aircraft AS T2 ON T2.aid = T1.aid GROUP BY T1.aid ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Certificate (aid VARCHAR(255), eid VARCHAR(255)); CREATE TABLE Aircraft (name VARCHAR(255), aid VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 247
} |
Show the name and distance of the aircrafts with more than 5000 distance and which at least 5 people have its certificate. | SELECT T2.name FROM Certificate AS T1 JOIN Aircraft AS T2 ON T2.aid = T1.aid WHERE T2.distance > 5000 GROUP BY T1.aid ORDER BY COUNT(*) >= 5 | CREATE TABLE Certificate (aid VARCHAR(255), eid VARCHAR(255)); CREATE TABLE Aircraft (name VARCHAR(255), aid VARCHAR(255), distance INTEGER) | generic | null | extra | extended | valid | valid | valid | [] | [] | [] | [
"Unsupported column expression: COUNT(*) >= 5"
] | [
"validated",
"extended",
"extended"
] | null | null | null | null | {
"split": "train",
"row_index": 248
} |
what is the salary and name of the employee who has the most number of aircraft certificates? | SELECT T1.name, T1.salary FROM Employee AS T1 JOIN Certificate AS T2 ON T1.eid = T2.eid GROUP BY T1.eid ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Certificate (eid VARCHAR(255), aid VARCHAR(255)); CREATE TABLE Employee (name VARCHAR(255), salary VARCHAR(255), eid VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 249
} |
What is the salary and name of the employee who has the most number of certificates on aircrafts with distance more than 5000? | SELECT T1.name FROM Employee AS T1 JOIN Certificate AS T2 ON T1.eid = T2.eid JOIN Aircraft AS T3 ON T3.aid = T2.aid WHERE T3.distance > 5000 GROUP BY T1.eid ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Aircraft (aid VARCHAR(255), distance INTEGER); CREATE TABLE Employee (name VARCHAR(255), eid VARCHAR(255)); CREATE TABLE Certificate (eid VARCHAR(255), aid VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 6 | 0 | 0 | {
"split": "train",
"row_index": 250
} |
How many allergies are there? | SELECT COUNT(DISTINCT allergy) FROM Allergy_type | CREATE TABLE Allergy_type (allergy 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": 251
} |
How many different allergy types exist? | SELECT COUNT(DISTINCT allergytype) FROM Allergy_type | CREATE TABLE Allergy_type (allergytype 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": 252
} |
Show all allergy types. | SELECT DISTINCT allergytype FROM Allergy_type | CREATE TABLE Allergy_type (allergytype 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": 253
} |
Show all allergies and their types. | SELECT allergy, allergytype FROM Allergy_type | CREATE TABLE Allergy_type (allergy VARCHAR(255), allergytype VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 254
} |
Show all allergies with type food. | SELECT DISTINCT allergy FROM Allergy_type WHERE allergytype = 'food' | CREATE TABLE Allergy_type (allergy VARCHAR(255), allergytype VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 255
} |
What is the type of allergy Cat? | SELECT allergytype FROM Allergy_type WHERE allergy = 'Cat' | CREATE TABLE Allergy_type (allergytype VARCHAR(255), allergy VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 256
} |
How many allergies have type animal? | SELECT COUNT(*) FROM Allergy_type WHERE allergytype = 'animal' | CREATE TABLE Allergy_type (allergytype 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": 257
} |
Show all allergy types and the number of allergies in each type. | SELECT allergytype, COUNT(*) FROM Allergy_type GROUP BY allergytype | CREATE TABLE Allergy_type (allergytype 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": 258
} |
Which allergy type has most number of allergies? | SELECT allergytype FROM Allergy_type GROUP BY allergytype ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Allergy_type (allergytype 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": 259
} |
Which allergy type has least number of allergies? | SELECT allergytype FROM Allergy_type GROUP BY allergytype ORDER BY COUNT(*) LIMIT 1 | CREATE TABLE Allergy_type (allergytype 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": 260
} |
How many students are there? | SELECT COUNT(*) FROM Student | CREATE TABLE Student (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 261
} |
Show first name and last name for all students. | SELECT Fname, Lname FROM Student | CREATE TABLE Student (Fname VARCHAR(255), Lname VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 262
} |
How many different advisors are listed? | SELECT COUNT(DISTINCT advisor) FROM Student | CREATE TABLE Student (advisor 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": 263
} |
Show all majors. | SELECT DISTINCT Major FROM Student | CREATE TABLE Student (Major 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": 264
} |
Show all cities where students live. | SELECT DISTINCT city_code FROM Student | CREATE TABLE Student (city_code 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": 265
} |
Show first name, last name, age for all female students. Their sex is F. | SELECT Fname, Lname, Age FROM Student WHERE Sex = 'F' | CREATE TABLE Student (Fname VARCHAR(255), Lname VARCHAR(255), Age VARCHAR(255), Sex VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 266
} |
Show student ids for all male students. | SELECT StuID FROM Student WHERE Sex = 'M' | CREATE TABLE Student (StuID VARCHAR(255), Sex VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 267
} |
How many students are age 18? | SELECT COUNT(*) FROM Student WHERE age = 18 | CREATE TABLE Student (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": 268
} |
Show all student ids who are older than 20. | SELECT StuID FROM Student WHERE age > 20 | CREATE TABLE Student (StuID VARCHAR(255), age INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 269
} |
Which city does the student whose last name is "Kim" live in? | SELECT city_code FROM Student WHERE LName = 'Kim' | CREATE TABLE Student (city_code VARCHAR(255), LName VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 270
} |
Who is the advisor of student with ID 1004? | SELECT Advisor FROM Student WHERE StuID = 1004 | CREATE TABLE Student (Advisor VARCHAR(255), StuID VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 271
} |
How many students live in HKG or CHI? | SELECT COUNT(*) FROM Student WHERE city_code = 'HKG' OR city_code = 'CHI' | CREATE TABLE Student (city_code 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": 272
} |
Show the minimum, average, and maximum age of all students. | SELECT MIN(age), AVG(age), MAX(age) FROM Student | CREATE TABLE Student (age 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": 273
} |
What is the last name of the youngest student? | SELECT LName FROM Student WHERE age = (SELECT MIN(age) FROM Student) | CREATE TABLE Student (LName VARCHAR(255), age INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 274
} |
Show the student id of the oldest student. | SELECT StuID FROM Student WHERE age = (SELECT MAX(age) FROM Student) | CREATE TABLE Student (StuID VARCHAR(255), age INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 275
} |
Show all majors and corresponding number of students. | SELECT major, COUNT(*) FROM Student GROUP BY major | CREATE TABLE Student (major 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": 276
} |
Which major has most number of students? | SELECT major FROM Student GROUP BY major ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Student (major 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": 277
} |
Show all ages and corresponding number of students. | SELECT age, COUNT(*) FROM Student GROUP BY age | CREATE TABLE Student (age 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": 278
} |
Show the average age for male and female students. | SELECT AVG(age), sex FROM Student GROUP BY sex | CREATE TABLE Student (sex VARCHAR(255), age INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 279
} |
Show all cities and corresponding number of students. | SELECT city_code, COUNT(*) FROM Student GROUP BY city_code | CREATE TABLE Student (city_code 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": 280
} |
Show all advisors and corresponding number of students. | SELECT advisor, COUNT(*) FROM Student GROUP BY advisor | CREATE TABLE Student (advisor 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": 281
} |
Which advisor has most number of students? | SELECT advisor FROM Student GROUP BY advisor ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Student (advisor 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": 282
} |
How many students have cat allergies? | SELECT COUNT(*) FROM Has_allergy WHERE Allergy = 'Cat' | CREATE TABLE Has_allergy (Allergy 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": 283
} |
Show all student IDs who have at least two allergies. | SELECT StuID FROM Has_allergy GROUP BY StuID HAVING COUNT(*) >= 2 | CREATE TABLE Has_allergy (StuID 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": 284
} |
What are the student ids of students who don't have any allergies? | SELECT StuID FROM Student EXCEPT SELECT StuID FROM Has_allergy | CREATE TABLE Has_allergy (StuID VARCHAR(255), Allergy VARCHAR(255)); CREATE TABLE Student (StuID VARCHAR(255), age INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 285
} |
How many female students have milk or egg allergies? | SELECT COUNT(*) FROM has_allergy AS T1 JOIN Student AS T2 ON T1.StuID = T2.StuID WHERE T2.sex = 'F' AND T1.allergy = 'Milk' OR T1.allergy = 'Eggs' | CREATE TABLE Student (StuID VARCHAR(255), sex VARCHAR(255)); CREATE TABLE has_allergy (StuID VARCHAR(255), allergy VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 286
} |
How many students have a food allergy? | SELECT COUNT(*) FROM Has_allergy AS T1 JOIN Allergy_type AS T2 ON T1.allergy = T2.allergy WHERE T2.allergytype = 'food' | CREATE TABLE Has_allergy (allergy VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Allergy_type (allergy VARCHAR(255), allergytype VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 287
} |
Which allergy has most number of students affected? | SELECT Allergy FROM Has_allergy GROUP BY Allergy ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Has_allergy (Allergy 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": 288
} |
Show all allergies with number of students affected. | SELECT Allergy, COUNT(*) FROM Has_allergy GROUP BY Allergy | CREATE TABLE Has_allergy (Allergy 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": 289
} |
Show all allergy type with number of students affected. | SELECT T2.allergytype, COUNT(*) FROM Has_allergy AS T1 JOIN Allergy_type AS T2 ON T1.allergy = T2.allergy GROUP BY T2.allergytype | CREATE TABLE Has_allergy (allergy VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Allergy_type (allergytype VARCHAR(255), allergy VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 290
} |
Find the last name and age of the student who has allergy to both milk and cat. | SELECT lname, age FROM Student WHERE StuID IN (SELECT StuID FROM Has_allergy WHERE Allergy = 'Milk' INTERSECT SELECT StuID FROM Has_allergy WHERE Allergy = 'Cat') | CREATE TABLE Has_allergy (lname VARCHAR(255), age VARCHAR(255), StuID VARCHAR(255), Allergy VARCHAR(255)); CREATE TABLE Student (lname VARCHAR(255), age VARCHAR(255), StuID VARCHAR(255), Allergy VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 291
} |
What are the allergies and their types that the student with first name Lisa has? And order the result by name of allergies. | SELECT T1.Allergy, T1.AllergyType FROM Allergy_type AS T1 JOIN Has_allergy AS T2 ON T1.Allergy = T2.Allergy JOIN Student AS T3 ON T3.StuID = T2.StuID WHERE T3.Fname = 'Lisa' ORDER BY T1.Allergy | CREATE TABLE Has_allergy (Allergy VARCHAR(255), StuID VARCHAR(255)); CREATE TABLE Student (StuID VARCHAR(255), Fname VARCHAR(255)); CREATE TABLE Allergy_type (Allergy VARCHAR(255), AllergyType VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 292
} |
Find the first name and gender of the student who has allergy to milk but not cat. | SELECT fname, sex FROM Student WHERE StuID IN (SELECT StuID FROM Has_allergy WHERE Allergy = 'Milk' EXCEPT SELECT StuID FROM Has_allergy WHERE Allergy = 'Cat') | CREATE TABLE Student (fname VARCHAR(255), sex VARCHAR(255), StuID VARCHAR(255), Allergy VARCHAR(255)); CREATE TABLE Has_allergy (fname VARCHAR(255), sex VARCHAR(255), StuID VARCHAR(255), Allergy VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 293
} |
Find the average age of the students who have allergies with food and animal types. | SELECT AVG(age) FROM Student WHERE StuID IN (SELECT T1.StuID FROM Has_allergy AS T1 JOIN Allergy_Type AS T2 ON T1.Allergy = T2.Allergy WHERE T2.allergytype = 'food' INTERSECT SELECT T1.StuID FROM Has_allergy AS T1 JOIN Allergy_Type AS T2 ON T1.Allergy = T2.Allergy WHERE T2.allergytype = 'animal') | CREATE TABLE Student (age INTEGER, StuID VARCHAR(255)); CREATE TABLE Allergy_Type (Allergy VARCHAR(255), allergytype VARCHAR(255)); CREATE TABLE Has_allergy (StuID VARCHAR(255), Allergy VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 294
} |
List the first and last name of the students who do not have any food type allergy. | SELECT fname, lname FROM Student WHERE NOT StuID IN (SELECT T1.StuID FROM Has_allergy AS T1 JOIN Allergy_Type AS T2 ON T1.Allergy = T2.Allergy WHERE T2.allergytype = 'food') | CREATE TABLE Student (fname VARCHAR(255), lname VARCHAR(255), StuID VARCHAR(255)); CREATE TABLE Allergy_Type (Allergy VARCHAR(255), allergytype VARCHAR(255)); CREATE TABLE Has_allergy (StuID VARCHAR(255), Allergy VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 295
} |
Find the number of male (sex is 'M') students who have some food type allery. | SELECT COUNT(*) FROM Student WHERE sex = 'M' AND StuID IN (SELECT StuID FROM Has_allergy AS T1 JOIN Allergy_Type AS T2 ON T1.Allergy = T2.Allergy WHERE T2.allergytype = 'food') | CREATE TABLE Has_allergy (Allergy VARCHAR(255), StuID VARCHAR(255)); CREATE TABLE Allergy_Type (Allergy VARCHAR(255), allergytype VARCHAR(255)); CREATE TABLE Student (sex VARCHAR(255), StuID VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 296
} |
Find the different first names and cities of the students who have allergy to milk or cat. | SELECT DISTINCT T1.fname, T1.city_code FROM Student AS T1 JOIN Has_Allergy AS T2 ON T1.stuid = T2.stuid WHERE T2.Allergy = 'Milk' OR T2.Allergy = 'Cat' | CREATE TABLE Has_Allergy (stuid VARCHAR(255), Allergy VARCHAR(255)); CREATE TABLE Student (fname VARCHAR(255), city_code VARCHAR(255), stuid VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 2 | {
"split": "train",
"row_index": 297
} |
Find the number of students who are older than 18 and do not have allergy to either food or animal. | SELECT COUNT(*) FROM Student WHERE age > 18 AND NOT StuID IN (SELECT StuID FROM Has_allergy AS T1 JOIN Allergy_Type AS T2 ON T1.Allergy = T2.Allergy WHERE T2.allergytype = 'food' OR T2.allergytype = 'animal') | CREATE TABLE Allergy_Type (Allergy VARCHAR(255), allergytype VARCHAR(255)); CREATE TABLE Has_allergy (Allergy VARCHAR(255), StuID VARCHAR(255)); CREATE TABLE Student (age VARCHAR(255), StuID VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 2 | {
"split": "train",
"row_index": 298
} |
Find the first name and major of the students who are not allegry to soy. | SELECT fname, major FROM Student WHERE NOT StuID IN (SELECT StuID FROM Has_allergy WHERE Allergy = 'Soy') | CREATE TABLE Has_allergy (fname VARCHAR(255), major VARCHAR(255), StuID VARCHAR(255), Allergy VARCHAR(255)); CREATE TABLE Student (fname VARCHAR(255), major VARCHAR(255), StuID VARCHAR(255), Allergy VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 299
} |
A list of the top 5 countries by number of invoices. List country name and number of invoices. | SELECT billing_country, COUNT(*) FROM invoices GROUP BY billing_country ORDER BY COUNT(*) DESC LIMIT 5 | CREATE TABLE invoices (billing_country VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 2 | {
"split": "train",
"row_index": 300
} |
A list of the top 8 countries by gross/total invoice size. List country name and gross invoice size. | SELECT billing_country, SUM(total) FROM invoices GROUP BY billing_country ORDER BY SUM(total) DESC LIMIT 8 | CREATE TABLE invoices (billing_country VARCHAR(255), total INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 2 | {
"split": "train",
"row_index": 301
} |
A list of the top 10 countries by average invoice size. List country name and average invoice size. | SELECT billing_country, AVG(total) FROM invoices GROUP BY billing_country ORDER BY AVG(total) DESC LIMIT 10 | CREATE TABLE invoices (billing_country VARCHAR(255), total INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 2 | {
"split": "train",
"row_index": 302
} |
Find out 5 customers who most recently purchased something. List customers' first and last name. | SELECT T1.first_name, T1.last_name FROM customers AS T1 JOIN invoices AS T2 ON T2.customer_id = T1.id ORDER BY T2.invoice_date DESC LIMIT 5 | CREATE TABLE customers (first_name VARCHAR(255), last_name VARCHAR(255), id VARCHAR(255)); CREATE TABLE invoices (customer_id VARCHAR(255), invoice_date VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 303
} |
Find out the top 10 customers by total number of orders. List customers' first and last name and the number of total orders. | SELECT T1.first_name, T1.last_name, COUNT(*) FROM customers AS T1 JOIN invoices AS T2 ON T2.customer_id = T1.id GROUP BY T1.id ORDER BY COUNT(*) DESC LIMIT 10 | CREATE TABLE customers (first_name VARCHAR(255), last_name VARCHAR(255), id VARCHAR(255)); CREATE TABLE invoices (customer_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 2 | {
"split": "train",
"row_index": 304
} |
List the top 10 customers by total gross sales. List customers' first and last name and total gross sales. | SELECT T1.first_name, T1.last_name, SUM(T2.total) FROM customers AS T1 JOIN invoices AS T2 ON T2.customer_id = T1.id GROUP BY T1.id ORDER BY SUM(T2.total) DESC LIMIT 10 | CREATE TABLE invoices (total INTEGER, customer_id VARCHAR(255)); CREATE TABLE customers (first_name VARCHAR(255), last_name VARCHAR(255), id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 2 | {
"split": "train",
"row_index": 305
} |
List the top 5 genres by number of tracks. List genres name and total tracks. | SELECT T1.name, COUNT(*) FROM genres AS T1 JOIN tracks AS T2 ON T2.genre_id = T1.id GROUP BY T1.id ORDER BY COUNT(*) DESC LIMIT 5 | CREATE TABLE tracks (genre_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE genres (name VARCHAR(255), id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 2 | {
"split": "train",
"row_index": 306
} |
List every album's title. | SELECT title FROM albums | CREATE TABLE albums (title 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": 307
} |
List every album ordered by album title in ascending order. | SELECT title FROM albums ORDER BY title | CREATE TABLE albums (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": 308
} |
List every album whose title starts with A in alphabetical order. | SELECT title FROM albums WHERE title LIKE 'A%' ORDER BY title | CREATE TABLE albums (title 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": 309
} |
List total amount of invoice from Chicago, IL. | SELECT SUM(total) FROM invoices WHERE billing_city = 'Chicago' AND billing_state = 'IL' | CREATE TABLE invoices (total INTEGER, billing_city VARCHAR(255), billing_state VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 311
} |
List the number of invoices from Chicago, IL. | SELECT COUNT(*) FROM invoices WHERE billing_city = 'Chicago' AND billing_state = 'IL' | CREATE TABLE invoices (billing_city VARCHAR(255), billing_state 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": 312
} |
List the number of invoices from the US, grouped by state. | SELECT billing_state, COUNT(*) FROM invoices WHERE billing_country = 'USA' GROUP BY billing_state | CREATE TABLE invoices (billing_state VARCHAR(255), billing_country 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": 313
} |
List the state in the US with the most invoices. | SELECT billing_state, COUNT(*) FROM invoices WHERE billing_country = 'USA' GROUP BY billing_state ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE invoices (billing_state VARCHAR(255), billing_country VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 2 | {
"split": "train",
"row_index": 314
} |
List the number of invoices and the invoice total from California. | SELECT billing_state, COUNT(*), SUM(total) FROM invoices WHERE billing_state = 'CA' | CREATE TABLE invoices (billing_state VARCHAR(255), total INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 315
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.