question string | answer string | context string | dialect string | spider_hardness string | extended_hardness string | classification_status string | syntax_status string | ddl_syntax_status string | schema_status string | syntax_errors list | ddl_syntax_errors list | schema_errors list | classification_errors list | status_history list | correction_status string | component1 int64 | component2 int64 | others int64 | validation_source dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Find the common login name of course authors and students. | SELECT login_name FROM Course_Authors_and_Tutors INTERSECT SELECT login_name FROM Students | CREATE TABLE Course_Authors_and_Tutors (login_name VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Students (login_name 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": 2250
} |
Find the common personal name of course authors and students. | SELECT personal_name FROM Course_Authors_and_Tutors INTERSECT SELECT personal_name FROM Students | CREATE TABLE Course_Authors_and_Tutors (personal_name VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Students (personal_name 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": 2251
} |
List the method, date and amount of all the payments, in ascending order of date. | SELECT Payment_Method_Code, Date_Payment_Made, Amount_Payment FROM Payments ORDER BY Date_Payment_Made | CREATE TABLE Payments (Payment_Method_Code VARCHAR(255), Date_Payment_Made VARCHAR(255), Amount_Payment VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2254
} |
Among all the claims, what is the settlement amount of the claim with the largest claim amount? List both the settlement amount and claim amount. | SELECT Amount_Settled, Amount_Claimed FROM Claims ORDER BY Amount_Claimed DESC LIMIT 1 | CREATE TABLE Claims (Amount_Settled VARCHAR(255), Amount_Claimed VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2255
} |
Among all the claims, what is the amount claimed in the claim with the least amount settled? List both the settlement amount and claim amount. | SELECT Amount_Settled, Amount_Claimed FROM Claims ORDER BY Amount_Settled LIMIT 1 | CREATE TABLE Claims (Amount_Settled VARCHAR(255), Amount_Claimed VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2256
} |
Among all the claims, which claims have a claimed amount larger than the average? List the date the claim was made and the date it was settled. | SELECT Date_Claim_Made, Date_Claim_Settled FROM Claims WHERE Amount_Claimed > (SELECT AVG(Amount_Claimed) FROM Claims) | CREATE TABLE Claims (Date_Claim_Made VARCHAR(255), Date_Claim_Settled VARCHAR(255), Amount_Claimed INTEGER) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 2257
} |
Among all the claims, which settlements have a claimed amount that is no more than the average? List the claim start date. | SELECT Date_Claim_Made FROM Claims WHERE Amount_Settled <= (SELECT AVG(Amount_Settled) FROM Claims) | CREATE TABLE Claims (Date_Claim_Made VARCHAR(255), Amount_Settled INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2258
} |
Which claim incurred the most number of settlements? List the claim id, the date the claim was made, and the number. | SELECT T1.claim_id, T1.date_claim_made, COUNT(*) FROM Claims AS T1 JOIN Settlements AS T2 ON T1.claim_id = T2.claim_id GROUP BY T1.claim_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Claims (claim_id VARCHAR(255), date_claim_made VARCHAR(255)); CREATE TABLE Settlements (claim_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 2 | {
"split": "train",
"row_index": 2260
} |
How many settlements were made on the claim with the most recent claim settlement date? List the number and the claim id. | SELECT COUNT(*), T1.claim_id FROM Claims AS T1 JOIN Settlements AS T2 ON T1.claim_id = T2.claim_id GROUP BY T1.claim_id ORDER BY T1.Date_Claim_Settled DESC LIMIT 1 | CREATE TABLE Settlements (claim_id VARCHAR(255)); CREATE TABLE Claims (claim_id VARCHAR(255), Date_Claim_Settled VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 2261
} |
Of all the claims, what was the earliest date when any claim was made? | SELECT Date_Claim_Made FROM Claims ORDER BY Date_Claim_Made LIMIT 1 | CREATE TABLE Claims (Date_Claim_Made 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": 2262
} |
What is the total amount of settlement made for all the settlements? | SELECT SUM(Amount_Settled) FROM Settlements | CREATE TABLE Settlements (Amount_Settled INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2263
} |
What are the claim dates and settlement dates of all the settlements? | SELECT Date_Claim_Made, Date_Claim_Settled FROM Settlements | CREATE TABLE Settlements (Date_Claim_Made VARCHAR(255), Date_Claim_Settled VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 2265
} |
What is the most popular payment method? | SELECT Payment_Method_Code FROM Payments GROUP BY Payment_Method_Code ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Payments (Payment_Method_Code 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": 2266
} |
With which kind of payment method were the least number of payments processed? | SELECT Payment_Method_Code FROM Payments GROUP BY Payment_Method_Code ORDER BY COUNT(*) LIMIT 1 | CREATE TABLE Payments (Payment_Method_Code 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": 2267
} |
What is the total amount of payment? | SELECT SUM(Amount_Payment) FROM Payments | CREATE TABLE Payments (Amount_Payment INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2268
} |
What are all the distinct details of the customers? | SELECT DISTINCT customer_details FROM Customers | CREATE TABLE Customers (customer_details 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": 2269
} |
Which kind of policy type was chosen by the most customers? | SELECT Policy_Type_Code FROM Customer_Policies GROUP BY Policy_Type_Code ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Customer_Policies (Policy_Type_Code 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": 2270
} |
How many settlements are there in total? | SELECT COUNT(*) FROM Settlements | CREATE TABLE Settlements (Id VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2271
} |
Which Payments were processed with Visa? List the payment Id, the date and the amount. | SELECT Payment_ID, Date_Payment_Made, Amount_Payment FROM Payments WHERE Payment_Method_Code = 'Visa' | CREATE TABLE Payments (Payment_ID VARCHAR(255), Date_Payment_Made VARCHAR(255), Amount_Payment VARCHAR(255), Payment_Method_Code VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2272
} |
Find the total claimed amount of all the claims. | SELECT SUM(Amount_Claimed) FROM Claims | CREATE TABLE Claims (Amount_Claimed INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2275
} |
Which department has the largest number of employees? | SELECT name FROM department GROUP BY departmentID ORDER BY COUNT(departmentID) DESC LIMIT 1 | CREATE TABLE department (name VARCHAR(255), departmentID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2276
} |
What is the employee id of the head whose department has the least number of employees? | SELECT head FROM department GROUP BY departmentID ORDER BY COUNT(departmentID) LIMIT 1 | CREATE TABLE department (head VARCHAR(255), departmentID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2277
} |
Find the id of the appointment with the most recent start date? | SELECT appointmentid FROM appointment ORDER BY START DESC LIMIT 1 | CREATE TABLE appointment (appointmentid VARCHAR(255), START VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2281
} |
List the name of physicians who took some appointment. | SELECT T2.name FROM appointment AS T1 JOIN physician AS T2 ON T1.Physician = T2.EmployeeID | CREATE TABLE appointment (Physician VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE physician (name VARCHAR(255), EmployeeID VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2282
} |
Find the names of all physicians and their primary affiliated departments' names. | SELECT T1.name, T3.name FROM physician AS T1 JOIN affiliated_with AS T2 ON T1.EmployeeID = T2.physician JOIN department AS T3 ON T2.department = T3.DepartmentID WHERE T2.PrimaryAffiliation = 1 | CREATE TABLE department (name VARCHAR(255), DepartmentID VARCHAR(255)); CREATE TABLE affiliated_with (physician VARCHAR(255), department VARCHAR(255), PrimaryAffiliation VARCHAR(255)); CREATE TABLE physician (name VARCHAR(255), EmployeeID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 2284
} |
What is the name of the patient who made the most recent appointment? | SELECT T1.name FROM patient AS T1 JOIN appointment AS T2 ON T1.ssn = T2.patient ORDER BY T2.start DESC LIMIT 1 | CREATE TABLE patient (name VARCHAR(255), ssn VARCHAR(255)); CREATE TABLE appointment (patient VARCHAR(255), start VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2285
} |
How many patients stay in room 112? | SELECT COUNT(patient) FROM stay WHERE room = 112 | CREATE TABLE stay (patient VARCHAR(255), room VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2286
} |
How many patients' prescriptions are made by physician John Dorian? | SELECT COUNT(T1.SSN) FROM patient AS T1 JOIN prescribes AS T2 ON T1.SSN = T2.patient JOIN physician AS T3 ON T2.physician = T3.employeeid WHERE T3.name = 'John Dorian' | CREATE TABLE patient (SSN VARCHAR(255), name VARCHAR(255)); CREATE TABLE prescribes (patient VARCHAR(255), physician VARCHAR(255)); CREATE TABLE physician (employeeid VARCHAR(255), name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2287
} |
Find the patient who most recently stayed in room 111. | SELECT patient FROM stay WHERE room = 111 ORDER BY staystart DESC LIMIT 1 | CREATE TABLE stay (patient VARCHAR(255), room VARCHAR(255), staystart VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2289
} |
What is the name of the nurse has the most appointments? | SELECT T1.name FROM nurse AS T1 JOIN appointment AS T2 ON T1.employeeid = T2.prepnurse GROUP BY T1.employeeid ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE nurse (name VARCHAR(255), employeeid VARCHAR(255)); CREATE TABLE appointment (prepnurse 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": 2290
} |
How many patients do each physician take care of? List their names and number of patients they take care of. | SELECT T1.name, COUNT(*) FROM physician AS T1 JOIN patient AS T2 ON T1.employeeid = T2.PCP GROUP BY T1.employeeid | CREATE TABLE patient (PCP VARCHAR(255), SSN VARCHAR(255)); CREATE TABLE physician (name VARCHAR(255), employeeid VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2291
} |
Find the name of physicians who are in charge of more than one patient. | SELECT T1.name FROM physician AS T1 JOIN patient AS T2 ON T1.employeeid = T2.PCP GROUP BY T1.employeeid HAVING COUNT(*) > 1 | CREATE TABLE patient (PCP VARCHAR(255), SSN VARCHAR(255)); CREATE TABLE physician (name VARCHAR(255), employeeid VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2292
} |
Find the number of rooms located on each block floor. | SELECT COUNT(*), T1.blockfloor FROM BLOCK AS T1 JOIN room AS T2 ON T1.blockfloor = T2.blockfloor AND T1.blockcode = T2.blockcode GROUP BY T1.blockfloor | CREATE TABLE room (blockfloor VARCHAR(255), blockcode VARCHAR(255)); CREATE TABLE BLOCK (blockfloor VARCHAR(255), blockcode VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2293
} |
Find the number of rooms for different block code? | SELECT COUNT(*), T1.blockcode FROM BLOCK AS T1 JOIN room AS T2 ON T1.blockfloor = T2.blockfloor AND T1.blockcode = T2.blockcode GROUP BY T1.blockcode | CREATE TABLE room (blockfloor VARCHAR(255), blockcode VARCHAR(255)); CREATE TABLE BLOCK (blockcode VARCHAR(255), blockfloor VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2294
} |
What are the unique block codes that have available rooms? | SELECT DISTINCT blockcode FROM room WHERE unavailable = 0 | CREATE TABLE room (blockcode VARCHAR(255), unavailable VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2295
} |
How many different types of rooms are there? | SELECT COUNT(DISTINCT roomtype) FROM room | CREATE TABLE room (roomtype 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": 2296
} |
What is the names of the physicians who prescribe medication Thesisin? | SELECT DISTINCT T1.name FROM physician AS T1 JOIN prescribes AS T2 ON T1.employeeid = T2.physician JOIN medication AS T3 ON T3.code = T2.medication WHERE T3.name = 'Thesisin' | CREATE TABLE physician (name VARCHAR(255), employeeid VARCHAR(255)); CREATE TABLE prescribes (physician VARCHAR(255), medication VARCHAR(255)); CREATE TABLE medication (code VARCHAR(255), name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2297
} |
Find the name and position of physicians who prescribe some medication whose brand is X? | SELECT DISTINCT T1.name, T1.position FROM physician AS T1 JOIN prescribes AS T2 ON T1.employeeid = T2.physician JOIN medication AS T3 ON T3.code = T2.medication WHERE T3.Brand = 'X' | CREATE TABLE medication (code VARCHAR(255), Brand VARCHAR(255)); CREATE TABLE prescribes (physician VARCHAR(255), medication VARCHAR(255)); CREATE TABLE physician (name VARCHAR(255), position VARCHAR(255), employeeid VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 2298
} |
Find the number of medications prescribed for each brand. | SELECT COUNT(*), T1.name FROM medication AS T1 JOIN prescribes AS T2 ON T1.code = T2.medication GROUP BY T1.brand | CREATE TABLE medication (name VARCHAR(255), brand VARCHAR(255), code VARCHAR(255)); CREATE TABLE prescribes (medication 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": 2299
} |
Find the name of physicians whose position title contains the word 'senior'. | SELECT name FROM physician WHERE POSITION LIKE '%senior%' | CREATE TABLE physician (name VARCHAR(255), POSITION VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2300
} |
Find the patient who has the most recent undergoing treatment? | SELECT patient FROM undergoes ORDER BY dateundergoes LIMIT 1 | CREATE TABLE undergoes (patient VARCHAR(255), dateundergoes VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2301
} |
Find the names of all patients who have an undergoing treatment and are staying in room 111. | SELECT DISTINCT T2.name FROM undergoes AS T1 JOIN patient AS T2 ON T1.patient = T2.SSN JOIN stay AS T3 ON T1.Stay = T3.StayID WHERE T3.room = 111 | CREATE TABLE undergoes (patient VARCHAR(255), Stay VARCHAR(255)); CREATE TABLE stay (StayID VARCHAR(255), room VARCHAR(255)); CREATE TABLE patient (name VARCHAR(255), SSN VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2302
} |
List the names of all distinct nurses ordered by alphabetical order? | SELECT DISTINCT name FROM nurse ORDER BY name | CREATE TABLE nurse (name VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2303
} |
Find the names of nurses who are nursing an undergoing treatment. | SELECT DISTINCT T2.name FROM undergoes AS T1 JOIN nurse AS T2 ON T1.AssistingNurse = T2.EmployeeID | CREATE TABLE undergoes (AssistingNurse VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE nurse (name VARCHAR(255), EmployeeID VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2304
} |
List the names of all distinct medications, ordered in an alphabetical order. | SELECT DISTINCT name FROM medication ORDER BY name | CREATE TABLE medication (name VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2305
} |
What are the names of the physician who prescribed the highest dose? | SELECT T1.name FROM physician AS T1 JOIN prescribes AS T2 ON T1.employeeid = T2.physician ORDER BY T2.dose DESC LIMIT 1 | CREATE TABLE prescribes (physician VARCHAR(255), dose VARCHAR(255)); CREATE TABLE physician (name VARCHAR(255), employeeid VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2306
} |
List the physicians' employee ids together with their primary affiliation departments' ids. | SELECT physician, department FROM affiliated_with WHERE primaryaffiliation = 1 | CREATE TABLE affiliated_with (physician VARCHAR(255), department VARCHAR(255), primaryaffiliation VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2307
} |
What nurses are on call with block floor 1 and block code 1? Tell me their names. | SELECT nurse FROM on_call WHERE blockfloor = 1 AND blockcode = 1 | CREATE TABLE on_call (nurse VARCHAR(255), blockfloor VARCHAR(255), blockcode VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2309
} |
What are the highest cost, lowest cost and average cost of procedures? | SELECT MAX(cost), MIN(cost), AVG(cost) FROM procedures | CREATE TABLE procedures (cost 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": 2310
} |
List the name and cost of all procedures sorted by the cost from the highest to the lowest. | SELECT name, cost FROM procedures ORDER BY cost DESC | CREATE TABLE procedures (name VARCHAR(255), cost VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2311
} |
Find the three most expensive procedures. | SELECT name FROM procedures ORDER BY cost LIMIT 3 | CREATE TABLE procedures (name VARCHAR(255), cost VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2312
} |
Find the physicians who are trained in a procedure that costs more than 5000. | SELECT T1.name FROM physician AS T1 JOIN trained_in AS T2 ON T1.employeeid = T2.physician JOIN procedures AS T3 ON T3.code = T2.treatment WHERE T3.cost > 5000 | CREATE TABLE trained_in (physician VARCHAR(255), treatment VARCHAR(255)); CREATE TABLE physician (name VARCHAR(255), employeeid VARCHAR(255)); CREATE TABLE procedures (code VARCHAR(255), cost INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2313
} |
Find the physician who was trained in the most expensive procedure? | SELECT T1.name FROM physician AS T1 JOIN trained_in AS T2 ON T1.employeeid = T2.physician JOIN procedures AS T3 ON T3.code = T2.treatment ORDER BY T3.cost DESC LIMIT 1 | CREATE TABLE trained_in (physician VARCHAR(255), treatment VARCHAR(255)); CREATE TABLE physician (name VARCHAR(255), employeeid VARCHAR(255)); CREATE TABLE procedures (code VARCHAR(255), cost VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 2314
} |
What is the average cost of procedures that physician John Wen was trained in? | SELECT AVG(T3.cost) FROM physician AS T1 JOIN trained_in AS T2 ON T1.employeeid = T2.physician JOIN procedures AS T3 ON T3.code = T2.treatment WHERE T1.name = 'John Wen' | CREATE TABLE trained_in (physician VARCHAR(255), treatment VARCHAR(255)); CREATE TABLE procedures (cost INTEGER, code VARCHAR(255)); CREATE TABLE physician (employeeid VARCHAR(255), name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2315
} |
Find the names of procedures which physician John Wen was trained in. | SELECT T3.name FROM physician AS T1 JOIN trained_in AS T2 ON T1.employeeid = T2.physician JOIN procedures AS T3 ON T3.code = T2.treatment WHERE T1.name = 'John Wen' | CREATE TABLE trained_in (physician VARCHAR(255), treatment VARCHAR(255)); CREATE TABLE physician (employeeid VARCHAR(255), name VARCHAR(255)); CREATE TABLE procedures (name VARCHAR(255), code VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2316
} |
Find the name of physicians who are affiliated with both Surgery and Psychiatry departments. | SELECT T1.name FROM physician AS T1 JOIN affiliated_with AS T2 ON T1.EmployeeID = T2.physician JOIN department AS T3 ON T2.department = T3.DepartmentID WHERE T3.name = 'Surgery' INTERSECT SELECT T1.name FROM physician AS T1 JOIN affiliated_with AS T2 ON T1.EmployeeID = T2.physician JOIN department AS T3 ON T2.departmen... | CREATE TABLE affiliated_with (physician VARCHAR(255), department VARCHAR(255)); CREATE TABLE department (DepartmentID VARCHAR(255), name VARCHAR(255)); CREATE TABLE physician (name VARCHAR(255), EmployeeID VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 1 | 0 | {
"split": "train",
"row_index": 2320
} |
Find the name of physicians who are affiliated with Surgery or Psychiatry department. | SELECT T1.name FROM physician AS T1 JOIN affiliated_with AS T2 ON T1.EmployeeID = T2.physician JOIN department AS T3 ON T2.department = T3.DepartmentID WHERE T3.name = 'Surgery' OR T3.name = 'Psychiatry' | CREATE TABLE affiliated_with (physician VARCHAR(255), department VARCHAR(255)); CREATE TABLE department (DepartmentID VARCHAR(255), name VARCHAR(255)); CREATE TABLE physician (name VARCHAR(255), EmployeeID VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 2321
} |
Find the number of patients who are not using the medication of Procrastin-X. | SELECT COUNT(*) FROM patient WHERE NOT SSN IN (SELECT T1.patient FROM Prescribes AS T1 JOIN Medication AS T2 ON T1.Medication = T2.Code WHERE T2.name = 'Procrastin-X') | CREATE TABLE Prescribes (patient VARCHAR(255), Medication VARCHAR(255)); CREATE TABLE patient (SSN VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Medication (Code VARCHAR(255), name VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 2323
} |
How many appointments are there? | SELECT COUNT(*) FROM appointment | CREATE TABLE appointment (Id VARCHAR(255), details VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2324
} |
Find the names of nurses who are on call. | SELECT DISTINCT T1.name FROM nurse AS T1 JOIN on_call AS T2 ON T1.EmployeeID = T2.nurse | CREATE TABLE on_call (nurse VARCHAR(255), shift VARCHAR(255)); CREATE TABLE nurse (name VARCHAR(255), EmployeeID VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2325
} |
How many ships are there? | SELECT COUNT(*) FROM ship | CREATE TABLE ship (Id VARCHAR(255), Name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2326
} |
List the name of ships in ascending order of tonnage. | SELECT Name FROM ship ORDER BY Tonnage | CREATE TABLE ship (Name VARCHAR(255), Tonnage VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2327
} |
What are the type and nationality of ships? | SELECT TYPE, Nationality FROM ship | CREATE TABLE ship (TYPE VARCHAR(255), Nationality VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 2328
} |
List the name of ships whose nationality is not "United States". | SELECT Name FROM ship WHERE Nationality <> 'United States' | CREATE TABLE ship (Name VARCHAR(255), Nationality VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2329
} |
Show the name of ships whose nationality is either United States or United Kingdom. | SELECT Name FROM ship WHERE Nationality = 'United States' OR Nationality = 'United Kingdom' | CREATE TABLE ship (Name VARCHAR(255), Nationality VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2330
} |
What is the name of the ship with the largest tonnage? | SELECT Name FROM ship ORDER BY Tonnage DESC LIMIT 1 | CREATE TABLE ship (Name VARCHAR(255), Tonnage VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2331
} |
Show different types of ships and the number of ships of each type. | SELECT TYPE, COUNT(*) FROM ship GROUP BY TYPE | CREATE TABLE ship (TYPE 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": 2332
} |
Please show the most common type of ships. | SELECT TYPE FROM ship GROUP BY TYPE ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE ship (TYPE 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": 2333
} |
List the nations that have more than two ships. | SELECT Nationality FROM ship GROUP BY Nationality HAVING COUNT(*) > 2 | CREATE TABLE ship (Nationality 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": 2334
} |
Show different types of ships and the average tonnage of ships of each type. | SELECT TYPE, AVG(Tonnage) FROM ship GROUP BY TYPE | CREATE TABLE ship (TYPE VARCHAR(255), Tonnage INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2335
} |
Show codes and fates of missions, and names of ships involved. | SELECT T1.Code, T1.Fate, T2.Name FROM mission AS T1 JOIN ship AS T2 ON T1.Ship_ID = T2.Ship_ID | CREATE TABLE mission (Code VARCHAR(255), Fate VARCHAR(255), Ship_ID VARCHAR(255)); CREATE TABLE ship (Name VARCHAR(255), Ship_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2336
} |
Show names of ships involved in a mission launched after 1928. | SELECT T2.Name FROM mission AS T1 JOIN ship AS T2 ON T1.Ship_ID = T2.Ship_ID WHERE T1.Launched_Year > 1928 | CREATE TABLE mission (Ship_ID VARCHAR(255), Launched_Year INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE ship (Name VARCHAR(255), Ship_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2337
} |
Show the distinct fate of missions that involve ships with nationality "United States" | SELECT DISTINCT T1.Fate FROM mission AS T1 JOIN ship AS T2 ON T1.Ship_ID = T2.Ship_ID WHERE T2.Nationality = 'United States' | CREATE TABLE mission (Fate VARCHAR(255), Ship_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE ship (Ship_ID VARCHAR(255), Nationality VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2338
} |
List the name of ships that are not involved in any mission | SELECT Name FROM ship WHERE NOT Ship_ID IN (SELECT Ship_ID FROM mission) | CREATE TABLE mission (Name VARCHAR(255), Ship_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE ship (Name VARCHAR(255), Ship_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2339
} |
Show the types of ships that have both ships with tonnage larger than 6000 and ships with tonnage smaller than 4000. | SELECT TYPE FROM ship WHERE Tonnage > 6000 INTERSECT SELECT TYPE FROM ship WHERE Tonnage < 4000 | CREATE TABLE ship (TYPE VARCHAR(255), Tonnage INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2340
} |
Find the number of students in total. | SELECT COUNT(*) FROM list | CREATE TABLE list (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2341
} |
Find the last names of students studying in room 111. | SELECT lastname FROM list WHERE classroom = 111 | CREATE TABLE list (lastname VARCHAR(255), classroom 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": 2342
} |
Find the first names of students studying in room 108. | SELECT firstname FROM list WHERE classroom = 108 | CREATE TABLE list (firstname VARCHAR(255), classroom 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": 2343
} |
What are the first names of students studying in room 107? | SELECT DISTINCT firstname FROM list WHERE classroom = 107 | CREATE TABLE list (firstname VARCHAR(255), classroom 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": 2344
} |
For each classroom report the grade that is taught in it. Report just the classroom number and the grade number. | SELECT DISTINCT classroom, grade FROM list | CREATE TABLE list (classroom VARCHAR(255), grade VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 2345
} |
Which grade is studying in classroom 103? | SELECT DISTINCT grade FROM list WHERE classroom = 103 | CREATE TABLE list (grade VARCHAR(255), classroom 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": 2346
} |
Find the grade studying in room 105. | SELECT DISTINCT grade FROM list WHERE classroom = 105 | CREATE TABLE list (grade VARCHAR(255), classroom 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": 2347
} |
Which classrooms are used by grade 4? | SELECT DISTINCT classroom FROM list WHERE grade = 4 | CREATE TABLE list (classroom VARCHAR(255), grade 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": 2348
} |
Which classrooms are used by grade 5? | SELECT DISTINCT classroom FROM list WHERE grade = 5 | CREATE TABLE list (classroom VARCHAR(255), grade 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": 2349
} |
Find the first names of all the teachers that teach in classroom 110. | SELECT firstname FROM teachers WHERE classroom = 110 | CREATE TABLE teachers (firstname VARCHAR(255), classroom 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": 2352
} |
Find the last names of teachers teaching in classroom 109. | SELECT lastname FROM teachers WHERE classroom = 109 | CREATE TABLE teachers (lastname VARCHAR(255), classroom VARCHAR(255), firstname VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2353
} |
Report the first name and last name of all the teachers. | SELECT DISTINCT firstname, lastname FROM teachers | CREATE TABLE teachers (firstname VARCHAR(255), lastname VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 2354
} |
Report the first name and last name of all the students. | SELECT DISTINCT firstname, lastname FROM list | CREATE TABLE list (firstname VARCHAR(255), lastname VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 2355
} |
Find all students taught by OTHA MOYER. Output the first and last names of the students. | SELECT T1.firstname, T1.lastname FROM list AS T1 JOIN teachers AS T2 ON T1.classroom = T2.classroom WHERE T2.firstname = 'OTHA' AND T2.lastname = 'MOYER' | CREATE TABLE list (firstname VARCHAR(255), lastname VARCHAR(255), classroom VARCHAR(255)); CREATE TABLE teachers (classroom VARCHAR(255), firstname VARCHAR(255), lastname VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 2 | {
"split": "train",
"row_index": 2356
} |
Find all students taught by MARROTTE KIRK. Output first and last names of students. | SELECT T1.firstname, T1.lastname FROM list AS T1 JOIN teachers AS T2 ON T1.classroom = T2.classroom WHERE T2.firstname = 'MARROTTE' AND T2.lastname = 'KIRK' | CREATE TABLE list (firstname VARCHAR(255), lastname VARCHAR(255), classroom VARCHAR(255)); CREATE TABLE teachers (classroom VARCHAR(255), firstname VARCHAR(255), lastname VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 2 | {
"split": "train",
"row_index": 2357
} |
Find the first and last name of all the teachers that teach EVELINA BROMLEY. | SELECT T2.firstname, T2.lastname FROM list AS T1 JOIN teachers AS T2 ON T1.classroom = T2.classroom WHERE T1.firstname = 'EVELINA' AND T1.lastname = 'BROMLEY' | CREATE TABLE teachers (firstname VARCHAR(255), lastname VARCHAR(255), classroom VARCHAR(255)); CREATE TABLE list (classroom VARCHAR(255), firstname VARCHAR(255), lastname VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 2 | {
"split": "train",
"row_index": 2358
} |
Find the last names of all the teachers that teach GELL TAMI. | SELECT T2.lastname FROM list AS T1 JOIN teachers AS T2 ON T1.classroom = T2.classroom WHERE T1.firstname = 'GELL' AND T1.lastname = 'TAMI' | CREATE TABLE teachers (lastname VARCHAR(255), classroom VARCHAR(255), firstname VARCHAR(255)); CREATE TABLE list (classroom VARCHAR(255), firstname VARCHAR(255), lastname VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2359
} |
How many students does LORIA ONDERSMA teaches? | SELECT COUNT(*) FROM list AS T1 JOIN teachers AS T2 ON T1.classroom = T2.classroom WHERE T2.firstname = 'LORIA' AND T2.lastname = 'ONDERSMA' | CREATE TABLE list (classroom VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE teachers (classroom VARCHAR(255), firstname VARCHAR(255), lastname VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2360
} |
How many students does KAWA GORDON teaches? | SELECT COUNT(*) FROM list AS T1 JOIN teachers AS T2 ON T1.classroom = T2.classroom WHERE T2.firstname = 'KAWA' AND T2.lastname = 'GORDON' | CREATE TABLE list (classroom VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE teachers (classroom VARCHAR(255), firstname VARCHAR(255), lastname VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2361
} |
Find the number of students taught by TARRING LEIA. | SELECT COUNT(*) FROM list AS T1 JOIN teachers AS T2 ON T1.classroom = T2.classroom WHERE T2.firstname = 'TARRING' AND T2.lastname = 'LEIA' | CREATE TABLE list (classroom VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE teachers (classroom VARCHAR(255), firstname VARCHAR(255), lastname VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2362
} |
How many teachers does the student named CHRISSY NABOZNY have? | SELECT COUNT(*) FROM list AS T1 JOIN teachers AS T2 ON T1.classroom = T2.classroom WHERE T1.firstname = 'CHRISSY' AND T1.lastname = 'NABOZNY' | CREATE TABLE teachers (classroom VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE list (classroom VARCHAR(255), firstname VARCHAR(255), lastname VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2363
} |
How many teachers does the student named MADLOCK RAY have? | SELECT COUNT(*) FROM list AS T1 JOIN teachers AS T2 ON T1.classroom = T2.classroom WHERE T1.firstname = 'MADLOCK' AND T1.lastname = 'RAY' | CREATE TABLE teachers (classroom VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE list (classroom VARCHAR(255), firstname VARCHAR(255), lastname VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2364
} |
Find all first-grade students who are NOT taught by OTHA MOYER. Report their first and last names. | SELECT DISTINCT T1.firstname, T1.lastname FROM list AS T1 JOIN teachers AS T2 ON T1.classroom = T2.classroom WHERE T1.grade = 1 EXCEPT SELECT T1.firstname, T1.lastname FROM list AS T1 JOIN teachers AS T2 ON T1.classroom = T2.classroom WHERE T2.firstname = 'OTHA' AND T2.lastname = 'MOYER' | CREATE TABLE list (firstname VARCHAR(255), lastname VARCHAR(255), classroom VARCHAR(255), grade VARCHAR(255)); CREATE TABLE teachers (classroom VARCHAR(255), firstname VARCHAR(255), lastname VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 1 | {
"split": "train",
"row_index": 2365
} |
Find the last names of the students in third grade that are not taught by COVIN JEROME. | SELECT DISTINCT T1.lastname FROM list AS T1 JOIN teachers AS T2 ON T1.classroom = T2.classroom WHERE T1.grade = 3 AND T2.firstname <> 'COVIN' AND T2.lastname <> 'JEROME' | CREATE TABLE list (lastname VARCHAR(255), classroom VARCHAR(255), grade VARCHAR(255), firstname VARCHAR(255)); CREATE TABLE teachers (classroom VARCHAR(255), lastname VARCHAR(255), firstname VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2366
} |
For each grade, report the grade, the number of classrooms in which it is taught and the total number of students in the grade. | SELECT grade, COUNT(DISTINCT classroom), COUNT(*) FROM list GROUP BY grade | CREATE TABLE list (grade VARCHAR(255), classroom 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": 2367
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.