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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
For each classroom, report the classroom number and the number of grades using it. | SELECT classroom, COUNT(DISTINCT grade) FROM list GROUP BY classroom | 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 | 1 | 0 | 1 | {
"split": "train",
"row_index": 2368
} |
Which classroom has the most students? | SELECT classroom FROM list GROUP BY classroom ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE list (classroom 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": 2369
} |
Report the number of students in each classroom. | SELECT classroom, COUNT(*) FROM list GROUP BY classroom | CREATE TABLE list (classroom 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": 2370
} |
For each grade 0 classroom, report the total number of students. | SELECT classroom, COUNT(*) FROM list WHERE grade = '0' GROUP BY classroom | CREATE TABLE list (classroom VARCHAR(255), grade VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2371
} |
Report the total number of students for each fourth-grade classroom. | SELECT classroom, COUNT(*) FROM list WHERE grade = '4' GROUP BY classroom | CREATE TABLE list (classroom VARCHAR(255), grade VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2372
} |
Find the name of the teacher who teaches the largest number of students. | SELECT T2.firstname, T2.lastname FROM list AS T1 JOIN teachers AS T2 ON T1.classroom = T2.classroom GROUP BY T2.firstname, T2.lastname ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE list (classroom VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE teachers (firstname VARCHAR(255), lastname VARCHAR(255), classroom VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 2 | {
"split": "train",
"row_index": 2373
} |
Find the number of students in one classroom. | SELECT COUNT(*), classroom FROM list GROUP BY classroom | CREATE TABLE list (classroom 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": 2374
} |
How many companies are headquartered in the US? | SELECT COUNT(*) FROM company WHERE Headquarters = 'USA' | CREATE TABLE company (Headquarters 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": 2375
} |
List the names of companies by ascending number of sales. | SELECT Name FROM company ORDER BY Sales_in_Billion | CREATE TABLE company (Name VARCHAR(255), Sales_in_Billion VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2376
} |
What are the headquarters and industries of all companies? | SELECT Headquarters, Industry FROM company | CREATE TABLE company (Headquarters VARCHAR(255), Industry VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 2377
} |
Show the names of companies in the banking or retailing industry? | SELECT Name FROM company WHERE Industry = 'Banking' OR Industry = 'Retailing' | CREATE TABLE company (Name VARCHAR(255), Industry VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2378
} |
What is the maximum and minimum market value of companies? | SELECT MAX(Market_Value_in_Billion), MIN(Market_Value_in_Billion) FROM company | CREATE TABLE company (Market_Value_in_Billion 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": 2379
} |
What is the headquarter of the company with the largest sales? | SELECT Headquarters FROM company ORDER BY Sales_in_Billion DESC LIMIT 1 | CREATE TABLE company (Headquarters VARCHAR(255), Sales_in_Billion VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2380
} |
Show the different headquarters and number of companies at each headquarter. | SELECT Headquarters, COUNT(*) FROM company GROUP BY Headquarters | CREATE TABLE company (Headquarters 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": 2381
} |
Show the most common headquarter for companies. | SELECT Headquarters FROM company GROUP BY Headquarters ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE company (Headquarters 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": 2382
} |
Show the headquarters that have at least two companies. | SELECT Headquarters FROM company GROUP BY Headquarters HAVING COUNT(*) >= 2 | CREATE TABLE company (Headquarters 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": 2383
} |
Show the headquarters that have both companies in banking industry and companies in oil and gas industry. | SELECT Headquarters FROM company WHERE Industry = 'Banking' INTERSECT SELECT Headquarters FROM company WHERE Industry = 'Oil and gas' | CREATE TABLE company (Headquarters VARCHAR(255), Industry VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2384
} |
Show the names of companies and of employees. | SELECT T3.Name, T2.Name FROM employment AS T1 JOIN people AS T2 ON T1.People_ID = T2.People_ID JOIN company AS T3 ON T1.Company_ID = T3.Company_ID | CREATE TABLE company (Name VARCHAR(255), Company_ID VARCHAR(255)); CREATE TABLE employment (People_ID VARCHAR(255), Company_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE people (Name VARCHAR(255), People_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2385
} |
Show names of companies and that of employees in descending order of number of years working for that employee. | SELECT T3.Name, T2.Name FROM employment AS T1 JOIN people AS T2 ON T1.People_ID = T2.People_ID JOIN company AS T3 ON T1.Company_ID = T3.Company_ID ORDER BY T1.Year_working | CREATE TABLE people (Name VARCHAR(255), People_ID VARCHAR(255)); CREATE TABLE company (Name VARCHAR(255), Company_ID VARCHAR(255)); CREATE TABLE employment (People_ID VARCHAR(255), Company_ID VARCHAR(255), Year_working VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 2386
} |
Show the names of employees that work for companies with sales bigger than 200. | SELECT T2.Name FROM employment AS T1 JOIN people AS T2 ON T1.People_ID = T2.People_ID JOIN company AS T3 ON T1.Company_ID = T3.Company_ID WHERE T3.Sales_in_Billion > 200 | CREATE TABLE employment (People_ID VARCHAR(255), Company_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE company (Company_ID VARCHAR(255), Sales_in_Billion INTEGER); CREATE TABLE people (Name VARCHAR(255), People_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2387
} |
Show the names of companies and the number of employees they have | SELECT T3.Name, COUNT(*) FROM employment AS T1 JOIN people AS T2 ON T1.People_ID = T2.People_ID JOIN company AS T3 ON T1.Company_ID = T3.Company_ID GROUP BY T3.Name | CREATE TABLE company (Name VARCHAR(255), Company_ID VARCHAR(255)); CREATE TABLE people (People_ID VARCHAR(255), Name VARCHAR(255)); CREATE TABLE employment (People_ID VARCHAR(255), Company_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 2388
} |
List the names of people that are not employed by any company | SELECT Name FROM people WHERE NOT People_ID IN (SELECT People_ID FROM employment) | CREATE TABLE employment (Name VARCHAR(255), People_ID VARCHAR(255)); CREATE TABLE people (Name VARCHAR(255), People_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2389
} |
list the names of the companies with more than 200 sales in the descending order of sales and profits. | SELECT name FROM company WHERE Sales_in_Billion > 200 ORDER BY Sales_in_Billion, Profits_in_Billion DESC | CREATE TABLE company (name VARCHAR(255), Sales_in_Billion INTEGER, Profits_in_Billion VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | null | medium | extended | valid | valid | valid | [] | [] | [] | [
"Mixed ORDER BY directions"
] | [
"validated",
"extended",
"extended"
] | null | null | null | null | {
"split": "train",
"row_index": 2390
} |
How many film are there? | SELECT COUNT(*) FROM film | CREATE TABLE film (Id VARCHAR(255), Title VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2391
} |
List the distinct director of all films. | SELECT DISTINCT Director FROM film | CREATE TABLE film (Director VARCHAR(255), Title VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2392
} |
What is the average ticket sales gross in dollars of films? | SELECT AVG(Gross_in_dollar) FROM film | CREATE TABLE film (Gross_in_dollar INTEGER, Title VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2393
} |
What are the low and high estimates of film markets? | SELECT Low_Estimate, High_Estimate FROM film_market_estimation | CREATE TABLE film_market_estimation (Low_Estimate VARCHAR(255), High_Estimate VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 2394
} |
What are the types of film market estimations in year 1995? | SELECT TYPE FROM film_market_estimation WHERE YEAR = 1995 | CREATE TABLE film_market_estimation (TYPE VARCHAR(255), YEAR VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2395
} |
What are the maximum and minimum number of cities in all markets. | SELECT MAX(Number_cities), MIN(Number_cities) FROM market | CREATE TABLE market (Number_cities INTEGER, Country VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 2 | {
"split": "train",
"row_index": 2396
} |
How many markets have number of cities smaller than 300? | SELECT COUNT(*) FROM market WHERE Number_cities < 300 | CREATE TABLE market (Number_cities INTEGER, Country VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2397
} |
List all countries of markets in ascending alphabetical order. | SELECT Country FROM market ORDER BY Country | CREATE TABLE market (Country VARCHAR(255), Number_cities INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2398
} |
List all countries of markets in descending order of number of cities. | SELECT Country FROM market ORDER BY Number_cities DESC | CREATE TABLE market (Country VARCHAR(255), Number_cities VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2399
} |
Please show the titles of films and the types of market estimations. | SELECT T1.Title, T2.Type FROM film AS T1 JOIN film_market_estimation AS T2 ON T1.Film_ID = T2.Film_ID | CREATE TABLE film (Title VARCHAR(255), Film_ID VARCHAR(255)); CREATE TABLE film_market_estimation (Type VARCHAR(255), Film_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2400
} |
Show the distinct director of films with market estimation in the year of 1995. | SELECT DISTINCT T1.Director FROM film AS T1 JOIN film_market_estimation AS T2 ON T1.Film_ID = T2.Film_ID WHERE T2.Year = 1995 | CREATE TABLE film (Director VARCHAR(255), Film_ID VARCHAR(255)); CREATE TABLE film_market_estimation (Film_ID VARCHAR(255), Year VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2401
} |
What is the average number of cities of markets with low film market estimate bigger than 10000? | SELECT AVG(T2.Number_cities) FROM film_market_estimation AS T1 JOIN market AS T2 ON T1.Market_ID = T2.Market_ID WHERE T1.Low_Estimate > 10000 | CREATE TABLE market (Number_cities INTEGER, Market_ID VARCHAR(255)); CREATE TABLE film_market_estimation (Market_ID VARCHAR(255), Low_Estimate INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2402
} |
Please list the countries and years of film market estimations. | SELECT T2.Country, T1.Year FROM film_market_estimation AS T1 JOIN market AS T2 ON T1.Market_ID = T2.Market_ID | CREATE TABLE film_market_estimation (Year VARCHAR(255), Market_ID VARCHAR(255)); CREATE TABLE market (Country VARCHAR(255), Market_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2403
} |
Please list the years of film market estimations when the market is in country "Japan" in descending order. | SELECT T1.Year FROM film_market_estimation AS T1 JOIN market AS T2 ON T1.Market_ID = T2.Market_ID WHERE T2.Country = 'Japan' ORDER BY T1.Year DESC | CREATE TABLE film_market_estimation (Year VARCHAR(255), Market_ID VARCHAR(255)); CREATE TABLE market (Market_ID VARCHAR(255), Country VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2404
} |
List the studios of each film and the number of films produced by that studio. | SELECT Studio, COUNT(*) FROM film GROUP BY Studio | CREATE TABLE film (Studio 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": 2405
} |
List the name of film studio that have the most number of films. | SELECT Studio FROM film GROUP BY Studio ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE film (Studio 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": 2406
} |
List the names of studios that have at least two films. | SELECT Studio FROM film GROUP BY Studio HAVING COUNT(*) >= 2 | CREATE TABLE film (Studio 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": 2407
} |
List the title of films that do not have any market estimation. | SELECT Title FROM film WHERE NOT Film_ID IN (SELECT Film_ID FROM film_market_estimation) | CREATE TABLE film_market_estimation (Title VARCHAR(255), Film_ID VARCHAR(255)); CREATE TABLE film (Title VARCHAR(255), Film_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2408
} |
Show the studios that have produced films with director "Nicholas Meyer" and "Walter Hill". | SELECT Studio FROM film WHERE Director = 'Nicholas Meyer' INTERSECT SELECT Studio FROM film WHERE Director = 'Walter Hill' | CREATE TABLE film (Studio VARCHAR(255), Director VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2409
} |
Find the titles and studios of the films that are produced by some film studios that contained the word "Universal". | SELECT title, Studio FROM film WHERE Studio LIKE '%Universal%' | CREATE TABLE film (title VARCHAR(255), Studio VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2410
} |
Show the studios that have not produced films with director "Walter Hill". | SELECT Studio FROM film EXCEPT SELECT Studio FROM film WHERE Director = 'Walter Hill' | CREATE TABLE film (Studio VARCHAR(255), Director VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 2411
} |
List the studios which average gross is above 4500000. | SELECT Studio FROM film GROUP BY Studio HAVING AVG(Gross_in_dollar) >= 4500000 | CREATE TABLE film (Studio VARCHAR(255), Gross_in_dollar INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2412
} |
What are the titles and directors of the films were never presented in China? | SELECT title, director FROM film WHERE NOT film_id IN (SELECT film_id FROM film_market_estimation AS T1 JOIN market AS T2 ON T1.market_id = T2.Market_ID WHERE country = 'China') | CREATE TABLE film (title VARCHAR(255), director VARCHAR(255), film_id VARCHAR(255), country VARCHAR(255)); CREATE TABLE market (Market_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE film_market_estimation (market_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 2414
} |
How many calendar items do we have? | SELECT COUNT(*) FROM Ref_calendar | CREATE TABLE Ref_calendar (Id VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2415
} |
Show all calendar dates and day Numbers. | SELECT calendar_date, day_Number FROM Ref_calendar | CREATE TABLE Ref_calendar (calendar_date VARCHAR(255), day_Number VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 2416
} |
Show the number of document types. | SELECT COUNT(*) FROM Ref_document_types | CREATE TABLE Ref_document_types (Id VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2417
} |
List all document type codes and document type names. | SELECT document_type_code, document_type_name FROM Ref_document_types | CREATE TABLE Ref_document_types (document_type_code VARCHAR(255), document_type_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 2418
} |
What is the name and description for document type code RV? | SELECT document_type_name, document_type_description FROM Ref_document_types WHERE document_type_code = 'RV' | CREATE TABLE Ref_document_types (document_type_name VARCHAR(255), document_type_description VARCHAR(255), document_type_code VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2419
} |
What is the document type code for document type "Paper"? | SELECT document_type_code FROM Ref_document_types WHERE document_type_name = 'Paper' | CREATE TABLE Ref_document_types (document_type_code VARCHAR(255), document_type_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2420
} |
Show the number of documents with document type code CV or BK. | SELECT COUNT(*) FROM All_documents WHERE document_type_code = 'CV' OR document_type_code = 'BK' | CREATE TABLE All_documents (document_type_code VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2421
} |
What is the date when the document "Marry CV" was stored? | SELECT date_stored FROM All_documents WHERE Document_name = 'Marry CV' | CREATE TABLE All_documents (date_stored VARCHAR(255), Document_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2422
} |
What is the document type name for the document with name "How to read a book"? | SELECT T2.document_type_name FROM All_documents AS T1 JOIN Ref_document_types AS T2 ON T1.document_type_code = T2.document_type_code WHERE T1.document_name = 'How to read a book' | CREATE TABLE Ref_document_types (document_type_name VARCHAR(255), document_type_code VARCHAR(255)); CREATE TABLE All_documents (document_type_code VARCHAR(255), document_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2424
} |
Show the number of locations. | SELECT COUNT(*) FROM Ref_locations | CREATE TABLE Ref_locations (Id VARCHAR(255), location_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2425
} |
List all location codes and location names. | SELECT location_code, location_name FROM Ref_locations | CREATE TABLE Ref_locations (location_code VARCHAR(255), location_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 2426
} |
What are the name and description for location code x? | SELECT location_name, location_description FROM Ref_locations WHERE location_code = 'x' | CREATE TABLE Ref_locations (location_name VARCHAR(255), location_description VARCHAR(255), location_code VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2427
} |
What is the location code for the country "Canada"? | SELECT location_code FROM Ref_locations WHERE location_name = 'Canada' | CREATE TABLE Ref_locations (location_code VARCHAR(255), location_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2428
} |
How many roles are there? | SELECT COUNT(*) FROM ROLES | CREATE TABLE ROLES (Id VARCHAR(255), role_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2429
} |
List all role codes, role names, and role descriptions. | SELECT role_code, role_name, role_description FROM ROLES | CREATE TABLE ROLES (role_code VARCHAR(255), role_name VARCHAR(255), role_description VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 2430
} |
What are the name and description for role code "MG"? | SELECT role_name, role_description FROM ROLES WHERE role_code = 'MG' | CREATE TABLE ROLES (role_name VARCHAR(255), role_description VARCHAR(255), role_code VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2431
} |
Show the description for role name "Proof Reader". | SELECT role_description FROM ROLES WHERE role_name = 'Proof Reader' | CREATE TABLE ROLES (role_description VARCHAR(255), role_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2432
} |
What is the id for the employee called Ebba? | SELECT employee_ID FROM Employees WHERE employee_name = 'Ebba' | CREATE TABLE Employees (employee_ID VARCHAR(255), employee_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2434
} |
Show the names of all the employees with role "HR". | SELECT employee_name FROM Employees WHERE role_code = 'HR' | CREATE TABLE Employees (employee_name VARCHAR(255), role_code VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2435
} |
Show all role codes and the number of employees in each role. | SELECT role_code, COUNT(*) FROM Employees GROUP BY role_code | CREATE TABLE Employees (role_code VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2436
} |
What is the role code with the largest number of employees? | SELECT role_code FROM Employees GROUP BY role_code ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Employees (role_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": 2437
} |
Show all role codes with at least 3 employees. | SELECT role_code FROM Employees GROUP BY role_code HAVING COUNT(*) >= 3 | CREATE TABLE Employees (role_code 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": 2438
} |
Show the role code with the least employees. | SELECT role_code FROM Employees GROUP BY role_code ORDER BY COUNT(*) LIMIT 1 | CREATE TABLE Employees (role_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": 2439
} |
What is the role name and role description for employee called Ebba? | SELECT T2.role_name, T2.role_description FROM Employees AS T1 JOIN ROLES AS T2 ON T1.role_code = T2.role_code WHERE T1.employee_name = 'Ebba' | CREATE TABLE Employees (role_code VARCHAR(255), employee_name VARCHAR(255)); CREATE TABLE ROLES (role_name VARCHAR(255), role_description VARCHAR(255), role_code VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2440
} |
Show the names of employees with role name Editor. | SELECT T1.employee_name FROM Employees AS T1 JOIN ROLES AS T2 ON T1.role_code = T2.role_code WHERE T2.role_name = 'Editor' | CREATE TABLE ROLES (role_code VARCHAR(255), role_name VARCHAR(255)); CREATE TABLE Employees (employee_name VARCHAR(255), role_code VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2441
} |
Show the employee ids for all employees with role name "Human Resource" or "Manager". | SELECT T1.employee_id FROM Employees AS T1 JOIN ROLES AS T2 ON T1.role_code = T2.role_code WHERE T2.role_name = 'Human Resource' OR T2.role_name = 'Manager' | CREATE TABLE Employees (employee_id VARCHAR(255), role_code VARCHAR(255)); CREATE TABLE ROLES (role_code VARCHAR(255), role_name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 2442
} |
What are the different location codes for documents? | SELECT DISTINCT location_code FROM Document_locations | CREATE TABLE Document_locations (location_code VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2443
} |
Show the location name for document "Robin CV". | SELECT T3.location_name FROM All_documents AS T1 JOIN Document_locations AS T2 ON T1.document_id = T2.document_id JOIN Ref_locations AS T3 ON T2.location_code = T3.location_code WHERE T1.document_name = 'Robin CV' | CREATE TABLE Ref_locations (location_name VARCHAR(255), location_code VARCHAR(255)); CREATE TABLE All_documents (document_id VARCHAR(255), document_name VARCHAR(255)); CREATE TABLE Document_locations (document_id VARCHAR(255), location_code VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2444
} |
Show the location code, the starting date and ending data in that location for all the documents. | SELECT location_code, date_in_location_from, date_in_locaton_to FROM Document_locations | CREATE TABLE Document_locations (location_code VARCHAR(255), date_in_location_from VARCHAR(255), date_in_locaton_to VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 2445
} |
What is "the date in location from" and "the date in location to" for the document with name "Robin CV"? | SELECT T1.date_in_location_from, T1.date_in_locaton_to FROM Document_locations AS T1 JOIN All_documents AS T2 ON T1.document_id = T2.document_id WHERE T2.document_name = 'Robin CV' | CREATE TABLE All_documents (document_id VARCHAR(255), document_name VARCHAR(255)); CREATE TABLE Document_locations (date_in_location_from VARCHAR(255), date_in_locaton_to VARCHAR(255), document_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2446
} |
Show the location codes and the number of documents in each location. | SELECT location_code, COUNT(*) FROM Document_locations GROUP BY location_code | CREATE TABLE Document_locations (location_code VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2447
} |
What is the location code with the most documents? | SELECT location_code FROM Document_locations GROUP BY location_code ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Document_locations (location_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": 2448
} |
Show the location codes with at least 3 documents. | SELECT location_code FROM Document_locations GROUP BY location_code HAVING COUNT(*) >= 3 | CREATE TABLE Document_locations (location_code 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": 2449
} |
Show the location name and code with the least documents. | SELECT T2.location_name, T1.location_code FROM Document_locations AS T1 JOIN Ref_locations AS T2 ON T1.location_code = T2.location_code GROUP BY T1.location_code ORDER BY COUNT(*) LIMIT 1 | CREATE TABLE Document_locations (location_code VARCHAR(255)); CREATE TABLE Ref_locations (location_name VARCHAR(255), location_code VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 2450
} |
What are the names of the employees who authorised the destruction and the employees who destroyed the corresponding documents? | SELECT T2.employee_name, T3.employee_name FROM Documents_to_be_destroyed AS T1 JOIN Employees AS T2 ON T1.Destruction_Authorised_by_Employee_ID = T2.employee_id JOIN Employees AS T3 ON T1.Destroyed_by_Employee_ID = T3.employee_id | CREATE TABLE Employees (employee_name VARCHAR(255), employee_id VARCHAR(255)); CREATE TABLE Documents_to_be_destroyed (Destruction_Authorised_by_Employee_ID VARCHAR(255), Destroyed_by_Employee_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2451
} |
Show the id of each employee and the number of document destruction authorised by that employee. | SELECT Destruction_Authorised_by_Employee_ID, COUNT(*) FROM Documents_to_be_destroyed GROUP BY Destruction_Authorised_by_Employee_ID | CREATE TABLE Documents_to_be_destroyed (Destruction_Authorised_by_Employee_ID 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": 2452
} |
Show the employee ids and the number of documents destroyed by each employee. | SELECT Destroyed_by_Employee_ID, COUNT(*) FROM Documents_to_be_destroyed GROUP BY Destroyed_by_Employee_ID | CREATE TABLE Documents_to_be_destroyed (Destroyed_by_Employee_ID 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": 2453
} |
Show the ids of the employees who don't authorize destruction for any document. | SELECT employee_id FROM Employees EXCEPT SELECT Destruction_Authorised_by_Employee_ID FROM Documents_to_be_destroyed | CREATE TABLE Documents_to_be_destroyed (employee_id VARCHAR(255), Destruction_Authorised_by_Employee_ID VARCHAR(255)); CREATE TABLE Employees (employee_id VARCHAR(255), Destruction_Authorised_by_Employee_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 2454
} |
Show the ids of all employees who have authorized destruction. | SELECT DISTINCT Destruction_Authorised_by_Employee_ID FROM Documents_to_be_destroyed | CREATE TABLE Documents_to_be_destroyed (Destruction_Authorised_by_Employee_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2455
} |
Show the ids of all employees who have destroyed a document. | SELECT DISTINCT Destroyed_by_Employee_ID FROM Documents_to_be_destroyed | CREATE TABLE Documents_to_be_destroyed (Destroyed_by_Employee_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2456
} |
Show the ids of all employees who don't destroy any document. | SELECT employee_id FROM Employees EXCEPT SELECT Destroyed_by_Employee_ID FROM Documents_to_be_destroyed | CREATE TABLE Employees (employee_id VARCHAR(255), Destroyed_by_Employee_ID VARCHAR(255)); CREATE TABLE Documents_to_be_destroyed (employee_id VARCHAR(255), Destroyed_by_Employee_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 2457
} |
Show the ids of all employees who have either destroyed a document or made an authorization to do this. | SELECT Destroyed_by_Employee_ID FROM Documents_to_be_destroyed UNION SELECT Destruction_Authorised_by_Employee_ID FROM Documents_to_be_destroyed | CREATE TABLE Documents_to_be_destroyed (Destroyed_by_Employee_ID VARCHAR(255), Destruction_Authorised_by_Employee_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 2458
} |
What are the names of all clubs? | SELECT clubname FROM club | CREATE TABLE club (clubname 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": 2459
} |
How many students are there? | SELECT COUNT(*) FROM student | CREATE TABLE student (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2460
} |
What are the first names of all the students? | SELECT DISTINCT fname FROM student | CREATE TABLE student (fname VARCHAR(255), lname VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2461
} |
Find the last names of the members of the club "Bootup Baltimore". | SELECT t3.lname FROM club AS t1 JOIN member_of_club AS t2 ON t1.clubid = t2.clubid JOIN student AS t3 ON t2.stuid = t3.stuid WHERE t1.clubname = 'Bootup Baltimore' | CREATE TABLE club (clubid VARCHAR(255), clubname VARCHAR(255)); CREATE TABLE student (lname VARCHAR(255), stuid VARCHAR(255)); CREATE TABLE member_of_club (clubid VARCHAR(255), stuid VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2462
} |
Who are the members of the club named "Hopkins Student Enterprises"? Show the last name. | SELECT t3.lname FROM club AS t1 JOIN member_of_club AS t2 ON t1.clubid = t2.clubid JOIN student AS t3 ON t2.stuid = t3.stuid WHERE t1.clubname = 'Hopkins Student Enterprises' | CREATE TABLE club (clubid VARCHAR(255), clubname VARCHAR(255)); CREATE TABLE student (lname VARCHAR(255), stuid VARCHAR(255)); CREATE TABLE member_of_club (clubid VARCHAR(255), stuid VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2463
} |
How many members does the club "Tennis Club" has? | SELECT COUNT(*) FROM club AS t1 JOIN member_of_club AS t2 ON t1.clubid = t2.clubid JOIN student AS t3 ON t2.stuid = t3.stuid WHERE t1.clubname = 'Tennis Club' | CREATE TABLE club (clubid VARCHAR(255), clubname VARCHAR(255)); CREATE TABLE member_of_club (clubid VARCHAR(255), stuid VARCHAR(255)); CREATE TABLE student (stuid VARCHAR(255), fname VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2464
} |
Find the number of members of club "Pen and Paper Gaming". | SELECT COUNT(*) FROM club AS t1 JOIN member_of_club AS t2 ON t1.clubid = t2.clubid JOIN student AS t3 ON t2.stuid = t3.stuid WHERE t1.clubname = 'Pen and Paper Gaming' | CREATE TABLE club (clubid VARCHAR(255), clubname VARCHAR(255)); CREATE TABLE member_of_club (clubid VARCHAR(255), stuid VARCHAR(255)); CREATE TABLE student (stuid VARCHAR(255), fname VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2465
} |
How many clubs does "Linda Smith" belong to? | SELECT COUNT(*) FROM club AS t1 JOIN member_of_club AS t2 ON t1.clubid = t2.clubid JOIN student AS t3 ON t2.stuid = t3.stuid WHERE t3.fname = 'Linda' AND t3.lname = 'Smith' | CREATE TABLE student (stuid VARCHAR(255), fname VARCHAR(255), lname VARCHAR(255)); CREATE TABLE member_of_club (clubid VARCHAR(255), stuid VARCHAR(255)); CREATE TABLE club (clubid VARCHAR(255), clubname VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 2466
} |
Find the number of clubs where "Tracy Kim" is a member. | SELECT COUNT(*) FROM club AS t1 JOIN member_of_club AS t2 ON t1.clubid = t2.clubid JOIN student AS t3 ON t2.stuid = t3.stuid WHERE t3.fname = 'Tracy' AND t3.lname = 'Kim' | CREATE TABLE student (stuid VARCHAR(255), fname VARCHAR(255), lname VARCHAR(255)); CREATE TABLE member_of_club (clubid VARCHAR(255), stuid VARCHAR(255)); CREATE TABLE club (clubid VARCHAR(255), clubname VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 2467
} |
Find all the female members of club "Bootup Baltimore". Show the first name and last name. | SELECT t3.fname, t3.lname FROM club AS t1 JOIN member_of_club AS t2 ON t1.clubid = t2.clubid JOIN student AS t3 ON t2.stuid = t3.stuid WHERE t1.clubname = 'Bootup Baltimore' AND t3.sex = 'F' | CREATE TABLE club (clubid VARCHAR(255), clubname VARCHAR(255)); CREATE TABLE student (fname VARCHAR(255), lname VARCHAR(255), stuid VARCHAR(255), sex VARCHAR(255)); CREATE TABLE member_of_club (clubid VARCHAR(255), stuid VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 2 | {
"split": "train",
"row_index": 2468
} |
Find all the male members of club "Hopkins Student Enterprises". Show the first name and last name. | SELECT t3.fname, t3.lname FROM club AS t1 JOIN member_of_club AS t2 ON t1.clubid = t2.clubid JOIN student AS t3 ON t2.stuid = t3.stuid WHERE t1.clubname = 'Hopkins Student Enterprises' AND t3.sex = 'M' | CREATE TABLE club (clubid VARCHAR(255), clubname VARCHAR(255)); CREATE TABLE student (fname VARCHAR(255), lname VARCHAR(255), stuid VARCHAR(255), sex VARCHAR(255)); CREATE TABLE member_of_club (clubid VARCHAR(255), stuid VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 2 | {
"split": "train",
"row_index": 2469
} |
Find all members of "Bootup Baltimore" whose major is "600". Show the first name and last name. | SELECT t3.fname, t3.lname FROM club AS t1 JOIN member_of_club AS t2 ON t1.clubid = t2.clubid JOIN student AS t3 ON t2.stuid = t3.stuid WHERE t1.clubname = 'Bootup Baltimore' AND t3.major = '600' | CREATE TABLE club (clubid VARCHAR(255), clubname VARCHAR(255)); CREATE TABLE member_of_club (clubid VARCHAR(255), stuid VARCHAR(255)); CREATE TABLE student (fname VARCHAR(255), lname VARCHAR(255), stuid VARCHAR(255), major VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 2 | {
"split": "train",
"row_index": 2470
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.