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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
What is the title and credits of the course that is taught in the largest classroom (with the highest capacity)? | SELECT T3.title, T3.credits FROM classroom AS T1 JOIN SECTION AS T2 ON T1.building = T2.building AND T1.room_number = T2.room_number JOIN course AS T3 ON T2.course_id = T3.course_id WHERE T1.capacity = (SELECT MAX(capacity) FROM classroom) | CREATE TABLE SECTION (
course_id VARCHAR(255),
building VARCHAR(255),
room_number VARCHAR(255)
);
CREATE TABLE course (
title VARCHAR(255),
credits INTEGER,
course_id VARCHAR(255)
);
CREATE TABLE classroom (
capacity INTEGER,
building VARCHAR(255),
room_number VARCHAR(255)
); | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 3 | 1 | 1 | {
"split": "train",
"row_index": 830
} |
What is the name of the customer who has made the minimum amount of payment in one claim? | SELECT t3.customer_details FROM claim_headers AS t1 JOIN policies AS t2 ON t1.policy_id = t2.policy_id JOIN customers AS t3 ON t2.customer_id = t3.customer_id WHERE t1.amount_piad = (SELECT MIN(amount_piad) FROM claim_headers) | CREATE TABLE claim_headers (policy_id VARCHAR(255), amount_piad INTEGER);
CREATE TABLE customers (customer_details VARCHAR(255), customer_id VARCHAR(255));
CREATE TABLE policies (policy_id VARCHAR(255), customer_id VARCHAR(255)); | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 3 | 1 | 0 | {
"split": "train",
"row_index": 873
} |
Show all church names except for those that had a wedding in year 2015. | SELECT c.name FROM church AS c WHERE NOT EXISTS (SELECT 1 FROM wedding AS w WHERE w.church_id = c.church_id AND w.year = '2015') | CREATE TABLE church (name VARCHAR(255), church_id VARCHAR(255)); CREATE TABLE wedding (church_id VARCHAR(255), year VARCHAR(255)) | mysql | null | hard | extended | valid | valid | valid | [] | [] | [] | [
"Unsupported predicate: EXISTS(SELECT 1 FROM wedding AS w WHERE w.church_id = c.church_id AND w.year = '2015')"
] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"extended"
] | corrected | null | null | null | {
"split": "train",
"row_index": 936
} |
Show all artist names who didn't have an exhibition in 2004. | SELECT name FROM artist EXCEPT SELECT T2.name FROM exhibition AS T1 JOIN artist AS T2 ON T1.artist_id = T2.artist_id WHERE T1.year = 2004 | CREATE TABLE exhibition (artist_id VARCHAR(255), year VARCHAR(255)); CREATE TABLE artist (name VARCHAR(255), artist_id VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 0 | 1 | 0 | {
"split": "train",
"row_index": 959
} |
Find the titles of items whose rating is higher than the average review rating of all items. | SELECT T1.title FROM item AS T1 JOIN review AS T2 ON T1.i_id = T2.i_id WHERE T2.rating > (SELECT AVG(rating) FROM review) | CREATE TABLE item (title VARCHAR(255), i_id VARCHAR(255)); CREATE TABLE review (i_id VARCHAR(255), rating INTEGER) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 1 | 0 | {
"split": "train",
"row_index": 974
} |
Find the name of the source user with the highest average trust score. | SELECT T1.name FROM useracct AS T1 JOIN trust AS T2 ON T1.u_id = T2.source_u_id GROUP BY T2.source_u_id ORDER BY AVG(`trust`) DESC LIMIT 1 | CREATE TABLE useracct (name VARCHAR(255), u_id VARCHAR(255)); CREATE TABLE trust (source_u_id VARCHAR(255), `trust` INTEGER) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 4 | 0 | 0 | {
"split": "train",
"row_index": 986
} |
Find the name and id of accounts whose checking balance is below the maximum checking balance. | SELECT T1.custid, T1.name FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid WHERE T2.balance < (SELECT MAX(balance) FROM checking) | CREATE TABLE accounts (custid VARCHAR(255), name VARCHAR(255)); CREATE TABLE checking (custid VARCHAR(255), balance INTEGER); | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 1 | 1 | {
"split": "train",
"row_index": 1033
} |
Find the names of accounts whose checking balance is above the average checking balance, but savings balance is below the average savings balance. | SELECT T1.name FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid WHERE T2.balance > (SELECT AVG(balance) FROM checking) INTERSECT SELECT T1.name FROM accounts AS T1 JOIN savings AS T2 ON T1.custid = T2.custid WHERE T2.balance < (SELECT AVG(balance) FROM savings) | CREATE TABLE checking (custid VARCHAR(255), balance INTEGER);
CREATE TABLE savings (custid VARCHAR(255), balance INTEGER);
CREATE TABLE accounts (name VARCHAR(255), custid VARCHAR(255)); | mysql | extra | extreme | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 2 | 0 | {
"split": "train",
"row_index": 1036
} |
Find the checking balance of the accounts whose savings balance is higher than the average savings balance. | SELECT T2.balance FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid WHERE T1.name IN (SELECT T1.name FROM accounts AS T1 JOIN savings AS T2 ON T1.custid = T2.custid WHERE T2.balance > (SELECT AVG(balance) FROM savings)) | CREATE TABLE accounts (custid VARCHAR(255), name VARCHAR(255)); CREATE TABLE checking (balance INTEGER, custid VARCHAR(255)); CREATE TABLE savings (balance INTEGER, custid VARCHAR(255)); | mysql | extra | extreme | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 1 | 0 | {
"split": "train",
"row_index": 1037
} |
Find the names and total checking and savings balances of accounts whose savings balance is higher than the average savings balance. | SELECT T1.name, T2.balance + T3.balance FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid JOIN savings AS T3 ON T1.custid = T3.custid WHERE T3.balance > (SELECT AVG(balance) FROM savings) | CREATE TABLE checking (balance INTEGER, custid VARCHAR(255)); CREATE TABLE savings (balance INTEGER, custid VARCHAR(255)); CREATE TABLE accounts (name VARCHAR(255), custid VARCHAR(255)) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 3 | 1 | 1 | {
"split": "train",
"row_index": 1040
} |
Find the name of accounts whose checking balance is below the average checking balance. | SELECT T1.name FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid WHERE T2.balance < (SELECT AVG(balance) FROM checking) | CREATE TABLE accounts (name VARCHAR(255), custid VARCHAR(255)); CREATE TABLE checking (custid VARCHAR(255), balance INTEGER); | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 1 | 0 | {
"split": "train",
"row_index": 1044
} |
Show the accelerator names and supporting operating systems that are not compatible with the browser named 'Opera'. | SELECT name, operating_system FROM web_client_accelerator EXCEPT SELECT T1.name, T1.operating_system FROM web_client_accelerator AS T1 JOIN accelerator_compatible_browser AS T2 ON T2.accelerator_id = T1.id JOIN browser AS T3 ON T2.browser_id = T3.id WHERE T3.name = 'Opera' | CREATE TABLE browser (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE web_client_accelerator (name VARCHAR(255), operating_system VARCHAR(255), id VARCHAR(255)); CREATE TABLE accelerator_compatible_browser (accelerator_id VARCHAR(255), browser_id VARCHAR(255)); | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 0 | 1 | 1 | {
"split": "train",
"row_index": 1067
} |
List the name, IHSAA Football Class, and Mascot of the schools that have more than 6000 of budgeted amount or were founded before 2003, in the order of percent of total invested budget and total budgeted budget. | SELECT T1.`School_name`, T1.`Mascot`, T1.`IHSAA_Football_Class` FROM `school` AS T1 JOIN `budget` AS T2 ON T1.`school_id` = T2.`school_id` WHERE T2.`Budgeted` > 6000 OR T1.`YEAR` < 2003 ORDER BY T2.`total_budget_percent_invested`, T2.`total_budget_percent_budgeted` | CREATE TABLE `school` ( `School_name` VARCHAR(255), `Mascot` VARCHAR(255), `IHSAA_Football_Class` VARCHAR(255), `school_id` VARCHAR(255), `YEAR` INTEGER ); CREATE TABLE `budget` ( `school_id` VARCHAR(255), `total_budget_percent_invested` VARCHAR(255), `total_budget_percent_budgeted` VARCHAR(255), `Budgeted` INTEGER ) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 4 | 0 | 2 | {
"split": "train",
"row_index": 1114
} |
Show the names of buildings except for those having an institution founded in 2003. | SELECT name FROM building EXCEPT SELECT T1.name FROM building AS T1 JOIN institution AS T2 ON T1.building_id = T2.building_id WHERE T2.founded = 2003 | CREATE TABLE building (name VARCHAR(255), building_id VARCHAR(255)); CREATE TABLE institution (building_id VARCHAR(255), founded INTEGER) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 0 | 1 | 0 | {
"split": "train",
"row_index": 1126
} |
List the names of phones that are not on any market. | SELECT `Name` FROM phone WHERE NOT `Phone_id` IN (SELECT `Phone_id` FROM phone_market) | CREATE TABLE phone (`Name` VARCHAR(255), `Phone_id` VARCHAR(255)); CREATE TABLE phone_market (`Name` VARCHAR(255), `Phone_id` VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 1 | 1 | 0 | {
"split": "train",
"row_index": 1189
} |
List roles that have more than one employee. List the role description and number of employees. | SELECT Roles.role_description, COUNT(Employees.employee_id) FROM Roles JOIN Employees ON Employees.role_code = Roles.role_code GROUP BY Employees.role_code HAVING COUNT(Employees.employee_id) > 1 | CREATE TABLE Roles (role_description VARCHAR(255), role_code VARCHAR(255)); CREATE TABLE Employees (employee_id VARCHAR(255), role_code VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 1 | {
"split": "train",
"row_index": 1262
} |
What is the document status description of the document with id 1? | SELECT Ref_Document_Status.document_status_description FROM Ref_Document_Status JOIN Documents ON Documents.document_status_code = Ref_Document_Status.document_status_code WHERE Documents.document_id = 1 | CREATE TABLE Documents (Id VARCHAR(255), document_id INTEGER, document_status_code VARCHAR(255)); CREATE TABLE Ref_Document_Status (Id VARCHAR(255), document_status_code VARCHAR(255), document_status_description VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 0 | {
"split": "train",
"row_index": 1263
} |
What is the name of the shipping agent of the document with id 2? | SELECT Ref_Shipping_Agents.shipping_agent_name FROM Ref_Shipping_Agents JOIN Documents ON Documents.shipping_agent_code = Ref_Shipping_Agents.shipping_agent_code WHERE Documents.document_id = 2 | CREATE TABLE Documents (Id VARCHAR(255), document_id INTEGER, shipping_agent_code VARCHAR(255)); CREATE TABLE Ref_Shipping_Agents (Id VARCHAR(255), shipping_agent_name VARCHAR(255), shipping_agent_code VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 0 | {
"split": "train",
"row_index": 1267
} |
How many documents were shipped by USPS? | SELECT COUNT(*) FROM Ref_Shipping_Agents JOIN Documents ON Documents.shipping_agent_code = Ref_Shipping_Agents.shipping_agent_code WHERE Ref_Shipping_Agents.shipping_agent_name = 'USPS' | CREATE TABLE Documents (Id VARCHAR(255), shipping_agent_code VARCHAR(255)); CREATE TABLE Ref_Shipping_Agents (Id VARCHAR(255), shipping_agent_code VARCHAR(255), shipping_agent_name VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 0 | {
"split": "train",
"row_index": 1268
} |
Which shipping agent shipped the most documents? List the shipping agent name and the number of documents. | SELECT Ref_Shipping_Agents.shipping_agent_name, COUNT(Documents.document_id) FROM Ref_Shipping_Agents JOIN Documents ON Documents.shipping_agent_code = Ref_Shipping_Agents.shipping_agent_code GROUP BY Ref_Shipping_Agents.shipping_agent_code ORDER BY COUNT(Documents.document_id) DESC LIMIT 1 | CREATE TABLE Documents (Id VARCHAR(255), document_id VARCHAR(255), shipping_agent_code VARCHAR(255)); CREATE TABLE Ref_Shipping_Agents (Id VARCHAR(255), shipping_agent_name VARCHAR(255), shipping_agent_code VARCHAR(255)) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 4 | 0 | 2 | {
"split": "train",
"row_index": 1269
} |
What address was the document with id 4 mailed to? | SELECT Addresses.address_details FROM Addresses JOIN Documents_Mailed ON Documents_Mailed.mailed_to_address_id = Addresses.address_id WHERE Documents_Mailed.document_id = 4 | CREATE TABLE Addresses (document_id VARCHAR(255), address_id INTEGER, address_details VARCHAR(255)); CREATE TABLE Documents_Mailed (document_id VARCHAR(255), mailed_to_address_id INTEGER) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 0 | {
"split": "train",
"row_index": 1271
} |
List the document ids of documents with the status done and type Paper, which not shipped by the shipping agent named USPS. | SELECT document_id FROM Documents WHERE document_status_code = 'done' AND document_type_code = 'Paper' EXCEPT SELECT Documents.document_id FROM Documents JOIN Ref_Shipping_Agents ON Documents.shipping_agent_code = Ref_Shipping_Agents.shipping_agent_code WHERE Ref_Shipping_Agents.shipping_agent_name = 'USPS' | CREATE TABLE Documents (document_id VARCHAR(255), document_status_code VARCHAR(255), document_type_code VARCHAR(255), shipping_agent_code VARCHAR(255)); CREATE TABLE Ref_Shipping_Agents (shipping_agent_code VARCHAR(255), shipping_agent_name VARCHAR(255)) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 1 | 1 | 1 | {
"split": "train",
"row_index": 1273
} |
List document id of documents status is done and document type is Paper and the document is shipped by shipping agent named USPS. | SELECT document_id FROM Documents WHERE document_status_code = 'done' AND document_type_code = 'Paper' INTERSECT SELECT Documents.document_id FROM Documents JOIN Ref_Shipping_Agents ON Documents.shipping_agent_code = Ref_Shipping_Agents.shipping_agent_code WHERE Ref_Shipping_Agents.shipping_agent_name = 'USPS' | CREATE TABLE Documents (document_id VARCHAR(255), document_status_code VARCHAR(255), document_type_code VARCHAR(255), shipping_agent_code VARCHAR(255)); CREATE TABLE Ref_Shipping_Agents (shipping_agent_code VARCHAR(255), shipping_agent_name VARCHAR(255)) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 1 | 1 | 1 | {
"split": "train",
"row_index": 1274
} |
List all employees in the circulation history of the document with id 1. List the employee's name. | SELECT Employees.employee_name FROM Employees JOIN Circulation_History ON Circulation_History.employee_id = Employees.employee_id WHERE Circulation_History.document_id = 1 | CREATE TABLE Circulation_History (Id VARCHAR(255), employee_id VARCHAR(255), document_id INTEGER);
CREATE TABLE Employees (Id VARCHAR(255), employee_id VARCHAR(255), employee_name VARCHAR(255)); | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 0 | {
"split": "train",
"row_index": 1279
} |
List the employees who have not showed up in any circulation history of documents. List the employee's name. | SELECT employee_name FROM Employees EXCEPT SELECT Employees.employee_name FROM Employees JOIN Circulation_History ON Circulation_History.employee_id = Employees.employee_id | CREATE TABLE Employees (employee_name VARCHAR(255), employee_id VARCHAR(255)); CREATE TABLE Circulation_History (employee_name VARCHAR(255), employee_id VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_ambiguous",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 0 | 1 | 0 | {
"split": "train",
"row_index": 1280
} |
Which employee has showed up in most circulation history documents. List the employee's name and the number of drafts and copies. | SELECT Employees.employee_name, COUNT(*) FROM Employees JOIN Circulation_History ON Circulation_History.employee_id = Employees.employee_id GROUP BY Circulation_History.document_id, Circulation_History.draft_number, Circulation_History.copy_number ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Circulation_History (Id VARCHAR(255), employee_id VARCHAR(255), document_id VARCHAR(255), draft_number INTEGER, copy_number INTEGER);
CREATE TABLE Employees (Id VARCHAR(255), employee_id VARCHAR(255), employee_name VARCHAR(255)); | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 4 | 0 | 3 | {
"split": "train",
"row_index": 1281
} |
Which events id does not have any participant with detail 'Kenyatta Kuhn'? | SELECT event_id FROM EVENTS EXCEPT SELECT T1.event_id FROM Participants_in_Events AS T1 JOIN Participants AS T2 ON T1.Participant_ID = T2.Participant_ID WHERE Participant_Details = 'Kenyatta Kuhn' | CREATE TABLE Participants (Participant_ID VARCHAR(255), Participant_Details VARCHAR(255)); CREATE TABLE EVENTS (event_id VARCHAR(255), Participant_Details VARCHAR(255)); CREATE TABLE Participants_in_Events (event_id VARCHAR(255), Participant_ID VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 0 | 1 | 0 | {
"split": "train",
"row_index": 1301
} |
What is the id, forname and surname of the driver who had the first position in terms of laptime at least twice? | SELECT T1.driverid, T1.forename, T1.surname FROM drivers AS T1 JOIN laptimes AS T2 ON T1.driverid = T2.driverid WHERE `POSITION` = '1' GROUP BY T1.driverid HAVING COUNT(*) >= 2 | CREATE TABLE drivers (driverid VARCHAR(255), forename VARCHAR(255), surname VARCHAR(255)); CREATE TABLE laptimes (driverid VARCHAR(255), `POSITION` INTEGER) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 3 | 0 | 1 | {
"split": "train",
"row_index": 1313
} |
What is the campus fee of "San Jose State University" in year 1996? | SELECT campusfee FROM campuses AS T1 JOIN csu_fees AS T2 ON T1.id = T2.campus WHERE T1.campus = 'San Jose State University' AND T2.year = 1996 | CREATE TABLE csu_fees (year INTEGER, campus VARCHAR(255)); CREATE TABLE campuses (id VARCHAR(255), campus VARCHAR(255), campusfee INTEGER) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 1 | {
"split": "train",
"row_index": 1407
} |
What is the campus fee of "San Francisco State University" in year 1996? | SELECT campusfee FROM campuses AS T1 JOIN csu_fees AS T2 ON T1.id = T2.campus WHERE T1.campus = 'San Francisco State University' AND T2.year = 1996 | CREATE TABLE csu_fees (year VARCHAR(255), campus VARCHAR(255)); CREATE TABLE campuses (id VARCHAR(255), campus VARCHAR(255), campusfee INTEGER) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 1 | {
"split": "train",
"row_index": 1408
} |
Find the names of the campus which has more faculties in 2002 than every campus in Orange county. | SELECT T1.campus FROM campuses AS T1 JOIN faculty AS T2 ON T1.id = T2.campus WHERE T2.year = 2002 AND T2.faculty > (SELECT MAX(T3.faculty) FROM campuses AS T4 JOIN faculty AS T3 ON T4.id = T3.campus WHERE T3.year = 2002 AND T4.county = 'Orange') | CREATE TABLE campuses (campus VARCHAR(255), id VARCHAR(255), county VARCHAR(255)); CREATE TABLE faculty (campus VARCHAR(255), year VARCHAR(255), faculty INTEGER) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 1 | 1 | {
"split": "train",
"row_index": 1418
} |
What campus had more than 400 total enrollment but more than 200 full time enrollment in year 1956? | SELECT t1.campus FROM campuses AS t1 JOIN enrollments AS t2 ON t1.id = t2.campus WHERE t2.year = 1956 AND t2.totalenrollment_ay > 400 AND t2.FTE_AY > 200 | CREATE TABLE campuses (id VARCHAR(255), campus VARCHAR(255)); CREATE TABLE enrollments (campus VARCHAR(255), year INTEGER, totalenrollment_ay INTEGER, FTE_AY INTEGER) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 1 | {
"split": "train",
"row_index": 1419
} |
What are the degrees conferred in "San Francisco State University" in 2001. | SELECT T2.degree FROM campuses AS T1 JOIN degrees AS T2 ON T1.id = T2.campus WHERE T1.campus = 'San Francisco State University' AND T2.year = 2001 | CREATE TABLE degrees (Id VARCHAR(255), campus VARCHAR(255), year INTEGER, degree VARCHAR(255)); CREATE TABLE campuses (Id VARCHAR(255), campus VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 1 | {
"split": "train",
"row_index": 1422
} |
What is the number of faculty lines in campus "Long Beach State University" in 2002? | SELECT T1.faculty FROM faculty AS T1 JOIN campuses AS T2 ON T1.campus = T2.id WHERE T1.year = 2002 AND T2.campus = 'Long Beach State University' | CREATE TABLE campuses (id VARCHAR(255), campus VARCHAR(255)); CREATE TABLE faculty (campus VARCHAR(255), year VARCHAR(255), faculty INTEGER) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 1 | {
"split": "train",
"row_index": 1424
} |
How many faculty lines are there in "San Francisco State University" in year 2004? | SELECT faculty FROM faculty AS T1 JOIN campuses AS T2 ON T1.campus = T2.id WHERE T1.year = 2004 AND T2.campus = 'San Francisco State University' | CREATE TABLE campuses (id VARCHAR(255), campus VARCHAR(255)); CREATE TABLE faculty (campus VARCHAR(255), year VARCHAR(255), faculty INTEGER) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 1 | {
"split": "train",
"row_index": 1425
} |
List the campus that have between 600 and 1000 faculty lines in year 2004. | SELECT `t1`.campus FROM campuses AS `t1` JOIN faculty AS `t2` ON `t1`.id = `t2`.campus WHERE `t2`.faculty >= 600 AND `t2`.faculty <= 1000 AND `t1`.year = 2004 | CREATE TABLE campuses (id VARCHAR(255), year INTEGER, campus VARCHAR(255)); CREATE TABLE faculty (campus VARCHAR(255), faculty INTEGER) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 1 | {
"split": "train",
"row_index": 1426
} |
What is the maximum stars and year for the most recent movie? | SELECT MAX(T1.stars), T2.year FROM Rating AS T1 JOIN Movie AS T2 ON T1.mID = T2.mID WHERE T2.year = (SELECT MAX(year) FROM Movie) | CREATE TABLE Rating (stars INTEGER, mID VARCHAR(255)); CREATE TABLE Movie (year INTEGER, mID VARCHAR(255)) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 1 | 1 | {
"split": "train",
"row_index": 1470
} |
Find the titles of all movies not reviewed by Chris Jackson. | SELECT DISTINCT title FROM Movie EXCEPT SELECT T2.title FROM Rating AS T1 JOIN Movie AS T2 ON T1.mID = T2.mID JOIN Reviewer AS T3 ON T1.rID = T3.rID WHERE T3.name = 'Chris Jackson' | CREATE TABLE Reviewer (rID VARCHAR(255), name VARCHAR(255)); CREATE TABLE Movie (title VARCHAR(255), mID VARCHAR(255)); CREATE TABLE Rating (mID VARCHAR(255), rID VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 0 | 1 | 0 | {
"split": "train",
"row_index": 1479
} |
For all directors who directed more than one movie, return the titles of all movies directed by them, along with the director name. Sort by director name, then movie title. | SELECT T1.title, T1.director FROM Movie AS T1 JOIN Movie AS T2 ON T1.director = T2.director WHERE T1.title <> T2.title ORDER BY T1.director, T1.title | CREATE TABLE Movie (title VARCHAR(255), director VARCHAR(255)); | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 3 | 0 | 1 | {
"split": "train",
"row_index": 1480
} |
For directors who had more than one movie, return the titles and produced years of all movies directed by them. | SELECT T1.title, T1.year FROM Movie AS T1 JOIN Movie AS T2 ON T1.director = T2.director WHERE T1.title <> T2.title | CREATE TABLE Movie (director VARCHAR(255), title VARCHAR(255), year VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 1 | {
"split": "train",
"row_index": 1481
} |
Find the average rating star for each movie that are not reviewed by Brittany Harris. | SELECT mID, AVG(stars) FROM Rating WHERE NOT mID IN (SELECT T1.mID FROM Rating AS T1 JOIN Reviewer AS T2 ON T1.rID = T2.rID WHERE T2.name = 'Brittany Harris') GROUP BY mID | CREATE TABLE Reviewer (rID VARCHAR(255), name VARCHAR(255)); CREATE TABLE Rating (mID VARCHAR(255), stars INTEGER, rID VARCHAR(255)) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 1 | 2 | {
"split": "train",
"row_index": 1494
} |
What are the ids of the movies that are not reviewed by Brittany Harris. | SELECT mID FROM Rating WHERE mID NOT IN (SELECT T1.mID FROM Rating AS T1 JOIN Reviewer AS T2 ON T1.rID = T2.rID WHERE T2.name = 'Brittany Harris') | CREATE TABLE Reviewer (rID VARCHAR(255), name VARCHAR(255)); CREATE TABLE Rating (mID VARCHAR(255), rID VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 1 | 1 | 0 | {
"split": "train",
"row_index": 1495
} |
Find the name of rooms booked by some customers whose first name contains ROY. | SELECT T2.roomName FROM Reservations AS T1 JOIN Rooms AS T2 ON T1.Room = T2.RoomId WHERE firstname LIKE '%ROY%' | CREATE TABLE Reservations (Room VARCHAR(255), firstname VARCHAR(255)); CREATE TABLE Rooms (roomName VARCHAR(255), RoomId VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 3 | 0 | 0 | {
"split": "train",
"row_index": 1558
} |
Find the average age and experience working length of journalists working on different role type. | SELECT AVG(t1.age), AVG(t1.Years_working), t2.work_type FROM journalist AS t1 JOIN news_report AS t2 ON t1.journalist_id = t2.journalist_id GROUP BY t2.work_type | CREATE TABLE news_report (work_type VARCHAR(255), journalist_id VARCHAR(255)); CREATE TABLE journalist (age INTEGER, journalist_id VARCHAR(255), Years_working INTEGER) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 2 | {
"split": "train",
"row_index": 1659
} |
How many times has the student Linda Smith visited Subway? | SELECT COUNT(*) FROM Student JOIN Visits_Restaurant ON Student.StuID = Visits_Restaurant.StuID JOIN Restaurant ON Visits_Restaurant.ResID = Restaurant.ResID WHERE Student.Fname = 'Linda' AND Student.Lname = 'Smith' AND Restaurant.ResName = 'Subway' | CREATE TABLE Visits_Restaurant (Id VARCHAR(255), StuID VARCHAR(255), ResID VARCHAR(255)); CREATE TABLE Student (Id VARCHAR(255), StuID VARCHAR(255), Fname VARCHAR(255), Lname VARCHAR(255)); CREATE TABLE Restaurant (Id VARCHAR(255), ResID VARCHAR(255), ResName VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 3 | 0 | 1 | {
"split": "train",
"row_index": 1679
} |
When did Linda Smith visit Subway? | SELECT Visits_Restaurant.TIME FROM Student JOIN Visits_Restaurant ON Student.StuID = Visits_Restaurant.StuID JOIN Restaurant ON Visits_Restaurant.ResID = Restaurant.ResID WHERE Student.Fname = 'Linda' AND Student.Lname = 'Smith' AND Restaurant.ResName = 'Subway' | CREATE TABLE Student (StuID VARCHAR(255), Fname VARCHAR(255), Lname VARCHAR(255)); CREATE TABLE Visits_Restaurant (StuID VARCHAR(255), ResID VARCHAR(255), TIME VARCHAR(255)); CREATE TABLE Restaurant (ResID VARCHAR(255), ResName VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_ambiguous",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 3 | 0 | 1 | {
"split": "train",
"row_index": 1680
} |
Which student visited restaurant most often? List student's first name and last name. | SELECT Student.Fname, Student.Lname FROM Student JOIN Visits_Restaurant ON Student.StuID = Visits_Restaurant.StuID GROUP BY Student.StuID ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Visits_Restaurant (Id VARCHAR(255), StuID VARCHAR(255)); CREATE TABLE Student (Id VARCHAR(255), StuID VARCHAR(255), Fname VARCHAR(255), Lname VARCHAR(255)) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 4 | 0 | 1 | {
"split": "train",
"row_index": 1682
} |
Find the names of customers who are not living in the state of California. | SELECT customer_name FROM customers EXCEPT SELECT t1.customer_name FROM customers AS t1 JOIN customer_addresses AS t2 ON t1.customer_id = t2.customer_id JOIN addresses AS t3 ON t2.address_id = t3.address_id WHERE t3.state_province_county = 'California' | CREATE TABLE customer_addresses (customer_id VARCHAR(255), address_id VARCHAR(255)); CREATE TABLE customers (customer_name VARCHAR(255), customer_id VARCHAR(255)); CREATE TABLE addresses (address_id VARCHAR(255), state_province_county VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 0 | 1 | 0 | {
"split": "train",
"row_index": 1689
} |
What is the first and last name of the professor in biology department? | SELECT T3.EMP_FNAME, T3.EMP_LNAME FROM professor AS T1 JOIN department AS T2 ON T1.dept_code = T2.dept_code JOIN employee AS T3 ON T1.EMP_NUM = T3.EMP_NUM WHERE T2.DEPT_NAME = 'Biology' | CREATE TABLE professor (dept_code VARCHAR(255), EMP_NUM VARCHAR(255)); CREATE TABLE department (dept_code VARCHAR(255), DEPT_NAME VARCHAR(255)); CREATE TABLE employee (EMP_FNAME VARCHAR(255), EMP_LNAME VARCHAR(255), EMP_NUM VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 3 | 0 | 1 | {
"split": "train",
"row_index": 1902
} |
What are the first names and date of birth of professors teaching course ACCT-211? | SELECT DISTINCT T1.EMP_FNAME, T1.EMP_DOB FROM employee AS T1 JOIN CLASS AS T2 ON T1.EMP_NUM = T2.PROF_NUM WHERE CRS_CODE = 'ACCT-211' | CREATE TABLE CLASS (PROF_NUM VARCHAR(255), CRS_CODE VARCHAR(255)); CREATE TABLE employee (EMP_FNAME VARCHAR(255), EMP_DOB VARCHAR(255), EMP_NUM VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 1 | {
"split": "train",
"row_index": 1903
} |
What is the first name of students who got grade C in any class? | SELECT DISTINCT stu_fname FROM student AS T1 JOIN enroll AS T2 ON T1.stu_num = T2.stu_num WHERE enroll_grade = 'C' | CREATE TABLE student (stu_num VARCHAR(255), stu_fname VARCHAR(255)); CREATE TABLE enroll (stu_num VARCHAR(255), enroll_grade VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 0 | {
"split": "train",
"row_index": 1947
} |
Find the first name of the professor who is teaching two courses with code CIS-220 and QM-261. | SELECT T1.emp_fname FROM employee AS T1 JOIN CLASS AS T2 ON T1.emp_num = T2.prof_num WHERE crs_code = 'CIS-220' INTERSECT SELECT T1.emp_fname FROM employee AS T1 JOIN CLASS AS T2 ON T1.emp_num = T2.prof_num WHERE crs_code = 'QM-261' | CREATE TABLE CLASS (prof_num VARCHAR(255), crs_code VARCHAR(255)); CREATE TABLE employee (emp_fname VARCHAR(255), emp_num VARCHAR(255)) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 1 | 0 | {
"split": "train",
"row_index": 1959
} |
display job title and average salary of employees. | SELECT T2.job_title, AVG(T1.salary) FROM employees AS T1 JOIN jobs AS T2 ON T1.job_id = T2.job_id GROUP BY T2.job_title | CREATE TABLE jobs (job_title VARCHAR(255), job_id VARCHAR(255)); CREATE TABLE employees (job_id VARCHAR(255), salary INTEGER) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 1 | {
"split": "train",
"row_index": 2055
} |
display the full name (first and last name), and salary of those employees who working in any department located in London. | SELECT first_name, last_name, salary FROM employees AS T1 JOIN departments AS T2 ON T1.department_id = T2.department_id JOIN locations AS T3 ON T2.location_id = T3.location_id WHERE T3.city = 'London' | CREATE TABLE locations (location_id VARCHAR(255), city VARCHAR(255)); CREATE TABLE employees (department_id VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255), salary INTEGER); CREATE TABLE departments (department_id VARCHAR(255), location_id VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 3 | 0 | 1 | {
"split": "train",
"row_index": 2082
} |
List the names of all songs that have 4 minute duration or are in English. | SELECT T2.song_name FROM files AS T1 JOIN song AS T2 ON T1.f_id = T2.f_id WHERE T1.duration LIKE '4:%' UNION SELECT song_name FROM song WHERE languages = 'english' | CREATE TABLE files (f_id VARCHAR(255), duration VARCHAR(255)); CREATE TABLE song (song_name VARCHAR(255), f_id VARCHAR(255), languages VARCHAR(255)) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 3 | 1 | 0 | {
"split": "train",
"row_index": 2110
} |
Return the names of songs for which format is mp3 and resolution is below 1000. | SELECT T2.song_name FROM files AS T1 JOIN song AS T2 ON T1.f_id = T2.f_id WHERE T1.formats = 'mp3' INTERSECT SELECT song_name FROM song WHERE resolution < 1000 | CREATE TABLE song (song_name VARCHAR(255), resolution INTEGER, f_id VARCHAR(255)); CREATE TABLE files (f_id VARCHAR(255), formats VARCHAR(255)) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 1 | 0 | {
"split": "train",
"row_index": 2115
} |
Return the names of singers who are from UK and released an English song. | SELECT artist_name FROM artist WHERE country = 'UK' INTERSECT SELECT T1.artist_name FROM artist AS T1 JOIN song AS T2 ON T1.artist_name = T2.artist_name WHERE T2.languages = 'english' | CREATE TABLE song (artist_name VARCHAR(255), languages VARCHAR(255)); CREATE TABLE artist (artist_name VARCHAR(255), country VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 1 | 1 | 0 | {
"split": "train",
"row_index": 2116
} |
What are first and last names of players participating in all star game in 1998? | SELECT name_first, name_last FROM player AS T1 JOIN all_star AS T2 ON T1.player_id = T2.player_id WHERE `YEAR` = 1998 | CREATE TABLE all_star (player_id VARCHAR(255), `YEAR` INTEGER); CREATE TABLE player (player_id VARCHAR(255), name_first VARCHAR(255), name_last VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 1 | {
"split": "train",
"row_index": 2135
} |
Show the name and prominence of the mountains whose picture is not taken by a lens of brand 'Sigma'. | SELECT name, prominence FROM mountain EXCEPT SELECT T1.name, T1.prominence FROM mountain AS T1 JOIN photos AS T2 ON T1.id = T2.mountain_id JOIN camera_lens AS T3 ON T2.camera_lens_id = T3.id WHERE T3.brand = 'Sigma' | CREATE TABLE camera_lens (id VARCHAR(255), brand VARCHAR(255)); CREATE TABLE mountain (name VARCHAR(255), prominence VARCHAR(255), id VARCHAR(255)); CREATE TABLE photos (mountain_id VARCHAR(255), camera_lens_id VARCHAR(255)); | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 0 | 1 | 1 | {
"split": "train",
"row_index": 2188
} |
Find all procedures which cost more than 1000 or which physician John Wen was trained in. | SELECT name FROM procedures WHERE cost > 1000 UNION 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 procedures (name VARCHAR(255), cost INTEGER, code VARCHAR(255)); CREATE TABLE physician (employeeid VARCHAR(255), name VARCHAR(255)); | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 1 | 1 | 0 | {
"split": "train",
"row_index": 2317
} |
Find the last names of the teachers that teach fifth grade. | SELECT DISTINCT T2.lastname FROM list AS T1 JOIN teachers AS T2 ON T1.classroom = T2.classroom WHERE T1.grade = 5 | CREATE TABLE list (classroom VARCHAR(255), grade INTEGER); CREATE TABLE teachers (lastname VARCHAR(255), classroom VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 0 | {
"split": "train",
"row_index": 2350
} |
Find the first names of the teachers that teach first grade. | SELECT DISTINCT T2.firstname FROM list AS T1 JOIN teachers AS T2 ON T1.classroom = T2.classroom WHERE T1.grade = 1 | CREATE TABLE list (classroom VARCHAR(255), grade INTEGER); CREATE TABLE teachers (firstname VARCHAR(255), classroom VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 0 | {
"split": "train",
"row_index": 2351
} |
What is the title of the film that has the highest high market estimation. | SELECT T1.title FROM film AS T1 JOIN film_market_estimation AS T2 ON T1.Film_ID = T2.Film_ID ORDER BY T2.high_estimate DESC LIMIT 1 | CREATE TABLE film (Film_ID VARCHAR(255), title VARCHAR(255)); CREATE TABLE film_market_estimation (Film_ID VARCHAR(255), high_estimate INTEGER) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 3 | 0 | 0 | {
"split": "train",
"row_index": 2413
} |
Show the name, role code, and date of birth for the employee with name 'Armani'. | SELECT employee_name, role_code, date_of_birth FROM Employees WHERE employee_name = 'Armani' | CREATE TABLE Employees (employee_name VARCHAR(255), role_code VARCHAR(255), date_of_birth VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 1 | 0 | 1 | {
"split": "train",
"row_index": 2433
} |
What is the total grant amount of the organisations described as research? | SELECT SUM(grant_amount) FROM Grants AS T1 JOIN Organisations AS T2 ON T1.organisation_id = T2.organisation_id JOIN organisation_Types AS T3 ON T2.organisation_type = T3.organisation_type WHERE T3.organisation_type_description = 'Research' | CREATE TABLE organisation_Types (organisation_type VARCHAR(255), organisation_type_description VARCHAR(255)); CREATE TABLE Grants (organisation_id VARCHAR(255), grant_amount INTEGER); CREATE TABLE Organisations (organisation_id VARCHAR(255), organisation_type VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 3 | 0 | 0 | {
"split": "train",
"row_index": 2495
} |
What are all the details of the organisations described as 'Sponsor'? Sort the result in an ascending order. | SELECT T1.organisation_details FROM Organisations AS T1 JOIN organisation_Types AS T2 ON T1.organisation_type = T2.organisation_type WHERE T2.organisation_type_description = 'Sponsor' ORDER BY T1.organisation_details ASC | CREATE TABLE organisation_Types (organisation_type VARCHAR(255), organisation_type_description VARCHAR(255)); CREATE TABLE Organisations (organisation_type VARCHAR(255), organisation_details VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 3 | 0 | 0 | {
"split": "train",
"row_index": 2519
} |
Find the name of the person who has friends with age above 40 and under age 30? | SELECT T1.name FROM Person AS T1 JOIN PersonFriend AS T2 ON T1.name = T2.name WHERE T2.friend IN (SELECT name FROM Person WHERE age > 40) INTERSECT SELECT T1.name FROM Person AS T1 JOIN PersonFriend AS T2 ON T1.name = T2.name WHERE T2.friend IN (SELECT name FROM Person WHERE age < 30) | CREATE TABLE Person (name VARCHAR(255), age INTEGER);
CREATE TABLE PersonFriend (name VARCHAR(255), friend VARCHAR(255)); | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 2 | 0 | {
"split": "train",
"row_index": 2555
} |
Find the name of the person who has friends with age above 40 but not under age 30? | SELECT T1.name FROM Person AS T1 JOIN PersonFriend AS T2 ON T1.name = T2.name WHERE T2.friend IN (SELECT name FROM Person WHERE age > 40) EXCEPT SELECT T1.name FROM Person AS T1 JOIN PersonFriend AS T2 ON T1.name = T2.name WHERE T2.friend IN (SELECT name FROM Person WHERE age < 30) | CREATE TABLE Person (name VARCHAR(255), age INTEGER);
CREATE TABLE PersonFriend (name VARCHAR(255), friend VARCHAR(255)); | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 2 | 0 | {
"split": "train",
"row_index": 2556
} |
Find the name of the person who has no student friends. | SELECT name FROM person EXCEPT SELECT T2.name FROM person AS T1 JOIN PersonFriend AS T2 ON T1.name = T2.friend WHERE T1.job = 'student' | CREATE TABLE person (name VARCHAR(255), job VARCHAR(255)); CREATE TABLE PersonFriend (name VARCHAR(255), friend VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_ambiguous",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 0 | 1 | 0 | {
"split": "train",
"row_index": 2557
} |
Who has friends that are older than the average age? Print their friends and their ages as well | SELECT DISTINCT T2.name, T2.friend, T1.age FROM Person AS T1 JOIN PersonFriend AS T2 ON T1.name = T2.friend WHERE T1.age > (SELECT AVG(age) FROM Person) | CREATE TABLE Person (age INTEGER, name VARCHAR(255)); CREATE TABLE PersonFriend (name VARCHAR(255), friend VARCHAR(255)) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 1 | 1 | {
"split": "train",
"row_index": 2566
} |
What is the age of the friend of Zach with longest year relationship? | SELECT T1.age FROM Person AS T1 JOIN PersonFriend AS T2 ON T1.name = T2.friend WHERE T2.name = 'Zach' AND T2.year = (SELECT MAX(`year`) FROM PersonFriend WHERE name = 'Zach') | CREATE TABLE PersonFriend (
friend VARCHAR(255),
name VARCHAR(255),
`year` INTEGER
);
CREATE TABLE Person (
age VARCHAR(255),
name VARCHAR(255)
); | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 1 | 1 | {
"split": "train",
"row_index": 2568
} |
Find the name, age, and job title of persons who are friends with Alice for the longest years. | SELECT T1.name, T1.age, T1.job FROM Person AS T1 JOIN PersonFriend AS T2 ON T1.name = T2.name WHERE T2.friend = 'Alice' AND T2.year = (SELECT MAX(year) FROM PersonFriend WHERE friend = 'Alice') | CREATE TABLE Person (
name VARCHAR(255),
age VARCHAR(255),
job VARCHAR(255)
);
CREATE TABLE PersonFriend (
name VARCHAR(255),
friend VARCHAR(255),
year INTEGER
); | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 1 | 2 | {
"split": "train",
"row_index": 2570
} |
Show the names of members in ascending order of their rank in rounds. | SELECT T1.Name FROM member AS T1 JOIN round AS T2 ON T1.Member_ID = T2.Member_ID ORDER BY Rank_in_Round | CREATE TABLE member (Name VARCHAR(255), Member_ID VARCHAR(255)); CREATE TABLE round (Member_ID VARCHAR(255), Rank_in_Round INTEGER) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 0 | {
"split": "train",
"row_index": 2588
} |
Show the names of customers who have at least 2 mailshots with outcome code 'Order'. | SELECT T2.customer_name FROM mailshot_customers AS T1 JOIN customers AS T2 ON T1.customer_id = T2.customer_id WHERE outcome_code = 'Order' GROUP BY T1.customer_id HAVING COUNT(*) >= 2 | CREATE TABLE customers (customer_name VARCHAR(255), customer_id VARCHAR(255)); CREATE TABLE mailshot_customers (customer_id VARCHAR(255), outcome_code VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 3 | 0 | 0 | {
"split": "train",
"row_index": 2677
} |
Show the names of customers having an order with shipping method FedEx and order status Paid. | SELECT T1.customer_name FROM customers AS T1 JOIN customer_orders AS T2 ON T1.customer_id = T2.customer_id WHERE `shipping_method_code` = 'FedEx' AND `order_status_code` = 'Paid' | CREATE TABLE customers (customer_name VARCHAR(255), customer_id VARCHAR(255)); CREATE TABLE customer_orders (customer_id VARCHAR(255), shipping_method_code VARCHAR(255), order_status_code VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 1 | {
"split": "train",
"row_index": 2683
} |
Return ids of all the products that are supplied by supplier id 2 and are more expensive than the average price of all products. | SELECT T1.product_id FROM product_suppliers AS T1 JOIN products AS T2 ON T1.product_id = T2.product_id WHERE T1.supplier_id = 2 AND T2.product_price > (SELECT AVG(product_price) FROM products) | CREATE TABLE products (product_id VARCHAR(255), product_price INTEGER);
CREATE TABLE product_suppliers (product_id VARCHAR(255), supplier_id VARCHAR(255)); | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 1 | 1 | {
"split": "train",
"row_index": 2735
} |
Find the id and name of the staff who has been assigned for the shortest period. | SELECT T1.staff_id, T1.staff_name FROM staff AS T1 JOIN Staff_Department_Assignments AS T2 ON T1.staff_id = T2.staff_id ORDER BY date_assigned_to - date_assigned_from LIMIT 1 | CREATE TABLE Staff_Department_Assignments (staff_id VARCHAR(255), date_assigned_from DATE, date_assigned_to DATE);
CREATE TABLE staff (staff_id VARCHAR(255), staff_name VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 3 | 0 | 1 | {
"split": "train",
"row_index": 2741
} |
Find all the stores in the district with the most population. | SELECT t1.store_name FROM store AS t1 JOIN store_district AS t2 ON t1.store_id = t2.store_id WHERE t2.district_id = (SELECT district_id FROM district ORDER BY city_population DESC LIMIT 1) | CREATE TABLE store (store_name VARCHAR(255), store_id VARCHAR(255)); CREATE TABLE store_district (store_id VARCHAR(255), district_id VARCHAR(255)); CREATE TABLE district (district_id VARCHAR(255), city_population INTEGER) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 1 | 0 | {
"split": "train",
"row_index": 2832
} |
What instruments does the the song "Le Pop" use? | SELECT T1.instrument FROM instruments AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE T2.title = 'Le Pop' | CREATE TABLE instruments (songid VARCHAR(255), instrument VARCHAR(255)); CREATE TABLE songs (songid VARCHAR(255), title VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 0 | {
"split": "train",
"row_index": 2977
} |
How many instruments does the song "Le Pop" use? | SELECT COUNT(DISTINCT instrument) FROM instruments AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = 'Le Pop' | CREATE TABLE instruments (songid VARCHAR(255), instrument VARCHAR(255)); CREATE TABLE songs (songid VARCHAR(255), title VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 0 | {
"split": "train",
"row_index": 2978
} |
What are the vocal types used in song "Le Pop"? | SELECT TYPE FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = 'Le Pop' | CREATE TABLE vocals (songid VARCHAR(255), TYPE VARCHAR(255)); CREATE TABLE songs (songid VARCHAR(255), title VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 0 | {
"split": "train",
"row_index": 2984
} |
How many songs have a lead vocal? | SELECT COUNT(DISTINCT title) FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE TYPE = 'lead' | CREATE TABLE vocals (songid VARCHAR(255), TYPE VARCHAR(255)); CREATE TABLE songs (songid VARCHAR(255), title VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 0 | {
"split": "train",
"row_index": 2986
} |
Find all the songs that do not have a lead vocal. | SELECT DISTINCT s.title FROM songs AS s WHERE NOT EXISTS (SELECT 1 FROM vocals v WHERE v.songid = s.songid AND v.`TYPE` = 'lead') | CREATE TABLE songs (title VARCHAR(255), songid VARCHAR(255)); CREATE TABLE vocals (songid VARCHAR(255), `TYPE` VARCHAR(255)) | mysql | null | hard | extended | valid | valid | valid | [] | [] | [] | [
"Unsupported predicate: EXISTS(SELECT 1 FROM vocals AS v WHERE v.songid = s.songid AND v.\"TYPE\" = 'lead')"
] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"extended"
] | corrected | null | null | null | {
"split": "train",
"row_index": 2988
} |
What instrument did the musician with last name "Heilo" use in the song "Badlands"? | SELECT T4.instrument FROM Performance AS T1 JOIN Band AS T2 ON T1.bandmate = T2.id JOIN Songs AS T3 ON T3.SongId = T1.SongId JOIN Instruments AS T4 ON T4.SongId = T3.SongId AND T4.bandmateid = T2.id WHERE T2.lastname = 'Heilo' AND T3.title = 'Badlands' | CREATE TABLE Songs (SongId VARCHAR(255), title VARCHAR(255)); CREATE TABLE Performance (bandmate VARCHAR(255), SongId VARCHAR(255)); CREATE TABLE Band (id VARCHAR(255), lastname VARCHAR(255)); CREATE TABLE Instruments (instrument VARCHAR(255), SongId VARCHAR(255), bandmateid VARCHAR(255)) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 4 | 0 | 1 | {
"split": "train",
"row_index": 2992
} |
How many instruments does the song "Badlands" use? | SELECT COUNT(DISTINCT instrument) FROM instruments AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = 'Badlands' | CREATE TABLE instruments (songid VARCHAR(255), instrument VARCHAR(255)); CREATE TABLE songs (songid VARCHAR(255), title VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 0 | {
"split": "train",
"row_index": 2993
} |
What are the vocal types used in song "Badlands"? | SELECT T1.TYPE FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE T2.title = 'Badlands' | CREATE TABLE vocals (songid VARCHAR(255), TYPE VARCHAR(255)); CREATE TABLE songs (songid VARCHAR(255), title VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 0 | {
"split": "train",
"row_index": 2994
} |
How many songs have a shared vocal? | SELECT COUNT(DISTINCT T2.title) FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE T1.`type` = 'shared' | CREATE TABLE vocals (songid VARCHAR(255), `type` VARCHAR(255)); CREATE TABLE songs (songid VARCHAR(255), title VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 0 | {
"split": "train",
"row_index": 2996
} |
Find all the songs that do not have a back vocal. | SELECT DISTINCT title FROM vocals AS t1 JOIN songs AS t2 ON t1.songid = t2.songid EXCEPT SELECT t2.title FROM vocals AS t1 JOIN songs AS t2 ON t1.songid = t2.songid WHERE TYPE = 'back' | CREATE TABLE songs (title VARCHAR(255), songid VARCHAR(255)); CREATE TABLE vocals (songid VARCHAR(255), `TYPE` VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 1 | 1 | 0 | {
"split": "train",
"row_index": 2997
} |
Which vocal type has the band mate with first name "Solveig" played the most? | SELECT T1.TYPE FROM vocals AS T1 JOIN band AS T2 ON T1.bandmate = T2.id WHERE T2.firstname = 'Solveig' GROUP BY T1.TYPE ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE vocals (bandmate VARCHAR(255), TYPE VARCHAR(255)); CREATE TABLE band (id VARCHAR(255), firstname VARCHAR(255)) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 5 | 0 | 0 | {
"split": "train",
"row_index": 2998
} |
Which vocal type did the musician with last name "Heilo" played in the song with title "Der Kapitan"? | SELECT TYPE FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid JOIN band AS T3 ON T1.bandmate = T3.id WHERE T3.lastname = 'Heilo' AND T2.title = 'Der Kapitan' | CREATE TABLE band (id VARCHAR(255), lastname VARCHAR(255)); CREATE TABLE vocals (songid VARCHAR(255), bandmate VARCHAR(255), TYPE VARCHAR(255)); CREATE TABLE songs (songid VARCHAR(255), title VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 3 | 0 | 1 | {
"split": "train",
"row_index": 2999
} |
Which vocal type has the band mate with first name "Marianne" played the most? | SELECT T1.TYPE FROM vocals AS T1 JOIN band AS T2 ON T1.bandmate = T2.id WHERE T2.firstname = 'Marianne' GROUP BY T1.TYPE ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE vocals (bandmate VARCHAR(255), TYPE VARCHAR(255)); CREATE TABLE band (id VARCHAR(255), firstname VARCHAR(255)) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 5 | 0 | 0 | {
"split": "train",
"row_index": 3001
} |
What are all the songs in albums under label "Universal Music Group"? | SELECT T3.title FROM albums AS T1 JOIN tracklists AS T2 ON T1.aid = T2.albumid JOIN songs AS T3 ON T2.songid = T3.songid WHERE T1.label = 'Universal Music Group' | CREATE TABLE songs (title VARCHAR(255), songid VARCHAR(255)); CREATE TABLE albums (aid VARCHAR(255), label VARCHAR(255)); CREATE TABLE tracklists (albumid VARCHAR(255), songid VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 3 | 0 | 0 | {
"split": "train",
"row_index": 3004
} |
Find the number of songs in all the studio albums. | SELECT COUNT(DISTINCT T3.title) FROM albums AS T1 JOIN tracklists AS T2 ON T1.aid = T2.albumid JOIN songs AS T3 ON T2.songid = T3.songid WHERE T1.type = 'Studio' | CREATE TABLE songs (title VARCHAR(255), songid VARCHAR(255)); CREATE TABLE albums (aid VARCHAR(255), `type` VARCHAR(255)); CREATE TABLE tracklists (albumid VARCHAR(255), songid VARCHAR(255)) | mysql | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 3 | 0 | 0 | {
"split": "train",
"row_index": 3005
} |
Find number of products which Sony does not make. | SELECT COUNT(DISTINCT name) FROM products WHERE NOT name IN (SELECT T1.name FROM products AS T1 JOIN manufacturers AS T2 ON T1.Manufacturer = T2.code WHERE T2.name = 'Sony') | CREATE TABLE manufacturers (code VARCHAR(255), name VARCHAR(255)); CREATE TABLE products (name VARCHAR(255), Manufacturer VARCHAR(255)) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 1 | 1 | 1 | {
"split": "train",
"row_index": 3028
} |
Select the names of manufacturer whose products have an average price higher than or equal to $150. | SELECT AVG(T1.price) AS avg_price, T2.name FROM products AS T1 JOIN Manufacturers AS T2 ON T1.manufacturer = T2.code GROUP BY T2.name HAVING AVG(T1.price) >= 150 | CREATE TABLE Manufacturers (name VARCHAR(255), code VARCHAR(255)); CREATE TABLE products (price INTEGER, manufacturer VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 1 | {
"split": "train",
"row_index": 3042
} |
List the first and last names of all distinct staff members who are assigned to the problem whose id is 1. | SELECT DISTINCT staff_first_name, staff_last_name FROM staff AS T1 JOIN problem_log AS T2 ON T1.staff_id = T2.assigned_to_staff_id WHERE T2.problem_id = 1 | CREATE TABLE problem_log (assigned_to_staff_id VARCHAR(255), problem_id VARCHAR(255)); CREATE TABLE staff (staff_id VARCHAR(255), staff_first_name VARCHAR(255), staff_last_name VARCHAR(255)) | mysql | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 0 | 1 | {
"split": "train",
"row_index": 3050
} |
What are the id of problems reported by the staff named Dameon Frami or Jolie Weber? | SELECT product_id FROM problems AS T1 JOIN staff AS T2 ON T1.reported_by_staff_id = T2.staff_id WHERE T2.staff_first_name = 'Dameon' AND T2.staff_last_name = 'Frami' UNION SELECT product_id FROM problems AS T1 JOIN staff AS T2 ON T1.reported_by_staff_id = T2.staff_id WHERE T2.staff_first_name = 'Jolie' AND T2.staff_las... | CREATE TABLE staff (staff_id VARCHAR(255), staff_first_name VARCHAR(255), staff_last_name VARCHAR(255)); CREATE TABLE problems (reported_by_staff_id VARCHAR(255), product_id INTEGER) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 1 | 1 | {
"split": "train",
"row_index": 3062
} |
What are the product ids for the problems reported by Christop Berge with closure authorised by Ashley Medhurst? | SELECT product_id FROM problems AS T1 JOIN staff AS T2 ON T1.reported_by_staff_id = T2.staff_id WHERE T2.staff_first_name = 'Christop' AND T2.staff_last_name = 'Berge' INTERSECT SELECT product_id FROM problems AS T1 JOIN staff AS T2 ON T1.closure_authorised_by_staff_id = T2.staff_id WHERE T2.staff_first_name = 'Ashley'... | CREATE TABLE problems (product_id VARCHAR(255), reported_by_staff_id VARCHAR(255), closure_authorised_by_staff_id VARCHAR(255)); CREATE TABLE staff (staff_id VARCHAR(255), staff_first_name VARCHAR(255), staff_last_name VARCHAR(255)) | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_ambiguous",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 1 | 1 | {
"split": "train",
"row_index": 3063
} |
What are the ids of the problems reported before the date of any problem reported by Lysanne Turcotte? | SELECT T1.problem_id FROM problems AS T1 JOIN staff AS T2 ON T1.reported_by_staff_id = T2.staff_id WHERE date_problem_reported < (SELECT MIN(date_problem_reported) FROM problems AS T3 JOIN staff AS T4 ON T3.reported_by_staff_id = T4.staff_id WHERE T4.staff_first_name = 'Lysanne' AND T4.staff_last_name = 'Turcotte') | CREATE TABLE problems (
problem_id VARCHAR(255),
reported_by_staff_id VARCHAR(255),
date_problem_reported DATE
);
CREATE TABLE staff (
staff_id VARCHAR(255),
staff_first_name VARCHAR(255),
staff_last_name VARCHAR(255)
); | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 1 | 0 | {
"split": "train",
"row_index": 3064
} |
What are the ids of the problems reported after the date of any problems reported by Rylan Homenick? | SELECT T1.problem_id FROM problems AS T1 JOIN staff AS T2 ON T1.reported_by_staff_id = T2.staff_id WHERE date_problem_reported > (SELECT MAX(date_problem_reported) FROM problems AS T3 JOIN staff AS T4 ON T3.reported_by_staff_id = T4.staff_id WHERE T4.staff_first_name = 'Rylan' AND T4.staff_last_name = 'Homenick') | CREATE TABLE problems (
problem_id VARCHAR(255),
reported_by_staff_id VARCHAR(255),
date_problem_reported DATE
);
CREATE TABLE staff (
staff_id VARCHAR(255),
staff_first_name VARCHAR(255),
staff_last_name VARCHAR(255)
); | mysql | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validation_failed",
"correction_corrected",
"extension_unchanged",
"classified"
] | corrected | 2 | 1 | 0 | {
"split": "train",
"row_index": 3065
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.