question string | answer string | context string | dialect string | spider_hardness string | extended_hardness string | classification_status string | syntax_status string | ddl_syntax_status string | schema_status string | syntax_errors list | ddl_syntax_errors list | schema_errors list | classification_errors list | status_history list | correction_status string | component1 int64 | component2 int64 | others int64 | validation_source dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Show the names of members that have a rank in round higher than 3. | SELECT T1.Name FROM member AS T1 JOIN round AS T2 ON T1.Member_ID = T2.Member_ID WHERE T2.Rank_in_Round > 3 | CREATE TABLE round (Member_ID VARCHAR(255), Rank_in_Round INTEGER); CREATE TABLE member (Name VARCHAR(255), Member_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2587
} |
List the names of members who did not participate in any round. | SELECT Name FROM member WHERE NOT Member_ID IN (SELECT Member_ID FROM round) | CREATE TABLE member (Name VARCHAR(255), Member_ID VARCHAR(255)); CREATE TABLE round (Name VARCHAR(255), Member_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2589
} |
Find the name and access counts of all documents, in alphabetic order of the document name. | SELECT document_name, access_count FROM documents ORDER BY document_name | CREATE TABLE documents (document_name VARCHAR(255), access_count VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2590
} |
Find the name of the document that has been accessed the greatest number of times, as well as the count of how many times it has been accessed? | SELECT document_name, access_count FROM documents ORDER BY access_count DESC LIMIT 1 | CREATE TABLE documents (document_name VARCHAR(255), access_count VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2591
} |
Find the types of documents with more than 4 documents. | SELECT document_type_code FROM documents GROUP BY document_type_code HAVING COUNT(*) > 4 | CREATE TABLE documents (document_type_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": 2592
} |
Find the total access count of all documents in the most popular document type. | SELECT SUM(access_count) FROM documents GROUP BY document_type_code ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE documents (access_count INTEGER, document_type_code VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 2593
} |
What is the average access count of documents? | SELECT AVG(access_count) FROM documents | CREATE TABLE documents (access_count INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2594
} |
What is the structure of the document with the least number of accesses? | SELECT t2.document_structure_description FROM documents AS t1 JOIN document_structures AS t2 ON t1.document_structure_code = t2.document_structure_code GROUP BY t1.document_structure_code ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE document_structures (document_structure_description VARCHAR(255), document_structure_code VARCHAR(255)); CREATE TABLE documents (document_structure_code VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 2595
} |
What is the type of the document named "David CV"? | SELECT document_type_code FROM documents WHERE document_name = 'David CV' | CREATE TABLE documents (document_type_code VARCHAR(255), document_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2596
} |
Find the list of documents that are both in the most three popular type and have the most three popular structure. | SELECT document_name FROM documents GROUP BY document_type_code ORDER BY COUNT(*) DESC LIMIT 3 INTERSECT SELECT document_name FROM documents GROUP BY document_structure_code ORDER BY COUNT(*) DESC LIMIT 3 | CREATE TABLE documents (document_name VARCHAR(255), document_type_code VARCHAR(255), document_structure_code VARCHAR(255)) | generic | null | extra | extended | valid | valid | valid | [] | [] | [] | [
"Unsupported intersect options: limit, order"
] | [
"validated",
"extended",
"extended"
] | null | null | null | null | {
"split": "train",
"row_index": 2597
} |
What document types do have more than 10000 total access number. | SELECT document_type_code FROM documents GROUP BY document_type_code HAVING SUM(access_count) > 10000 | CREATE TABLE documents (document_type_code VARCHAR(255), access_count INTEGER, id INTEGER PRIMARY KEY AUTOINCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2598
} |
What are all the section titles of the document named "David CV"? | SELECT t2.section_title FROM documents AS t1 JOIN document_sections AS t2 ON t1.document_code = t2.document_code WHERE t1.document_name = 'David CV' | CREATE TABLE documents (document_code VARCHAR(255), document_name VARCHAR(255)); CREATE TABLE document_sections (section_title VARCHAR(255), document_code VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2599
} |
Find all the name of documents without any sections. | SELECT document_name FROM documents WHERE NOT document_code IN (SELECT document_code FROM document_sections) | CREATE TABLE document_sections (document_name VARCHAR(255), document_code VARCHAR(255)); CREATE TABLE documents (document_name VARCHAR(255), document_code VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2600
} |
List all the username and passwords of users with the most popular role. | SELECT user_name, password FROM users GROUP BY role_code ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE users (user_name VARCHAR(255), password VARCHAR(255), role_code VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 2601
} |
Find the average access counts of documents with functional area "Acknowledgement". | SELECT AVG(t1.access_count) FROM documents AS t1 JOIN document_functional_areas AS t2 ON t1.document_code = t2.document_code JOIN functional_areas AS t3 ON t2.functional_area_code = t3.functional_area_code WHERE t3.functional_area_description = 'Acknowledgement' | CREATE TABLE document_functional_areas (document_code VARCHAR(255), functional_area_code VARCHAR(255)); CREATE TABLE documents (access_count INTEGER, document_code VARCHAR(255)); CREATE TABLE functional_areas (functional_area_code VARCHAR(255), functional_area_description VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2602
} |
What is the name of the document with the most number of sections? | SELECT t1.document_name FROM documents AS t1 JOIN document_sections AS t2 ON t1.document_code = t2.document_code GROUP BY t1.document_code ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE document_sections (document_code VARCHAR(255), id INTEGER PRIMARY KEY AUTOINCREMENT); CREATE TABLE documents (document_name VARCHAR(255), document_code VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 2604
} |
List all the document names which contains "CV". | SELECT document_name FROM documents WHERE document_name LIKE '%CV%' | CREATE TABLE documents (document_name VARCHAR(255), id INTEGER PRIMARY KEY AUTOINCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2605
} |
How many users are logged in? | SELECT COUNT(*) FROM users WHERE user_login = 1 | CREATE TABLE users (user_login VARCHAR(255), id INTEGER PRIMARY KEY AUTOINCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2606
} |
Find the description of the most popular role among the users that have logged in. | SELECT role_description FROM ROLES WHERE role_code = (SELECT role_code FROM users WHERE user_login = 1 GROUP BY role_code ORDER BY COUNT(*) DESC LIMIT 1) | CREATE TABLE users (role_description VARCHAR(255), role_code VARCHAR(255), user_login VARCHAR(255)); CREATE TABLE ROLES (role_description VARCHAR(255), role_code VARCHAR(255), user_login VARCHAR(255)) | generic | hard | extreme | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2607
} |
Find the average access count of documents with the least popular structure. | SELECT AVG(access_count) FROM documents GROUP BY document_structure_code ORDER BY COUNT(*) LIMIT 1 | CREATE TABLE documents (access_count INTEGER, document_structure_code VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 2608
} |
List all the image name and URLs in the order of their names. | SELECT image_name, image_url FROM images ORDER BY image_name | CREATE TABLE images (image_name VARCHAR(255), image_url VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2609
} |
Find the number of users in each role. | SELECT COUNT(*), role_code FROM users GROUP BY role_code | CREATE TABLE users (role_code VARCHAR(255), id INTEGER PRIMARY KEY AUTOINCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2610
} |
What document types have more than 2 corresponding documents? | SELECT document_type_code FROM documents GROUP BY document_type_code HAVING COUNT(*) > 2 | CREATE TABLE documents (document_type_code VARCHAR(255), id INTEGER PRIMARY KEY AUTOINCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2611
} |
How many companies are there? | SELECT COUNT(*) FROM Companies | CREATE TABLE Companies (Id VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2612
} |
List the names of companies in descending order of market value. | SELECT name FROM Companies ORDER BY Market_Value_billion DESC | CREATE TABLE Companies (name VARCHAR(255), Market_Value_billion VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2613
} |
What are the names of companies whose headquarters are not "USA"? | SELECT name FROM Companies WHERE Headquarters <> 'USA' | CREATE TABLE Companies (name VARCHAR(255), 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": 2614
} |
What are the name and assets of each company, sorted in ascending order of company name? | SELECT name, Assets_billion FROM Companies ORDER BY name | CREATE TABLE Companies (name VARCHAR(255), Assets_billion 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": 2615
} |
What are the average profits of companies? | SELECT AVG(Profits_billion) FROM Companies | CREATE TABLE Companies (Profits_billion INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT, name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2616
} |
What are the maximum and minimum sales of the companies whose industries are not "Banking". | SELECT MAX(Sales_billion), MIN(Sales_billion) FROM Companies WHERE Industry <> 'Banking' | CREATE TABLE Companies (Sales_billion INTEGER, Industry VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 2617
} |
How many different industries are the companies in? | SELECT COUNT(DISTINCT Industry) FROM Companies | CREATE TABLE Companies (Industry VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT, name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2618
} |
List the names of buildings in descending order of building height. | SELECT name FROM buildings ORDER BY Height DESC | CREATE TABLE buildings (name VARCHAR(255), Height 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": 2619
} |
Find the stories of the building with the largest height. | SELECT Stories FROM buildings ORDER BY Height DESC LIMIT 1 | CREATE TABLE buildings (Stories VARCHAR(255), Height VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2620
} |
List the name of a building along with the name of a company whose office is in the building. | SELECT T3.name, T2.name FROM Office_locations AS T1 JOIN buildings AS T2 ON T1.building_id = T2.id JOIN Companies AS T3 ON T1.company_id = T3.id | CREATE TABLE buildings (name VARCHAR(255), id VARCHAR(255)); CREATE TABLE Office_locations (building_id VARCHAR(255), company_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Companies (name VARCHAR(255), id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2621
} |
Show the names of the buildings that have more than one company offices. | SELECT T2.name FROM Office_locations AS T1 JOIN buildings AS T2 ON T1.building_id = T2.id JOIN Companies AS T3 ON T1.company_id = T3.id GROUP BY T1.building_id HAVING COUNT(*) > 1 | CREATE TABLE buildings (name VARCHAR(255), id VARCHAR(255)); CREATE TABLE Companies (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE Office_locations (building_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 | 0 | {
"split": "train",
"row_index": 2622
} |
Show the name of the building that has the most company offices. | SELECT T2.name FROM Office_locations AS T1 JOIN buildings AS T2 ON T1.building_id = T2.id JOIN Companies AS T3 ON T1.company_id = T3.id GROUP BY T1.building_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE buildings (name VARCHAR(255), id VARCHAR(255)); CREATE TABLE Companies (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE Office_locations (building_id VARCHAR(255), company_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 5 | 0 | 0 | {
"split": "train",
"row_index": 2623
} |
Please show the names of the buildings whose status is "on-hold", in ascending order of stories. | SELECT name FROM buildings WHERE Status = 'on-hold' ORDER BY Stories | CREATE TABLE buildings (name VARCHAR(255), Status VARCHAR(255), Stories VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2624
} |
Please show each industry and the corresponding number of companies in that industry. | SELECT Industry, COUNT(*) FROM Companies GROUP BY Industry | CREATE TABLE Companies (Industry VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT, name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2625
} |
Please show the industries of companies in descending order of the number of companies. | SELECT Industry FROM Companies GROUP BY Industry ORDER BY COUNT(*) DESC | CREATE TABLE Companies (Industry VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT, name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2626
} |
List the industry shared by the most companies. | SELECT Industry FROM Companies GROUP BY Industry ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Companies (Industry VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT, name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2627
} |
List the names of buildings that have no company office. | SELECT name FROM buildings WHERE NOT id IN (SELECT building_id FROM Office_locations) | CREATE TABLE buildings (name VARCHAR(255), id VARCHAR(255), building_id VARCHAR(255)); CREATE TABLE Office_locations (name VARCHAR(255), id VARCHAR(255), building_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2628
} |
Show the industries shared by companies whose headquarters are "USA" and companies whose headquarters are "China". | SELECT Industry FROM Companies WHERE Headquarters = 'USA' INTERSECT SELECT Industry FROM Companies WHERE Headquarters = 'China' | CREATE TABLE Companies (Industry VARCHAR(255), Headquarters VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2629
} |
Find the number of companies whose industry is "Banking" or "Conglomerate", | SELECT COUNT(*) FROM Companies WHERE Industry = 'Banking' OR Industry = 'Conglomerate' | CREATE TABLE Companies (Industry 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": 2630
} |
Show the headquarters shared by more than two companies. | SELECT Headquarters FROM Companies GROUP BY Headquarters HAVING COUNT(*) > 2 | CREATE TABLE Companies (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": 2631
} |
How many products are there? | SELECT COUNT(*) FROM Products | CREATE TABLE Products (Id VARCHAR(255), Name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2632
} |
List the name of products in ascending order of price. | SELECT Product_Name FROM Products ORDER BY Product_Price | CREATE TABLE Products (Product_Name VARCHAR(255), Product_Price VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2633
} |
What are the names and type codes of products? | SELECT Product_Name, Product_Type_Code FROM Products | CREATE TABLE Products (Product_Name VARCHAR(255), Product_Type_Code VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 2634
} |
Show the prices of the products named "Dining" or "Trading Policy". | SELECT Product_Price FROM Products WHERE Product_Name = 'Dining' OR Product_Name = 'Trading Policy' | CREATE TABLE Products (Product_Price VARCHAR(255), Product_Name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2635
} |
What is the average price for products? | SELECT AVG(Product_Price) FROM Products | CREATE TABLE Products (Product_Price INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2636
} |
What is the name of the product with the highest price? | SELECT Product_Name FROM Products ORDER BY Product_Price DESC LIMIT 1 | CREATE TABLE Products (Product_Name VARCHAR(255), Product_Price VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2637
} |
Show different type codes of products and the number of products with each type code. | SELECT Product_Type_Code, COUNT(*) FROM Products GROUP BY Product_Type_Code | CREATE TABLE Products (Product_Type_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": 2638
} |
Show the most common type code across products. | SELECT Product_Type_Code FROM Products GROUP BY Product_Type_Code ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Products (Product_Type_Code VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2639
} |
Show the product type codes that have at least two products. | SELECT Product_Type_Code FROM Products GROUP BY Product_Type_Code HAVING COUNT(*) >= 2 | CREATE TABLE Products (Product_Type_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": 2640
} |
Show the product type codes that have both products with price higher than 4500 and products with price lower than 3000. | SELECT Product_Type_Code FROM Products WHERE Product_Price > 4500 INTERSECT SELECT Product_Type_Code FROM Products WHERE Product_Price < 3000 | CREATE TABLE Products (Product_Type_Code VARCHAR(255), Product_Price INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2641
} |
Show the names of products and the number of events they are in. | SELECT T1.Product_Name, COUNT(*) FROM Products AS T1 JOIN Products_in_Events AS T2 ON T1.Product_ID = T2.Product_ID GROUP BY T1.Product_Name | CREATE TABLE Products (Product_Name VARCHAR(255), Product_ID VARCHAR(255)); CREATE TABLE Products_in_Events (Product_ID 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": 2642
} |
Show the names of products and the number of events they are in, sorted by the number of events in descending order. | SELECT T1.Product_Name, COUNT(*) FROM Products AS T1 JOIN Products_in_Events AS T2 ON T1.Product_ID = T2.Product_ID GROUP BY T1.Product_Name ORDER BY COUNT(*) DESC | CREATE TABLE Products (Product_Name VARCHAR(255), Product_ID VARCHAR(255)); CREATE TABLE Products_in_Events (Product_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 2 | {
"split": "train",
"row_index": 2643
} |
Show the names of products that are in at least two events. | SELECT T1.Product_Name FROM Products AS T1 JOIN Products_in_Events AS T2 ON T1.Product_ID = T2.Product_ID GROUP BY T1.Product_Name HAVING COUNT(*) >= 2 | CREATE TABLE Products (Product_Name VARCHAR(255), Product_ID VARCHAR(255)); CREATE TABLE Products_in_Events (Product_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2644
} |
Show the names of products that are in at least two events in ascending alphabetical order of product name. | SELECT T1.Product_Name FROM Products AS T1 JOIN Products_in_Events AS T2 ON T1.Product_ID = T2.Product_ID GROUP BY T1.Product_Name HAVING COUNT(*) >= 2 ORDER BY T1.Product_Name | CREATE TABLE Products (Product_Name VARCHAR(255), Product_ID VARCHAR(255)); CREATE TABLE Products_in_Events (Product_ID 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": 2645
} |
List the names of products that are not in any event. | SELECT Product_Name FROM Products WHERE NOT Product_ID IN (SELECT Product_ID FROM Products_in_Events) | CREATE TABLE Products (Product_Name VARCHAR(255), Product_ID VARCHAR(255)); CREATE TABLE Products_in_Events (Product_Name VARCHAR(255), Product_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2646
} |
How many artworks are there? | SELECT COUNT(*) FROM artwork | CREATE TABLE artwork (Id VARCHAR(255), Name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2647
} |
List the name of artworks in ascending alphabetical order. | SELECT Name FROM artwork ORDER BY Name | CREATE TABLE artwork (Name VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2648
} |
List the name of artworks whose type is not "Program Talent Show". | SELECT Name FROM artwork WHERE TYPE <> 'Program Talent Show' | CREATE TABLE artwork (Name VARCHAR(255), TYPE VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2649
} |
What are the names and locations of festivals? | SELECT Festival_Name, LOCATION FROM festival_detail | CREATE TABLE festival_detail (Festival_Name VARCHAR(255), LOCATION VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 2650
} |
What are the names of the chairs of festivals, sorted in ascending order of the year held? | SELECT Chair_Name FROM festival_detail ORDER BY YEAR | CREATE TABLE festival_detail (Chair_Name VARCHAR(255), YEAR VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2651
} |
What is the location of the festival with the largest number of audience? | SELECT LOCATION FROM festival_detail ORDER BY Num_of_Audience DESC LIMIT 1 | CREATE TABLE festival_detail (LOCATION VARCHAR(255), Num_of_Audience VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2652
} |
What are the names of festivals held in year 2007? | SELECT Festival_Name FROM festival_detail WHERE YEAR = 2007 | CREATE TABLE festival_detail (Festival_Name VARCHAR(255), YEAR VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2653
} |
What is the average number of audience for festivals? | SELECT AVG(Num_of_Audience) FROM festival_detail | CREATE TABLE festival_detail (Num_of_Audience INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2654
} |
Show the names of the three most recent festivals. | SELECT Festival_Name FROM festival_detail ORDER BY YEAR DESC LIMIT 3 | CREATE TABLE festival_detail (Festival_Name VARCHAR(255), YEAR VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2655
} |
For each nomination, show the name of the artwork and name of the festival where it is nominated. | SELECT T2.Name, T3.Festival_Name FROM nomination AS T1 JOIN artwork AS T2 ON T1.Artwork_ID = T2.Artwork_ID JOIN festival_detail AS T3 ON T1.Festival_ID = T3.Festival_ID | CREATE TABLE artwork (Name VARCHAR(255), Artwork_ID VARCHAR(255)); CREATE TABLE nomination (Artwork_ID VARCHAR(255), Festival_ID VARCHAR(255)); CREATE TABLE festival_detail (Festival_Name VARCHAR(255), Festival_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2656
} |
Show distinct types of artworks that are nominated in festivals in 2007. | SELECT DISTINCT T2.Type FROM nomination AS T1 JOIN artwork AS T2 ON T1.Artwork_ID = T2.Artwork_ID JOIN festival_detail AS T3 ON T1.Festival_ID = T3.Festival_ID WHERE T3.Year = 2007 | CREATE TABLE nomination (Artwork_ID VARCHAR(255), Festival_ID VARCHAR(255)); CREATE TABLE festival_detail (Festival_ID VARCHAR(255), Year VARCHAR(255)); CREATE TABLE artwork (Type VARCHAR(255), Artwork_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2657
} |
Show the names of artworks in ascending order of the year they are nominated in. | SELECT T2.Name FROM nomination AS T1 JOIN artwork AS T2 ON T1.Artwork_ID = T2.Artwork_ID JOIN festival_detail AS T3 ON T1.Festival_ID = T3.Festival_ID ORDER BY T3.Year | CREATE TABLE artwork (Name VARCHAR(255), Artwork_ID VARCHAR(255)); CREATE TABLE nomination (Artwork_ID VARCHAR(255), Festival_ID VARCHAR(255)); CREATE TABLE festival_detail (Festival_ID VARCHAR(255), Year VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2658
} |
Show the names of festivals that have nominated artworks of type "Program Talent Show". | SELECT T3.Festival_Name FROM nomination AS T1 JOIN artwork AS T2 ON T1.Artwork_ID = T2.Artwork_ID JOIN festival_detail AS T3 ON T1.Festival_ID = T3.Festival_ID WHERE T2.Type = 'Program Talent Show' | CREATE TABLE nomination (Artwork_ID VARCHAR(255), Festival_ID VARCHAR(255)); CREATE TABLE artwork (Artwork_ID VARCHAR(255), Type VARCHAR(255)); CREATE TABLE festival_detail (Festival_Name VARCHAR(255), Festival_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2659
} |
Show the ids and names of festivals that have at least two nominations for artworks. | SELECT T1.Festival_ID, T3.Festival_Name FROM nomination AS T1 JOIN artwork AS T2 ON T1.Artwork_ID = T2.Artwork_ID JOIN festival_detail AS T3 ON T1.Festival_ID = T3.Festival_ID GROUP BY T1.Festival_ID HAVING COUNT(*) >= 2 | CREATE TABLE nomination (Festival_ID VARCHAR(255), Artwork_ID VARCHAR(255)); CREATE TABLE festival_detail (Festival_Name VARCHAR(255), Festival_ID VARCHAR(255)); CREATE TABLE artwork (Artwork_ID VARCHAR(255), Name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 2660
} |
Show the id, name of each festival and the number of artworks it has nominated. | SELECT T1.Festival_ID, T3.Festival_Name, COUNT(*) FROM nomination AS T1 JOIN artwork AS T2 ON T1.Artwork_ID = T2.Artwork_ID JOIN festival_detail AS T3 ON T1.Festival_ID = T3.Festival_ID GROUP BY T1.Festival_ID | CREATE TABLE nomination (Festival_ID VARCHAR(255), Artwork_ID VARCHAR(255)); CREATE TABLE festival_detail (Festival_Name VARCHAR(255), Festival_ID VARCHAR(255)); CREATE TABLE artwork (Artwork_ID VARCHAR(255), Name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 2661
} |
Please show different types of artworks with the corresponding number of artworks of each type. | SELECT TYPE, COUNT(*) FROM artwork GROUP BY TYPE | CREATE TABLE artwork (TYPE VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2662
} |
List the most common type of artworks. | SELECT TYPE FROM artwork GROUP BY TYPE ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE artwork (TYPE VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2663
} |
List the year in which there are more than one festivals. | SELECT YEAR FROM festival_detail GROUP BY YEAR HAVING COUNT(*) > 1 | CREATE TABLE festival_detail (YEAR 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": 2664
} |
List the name of artworks that are not nominated. | SELECT Name FROM Artwork WHERE NOT Artwork_ID IN (SELECT Artwork_ID FROM nomination) | CREATE TABLE nomination (Name VARCHAR(255), Artwork_ID VARCHAR(255)); CREATE TABLE Artwork (Name VARCHAR(255), Artwork_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2665
} |
Show the number of audience in year 2008 or 2010. | SELECT Num_of_Audience FROM festival_detail WHERE YEAR = 2008 OR YEAR = 2010 | CREATE TABLE festival_detail (Num_of_Audience VARCHAR(255), YEAR VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2666
} |
What are the total number of the audiences who visited any of the festivals? | SELECT SUM(Num_of_Audience) FROM festival_detail | CREATE TABLE festival_detail (Num_of_Audience INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2667
} |
In which year are there festivals both inside the 'United States' and outside the 'United States'? | SELECT YEAR FROM festival_detail WHERE LOCATION = 'United States' INTERSECT SELECT YEAR FROM festival_detail WHERE LOCATION <> 'United States' | CREATE TABLE festival_detail (YEAR VARCHAR(255), LOCATION VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2668
} |
How many premises are there? | SELECT COUNT(*) FROM premises | CREATE TABLE premises (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2669
} |
What are all the distinct premise types? | SELECT DISTINCT premises_type FROM premises | CREATE TABLE premises (premises_type 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": 2670
} |
Find the types and details for all premises and order by the premise type. | SELECT premises_type, premise_details FROM premises ORDER BY premises_type | CREATE TABLE premises (premises_type VARCHAR(255), premise_details VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2671
} |
Show each premise type and the number of premises in that type. | SELECT premises_type, COUNT(*) FROM premises GROUP BY premises_type | CREATE TABLE premises (premises_type VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2672
} |
Show all distinct product categories along with the number of mailshots in each category. | SELECT product_category, COUNT(*) FROM mailshot_campaigns GROUP BY product_category | CREATE TABLE mailshot_campaigns (product_category 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": 2673
} |
Show the name and phone of the customer without any mailshot. | SELECT customer_name, customer_phone FROM customers WHERE NOT customer_id IN (SELECT customer_id FROM mailshot_customers) | CREATE TABLE customers (customer_name VARCHAR(255), customer_phone VARCHAR(255), customer_id VARCHAR(255)); CREATE TABLE mailshot_customers (customer_name VARCHAR(255), customer_phone VARCHAR(255), customer_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 2674
} |
Show the name and phone for customers with a mailshot with outcome code 'No Response'. | SELECT T1.customer_name, T1.customer_phone FROM customers AS T1 JOIN mailshot_customers AS T2 ON T1.customer_id = T2.customer_id WHERE T2.outcome_code = 'No Response' | CREATE TABLE customers (customer_name VARCHAR(255), customer_phone VARCHAR(255), customer_id VARCHAR(255)); CREATE TABLE mailshot_customers (customer_id VARCHAR(255), outcome_code VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2675
} |
Show the outcome code of mailshots along with the number of mailshots in each outcome code. | SELECT outcome_code, COUNT(*) FROM mailshot_customers GROUP BY outcome_code | CREATE TABLE mailshot_customers (outcome_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": 2676
} |
Show the names of customers who have the most mailshots. | SELECT T2.customer_name FROM mailshot_customers AS T1 JOIN customers AS T2 ON T1.customer_id = T2.customer_id GROUP BY T1.customer_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE customers (customer_name VARCHAR(255), customer_id VARCHAR(255)); CREATE TABLE mailshot_customers (customer_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 2678
} |
What are the name and payment method of customers who have both mailshots in 'Order' outcome and mailshots in 'No Response' outcome. | SELECT T2.customer_name, T2.payment_method FROM mailshot_customers AS T1 JOIN customers AS T2 ON T1.customer_id = T2.customer_id WHERE T1.outcome_code = 'Order' INTERSECT SELECT T2.customer_name, T2.payment_method FROM mailshot_customers AS T1 JOIN customers AS T2 ON T1.customer_id = T2.customer_id WHERE T1.outcome_cod... | CREATE TABLE customers (customer_name VARCHAR(255), payment_method VARCHAR(255), customer_id VARCHAR(255)); CREATE TABLE mailshot_customers (customer_id VARCHAR(255), outcome_code VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 1 | {
"split": "train",
"row_index": 2679
} |
Show the premise type and address type code for all customer addresses. | SELECT T2.premises_type, T1.address_type_code FROM customer_addresses AS T1 JOIN premises AS T2 ON T1.premise_id = T2.premise_id | CREATE TABLE premises (premises_type VARCHAR(255), premise_id VARCHAR(255)); CREATE TABLE customer_addresses (address_type_code VARCHAR(255), premise_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2680
} |
What are the distinct address type codes for all customer addresses? | SELECT DISTINCT address_type_code FROM customer_addresses | CREATE TABLE customer_addresses (address_type_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": 2681
} |
Show the shipping charge and customer id for customer orders with order status Cancelled or Paid. | SELECT order_shipping_charges, customer_id FROM customer_orders WHERE order_status_code = 'Cancelled' OR order_status_code = 'Paid' | CREATE TABLE customer_orders (order_shipping_charges VARCHAR(255), customer_id VARCHAR(255), order_status_code VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 2 | {
"split": "train",
"row_index": 2682
} |
How many courses are there in total? | SELECT COUNT(*) FROM COURSE | CREATE TABLE COURSE (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2684
} |
How many courses have more than 2 credits? | SELECT COUNT(*) FROM COURSE WHERE Credits > 2 | CREATE TABLE COURSE (Credits INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2685
} |
List all names of courses with 1 credit? | SELECT CName FROM COURSE WHERE Credits = 1 | CREATE TABLE COURSE (CName VARCHAR(255), Credits VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2686
} |
Which courses are taught on days MTW? | SELECT CName FROM COURSE WHERE Days = 'MTW' | CREATE TABLE COURSE (CName VARCHAR(255), Days VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2687
} |
What is the number of departments in Division "AS"? | SELECT COUNT(*) FROM DEPARTMENT WHERE Division = 'AS' | CREATE TABLE DEPARTMENT (Division 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": 2688
} |
What are the phones of departments in Room 268? | SELECT DPhone FROM DEPARTMENT WHERE Room = 268 | CREATE TABLE DEPARTMENT (DPhone VARCHAR(255), Room VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2689
} |
Find the number of students that have at least one grade "B". | SELECT COUNT(DISTINCT StuID) FROM ENROLLED_IN WHERE Grade = 'B' | CREATE TABLE ENROLLED_IN (StuID VARCHAR(255), Grade VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2690
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.