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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
List the weight of the body builders who have snatch score higher than 140 or have the height greater than 200. | SELECT T2.weight FROM body_builder AS T1 JOIN people AS T2 ON T1.people_id = T2.people_id WHERE T1.snatch > 140 OR T2.height > 200 | CREATE TABLE people (weight VARCHAR(255), people_id VARCHAR(255), height VARCHAR(255)); CREATE TABLE body_builder (people_id VARCHAR(255), snatch VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 657
} |
What are the total scores of the body builders whose birthday contains the string "January" ? | SELECT T1.total FROM body_builder AS T1 JOIN people AS T2 ON T1.people_id = T2.people_id WHERE T2.Birth_Date LIKE '%January%' | CREATE TABLE people (people_id VARCHAR(255), Birth_Date VARCHAR(255)); CREATE TABLE body_builder (total VARCHAR(255), people_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 658
} |
What is the minimum snatch score? | SELECT MIN(snatch) FROM body_builder | CREATE TABLE body_builder (snatch 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": 659
} |
How many elections are there? | SELECT COUNT(*) FROM election | CREATE TABLE election (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 660
} |
List the votes of elections in descending order. | SELECT Votes FROM election ORDER BY Votes DESC | CREATE TABLE election (Votes 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": 661
} |
List the dates and vote percents of elections. | SELECT Date, Vote_Percent FROM election | CREATE TABLE election (Date VARCHAR(255), Vote_Percent VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 662
} |
What are the minimum and maximum vote percents of elections? | SELECT MIN(Vote_Percent), MAX(Vote_Percent) FROM election | CREATE TABLE election (Vote_Percent 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": 663
} |
What are the names and parties of representatives? | SELECT Name, Party FROM representative | CREATE TABLE representative (Name VARCHAR(255), Party VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 664
} |
What are the names of representatives whose party is not "Republican"? | SELECT Name FROM Representative WHERE Party <> 'Republican' | CREATE TABLE Representative (Name VARCHAR(255), Party VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 665
} |
What are the life spans of representatives from New York state or Indiana state? | SELECT Lifespan FROM representative WHERE State = 'New York' OR State = 'Indiana' | CREATE TABLE representative (Lifespan VARCHAR(255), State VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 666
} |
What are the names of representatives and the dates of elections they participated in. | SELECT T2.Name, T1.Date FROM election AS T1 JOIN representative AS T2 ON T1.Representative_ID = T2.Representative_ID | CREATE TABLE election (Date VARCHAR(255), Representative_ID VARCHAR(255)); CREATE TABLE representative (Name VARCHAR(255), Representative_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 667
} |
What is the average number of votes of representatives from party "Republican"? | SELECT AVG(T1.Votes) FROM election AS T1 JOIN representative AS T2 ON T1.Representative_ID = T2.Representative_ID WHERE T2.Party = 'Republican' | CREATE TABLE election (Votes INTEGER, Representative_ID VARCHAR(255)); CREATE TABLE representative (Representative_ID VARCHAR(255), Party VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 672
} |
What are the different parties of representative? Show the party name and the number of representatives in each party. | SELECT Party, COUNT(*) FROM representative GROUP BY Party | CREATE TABLE representative (Party 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": 673
} |
What is the party that has the largest number of representatives? | SELECT Party, COUNT(*) FROM representative GROUP BY Party ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE representative (Party 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": 674
} |
What parties have at least three representatives? | SELECT Party FROM representative GROUP BY Party HAVING COUNT(*) >= 3 | CREATE TABLE representative (Party 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": 675
} |
What states have at least two representatives? | SELECT State FROM representative GROUP BY State HAVING COUNT(*) >= 2 | CREATE TABLE representative (State 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": 676
} |
List the names of representatives that have not participated in elections listed here. | SELECT Name FROM representative WHERE NOT Representative_ID IN (SELECT Representative_ID FROM election) | CREATE TABLE election (Name VARCHAR(255), Representative_ID VARCHAR(255)); CREATE TABLE representative (Name VARCHAR(255), Representative_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 677
} |
Show the parties that have both representatives in New York state and representatives in Pennsylvania state. | SELECT Party FROM representative WHERE State = 'New York' INTERSECT SELECT Party FROM representative WHERE State = 'Pennsylvania' | CREATE TABLE representative (Party VARCHAR(255), State VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 678
} |
How many distinct parties are there for representatives? | SELECT COUNT(DISTINCT Party) FROM representative | CREATE TABLE representative (Party 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": 679
} |
How many apartment bookings are there in total? | SELECT COUNT(*) FROM Apartment_Bookings | CREATE TABLE Apartment_Bookings (Id VARCHAR(255), booking_date DATE) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 680
} |
Show the start dates and end dates of all the apartment bookings. | SELECT booking_start_date, booking_end_date FROM Apartment_Bookings | CREATE TABLE Apartment_Bookings (booking_start_date VARCHAR(255), booking_end_date VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 681
} |
Show all distinct building descriptions. | SELECT DISTINCT building_description FROM Apartment_Buildings | CREATE TABLE Apartment_Buildings (building_description 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": 682
} |
Show the short names of the buildings managed by "Emma". | SELECT building_short_name FROM Apartment_Buildings WHERE building_manager = 'Emma' | CREATE TABLE Apartment_Buildings (building_short_name VARCHAR(255), building_manager VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 683
} |
Show the addresses and phones of all the buildings managed by "Brenden". | SELECT building_address, building_phone FROM Apartment_Buildings WHERE building_manager = 'Brenden' | CREATE TABLE Apartment_Buildings (building_address VARCHAR(255), building_phone VARCHAR(255), building_manager VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 684
} |
What are the building full names that contain the word "court"? | SELECT building_full_name FROM Apartment_Buildings WHERE building_full_name LIKE '%court%' | CREATE TABLE Apartment_Buildings (building_full_name 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": 685
} |
What is the minimum and maximum number of bathrooms of all the apartments? | SELECT MIN(bathroom_count), MAX(bathroom_count) FROM Apartments | CREATE TABLE Apartments (bathroom_count 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": 686
} |
What is the average number of bedrooms of all apartments? | SELECT AVG(bedroom_count) FROM Apartments | CREATE TABLE Apartments (bedroom_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": 687
} |
Return the apartment number and the number of rooms for each apartment. | SELECT apt_number, room_count FROM Apartments | CREATE TABLE Apartments (apt_number VARCHAR(255), room_count VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 688
} |
What is the average number of rooms of apartments with type code "Studio"? | SELECT AVG(room_count) FROM Apartments WHERE apt_type_code = 'Studio' | CREATE TABLE Apartments (room_count INTEGER, apt_type_code VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 689
} |
Return the apartment numbers of the apartments with type code "Flat". | SELECT apt_number FROM Apartments WHERE apt_type_code = 'Flat' | CREATE TABLE Apartments (apt_number VARCHAR(255), apt_type_code VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 690
} |
Return the first names and last names of all guests | SELECT guest_first_name, guest_last_name FROM Guests | CREATE TABLE Guests (guest_first_name VARCHAR(255), guest_last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 691
} |
Return the date of birth for all the guests with gender code "Male". | SELECT date_of_birth FROM Guests WHERE gender_code = 'Male' | CREATE TABLE Guests (date_of_birth VARCHAR(255), gender_code VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 692
} |
Show the apartment numbers, start dates, and end dates of all the apartment bookings. | SELECT T2.apt_number, T1.booking_start_date, T1.booking_start_date FROM Apartment_Bookings AS T1 JOIN Apartments AS T2 ON T1.apt_id = T2.apt_id | CREATE TABLE Apartment_Bookings (booking_start_date VARCHAR(255), apt_id VARCHAR(255), booking_end_date VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Apartments (apt_number VARCHAR(255), apt_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 693
} |
What are the booking start and end dates of the apartments with type code "Duplex"? | SELECT T1.booking_start_date, T1.booking_start_date FROM Apartment_Bookings AS T1 JOIN Apartments AS T2 ON T1.apt_id = T2.apt_id WHERE T2.apt_type_code = 'Duplex' | CREATE TABLE Apartments (apt_id VARCHAR(255), apt_type_code VARCHAR(255)); CREATE TABLE Apartment_Bookings (booking_start_date VARCHAR(255), apt_id VARCHAR(255), booking_end_date 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": 694
} |
What are the booking start and end dates of the apartments with more than 2 bedrooms? | SELECT T1.booking_start_date, T1.booking_start_date FROM Apartment_Bookings AS T1 JOIN Apartments AS T2 ON T1.apt_id = T2.apt_id WHERE T2.bedroom_count > 2 | CREATE TABLE Apartment_Bookings (booking_start_date VARCHAR(255), apt_id VARCHAR(255), booking_end_date VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Apartments (apt_id VARCHAR(255), bedroom_count INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 695
} |
What is the booking status code of the apartment with apartment number "Suite 634"? | SELECT T1.booking_status_code FROM Apartment_Bookings AS T1 JOIN Apartments AS T2 ON T1.apt_id = T2.apt_id WHERE T2.apt_number = 'Suite 634' | CREATE TABLE Apartments (apt_id VARCHAR(255), apt_number VARCHAR(255)); CREATE TABLE Apartment_Bookings (booking_status_code VARCHAR(255), apt_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": 696
} |
Show the distinct apartment numbers of the apartments that have bookings with status code "Confirmed". | SELECT DISTINCT T2.apt_number FROM Apartment_Bookings AS T1 JOIN Apartments AS T2 ON T1.apt_id = T2.apt_id WHERE T1.booking_status_code = 'Confirmed' | CREATE TABLE Apartments (apt_number VARCHAR(255), apt_id VARCHAR(255)); CREATE TABLE Apartment_Bookings (apt_id VARCHAR(255), booking_status_code 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": 697
} |
Show the guest first names, start dates, and end dates of all the apartment bookings. | SELECT T2.guest_first_name, T1.booking_start_date, T1.booking_start_date FROM Apartment_Bookings AS T1 JOIN Guests AS T2 ON T1.guest_id = T2.guest_id | CREATE TABLE Apartment_Bookings (booking_start_date VARCHAR(255), guest_id VARCHAR(255), booking_end_date VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Guests (guest_first_name VARCHAR(255), guest_id VARCHAR(255), guest_last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 699
} |
Show the start dates and end dates of all the apartment bookings made by guests with gender code "Female". | SELECT T1.booking_start_date, T1.booking_start_date FROM Apartment_Bookings AS T1 JOIN Guests AS T2 ON T1.guest_id = T2.guest_id WHERE T2.gender_code = 'Female' | CREATE TABLE Apartment_Bookings (booking_start_date VARCHAR(255), guest_id VARCHAR(255), booking_end_date VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Guests (guest_id VARCHAR(255), gender_code VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 700
} |
Show the first names and last names of all the guests that have apartment bookings with status code "Confirmed". | SELECT T2.guest_first_name, T2.guest_last_name FROM Apartment_Bookings AS T1 JOIN Guests AS T2 ON T1.guest_id = T2.guest_id WHERE T1.booking_status_code = 'Confirmed' | CREATE TABLE Apartment_Bookings (guest_id VARCHAR(255), booking_status_code VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Guests (guest_first_name VARCHAR(255), guest_last_name VARCHAR(255), guest_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 701
} |
Show the facility codes of apartments with more than 4 bedrooms. | SELECT T1.facility_code FROM Apartment_Facilities AS T1 JOIN Apartments AS T2 ON T1.apt_id = T2.apt_id WHERE T2.bedroom_count > 4 | CREATE TABLE Apartment_Facilities (facility_code VARCHAR(255), apt_id VARCHAR(255)); CREATE TABLE Apartments (apt_id VARCHAR(255), bedroom_count INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 702
} |
Show the total number of rooms of all apartments with facility code "Gym". | SELECT SUM(T2.room_count) FROM Apartment_Facilities AS T1 JOIN Apartments AS T2 ON T1.apt_id = T2.apt_id WHERE T1.facility_code = 'Gym' | CREATE TABLE Apartments (room_count INTEGER, apt_id VARCHAR(255)); CREATE TABLE Apartment_Facilities (apt_id VARCHAR(255), facility_code VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 703
} |
Show the total number of rooms of the apartments in the building with short name "Columbus Square". | SELECT SUM(T2.room_count) FROM Apartment_Buildings AS T1 JOIN Apartments AS T2 ON T1.building_id = T2.building_id WHERE T1.building_short_name = 'Columbus Square' | CREATE TABLE Apartment_Buildings (building_id VARCHAR(255), building_short_name VARCHAR(255)); CREATE TABLE Apartments (room_count INTEGER, building_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 704
} |
Show the addresses of the buildings that have apartments with more than 2 bathrooms. | SELECT T1.building_address FROM Apartment_Buildings AS T1 JOIN Apartments AS T2 ON T1.building_id = T2.building_id WHERE T2.bathroom_count > 2 | CREATE TABLE Apartment_Buildings (building_address VARCHAR(255), building_id VARCHAR(255)); CREATE TABLE Apartments (building_id VARCHAR(255), bathroom_count INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 705
} |
Show the apartment type codes and apartment numbers in the buildings managed by "Kyle". | SELECT T2.apt_type_code, T2.apt_number FROM Apartment_Buildings AS T1 JOIN Apartments AS T2 ON T1.building_id = T2.building_id WHERE T1.building_manager = 'Kyle' | CREATE TABLE Apartment_Buildings (building_id VARCHAR(255), building_manager VARCHAR(255)); CREATE TABLE Apartments (apt_type_code VARCHAR(255), apt_number VARCHAR(255), building_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 706
} |
Show the booking status code and the corresponding number of bookings. | SELECT booking_status_code, COUNT(*) FROM Apartment_Bookings GROUP BY booking_status_code | CREATE TABLE Apartment_Bookings (booking_status_code VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT, apt_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 707
} |
Return all the apartment numbers sorted by the room count in ascending order. | SELECT apt_number FROM Apartments ORDER BY room_count | CREATE TABLE Apartments (apt_number VARCHAR(255), room_count VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 708
} |
Return the apartment number with the largest number of bedrooms. | SELECT apt_number FROM Apartments ORDER BY bedroom_count DESC LIMIT 1 | CREATE TABLE Apartments (apt_number VARCHAR(255), bedroom_count VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 709
} |
Show the apartment type codes and the corresponding number of apartments sorted by the number of apartments in ascending order. | SELECT apt_type_code, COUNT(*) FROM Apartments GROUP BY apt_type_code ORDER BY COUNT(*) | CREATE TABLE Apartments (apt_type_code 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": 710
} |
Show the top 3 apartment type codes sorted by the average number of rooms in descending order. | SELECT apt_type_code FROM Apartments GROUP BY apt_type_code ORDER BY AVG(room_count) DESC LIMIT 3 | CREATE TABLE Apartments (apt_type_code VARCHAR(255), room_count INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 711
} |
Show the apartment type code that has the largest number of total rooms, together with the number of bathrooms and number of bedrooms. | SELECT apt_type_code, bathroom_count, bedroom_count FROM Apartments GROUP BY apt_type_code ORDER BY SUM(room_count) DESC LIMIT 1 | CREATE TABLE Apartments (apt_type_code VARCHAR(255), bathroom_count VARCHAR(255), bedroom_count VARCHAR(255), room_count INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 712
} |
Show the most common apartment type code. | SELECT apt_type_code FROM Apartments GROUP BY apt_type_code ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Apartments (apt_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": 713
} |
Show the most common apartment type code among apartments with more than 1 bathroom. | SELECT apt_type_code FROM Apartments WHERE bathroom_count > 1 GROUP BY apt_type_code ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Apartments (apt_type_code VARCHAR(255), bathroom_count INTEGER) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 714
} |
Show each apartment type code, and the maximum and minimum number of rooms for each type. | SELECT apt_type_code, MAX(room_count), MIN(room_count) FROM Apartments GROUP BY apt_type_code | CREATE TABLE Apartments (apt_type_code VARCHAR(255), room_count INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 715
} |
Show each gender code and the corresponding count of guests sorted by the count in descending order. | SELECT gender_code, COUNT(*) FROM Guests GROUP BY gender_code ORDER BY COUNT(*) DESC | CREATE TABLE Guests (gender_code 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": 716
} |
How many apartments do not have any facility? | SELECT COUNT(*) FROM Apartments WHERE NOT apt_id IN (SELECT apt_id FROM Apartment_Facilities) | CREATE TABLE Apartment_Facilities (apt_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Apartments (apt_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 717
} |
Show the apartment numbers of apartments with bookings that have status code both "Provisional" and "Confirmed" | SELECT T2.apt_number FROM Apartment_Bookings AS T1 JOIN Apartments AS T2 ON T1.apt_id = T2.apt_id WHERE T1.booking_status_code = 'Confirmed' INTERSECT SELECT T2.apt_number FROM Apartment_Bookings AS T1 JOIN Apartments AS T2 ON T1.apt_id = T2.apt_id WHERE T1.booking_status_code = 'Provisional' | CREATE TABLE Apartments (apt_number VARCHAR(255), apt_id VARCHAR(255)); CREATE TABLE Apartment_Bookings (apt_id VARCHAR(255), booking_status_code VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 718
} |
Show the apartment numbers of apartments with unit status availability of both 0 and 1. | SELECT T1.apt_number FROM Apartments AS T1 JOIN View_Unit_Status AS T2 ON T1.apt_id = T2.apt_id WHERE T2.available_yn = 0 INTERSECT SELECT T1.apt_number FROM Apartments AS T1 JOIN View_Unit_Status AS T2 ON T1.apt_id = T2.apt_id WHERE T2.available_yn = 1 | CREATE TABLE View_Unit_Status (apt_id VARCHAR(255), available_yn VARCHAR(255)); CREATE TABLE Apartments (apt_number VARCHAR(255), apt_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 719
} |
How many games are held after season 2007? | SELECT COUNT(*) FROM game WHERE season > 2007 | CREATE TABLE game (season 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": 720
} |
List the dates of games by the home team name in descending order. | SELECT Date FROM game ORDER BY home_team DESC | CREATE TABLE game (Date VARCHAR(255), home_team VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 721
} |
List the season, home team, away team of all the games. | SELECT season, home_team, away_team FROM game | CREATE TABLE game (season VARCHAR(255), home_team VARCHAR(255), away_team VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 722
} |
What are the maximum, minimum and average home games each stadium held? | SELECT MAX(home_games), MIN(home_games), AVG(home_games) FROM stadium | CREATE TABLE stadium (home_games 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": 723
} |
What is the average attendance of stadiums with capacity percentage higher than 100%? | SELECT average_attendance FROM stadium WHERE capacity_percentage > 100 | CREATE TABLE stadium (average_attendance VARCHAR(255), capacity_percentage INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 724
} |
What are the player name, number of matches, and information source for players who do not suffer from injury of 'Knee problem'? | SELECT player, number_of_matches, SOURCE FROM injury_accident WHERE injury <> 'Knee problem' | CREATE TABLE injury_accident (player VARCHAR(255), number_of_matches VARCHAR(255), SOURCE VARCHAR(255), injury VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 725
} |
What is the season of the game which causes the player 'Walter Samuel' to get injured? | SELECT T1.season FROM game AS T1 JOIN injury_accident AS T2 ON T1.id = T2.game_id WHERE T2.player = 'Walter Samuel' | CREATE TABLE injury_accident (game_id VARCHAR(255), player VARCHAR(255)); CREATE TABLE game (season VARCHAR(255), id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 726
} |
What are the ids, scores, and dates of the games which caused at least two injury accidents? | SELECT T1.id, T1.score, T1.date FROM game AS T1 JOIN injury_accident AS T2 ON T2.game_id = T1.id GROUP BY T1.id HAVING COUNT(*) >= 2 | CREATE TABLE game (id VARCHAR(255), score VARCHAR(255), date VARCHAR(255)); CREATE TABLE injury_accident (game_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": 727
} |
What are the id and name of the stadium where the most injury accidents happened? | SELECT T1.id, T1.name FROM stadium AS T1 JOIN game AS T2 ON T1.id = T2.stadium_id JOIN injury_accident AS T3 ON T2.id = T3.game_id GROUP BY T1.id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE stadium (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE injury_accident (game_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE game (stadium_id VARCHAR(255), id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 5 | 0 | 1 | {
"split": "train",
"row_index": 728
} |
In which season and which stadium did any player have an injury of 'Foot injury' or 'Knee problem'? | SELECT T1.season, T2.name FROM game AS T1 JOIN stadium AS T2 ON T1.stadium_id = T2.id JOIN injury_accident AS T3 ON T1.id = T3.game_id WHERE T3.injury = 'Foot injury' OR T3.injury = 'Knee problem' | CREATE TABLE stadium (name VARCHAR(255), id VARCHAR(255)); CREATE TABLE injury_accident (game_id VARCHAR(255), injury VARCHAR(255)); CREATE TABLE game (season VARCHAR(255), stadium_id VARCHAR(255), id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 2 | {
"split": "train",
"row_index": 729
} |
How many different kinds of information sources are there for injury accidents? | SELECT COUNT(DISTINCT SOURCE) FROM injury_accident | CREATE TABLE injury_accident (SOURCE 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": 730
} |
How many games are free of injury accidents? | SELECT COUNT(*) FROM game WHERE NOT id IN (SELECT game_id FROM injury_accident) | CREATE TABLE injury_accident (id VARCHAR(255), game_id VARCHAR(255)); CREATE TABLE game (id VARCHAR(255), game_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 731
} |
How many distinct kinds of injuries happened after season 2010? | SELECT COUNT(DISTINCT T1.injury) FROM injury_accident AS T1 JOIN game AS T2 ON T1.game_id = T2.id WHERE T2.season > 2010 | CREATE TABLE injury_accident (injury VARCHAR(255), game_id VARCHAR(255)); CREATE TABLE game (id VARCHAR(255), season INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 732
} |
List the name of the stadium where both the player 'Walter Samuel' and the player 'Thiago Motta' got injured. | SELECT T2.name FROM game AS T1 JOIN stadium AS T2 ON T1.stadium_id = T2.id JOIN injury_accident AS T3 ON T1.id = T3.game_id WHERE T3.player = 'Walter Samuel' INTERSECT SELECT T2.name FROM game AS T1 JOIN stadium AS T2 ON T1.stadium_id = T2.id JOIN injury_accident AS T3 ON T1.id = T3.game_id WHERE T3.player = 'Thiago Mo... | CREATE TABLE stadium (name VARCHAR(255), id VARCHAR(255)); CREATE TABLE game (stadium_id VARCHAR(255), id VARCHAR(255)); CREATE TABLE injury_accident (game_id VARCHAR(255), player VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 1 | 0 | {
"split": "train",
"row_index": 733
} |
Which stadium name contains the substring "Bank"? | SELECT name FROM stadium WHERE name LIKE '%Bank%' | CREATE TABLE stadium (name 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": 735
} |
How many games has each stadium held? | SELECT T1.id, COUNT(*) FROM stadium AS T1 JOIN game AS T2 ON T1.id = T2.stadium_id GROUP BY T1.id | CREATE TABLE stadium (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE game (stadium_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": 736
} |
For each injury accident, find the date of the game and the name of the injured player in the game, and sort the results in descending order of game season. | SELECT T1.date, T2.player FROM game AS T1 JOIN injury_accident AS T2 ON T1.id = T2.game_id ORDER BY T1.season DESC | CREATE TABLE game (date VARCHAR(255), id VARCHAR(255), season VARCHAR(255)); CREATE TABLE injury_accident (player VARCHAR(255), game_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 737
} |
List all country and league names. | SELECT T1.name, T2.name FROM Country AS T1 JOIN League AS T2 ON T1.id = T2.country_id | CREATE TABLE League (name VARCHAR(255), country_id VARCHAR(255)); CREATE TABLE Country (name VARCHAR(255), id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 738
} |
How many leagues are there in England? | SELECT COUNT(*) FROM Country AS T1 JOIN League AS T2 ON T1.id = T2.country_id WHERE T1.name = 'England' | CREATE TABLE League (country_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Country (id VARCHAR(255), name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 739
} |
What is the average weight of all players? | SELECT AVG(weight) FROM Player | CREATE TABLE Player (weight 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": 740
} |
What is the maximum and minimum height of all players? | SELECT MAX(weight), MIN(weight) FROM Player | CREATE TABLE Player (weight 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": 741
} |
List the names of all players who have a crossing score higher than 90 and prefer their right foot. | SELECT DISTINCT T1.player_name FROM Player AS T1 JOIN Player_Attributes AS T2 ON T1.player_api_id = T2.player_api_id WHERE T2.crossing > 90 AND T2.preferred_foot = 'right' | CREATE TABLE Player (player_name VARCHAR(255), player_api_id VARCHAR(255)); CREATE TABLE Player_Attributes (player_api_id VARCHAR(255), crossing VARCHAR(255), preferred_foot VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 744
} |
List the names of all left-footed players who have overall rating between 85 and 90. | SELECT DISTINCT T1.player_name FROM Player AS T1 JOIN Player_Attributes AS T2 ON T1.player_api_id = T2.player_api_id WHERE T2.preferred_foot = 'left' AND T2.overall_rating >= 85 AND T2.overall_rating <= 90 | CREATE TABLE Player (player_name VARCHAR(255), player_api_id VARCHAR(255)); CREATE TABLE Player_Attributes (player_api_id VARCHAR(255), overall_rating VARCHAR(255), preferred_foot VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 745
} |
What is the average rating for right-footed players and left-footed players? | SELECT preferred_foot, AVG(overall_rating) FROM Player_Attributes GROUP BY preferred_foot | CREATE TABLE Player_Attributes (preferred_foot VARCHAR(255), overall_rating INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 746
} |
Of all players with an overall rating greater than 80, how many are right-footed and left-footed? | SELECT preferred_foot, COUNT(*) FROM Player_Attributes WHERE overall_rating > 80 GROUP BY preferred_foot | CREATE TABLE Player_Attributes (preferred_foot VARCHAR(255), overall_rating INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 747
} |
List all of the player ids with a height of at least 180cm and an overall rating higher than 85. | SELECT player_api_id FROM Player WHERE height >= 180 INTERSECT SELECT player_api_id FROM Player_Attributes WHERE overall_rating > 85 | CREATE TABLE Player_Attributes (player_api_id VARCHAR(255), height VARCHAR(255), overall_rating INTEGER); CREATE TABLE Player (player_api_id VARCHAR(255), height VARCHAR(255), overall_rating INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 748
} |
List all of the ids for left-footed players with a height between 180cm and 190cm. | SELECT player_api_id FROM Player WHERE height >= 180 AND height <= 190 INTERSECT SELECT player_api_id FROM Player_Attributes WHERE preferred_foot = 'left' | CREATE TABLE Player_Attributes (player_api_id VARCHAR(255), preferred_foot VARCHAR(255), height VARCHAR(255)); CREATE TABLE Player (player_api_id VARCHAR(255), preferred_foot VARCHAR(255), height VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 749
} |
How many performances are there? | SELECT COUNT(*) FROM performance | CREATE TABLE performance (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 752
} |
List the hosts of performances in ascending order of attendance. | SELECT HOST FROM performance ORDER BY Attendance | CREATE TABLE performance (HOST VARCHAR(255), Attendance VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 753
} |
What are the dates and locations of performances? | SELECT Date, LOCATION FROM performance | CREATE TABLE performance (Date VARCHAR(255), LOCATION VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 754
} |
Show the attendances of the performances at location "TD Garden" or "Bell Centre" | SELECT Attendance FROM performance WHERE LOCATION = 'TD Garden' OR LOCATION = 'Bell Centre' | CREATE TABLE performance (Attendance VARCHAR(255), LOCATION VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 755
} |
What is the average number of attendees for performances? | SELECT AVG(Attendance) FROM performance | CREATE TABLE performance (Attendance INTEGER, event_date VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 756
} |
What is the date of the performance with the highest number of attendees? | SELECT Date FROM performance ORDER BY Attendance DESC LIMIT 1 | CREATE TABLE performance (Date VARCHAR(255), Attendance VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 757
} |
Show different locations and the number of performances at each location. | SELECT LOCATION, COUNT(*) FROM performance GROUP BY LOCATION | CREATE TABLE performance (LOCATION 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": 758
} |
Show the most common location of performances. | SELECT LOCATION FROM performance GROUP BY LOCATION ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE performance (LOCATION 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": 759
} |
Show the locations that have at least two performances. | SELECT LOCATION FROM performance GROUP BY LOCATION HAVING COUNT(*) >= 2 | CREATE TABLE performance (LOCATION 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": 760
} |
Show the locations that have both performances with more than 2000 attendees and performances with less than 1000 attendees. | SELECT LOCATION FROM performance WHERE Attendance > 2000 INTERSECT SELECT LOCATION FROM performance WHERE Attendance < 1000 | CREATE TABLE performance (LOCATION VARCHAR(255), Attendance INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 761
} |
Show the names of members and the location of the performances they attended. | SELECT T2.Name, T3.Location FROM member_attendance AS T1 JOIN member AS T2 ON T1.Member_ID = T2.Member_ID JOIN performance AS T3 ON T1.Performance_ID = T3.Performance_ID | CREATE TABLE performance (Location VARCHAR(255), Performance_ID VARCHAR(255)); CREATE TABLE member (Name VARCHAR(255), Member_ID VARCHAR(255)); CREATE TABLE member_attendance (Member_ID VARCHAR(255), Performance_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 762
} |
Show the names of members and the location of performances they attended in ascending alphabetical order of their names. | SELECT T2.Name, T3.Location FROM member_attendance AS T1 JOIN member AS T2 ON T1.Member_ID = T2.Member_ID JOIN performance AS T3 ON T1.Performance_ID = T3.Performance_ID ORDER BY T2.Name | CREATE TABLE performance (Location VARCHAR(255), Performance_ID VARCHAR(255)); CREATE TABLE member (Name VARCHAR(255), Member_ID VARCHAR(255)); CREATE TABLE member_attendance (Member_ID VARCHAR(255), Performance_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 763
} |
Show the dates of performances with attending members whose roles are "Violin". | SELECT T3.Date FROM member_attendance AS T1 JOIN member AS T2 ON T1.Member_ID = T2.Member_ID JOIN performance AS T3 ON T1.Performance_ID = T3.Performance_ID WHERE T2.Role = 'Violin' | CREATE TABLE performance (Date VARCHAR(255), Performance_ID VARCHAR(255)); CREATE TABLE member (Member_ID VARCHAR(255), Role VARCHAR(255)); CREATE TABLE member_attendance (Member_ID VARCHAR(255), Performance_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 764
} |
Show the names of members and the dates of performances they attended in descending order of attendance of the performances. | SELECT T2.Name, T3.Date FROM member_attendance AS T1 JOIN member AS T2 ON T1.Member_ID = T2.Member_ID JOIN performance AS T3 ON T1.Performance_ID = T3.Performance_ID ORDER BY T3.Attendance DESC | CREATE TABLE performance (Date VARCHAR(255), Performance_ID VARCHAR(255), Attendance VARCHAR(255)); CREATE TABLE member (Name VARCHAR(255), Member_ID VARCHAR(255)); CREATE TABLE member_attendance (Member_ID VARCHAR(255), Performance_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 765
} |
List the names of members who did not attend any performance. | SELECT Name FROM member WHERE NOT Member_ID IN (SELECT Member_ID FROM member_attendance) | CREATE TABLE member (Name VARCHAR(255), Member_ID VARCHAR(255)); CREATE TABLE member_attendance (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": 766
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.