question string | answer string | context string | dialect string | spider_hardness string | extended_hardness string | classification_status string | syntax_status string | ddl_syntax_status string | schema_status string | syntax_errors list | ddl_syntax_errors list | schema_errors list | classification_errors list | status_history list | correction_status string | component1 int64 | component2 int64 | others int64 | validation_source dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
How many distinct locations have the things with service detail 'Unsatisfied' been located in? | SELECT COUNT(DISTINCT T2.Location_Code) FROM Things AS T1 JOIN Timed_Locations_of_Things AS T2 ON T1.thing_id = T2.thing_id WHERE T1.service_details = 'Unsatisfied' | CREATE TABLE Timed_Locations_of_Things (Location_Code VARCHAR(255), thing_id VARCHAR(255)); CREATE TABLE Things (thing_id VARCHAR(255), service_details VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2797
} |
How many different status codes of things are there? | SELECT COUNT(DISTINCT Status_of_Thing_Code) FROM Timed_Status_of_Things | CREATE TABLE Timed_Status_of_Things (Status_of_Thing_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": 2798
} |
Which organizations are not a parent organization of others? List the organization id. | SELECT organization_id FROM organizations EXCEPT SELECT parent_organization_id FROM organizations | CREATE TABLE organizations (organization_id VARCHAR(255), parent_organization_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 2799
} |
When is the last day any resident moved in? | SELECT MAX(date_moved_in) FROM Residents | CREATE TABLE Residents (date_moved_in 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": 2800
} |
What are the resident details containing the substring 'Miss'? | SELECT other_details FROM Residents WHERE other_details LIKE '%Miss%' | CREATE TABLE Residents (other_details 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": 2801
} |
List the customer event id and the corresponding move in date and property id. | SELECT customer_event_id, date_moved_in, property_id FROM customer_events | CREATE TABLE customer_events (customer_event_id VARCHAR(255), date_moved_in VARCHAR(255), property_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 2802
} |
How many customers did not have any event? | SELECT COUNT(*) FROM customers WHERE NOT customer_id IN (SELECT customer_id FROM customer_events) | CREATE TABLE customers (customer_id VARCHAR(255), name VARCHAR(255)); CREATE TABLE customer_events (customer_id VARCHAR(255), event_date VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 2803
} |
What are the distinct move in dates of the residents? | SELECT DISTINCT date_moved_in FROM residents | CREATE TABLE residents (date_moved_in 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": 2804
} |
List the locations of schools in ascending order of enrollment. | SELECT LOCATION FROM school ORDER BY Enrollment | CREATE TABLE school (LOCATION VARCHAR(255), Enrollment VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2805
} |
List the locations of schools in descending order of founded year. | SELECT LOCATION FROM school ORDER BY Founded DESC | CREATE TABLE school (LOCATION VARCHAR(255), Founded VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2806
} |
What are the enrollments of schools whose denomination is not "Catholic"? | SELECT Enrollment FROM school WHERE Denomination <> 'Catholic' | CREATE TABLE school (Enrollment VARCHAR(255), Denomination VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2807
} |
What is the average enrollment of schools? | SELECT AVG(Enrollment) FROM school | CREATE TABLE school (Enrollment INTEGER, school_id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2808
} |
What are the teams of the players, sorted in ascending alphabetical order? | SELECT Team FROM player ORDER BY Team | CREATE TABLE player (Team VARCHAR(255), player_id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2809
} |
Find the team of the player of the highest age. | SELECT Team FROM player ORDER BY Age DESC LIMIT 1 | CREATE TABLE player (Team VARCHAR(255), Age VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2810
} |
List the teams of the players with the top 5 largest ages. | SELECT Team FROM player ORDER BY Age DESC LIMIT 5 | CREATE TABLE player (Team VARCHAR(255), Age VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2811
} |
For each player, show the team and the location of school they belong to. | SELECT T1.Team, T2.Location FROM player AS T1 JOIN school AS T2 ON T1.School_ID = T2.School_ID | CREATE TABLE school (Location VARCHAR(255), School_ID VARCHAR(255)); CREATE TABLE player (Team VARCHAR(255), School_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2812
} |
Show the locations of schools that have more than 1 player. | SELECT T2.Location FROM player AS T1 JOIN school AS T2 ON T1.School_ID = T2.School_ID GROUP BY T1.School_ID HAVING COUNT(*) > 1 | CREATE TABLE player (School_ID VARCHAR(255), name VARCHAR(255)); CREATE TABLE school (Location VARCHAR(255), School_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2813
} |
Show the denomination of the school that has the most players. | SELECT T2.Denomination FROM player AS T1 JOIN school AS T2 ON T1.School_ID = T2.School_ID GROUP BY T1.School_ID ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE player (School_ID VARCHAR(255), name VARCHAR(255)); CREATE TABLE school (Denomination VARCHAR(255), School_ID VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 2814
} |
Show locations and nicknames of schools. | SELECT T1.Location, T2.Nickname FROM school AS T1 JOIN school_details AS T2 ON T1.School_ID = T2.School_ID | CREATE TABLE school (Location VARCHAR(255), School_ID VARCHAR(255)); CREATE TABLE school_details (Nickname VARCHAR(255), School_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2815
} |
Please show different denominations and the corresponding number of schools. | SELECT Denomination, COUNT(*) FROM school GROUP BY Denomination | CREATE TABLE school (Denomination 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": 2816
} |
Please show different denominations and the corresponding number of schools in descending order. | SELECT Denomination, COUNT(*) FROM school GROUP BY Denomination ORDER BY COUNT(*) DESC | CREATE TABLE school (Denomination VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT, name VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 2 | {
"split": "train",
"row_index": 2817
} |
List the school color of the school that has the largest enrollment. | SELECT School_Colors FROM school ORDER BY Enrollment DESC LIMIT 1 | CREATE TABLE school (School_Colors VARCHAR(255), Enrollment VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2818
} |
List the locations of schools that do not have any player. | SELECT LOCATION FROM school WHERE NOT School_ID IN (SELECT School_ID FROM Player) | CREATE TABLE school (LOCATION VARCHAR(255), School_ID VARCHAR(255)); CREATE TABLE Player (LOCATION VARCHAR(255), School_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2819
} |
Show the denomination shared by schools founded before 1890 and schools founded after 1900 | SELECT Denomination FROM school WHERE Founded < 1890 INTERSECT SELECT Denomination FROM school WHERE Founded > 1900 | CREATE TABLE school (Denomination VARCHAR(255), Founded INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2820
} |
Show the nicknames of schools that are not in division 1. | SELECT Nickname FROM school_details WHERE Division <> 'Division 1' | CREATE TABLE school_details (Nickname VARCHAR(255), Division VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2821
} |
Show the denomination shared by more than one school. | SELECT Denomination FROM school GROUP BY Denomination HAVING COUNT(*) > 1 | CREATE TABLE school (Denomination VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT, location VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2822
} |
Find all the distinct district names ordered by city area in descending. | SELECT DISTINCT District_name FROM district ORDER BY city_area DESC | CREATE TABLE district (District_name VARCHAR(255), city_area VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2823
} |
Find the list of page size which have more than 3 product listed | SELECT max_page_size FROM product GROUP BY max_page_size HAVING COUNT(*) > 3 | CREATE TABLE product (max_page_size VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT, name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2824
} |
Find the name and population of district with population between 200000 and 2000000 | SELECT District_name, City_Population FROM district WHERE City_Population BETWEEN 200000 AND 2000000 | CREATE TABLE district (District_name VARCHAR(255), City_Population INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2825
} |
Find the name all districts with city area greater than 10 or population larger than 100000 | SELECT district_name FROM district WHERE city_area > 10 OR City_Population > 100000 | CREATE TABLE district (district_name VARCHAR(255), city_area VARCHAR(255), City_Population VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2826
} |
Which district has the largest population? | SELECT district_name FROM district ORDER BY city_population DESC LIMIT 1 | CREATE TABLE district (district_name VARCHAR(255), city_population VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2827
} |
Which district has the least area? | SELECT district_name FROM district ORDER BY city_area LIMIT 1 | CREATE TABLE district (district_name VARCHAR(255), city_area VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2828
} |
Find the total population of the top 3 districts with the largest area. | SELECT SUM(city_population) FROM district ORDER BY city_area DESC LIMIT 3 | CREATE TABLE district (city_population INTEGER, city_area VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2829
} |
Find all types of store and number of them. | SELECT TYPE, COUNT(*) FROM store GROUP BY TYPE | CREATE TABLE store (TYPE 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": 2830
} |
Find the names of all stores in Khanewal District. | SELECT t1.store_name FROM store AS t1 JOIN store_district AS t2 ON t1.store_id = t2.store_id JOIN district AS t3 ON t2.district_id = t3.district_id WHERE t3.district_name = 'Khanewal District' | CREATE TABLE district (district_id VARCHAR(255), district_name VARCHAR(255)); CREATE TABLE store_district (store_id VARCHAR(255), district_id VARCHAR(255)); CREATE TABLE store (store_name VARCHAR(255), store_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2831
} |
Which city is the headquarter of the store named "Blackville" in? | SELECT t3.headquartered_city FROM store AS t1 JOIN store_district AS t2 ON t1.store_id = t2.store_id JOIN district AS t3 ON t2.district_id = t3.district_id WHERE t1.store_name = 'Blackville' | CREATE TABLE store (store_id VARCHAR(255), store_name VARCHAR(255)); CREATE TABLE district (headquartered_city VARCHAR(255), district_id VARCHAR(255)); CREATE TABLE store_district (store_id VARCHAR(255), district_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2833
} |
Find the number of stores in each city. | SELECT t3.headquartered_city, COUNT(*) FROM store AS t1 JOIN store_district AS t2 ON t1.store_id = t2.store_id JOIN district AS t3 ON t2.district_id = t3.district_id GROUP BY t3.headquartered_city | CREATE TABLE district (headquartered_city VARCHAR(255), district_id VARCHAR(255)); CREATE TABLE store_district (store_id VARCHAR(255), district_id VARCHAR(255)); CREATE TABLE store (store_id VARCHAR(255), store_name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 2834
} |
Find the city with the most number of stores. | SELECT t3.headquartered_city FROM store AS t1 JOIN store_district AS t2 ON t1.store_id = t2.store_id JOIN district AS t3 ON t2.district_id = t3.district_id GROUP BY t3.headquartered_city ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE district (headquartered_city VARCHAR(255), district_id VARCHAR(255)); CREATE TABLE store_district (store_id VARCHAR(255), district_id VARCHAR(255)); CREATE TABLE store (store_id VARCHAR(255), store_name VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 5 | 0 | 0 | {
"split": "train",
"row_index": 2835
} |
What is the average pages per minute color? | SELECT AVG(pages_per_minute_color) FROM product | CREATE TABLE product (pages_per_minute_color INTEGER, id INTEGER PRIMARY KEY AUTOINCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2836
} |
What products are available at store named "Miramichi"? | SELECT t1.product FROM product AS t1 JOIN store_product AS t2 ON t1.product_id = t2.product_id JOIN store AS t3 ON t2.store_id = t3.store_id WHERE t3.store_name = 'Miramichi' | CREATE TABLE store_product (product_id VARCHAR(255), store_id VARCHAR(255)); CREATE TABLE store (store_id VARCHAR(255), store_name VARCHAR(255)); CREATE TABLE product (product VARCHAR(255), product_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2837
} |
Find products with max page size as "A4" and pages per minute color smaller than 5. | SELECT product FROM product WHERE max_page_size = 'A4' AND pages_per_minute_color < 5 | CREATE TABLE product (product VARCHAR(255), max_page_size VARCHAR(255), pages_per_minute_color VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2838
} |
Find products with max page size as "A4" or pages per minute color smaller than 5. | SELECT product FROM product WHERE max_page_size = 'A4' OR pages_per_minute_color < 5 | CREATE TABLE product (product VARCHAR(255), max_page_size VARCHAR(255), pages_per_minute_color VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2839
} |
Find all the product whose name contains the word "Scanner". | SELECT product FROM product WHERE product LIKE '%Scanner%' | CREATE TABLE product (product 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": 2840
} |
Find the most prominent max page size among all the products. | SELECT max_page_size FROM product GROUP BY max_page_size ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE product (max_page_size VARCHAR(255), id INTEGER PRIMARY KEY AUTOINCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2841
} |
Find the name of the products that are not using the most frequently-used max page size. | SELECT product FROM product WHERE product <> (SELECT max_page_size FROM product GROUP BY max_page_size ORDER BY COUNT(*) DESC LIMIT 1) | CREATE TABLE product (product VARCHAR(255), max_page_size VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2842
} |
Find the names of districts where have both city mall and village store type stores. | SELECT t3.District_name FROM store AS t1 JOIN store_district AS t2 ON t1.store_id = t2.store_id JOIN district AS t3 ON t2.district_id = t3.district_id WHERE t1.Type = 'City Mall' INTERSECT SELECT t3.District_name FROM store AS t1 JOIN store_district AS t2 ON t1.store_id = t2.store_id JOIN district AS t3 ON t2.district_... | CREATE TABLE district (District_name VARCHAR(255), district_id VARCHAR(255)); CREATE TABLE store (store_id VARCHAR(255), Type VARCHAR(255)); CREATE TABLE store_district (store_id VARCHAR(255), district_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 1 | 0 | {
"split": "train",
"row_index": 2844
} |
What is the total enrollment number of all colleges? | SELECT SUM(enr) FROM College | CREATE TABLE College (enr 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": 2845
} |
What is the average enrollment number? | SELECT AVG(enr) FROM College | CREATE TABLE College (enr 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": 2846
} |
How many colleges in total? | SELECT COUNT(*) FROM College | CREATE TABLE College (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2847
} |
How many players have more than 1000 hours of training? | SELECT COUNT(*) FROM Player WHERE HS > 1000 | CREATE TABLE Player (HS 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": 2848
} |
How many colleges has more than 15000 students? | SELECT COUNT(*) FROM College WHERE enr > 15000 | CREATE TABLE College (enr 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": 2849
} |
What is the average training hours of all players? | SELECT AVG(HS) FROM Player | CREATE TABLE Player (HS 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": 2850
} |
Find the name and training hours of players whose hours are below 1500. | SELECT pName, HS FROM Player WHERE HS < 1500 | CREATE TABLE Player (pName VARCHAR(255), HS INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2851
} |
How many different colleges do attend the tryout test? | SELECT COUNT(DISTINCT cName) FROM tryout | CREATE TABLE tryout (cName 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": 2852
} |
What are the unique types of player positions in the tryout? | SELECT COUNT(DISTINCT pPos) FROM tryout | CREATE TABLE tryout (pPos 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": 2853
} |
How many students got accepted after the tryout? | SELECT COUNT(*) FROM tryout WHERE decision = 'yes' | CREATE TABLE tryout (decision 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": 2854
} |
How many students whose are playing the role of goalie? | SELECT COUNT(*) FROM tryout WHERE pPos = 'goalie' | CREATE TABLE tryout (pPos 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": 2855
} |
Find the max, average and min training hours of all players. | SELECT AVG(HS), MAX(HS), MIN(HS) FROM Player | CREATE TABLE Player (HS 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": 2856
} |
What is average enrollment of colleges in the state FL? | SELECT AVG(enr) FROM College WHERE state = 'FL' | CREATE TABLE College (enr INTEGER, state VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2857
} |
What are the names of players whose training hours is between 500 and 1500? | SELECT pName FROM Player WHERE HS BETWEEN 500 AND 1500 | CREATE TABLE Player (pName VARCHAR(255), HS INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2858
} |
Find the players whose names contain letter 'a'. | SELECT DISTINCT pName FROM Player WHERE pName LIKE '%a%' | CREATE TABLE Player (pName 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": 2859
} |
Find the name, enrollment of the colleges whose size is bigger than 10000 and location is in state LA. | SELECT cName, enr FROM College WHERE enr > 10000 AND state = 'LA' | CREATE TABLE College (cName VARCHAR(255), enr VARCHAR(255), state VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 2860
} |
List the name of the colleges whose enrollment is greater 18000 sorted by the college's name. | SELECT cName FROM College WHERE enr > 18000 ORDER BY cName | CREATE TABLE College (cName VARCHAR(255), enr INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2862
} |
Find the name of players whose card is yes in the descending order of training hours. | SELECT pName FROM Player WHERE yCard = 'yes' ORDER BY HS DESC | CREATE TABLE Player (pName VARCHAR(255), yCard VARCHAR(255), HS 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": 2863
} |
Find the name of different colleges involved in the tryout in alphabetical order. | SELECT DISTINCT cName FROM tryout ORDER BY cName | CREATE TABLE tryout (cName 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": 2864
} |
Which position is most popular among players in the tryout? | SELECT pPos FROM tryout GROUP BY pPos ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE tryout (pPos 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": 2865
} |
Find the number of students who participate in the tryout for each college ordered by descending count. | SELECT COUNT(*), cName FROM tryout GROUP BY cName ORDER BY COUNT(*) DESC | CREATE TABLE tryout (cName VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 2 | {
"split": "train",
"row_index": 2866
} |
What is minimum hours of the students playing in different position? | SELECT MIN(T2.HS), T1.pPos FROM tryout AS T1 JOIN player AS T2 ON T1.pID = T2.pID GROUP BY T1.pPos | CREATE TABLE player (HS INTEGER, pID VARCHAR(255)); CREATE TABLE tryout (pPos VARCHAR(255), pID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2867
} |
What are the names of schools with the top 3 largest size? | SELECT cName FROM college ORDER BY enr DESC LIMIT 3 | CREATE TABLE college (cName VARCHAR(255), enr VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2868
} |
What is the name of school that has the smallest enrollment in each state? | SELECT cName, state, MIN(enr) FROM college GROUP BY state | CREATE TABLE college (cName VARCHAR(255), state VARCHAR(255), enr INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2869
} |
Find the states where have some college students in tryout and their decisions are yes. | SELECT DISTINCT T1.state FROM college AS T1 JOIN tryout AS T2 ON T1.cName = T2.cName WHERE T2.decision = 'yes' | CREATE TABLE tryout (cName VARCHAR(255), decision VARCHAR(255)); CREATE TABLE college (state VARCHAR(255), cName VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2871
} |
Find the name and college of students whose decisions are yes in the tryout. | SELECT T1.pName, T2.cName FROM player AS T1 JOIN tryout AS T2 ON T1.pID = T2.pID WHERE T2.decision = 'yes' | CREATE TABLE tryout (cName VARCHAR(255), pID VARCHAR(255), decision VARCHAR(255)); CREATE TABLE player (pName VARCHAR(255), pID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2872
} |
Find the name of all students who were in the tryout sorted in alphabetic order. | SELECT T1.pName FROM player AS T1 JOIN tryout AS T2 ON T1.pID = T2.pID ORDER BY T1.pName | CREATE TABLE tryout (pID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE player (pName VARCHAR(255), pID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2873
} |
Find the name and hours of the students whose tryout decision is yes. | SELECT T1.pName, T1.HS FROM player AS T1 JOIN tryout AS T2 ON T1.pID = T2.pID WHERE T2.decision = 'yes' | CREATE TABLE player (pName VARCHAR(255), HS VARCHAR(255), pID VARCHAR(255)); CREATE TABLE tryout (pID VARCHAR(255), decision VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2874
} |
Find the states of the colleges that have students in the tryout who played in striker position. | SELECT T1.state FROM college AS T1 JOIN tryout AS T2 ON T1.cName = T2.cName WHERE T2.pPos = 'striker' | CREATE TABLE tryout (cName VARCHAR(255), pPos VARCHAR(255)); CREATE TABLE college (state VARCHAR(255), cName VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2875
} |
Find the names of the students who are in the position of striker and got a yes tryout decision. | SELECT T1.pName FROM player AS T1 JOIN tryout AS T2 ON T1.pID = T2.pID WHERE T2.decision = 'yes' AND T2.pPos = 'striker' | CREATE TABLE tryout (pID VARCHAR(255), decision VARCHAR(255), pPos VARCHAR(255)); CREATE TABLE player (pName VARCHAR(255), pID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2876
} |
Find the state of the college which player Charles is attending. | SELECT T1.state FROM college AS T1 JOIN tryout AS T2 ON T1.cName = T2.cName JOIN player AS T3 ON T2.pID = T3.pID WHERE T3.pName = 'Charles' | CREATE TABLE tryout (cName VARCHAR(255), pID VARCHAR(255)); CREATE TABLE player (pID VARCHAR(255), pName VARCHAR(255)); CREATE TABLE college (state VARCHAR(255), cName VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2877
} |
Find the average and maximum hours for the students whose tryout decision is yes. | SELECT AVG(T1.HS), MAX(T1.HS) FROM player AS T1 JOIN tryout AS T2 ON T1.pID = T2.pID WHERE T2.decision = 'yes' | CREATE TABLE player (HS INTEGER, pID VARCHAR(255)); CREATE TABLE tryout (pID VARCHAR(255), decision VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 2 | {
"split": "train",
"row_index": 2878
} |
Find the average hours for the students whose tryout decision is no. | SELECT AVG(T1.HS) FROM player AS T1 JOIN tryout AS T2 ON T1.pID = T2.pID WHERE T2.decision = 'no' | CREATE TABLE player (HS INTEGER, pID VARCHAR(255)); CREATE TABLE tryout (pID VARCHAR(255), decision VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 2879
} |
What is the maximum training hours for the students whose training hours is greater than 1000 in different positions? | SELECT MAX(T1.HS), pPos FROM player AS T1 JOIN tryout AS T2 ON T1.pID = T2.pID WHERE T1.HS > 1000 GROUP BY T2.pPos | CREATE TABLE player (HS INTEGER, pID VARCHAR(255)); CREATE TABLE tryout (pPos VARCHAR(255), pID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 2880
} |
Which colleges do the tryout players whose name starts with letter D go to? | SELECT T1.cName FROM tryout AS T1 JOIN player AS T2 ON T1.pID = T2.pID WHERE T2.pName LIKE 'D%' | CREATE TABLE tryout (cName VARCHAR(255), pID VARCHAR(255)); CREATE TABLE player (pID VARCHAR(255), pName VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 2881
} |
Which college has any student who is a goalie and succeeded in the tryout. | SELECT cName FROM tryout WHERE decision = 'yes' AND pPos = 'goalie' | CREATE TABLE tryout (cName VARCHAR(255), decision VARCHAR(255), pPos VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 2882
} |
Find the name of the tryout players who are from the college with largest size. | SELECT T2.pName FROM tryout AS T1 JOIN player AS T2 ON T1.pID = T2.pID WHERE T1.cName = (SELECT cName FROM college ORDER BY enr DESC LIMIT 1) | CREATE TABLE college (cName VARCHAR(255), enr VARCHAR(255)); CREATE TABLE tryout (pID VARCHAR(255), cName VARCHAR(255)); CREATE TABLE player (pName VARCHAR(255), pID VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 2883
} |
What is the state and enrollment of the colleges where have any students who got accepted in the tryout decision. | SELECT DISTINCT T1.state, T1.enr FROM college AS T1 JOIN tryout AS T2 ON T1.cName = T2.cName WHERE T2.decision = 'yes' | CREATE TABLE tryout (cName VARCHAR(255), decision VARCHAR(255)); CREATE TABLE college (state VARCHAR(255), enr VARCHAR(255), cName VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 2884
} |
Find the names of either colleges in LA with greater than 15000 size or in state AZ with less than 13000 enrollment. | SELECT cName FROM College WHERE enr < 13000 AND state = 'AZ' UNION SELECT cName FROM College WHERE enr > 15000 AND state = 'LA' | CREATE TABLE College (cName VARCHAR(255), enr VARCHAR(255), state VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 2885
} |
Find the names of schools that have some students playing in goalie and mid positions. | SELECT cName FROM tryout WHERE pPos = 'goalie' INTERSECT SELECT cName FROM tryout WHERE pPos = 'mid' | CREATE TABLE tryout (cName VARCHAR(255), pPos VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2886
} |
Find the names of states that have some college students playing in goalie and mid positions. | SELECT T1.state FROM college AS T1 JOIN tryout AS T2 ON T1.cName = T2.cName WHERE T2.pPos = 'goalie' INTERSECT SELECT T1.state FROM college AS T1 JOIN tryout AS T2 ON T1.cName = T2.cName WHERE T2.pPos = 'mid' | CREATE TABLE tryout (cName VARCHAR(255), pPos VARCHAR(255)); CREATE TABLE college (state VARCHAR(255), cName VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 2887
} |
How many schools have some students playing in goalie and mid positions. | SELECT COUNT(*) FROM (SELECT cName FROM tryout WHERE pPos = 'goalie' INTERSECT SELECT cName FROM tryout WHERE pPos = 'mid') | CREATE TABLE tryout (cName VARCHAR(255), pPos VARCHAR(255)) | generic | easy | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2888
} |
Find the names of schools that have some players in the mid position but not in the goalie position. | SELECT cName FROM tryout WHERE pPos = 'mid' EXCEPT SELECT cName FROM tryout WHERE pPos = 'goalie' | CREATE TABLE tryout (cName VARCHAR(255), pPos VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2889
} |
Find the names of states that have some college students playing in the mid position but not in the goalie position. | SELECT T1.state FROM college AS T1 JOIN tryout AS T2 ON T1.cName = T2.cName WHERE T2.pPos = 'mid' EXCEPT SELECT T1.state FROM college AS T1 JOIN tryout AS T2 ON T1.cName = T2.cName WHERE T2.pPos = 'goalie' | CREATE TABLE tryout (cName VARCHAR(255), pPos VARCHAR(255)); CREATE TABLE college (state VARCHAR(255), cName VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 2890
} |
How many states that have some college students playing in the mid position but not in the goalie position. | SELECT COUNT(*) FROM (SELECT T1.state FROM college AS T1 JOIN tryout AS T2 ON T1.cName = T2.cName WHERE T2.pPos = 'mid' EXCEPT SELECT T1.state FROM college AS T1 JOIN tryout AS T2 ON T1.cName = T2.cName WHERE T2.pPos = 'goalie') | CREATE TABLE tryout (cName VARCHAR(255), pPos VARCHAR(255)); CREATE TABLE college (state VARCHAR(255), cName VARCHAR(255)) | generic | easy | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2891
} |
Find the states where have the colleges whose enrollments are less than the largest size. | SELECT DISTINCT state FROM college WHERE enr < (SELECT MAX(enr) FROM college) | CREATE TABLE college (state VARCHAR(255), enr INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2892
} |
Find names of colleges with enrollment greater than that of some (at least one) college in the FL state. | SELECT DISTINCT cName FROM college WHERE enr > (SELECT MIN(enr) FROM college WHERE state = 'FL') | CREATE TABLE college (cName VARCHAR(255), enr INTEGER, state VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2893
} |
Find names of all colleges whose enrollment is greater than that of all colleges in the FL state. | SELECT cName FROM college WHERE enr > (SELECT MAX(enr) FROM college WHERE state = 'FL') | CREATE TABLE college (cName VARCHAR(255), enr INTEGER, state VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2894
} |
What is the total number of enrollment of schools that do not have any goalie player? | SELECT SUM(enr) FROM college WHERE NOT cName IN (SELECT cName FROM tryout WHERE pPos = 'goalie') | CREATE TABLE college (enr INTEGER, cName VARCHAR(255), pPos VARCHAR(255)); CREATE TABLE tryout (enr INTEGER, cName VARCHAR(255), pPos VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 2895
} |
What is the number of states that has some college whose enrollment is larger than the average enrollment? | SELECT COUNT(DISTINCT state) FROM college WHERE enr > (SELECT AVG(enr) FROM college) | CREATE TABLE college (state VARCHAR(255), enr INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2896
} |
What is the number of states that has some colleges whose enrollment is smaller than the average enrollment? | SELECT COUNT(DISTINCT state) FROM college WHERE enr < (SELECT AVG(enr) FROM college) | CREATE TABLE college (state VARCHAR(255), enr INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 2897
} |
How many devices are there? | SELECT COUNT(*) FROM device | CREATE TABLE device (Id VARCHAR(255), model VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 2898
} |
List the carriers of devices in ascending alphabetical order. | SELECT Carrier FROM device ORDER BY Carrier | CREATE TABLE device (Carrier 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": 2899
} |
What are the carriers of devices whose software platforms are not "Android"? | SELECT Carrier FROM device WHERE Software_Platform <> 'Android' | CREATE TABLE device (Carrier VARCHAR(255), Software_Platform VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 2900
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.