Datasets:
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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
How many heads of the departments are older than 56 ? | SELECT COUNT(*) FROM head WHERE age > 56 | CREATE TABLE head (age 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": 0
} |
List the name, born state and age of the heads of departments ordered by age. | SELECT name, born_state, age FROM head ORDER BY age | CREATE TABLE head (name VARCHAR(255), born_state VARCHAR(255), age VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1
} |
List the creation year, name and budget of each department. | SELECT creation, name, budget_in_billions FROM department | CREATE TABLE department (creation VARCHAR(255), name VARCHAR(255), budget_in_billions VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 2
} |
What are the maximum and minimum budget of the departments? | SELECT MAX(budget_in_billions), MIN(budget_in_billions) FROM department | CREATE TABLE department (budget_in_billions 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": 3
} |
What are the names of the heads who are born outside the California state? | SELECT name FROM head WHERE born_state <> 'California' | CREATE TABLE head (name VARCHAR(255), born_state 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": 5
} |
What are the distinct creation years of the departments managed by a secretary born in state 'Alabama'? | SELECT DISTINCT T1.creation FROM department AS T1 JOIN management AS T2 ON T1.department_id = T2.department_id JOIN head AS T3 ON T2.head_id = T3.head_id WHERE T3.born_state = 'Alabama' | CREATE TABLE department (creation VARCHAR(255), department_id VARCHAR(255)); CREATE TABLE management (department_id VARCHAR(255), head_id VARCHAR(255)); CREATE TABLE head (head_id VARCHAR(255), born_state VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 6
} |
What are the names of the states where at least 3 heads were born? | SELECT born_state FROM head GROUP BY born_state HAVING COUNT(*) >= 3 | CREATE TABLE head (born_state 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": 7
} |
In which year were most departments established? | SELECT creation FROM department GROUP BY creation ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE department (creation 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": 8
} |
Show the name and number of employees for the departments managed by heads whose temporary acting value is 'Yes'? | SELECT T1.name, T1.num_employees FROM department AS T1 JOIN management AS T2 ON T1.department_id = T2.department_id WHERE T2.temporary_acting = 'Yes' | CREATE TABLE management (department_id VARCHAR(255), temporary_acting VARCHAR(255)); CREATE TABLE department (name VARCHAR(255), num_employees VARCHAR(255), department_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 9
} |
How many acting statuses are there? | SELECT COUNT(DISTINCT temporary_acting) FROM management | CREATE TABLE management (temporary_acting 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": 10
} |
How many departments are led by heads who are not mentioned? | SELECT COUNT(*) FROM department WHERE NOT department_id IN (SELECT department_id FROM management) | CREATE TABLE management (department_id VARCHAR(255), info VARCHAR(255)); CREATE TABLE department (department_id VARCHAR(255), info VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 11
} |
What are the distinct ages of the heads who are acting? | SELECT DISTINCT T1.age FROM management AS T2 JOIN head AS T1 ON T1.head_id = T2.head_id WHERE T2.temporary_acting = 'Yes' | CREATE TABLE head (age VARCHAR(255), head_id VARCHAR(255)); CREATE TABLE management (head_id VARCHAR(255), temporary_acting VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 12
} |
List the states where both the secretary of 'Treasury' department and the secretary of 'Homeland Security' were born. | SELECT T3.born_state FROM department AS T1 JOIN management AS T2 ON T1.department_id = T2.department_id JOIN head AS T3 ON T2.head_id = T3.head_id WHERE T1.name = 'Treasury' INTERSECT SELECT T3.born_state FROM department AS T1 JOIN management AS T2 ON T1.department_id = T2.department_id JOIN head AS T3 ON T2.head_id = ... | CREATE TABLE management (department_id VARCHAR(255), head_id VARCHAR(255)); CREATE TABLE head (born_state VARCHAR(255), head_id VARCHAR(255)); CREATE TABLE department (department_id VARCHAR(255), name VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 1 | 0 | {
"split": "train",
"row_index": 13
} |
Which department has more than 1 head at a time? List the id, name and the number of heads. | SELECT T1.department_id, T1.name, COUNT(*) FROM management AS T2 JOIN department AS T1 ON T1.department_id = T2.department_id GROUP BY T1.department_id HAVING COUNT(*) > 1 | CREATE TABLE management (department_id VARCHAR(255), role VARCHAR(255)); CREATE TABLE department (department_id VARCHAR(255), name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 14
} |
Which head's name has the substring 'Ha'? List the id and name. | SELECT head_id, name FROM head WHERE name LIKE '%Ha%' | CREATE TABLE head (head_id VARCHAR(255), name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 15
} |
How many farms are there? | SELECT COUNT(*) FROM farm | CREATE TABLE farm (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 16
} |
List the total number of horses on farms in ascending order. | SELECT Total_Horses FROM farm ORDER BY Total_Horses | CREATE TABLE farm (Total_Horses 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": 17
} |
What are the hosts of competitions whose theme is not "Aliens"? | SELECT Hosts FROM farm_competition WHERE Theme <> 'Aliens' | CREATE TABLE farm_competition (Hosts VARCHAR(255), Theme VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 18
} |
What are the themes of farm competitions sorted by year in ascending order? | SELECT Theme FROM farm_competition ORDER BY YEAR | CREATE TABLE farm_competition (Theme VARCHAR(255), YEAR VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 19
} |
What are the maximum and minimum number of cows across all farms. | SELECT MAX(Cows), MIN(Cows) FROM farm | CREATE TABLE farm (Cows 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": 21
} |
How many different statuses do cities have? | SELECT COUNT(DISTINCT Status) FROM city | CREATE TABLE city (Status 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": 22
} |
List official names of cities in descending order of population. | SELECT Official_Name FROM city ORDER BY Population DESC | CREATE TABLE city (Official_Name VARCHAR(255), Population VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 23
} |
List the official name and status of the city with the largest population. | SELECT Official_Name, Status FROM city ORDER BY Population DESC LIMIT 1 | CREATE TABLE city (Official_Name VARCHAR(255), Status VARCHAR(255), Population VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 24
} |
Show the years and the official names of the host cities of competitions. | SELECT T2.Year, T1.Official_Name FROM city AS T1 JOIN farm_competition AS T2 ON T1.City_ID = T2.Host_city_ID | CREATE TABLE city (Official_Name VARCHAR(255), City_ID VARCHAR(255)); CREATE TABLE farm_competition (Year VARCHAR(255), Host_city_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 25
} |
Show the official names of the cities that have hosted more than one competition. | SELECT T1.Official_Name FROM city AS T1 JOIN farm_competition AS T2 ON T1.City_ID = T2.Host_city_ID GROUP BY T2.Host_city_ID HAVING COUNT(*) > 1 | CREATE TABLE farm_competition (Host_city_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE city (Official_Name VARCHAR(255), City_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 26
} |
Show the status of the city that has hosted the greatest number of competitions. | SELECT T1.Status FROM city AS T1 JOIN farm_competition AS T2 ON T1.City_ID = T2.Host_city_ID GROUP BY T2.Host_city_ID ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE city (Status VARCHAR(255), City_ID VARCHAR(255)); CREATE TABLE farm_competition (Host_city_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 27
} |
Please show the themes of competitions with host cities having populations larger than 1000. | SELECT T2.Theme FROM city AS T1 JOIN farm_competition AS T2 ON T1.City_ID = T2.Host_city_ID WHERE T1.Population > 1000 | CREATE TABLE city (City_ID VARCHAR(255), Population INTEGER); CREATE TABLE farm_competition (Theme VARCHAR(255), Host_city_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 28
} |
Please show the different statuses of cities and the average population of cities with each status. | SELECT Status, AVG(Population) FROM city GROUP BY Status | CREATE TABLE city (Status VARCHAR(255), Population INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 29
} |
Please show the different statuses, ordered by the number of cities that have each. | SELECT Status FROM city GROUP BY Status ORDER BY COUNT(*) | CREATE TABLE city (Status 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": 30
} |
List the most common type of Status across cities. | SELECT Status FROM city GROUP BY Status ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE city (Status VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 31
} |
List the official names of cities that have not held any competition. | SELECT Official_Name FROM city WHERE NOT City_ID IN (SELECT Host_city_ID FROM farm_competition) | CREATE TABLE farm_competition (Official_Name VARCHAR(255), City_ID VARCHAR(255), Host_city_ID VARCHAR(255)); CREATE TABLE city (Official_Name VARCHAR(255), City_ID VARCHAR(255), Host_city_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 32
} |
Show the status shared by cities with population bigger than 1500 and smaller than 500. | SELECT Status FROM city WHERE Population > 1500 INTERSECT SELECT Status FROM city WHERE Population < 500 | CREATE TABLE city (Status VARCHAR(255), Population INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 33
} |
Find the official names of cities with population bigger than 1500 or smaller than 500. | SELECT Official_Name FROM city WHERE Population > 1500 OR Population < 500 | CREATE TABLE city (Official_Name VARCHAR(255), Population VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 34
} |
Show the census ranking of cities whose status are not "Village". | SELECT Census_Ranking FROM city WHERE Status <> 'Village' | CREATE TABLE city (Census_Ranking VARCHAR(255), Status VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 35
} |
which course has most number of registered students? | SELECT T1.course_name FROM courses AS T1 JOIN student_course_registrations AS T2 ON T1.course_id = T2.course_Id GROUP BY T1.course_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE courses (course_name VARCHAR(255), course_id VARCHAR(255)); CREATE TABLE student_course_registrations (course_Id VARCHAR(255), student_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 36
} |
what is id of students who registered some courses but the least number of courses in these students? | SELECT student_id FROM student_course_registrations GROUP BY student_id ORDER BY COUNT(*) LIMIT 1 | CREATE TABLE student_course_registrations (student_id VARCHAR(255), course_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 37
} |
what are the first name and last name of all candidates? | SELECT T2.first_name, T2.last_name FROM candidates AS T1 JOIN people AS T2 ON T1.candidate_id = T2.person_id | CREATE TABLE candidates (candidate_id VARCHAR(255), person_id VARCHAR(255)); CREATE TABLE people (first_name VARCHAR(255), last_name VARCHAR(255), person_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 38
} |
List the id of students who never attends courses? | SELECT student_id FROM students WHERE NOT student_id IN (SELECT student_id FROM student_course_attendance) | CREATE TABLE student_course_attendance (student_id VARCHAR(255), course_id VARCHAR(255)); CREATE TABLE students (student_id VARCHAR(255), student_name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 39
} |
List the id of students who attended some courses? | SELECT student_id FROM student_course_attendance | CREATE TABLE student_course_attendance (student_id VARCHAR(255), course_id VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 40
} |
What are the ids of all students for courses and what are the names of those courses? | SELECT T1.student_id, T2.course_name FROM student_course_registrations AS T1 JOIN courses AS T2 ON T1.course_id = T2.course_id | CREATE TABLE courses (course_name VARCHAR(255), course_id VARCHAR(255)); CREATE TABLE student_course_registrations (student_id VARCHAR(255), course_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 41
} |
What is detail of the student who most recently registered course? | SELECT T2.student_details FROM student_course_registrations AS T1 JOIN students AS T2 ON T1.student_id = T2.student_id ORDER BY T1.registration_date DESC LIMIT 1 | CREATE TABLE student_course_registrations (student_id VARCHAR(255), registration_date VARCHAR(255)); CREATE TABLE students (student_details VARCHAR(255), student_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 42
} |
How many students attend course English? | SELECT COUNT(*) FROM courses AS T1 JOIN student_course_attendance AS T2 ON T1.course_id = T2.course_id WHERE T1.course_name = 'English' | CREATE TABLE student_course_attendance (course_id VARCHAR(255), student_id VARCHAR(255)); CREATE TABLE courses (course_id VARCHAR(255), course_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 43
} |
How many courses do the student whose id is 171 attend? | SELECT COUNT(*) FROM courses AS T1 JOIN student_course_attendance AS T2 ON T1.course_id = T2.course_id WHERE T2.student_id = 171 | CREATE TABLE courses (course_id VARCHAR(255), course_name VARCHAR(255)); CREATE TABLE student_course_attendance (course_id VARCHAR(255), student_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 44
} |
Find id of the candidate whose email is stanley.monahan@example.org? | SELECT T2.candidate_id FROM people AS T1 JOIN candidates AS T2 ON T1.person_id = T2.candidate_id WHERE T1.email_address = 'stanley.monahan@example.org' | CREATE TABLE candidates (candidate_id VARCHAR(255), person_id VARCHAR(255)); CREATE TABLE people (person_id VARCHAR(255), email_address VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 45
} |
Find id of the candidate who most recently accessed the course? | SELECT candidate_id FROM candidate_assessments ORDER BY assessment_date DESC LIMIT 1 | CREATE TABLE candidate_assessments (candidate_id VARCHAR(255), assessment_date VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 46
} |
What is detail of the student who registered the most number of courses? | SELECT T1.student_details FROM students AS T1 JOIN student_course_registrations AS T2 ON T1.student_id = T2.student_id GROUP BY T1.student_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE students (student_details VARCHAR(255), student_id VARCHAR(255)); CREATE TABLE student_course_registrations (student_id VARCHAR(255), course_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 47
} |
List the id of students who registered some courses and the number of their registered courses? | SELECT T1.student_id, COUNT(*) FROM students AS T1 JOIN student_course_registrations AS T2 ON T1.student_id = T2.student_id GROUP BY T1.student_id | CREATE TABLE students (student_id VARCHAR(255), name VARCHAR(255)); CREATE TABLE student_course_registrations (student_id VARCHAR(255), course_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 48
} |
How many registed students do each course have? List course name and the number of their registered students? | SELECT T3.course_name, COUNT(*) FROM students AS T1 JOIN student_course_registrations AS T2 ON T1.student_id = T2.student_id JOIN courses AS T3 ON T2.course_id = T3.course_id GROUP BY T2.course_id | CREATE TABLE students (student_id VARCHAR(255), name VARCHAR(255)); CREATE TABLE courses (course_name VARCHAR(255), course_id VARCHAR(255)); CREATE TABLE student_course_registrations (course_id VARCHAR(255), student_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 49
} |
Find id of candidates whose assessment code is "Pass"? | SELECT candidate_id FROM candidate_assessments WHERE asessment_outcome_code = 'Pass' | CREATE TABLE candidate_assessments (candidate_id VARCHAR(255), asessment_outcome_code VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 50
} |
Find the cell mobile number of the candidates whose assessment code is "Fail"? | SELECT T3.cell_mobile_number FROM candidates AS T1 JOIN candidate_assessments AS T2 ON T1.candidate_id = T2.candidate_id JOIN people AS T3 ON T1.candidate_id = T3.person_id WHERE T2.asessment_outcome_code = 'Fail' | CREATE TABLE candidates (candidate_id VARCHAR(255), name VARCHAR(255)); CREATE TABLE people (cell_mobile_number VARCHAR(255), person_id VARCHAR(255)); CREATE TABLE candidate_assessments (candidate_id VARCHAR(255), asessment_outcome_code VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 51
} |
What are the id of students who registered course 301? | SELECT student_id FROM student_course_attendance WHERE course_id = 301 | CREATE TABLE student_course_attendance (student_id VARCHAR(255), course_id VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 52
} |
What is the id of the student who most recently registered course 301? | SELECT student_id FROM student_course_attendance WHERE course_id = 301 ORDER BY date_of_attendance DESC LIMIT 1 | CREATE TABLE student_course_attendance (student_id VARCHAR(255), course_id VARCHAR(255), date_of_attendance VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 53
} |
Find distinct cities of addresses of people? | SELECT DISTINCT T1.city FROM addresses AS T1 JOIN people_addresses AS T2 ON T1.address_id = T2.address_id | CREATE TABLE addresses (city VARCHAR(255), address_id VARCHAR(255)); CREATE TABLE people_addresses (address_id VARCHAR(255), person_id VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 54
} |
Find distinct cities of address of students? | SELECT DISTINCT T1.city FROM addresses AS T1 JOIN people_addresses AS T2 ON T1.address_id = T2.address_id JOIN students AS T3 ON T2.person_id = T3.student_id | CREATE TABLE students (student_id VARCHAR(255), name VARCHAR(255)); CREATE TABLE addresses (city VARCHAR(255), address_id VARCHAR(255)); CREATE TABLE people_addresses (address_id VARCHAR(255), person_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 55
} |
List the names of courses in alphabetical order? | SELECT course_name FROM courses ORDER BY course_name | CREATE TABLE courses (course_name VARCHAR(255), course_id VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 56
} |
List the first names of people in alphabetical order? | SELECT first_name FROM people ORDER BY first_name | CREATE TABLE people (first_name VARCHAR(255), last_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 57
} |
What are the id of students who registered courses or attended courses? | SELECT student_id FROM student_course_registrations UNION SELECT student_id FROM student_course_attendance | CREATE TABLE student_course_attendance (student_id VARCHAR(255), course_id VARCHAR(255)); CREATE TABLE student_course_registrations (student_id VARCHAR(255), course_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 58
} |
Find the id of courses which are registered or attended by student whose id is 121? | SELECT course_id FROM student_course_registrations WHERE student_id = 121 UNION SELECT course_id FROM student_course_attendance WHERE student_id = 121 | CREATE TABLE student_course_attendance (course_id VARCHAR(255), student_id VARCHAR(255)); CREATE TABLE student_course_registrations (course_id VARCHAR(255), student_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 59
} |
List the id of students who registered course statistics in the order of registration date. | SELECT T2.student_id FROM courses AS T1 JOIN student_course_registrations AS T2 ON T1.course_id = T2.course_id WHERE T1.course_name = 'statistics' ORDER BY T2.registration_date | CREATE TABLE student_course_registrations (student_id VARCHAR(255), course_id VARCHAR(255), registration_date VARCHAR(255)); CREATE TABLE courses (course_id VARCHAR(255), course_name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 61
} |
List the id of students who attended statistics courses in the order of attendance date. | SELECT T2.student_id FROM courses AS T1 JOIN student_course_attendance AS T2 ON T1.course_id = T2.course_id WHERE T1.course_name = 'statistics' ORDER BY T2.date_of_attendance | CREATE TABLE student_course_attendance (student_id VARCHAR(255), course_id VARCHAR(255), date_of_attendance VARCHAR(255)); CREATE TABLE courses (course_id VARCHAR(255), course_name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 62
} |
Give me the dates when the max temperature was higher than 85. | SELECT date FROM weather WHERE max_temperature_f > 85 | CREATE TABLE weather (date VARCHAR(255), max_temperature_f INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 63
} |
What are the names of stations that have latitude lower than 37.5? | SELECT name FROM station WHERE lat < 37.5 | CREATE TABLE station (name VARCHAR(255), lat INTEGER, long INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 64
} |
For each city, return the highest latitude among its stations. | SELECT city, MAX(lat) FROM station GROUP BY city | CREATE TABLE station (city VARCHAR(255), lat INTEGER, long INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 65
} |
Give me the start station and end station for the trips with the three oldest id. | SELECT start_station_name, end_station_name FROM trip ORDER BY id LIMIT 3 | CREATE TABLE trip (start_station_name VARCHAR(255), end_station_name VARCHAR(255), id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 66
} |
What is the average latitude and longitude of stations located in San Jose city? | SELECT AVG(lat), AVG(long) FROM station WHERE city = 'San Jose' | CREATE TABLE station (lat INTEGER, long INTEGER, city VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 67
} |
What is the id of the trip that has the shortest duration? | SELECT id FROM trip ORDER BY duration LIMIT 1 | CREATE TABLE trip (id VARCHAR(255), duration VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 68
} |
What is the total and maximum duration of trips with bike id 636? | SELECT SUM(duration), MAX(duration) FROM trip WHERE bike_id = 636 | CREATE TABLE trip (duration INTEGER, bike_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 69
} |
For each zip code, return the average mean temperature of August there. | SELECT zip_code, AVG(mean_temperature_f) FROM weather WHERE date LIKE '8/%' GROUP BY zip_code | CREATE TABLE weather (zip_code VARCHAR(255), mean_temperature_f INTEGER, date VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 70
} |
From the trip record, find the number of unique bikes. | SELECT COUNT(DISTINCT bike_id) FROM trip | CREATE TABLE trip (bike_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 71
} |
What is the number of distinct cities the stations are located at? | SELECT COUNT(DISTINCT city) FROM station | CREATE TABLE station (city 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": 72
} |
How many stations does Mountain View city has? | SELECT COUNT(*) FROM station WHERE city = 'Mountain View' | CREATE TABLE station (city 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": 73
} |
Return the unique name for stations that have ever had 7 bikes available. | SELECT DISTINCT T1.name FROM station AS T1 JOIN status AS T2 ON T1.id = T2.station_id WHERE T2.bikes_available = 7 | CREATE TABLE station (name VARCHAR(255), id VARCHAR(255)); CREATE TABLE status (station_id VARCHAR(255), bikes_available VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 74
} |
Which start station had the most trips starting from August? Give me the name and id of the station. | SELECT start_station_name, start_station_id FROM trip WHERE start_date LIKE '8/%' GROUP BY start_station_name ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE trip (start_station_name VARCHAR(255), start_station_id VARCHAR(255), start_date VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 5 | 0 | 1 | {
"split": "train",
"row_index": 75
} |
Which bike traveled the most often in zip code 94002? | SELECT bike_id FROM trip WHERE zip_code = 94002 GROUP BY bike_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE trip (bike_id VARCHAR(255), zip_code VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 76
} |
How many days had both mean humidity above 50 and mean visibility above 8? | SELECT COUNT(*) FROM weather WHERE mean_humidity > 50 AND mean_visibility_miles > 8 | CREATE TABLE weather (mean_humidity VARCHAR(255), mean_visibility_miles 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": 77
} |
What is the latitude, longitude, city of the station from which the shortest trip started? | SELECT T1.lat, T1.long, T1.city FROM station AS T1 JOIN trip AS T2 ON T1.id = T2.start_station_id ORDER BY T2.duration LIMIT 1 | CREATE TABLE trip (start_station_id VARCHAR(255), duration VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE station (lat VARCHAR(255), long VARCHAR(255), city VARCHAR(255), id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 78
} |
What are the ids of stations that are located in San Francisco and have average bike availability above 10. | SELECT id FROM station WHERE city = 'San Francisco' INTERSECT SELECT station_id FROM status GROUP BY station_id HAVING AVG(bikes_available) > 10 | CREATE TABLE status (id VARCHAR(255), station_id VARCHAR(255), city VARCHAR(255), bikes_available INTEGER); CREATE TABLE station (id VARCHAR(255), station_id VARCHAR(255), city VARCHAR(255), bikes_available INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 79
} |
What is the 3 most common cloud cover rates in the region of zip code 94107? | SELECT cloud_cover FROM weather WHERE zip_code = 94107 GROUP BY cloud_cover ORDER BY COUNT(*) DESC LIMIT 3 | CREATE TABLE weather (cloud_cover VARCHAR(255), zip_code VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 81
} |
What is the zip code in which the average mean sea level pressure is the lowest? | SELECT zip_code FROM weather GROUP BY zip_code ORDER BY AVG(mean_sea_level_pressure_inches) LIMIT 1 | CREATE TABLE weather (zip_code VARCHAR(255), mean_sea_level_pressure_inches INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 82
} |
What is the average bike availability in stations that are not located in Palo Alto? | SELECT AVG(bikes_available) FROM status WHERE NOT station_id IN (SELECT id FROM station WHERE city = 'Palo Alto') | CREATE TABLE status (bikes_available INTEGER, station_id VARCHAR(255), id VARCHAR(255), city VARCHAR(255)); CREATE TABLE station (bikes_available INTEGER, station_id VARCHAR(255), id VARCHAR(255), city VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 83
} |
What is the average longitude of stations that never had bike availability more than 10? | SELECT AVG(long) FROM station WHERE NOT id IN (SELECT station_id FROM status GROUP BY station_id HAVING MAX(bikes_available) > 10) | CREATE TABLE station (long INTEGER, id VARCHAR(255), station_id VARCHAR(255), bikes_available INTEGER); CREATE TABLE status (long INTEGER, id VARCHAR(255), station_id VARCHAR(255), bikes_available INTEGER) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 84
} |
When and in what zip code did max temperature reach 80? | SELECT date, zip_code FROM weather WHERE max_temperature_f >= 80 | CREATE TABLE weather (date VARCHAR(255), zip_code VARCHAR(255), max_temperature_f VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 85
} |
Give me ids for all the trip that took place in a zip code area with average mean temperature above 60. | SELECT T1.id FROM trip AS T1 JOIN weather AS T2 ON T1.zip_code = T2.zip_code GROUP BY T2.zip_code HAVING AVG(T2.mean_temperature_f) > 60 | CREATE TABLE trip (id VARCHAR(255), zip_code VARCHAR(255)); CREATE TABLE weather (zip_code VARCHAR(255), mean_temperature_f INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 86
} |
For each zip code, return how many times max wind speed reached 25? | SELECT zip_code, COUNT(*) FROM weather WHERE max_wind_Speed_mph >= 25 GROUP BY zip_code | CREATE TABLE weather (zip_code VARCHAR(255), max_wind_Speed_mph VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 87
} |
On which day and in which zip code was the min dew point lower than any day in zip code 94107? | SELECT date, zip_code FROM weather WHERE min_dew_point_f < (SELECT MIN(min_dew_point_f) FROM weather WHERE zip_code = 94107) | CREATE TABLE weather (date VARCHAR(255), zip_code VARCHAR(255), min_dew_point_f INTEGER) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 88
} |
For each trip, return its ending station's installation date. | SELECT T1.id, T2.installation_date FROM trip AS T1 JOIN station AS T2 ON T1.end_station_id = T2.id | CREATE TABLE station (installation_date VARCHAR(255), id VARCHAR(255)); CREATE TABLE trip (id VARCHAR(255), end_station_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 89
} |
Which trip started from the station with the largest dock count? Give me the trip id. | SELECT T1.id FROM trip AS T1 JOIN station AS T2 ON T1.start_station_id = T2.id ORDER BY T2.dock_count DESC LIMIT 1 | CREATE TABLE trip (id VARCHAR(255), start_station_id VARCHAR(255)); CREATE TABLE station (id VARCHAR(255), dock_count VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 90
} |
Count the number of trips that did not end in San Francisco city. | SELECT COUNT(*) FROM trip AS T1 JOIN station AS T2 ON T1.end_station_id = T2.id WHERE T2.city <> 'San Francisco' | CREATE TABLE trip (end_station_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE station (id VARCHAR(255), city VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 91
} |
In zip code 94107, on which day neither Fog nor Rain was not observed? | SELECT date FROM weather WHERE zip_code = 94107 AND EVENTS <> 'Fog' AND EVENTS <> 'Rain' | CREATE TABLE weather (date VARCHAR(255), EVENTS VARCHAR(255), zip_code VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 92
} |
What are the ids of stations that have latitude above 37.4 and never had bike availability below 7? | SELECT id FROM station WHERE lat > 37.4 EXCEPT SELECT station_id FROM status GROUP BY station_id HAVING MIN(bikes_available) < 7 | CREATE TABLE status (id VARCHAR(255), station_id VARCHAR(255), lat INTEGER, bikes_available INTEGER); CREATE TABLE station (id VARCHAR(255), station_id VARCHAR(255), lat INTEGER, bikes_available INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 93
} |
What are the name, latitude, and city of the station with the lowest latitude? | SELECT name, lat, city FROM station ORDER BY lat LIMIT 1 | CREATE TABLE station (name VARCHAR(255), lat VARCHAR(255), city VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 95
} |
What are the date, mean temperature and mean humidity for the top 3 days with the largest max gust speeds? | SELECT date, mean_temperature_f, mean_humidity FROM weather ORDER BY max_gust_speed_mph DESC LIMIT 3 | CREATE TABLE weather (date VARCHAR(255), mean_temperature_f VARCHAR(255), mean_humidity VARCHAR(255), max_gust_speed_mph VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 96
} |
List the name and the number of stations for all the cities that have at least 15 stations. | SELECT city, COUNT(*) FROM station GROUP BY city HAVING COUNT(*) >= 15 | CREATE TABLE station (city 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": 97
} |
Find the ids and names of stations from which at least 200 trips started. | SELECT start_station_id, start_station_name FROM trip GROUP BY start_station_name HAVING COUNT(*) >= 200 | CREATE TABLE trip (start_station_id VARCHAR(255), start_station_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 98
} |
Find the zip code in which the average mean visibility is lower than 10. | SELECT zip_code FROM weather GROUP BY zip_code HAVING AVG(mean_visibility_miles) < 10 | CREATE TABLE weather (zip_code VARCHAR(255), mean_visibility_miles INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 99
} |
List all the cities in a decreasing order of each city's stations' highest latitude. | SELECT city FROM station GROUP BY city ORDER BY MAX(lat) DESC | CREATE TABLE station (city VARCHAR(255), lat INTEGER, long INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 100
} |
What are the dates that had the top 5 cloud cover rates? Also tell me the cloud cover rate. | SELECT date, cloud_cover FROM weather ORDER BY cloud_cover DESC LIMIT 5 | CREATE TABLE weather (date VARCHAR(255), cloud_cover VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 101
} |
What are the ids and durations of the trips with the top 3 durations? | SELECT id, duration FROM trip ORDER BY duration DESC LIMIT 3 | CREATE TABLE trip (id VARCHAR(255), duration VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 102
} |
List all the distinct stations from which a trip of duration below 100 started. | SELECT DISTINCT start_station_name FROM trip WHERE duration < 100 | CREATE TABLE trip (start_station_name VARCHAR(255), duration INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 105
} |
Find all the zip codes in which the max dew point have never reached 70. | SELECT DISTINCT zip_code FROM weather EXCEPT SELECT DISTINCT zip_code FROM weather WHERE max_dew_point_f >= 70 | CREATE TABLE weather (zip_code VARCHAR(255), max_dew_point_f VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 106
} |
End of preview. Expand in Data Studio
sql-create-context refined
This dataset is a refinement of
philschmid/sql-create-context-copy.
It is not a new collection of questions. The copy is itself a duplicate of
b-mc2/sql-create-context.
Row order and the 78,577 questions are preserved. The SQL answers are
preserved except for quote normalisation and 541 structural repairs. The
CREATE TABLE context is preserved or expanded, and every row has
extended_hardness. Where the official Spider adapter accepts the statement,
the row also has spider_hardness.
The dataset file is data/sql/sql_context_v2.json in the
sql_tools repository. On the Hub the
same file is sql_context_v2.json, next to this README.md.
What changed relative to sql-create-context-copy
| Step | What it does to the copy | Rows affected |
|---|---|---|
| Quote rewrite | Double-quoted string literals in answer become single-quoted SQL strings. An apostrophe inside a literal is doubled. question and context are copied unchanged. Three FROM "t" table names stay double-quoted. |
62,967 statements changed; 503 apostrophes doubled |
| Validation | Generic SQLGlot check of SQL syntax, DDL syntax, and schema references. No SQL is executed. | 78,036 valid; 541 rejected |
| Repair | Only the 541 rejected rows are rewritten. A candidate is kept only when the new SQL and DDL validate. | 541 applied |
| DDL expansion | A model may add columns and give bare VARCHAR a length. The SQL query is not changed. Failed expansions keep the previous DDL. |
68,983 expanded; 8,025 unchanged; 1,569 failed, all kept |
| Hardness | spider_hardness where the official adapter accepts the statement, and extended_hardness on every row. |
78,577 extended labels; 75,382 Spider labels |
dialect is generic on the 78,036 rows that passed the first validation, and
mysql on the 541 repaired rows. correction_status is corrected on those
541 rows and empty otherwise. Compare spider_hardness and
extended_hardness only when both are set. They use the same names
(easy, medium, hard, extra). extended_hardness can also be
extreme.
Hardness counts
Spider shares are of the 75,382 rows with a Spider label. Extended shares are of all 78,577 rows.
| Label | Spider | Extended |
|---|---|---|
| easy | 51,082 | 53,001 |
| medium | 22,693 | 23,957 |
| hard | 913 | 921 |
| extra | 694 | 690 |
| extreme | 8 | |
| labeled | 75,382 | 78,577 |
classification_status is classified when both labels are set (75,382 rows)
and extended when only extended_hardness is set (3,195 rows). No row lacks
an extended label. The last entry of status_history is the same value.
Columns
Training and evaluation use question, answer, context, dialect,
spider_hardness, and extended_hardness.
| Column | Meaning |
|---|---|
question |
Natural-language question, unchanged from the copy. |
answer |
SQL query. Quotes are normalised. SQL text changes only on the 541 repaired rows. |
context |
One or more CREATE TABLE statements. Expanded rows have a richer DDL; unchanged and failed rows keep the previous DDL. |
dialect |
generic, or mysql on a repaired row. |
spider_hardness |
easy, medium, hard, extra, or empty. |
extended_hardness |
easy, medium, hard, extra, or extreme. Always set. |
classification_status |
classified or extended. |
syntax_status, ddl_syntax_status, schema_status |
Result of the structural checks. |
syntax_errors, ddl_syntax_errors, schema_errors, classification_errors |
Diagnostic lists. Empty when the check passed. |
status_history |
Ordered record of the pipeline events for the row. |
correction_status |
corrected on repaired rows; empty otherwise. |
component1, component2, others |
Spider counters. Empty when spider_hardness is empty. |
validation_source |
Split name and row index in the source copy. |
Limitations
Validation and hardness do not execute SQL. A row can be structurally valid
and still be a poor answer to its question. The 541 repairs were accepted
because the repaired SQL and DDL parse and the names resolve, not because a
database returned the expected rows. Columns added during expansion were
proposed by openai/gpt-oss-120b. They are not columns from a production
schema. Hardness measures statement shape, not how difficult a person would
find the question.
License and attribution
The source dataset is released under CC BY 4.0. This refinement is distributed under the same license. Cite the source dataset as well as this refinement.
Citation
@misc{bayer2026sqlcreatecontextrefined,
title = {sql-create-context refined},
author = {Bayer, Thomas and Grok},
year = {2026},
url = {https://github.com/bayerth/sql_tools},
note = {Refinement of philschmid/sql-create-context-copy, itself a duplicate of b-mc2/sql-create-context.}
}
@misc{bmc2_2023_sqlcreatecontext,
title = {sql-create-context Dataset},
author = {b-mc2},
year = {2023},
url = {https://huggingface.co/datasets/b-mc2/sql-create-context},
note = {Built by modifying WikiSQL and Spider.}
}
@inproceedings{yu2018spider,
title = {Spider: A Large-Scale Human-Labeled Dataset for Complex and Cross-Domain Semantic Parsing and Text-to-{SQL} Task},
author = {Yu, Tao and Zhang, Rui and Yang, Kai and Yasunaga, Michihiro and Wang, Dongxu and Li, Zifan and Ma, James and Li, Irene and Yao, Qingning and Roman, Shanelle and Zhang, Zilin and Radev, Dragomir},
booktitle = {Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing},
pages = {3911--3921},
year = {2018},
address = {Brussels, Belgium}
}
- Downloads last month
- 25