question string | answer string | context string | dialect string | spider_hardness string | extended_hardness string | classification_status string | syntax_status string | ddl_syntax_status string | schema_status string | syntax_errors list | ddl_syntax_errors list | schema_errors list | classification_errors list | status_history list | correction_status string | component1 int64 | component2 int64 | others int64 | validation_source dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
What is the total budget amount for school "Glenn" in all years? | SELECT SUM(T1.budgeted) FROM budget AS T1 JOIN school AS T2 ON T1.school_id = T2.school_id WHERE T2.school_name = 'Glenn' | CREATE TABLE budget (budgeted INTEGER, school_id VARCHAR, id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE school (school_id VARCHAR, school_name VARCHAR) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1110
} |
Show the names of schools with a total budget amount greater than 100 or a total endowment greater than 10. | SELECT T2.school_name FROM budget AS T1 JOIN school AS T2 ON T1.school_id = T2.school_id JOIN endowment AS T3 ON T2.school_id = T3.school_id GROUP BY T2.school_name HAVING SUM(T1.budgeted) > 100 OR SUM(T3.amount) > 10 | CREATE TABLE endowment (school_id VARCHAR, amount INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE budget (school_id VARCHAR, budgeted INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE school (school_name VARCHAR, school_id VARCHAR) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 1111
} |
Find the names of schools that have more than one donator with donation amount above 8.5. | SELECT T2.School_name FROM endowment AS T1 JOIN school AS T2 ON T1.school_id = T2.school_id WHERE T1.amount > 8.5 GROUP BY T1.school_id HAVING COUNT(*) > 1 | CREATE TABLE school (School_name VARCHAR, school_id VARCHAR); CREATE TABLE endowment (school_id VARCHAR, amount INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 1112
} |
How many buildings are there? | SELECT COUNT(*) FROM building | CREATE TABLE building (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 1115
} |
Show the name, street address, and number of floors for all buildings ordered by the number of floors. | SELECT name, street_address, floors FROM building ORDER BY floors | CREATE TABLE building (name VARCHAR(255), street_address VARCHAR(255), floors VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1116
} |
What is the name of the tallest building? | SELECT name FROM building ORDER BY height_feet DESC LIMIT 1 | CREATE TABLE building (name VARCHAR(255), height_feet VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1117
} |
What are the average, maximum, and minimum number of floors for all buildings? | SELECT AVG(floors), MAX(floors), MIN(floors) FROM building | CREATE TABLE building (floors INTEGER, building_id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 2 | {
"split": "train",
"row_index": 1118
} |
List the names of buildings with at least 200 feet of height and with at least 20 floors. | SELECT name FROM building WHERE height_feet >= 200 AND floors >= 20 | CREATE TABLE building (name VARCHAR(255), height_feet VARCHAR(255), floors VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1120
} |
Show the names and locations of institutions that are founded after 1990 and have the type "Private". | SELECT institution, LOCATION FROM institution WHERE founded > 1990 AND TYPE = 'Private' | CREATE TABLE institution (institution VARCHAR(255), LOCATION VARCHAR(255), founded VARCHAR(255), TYPE VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 1121
} |
Show institution types, along with the number of institutions and total enrollment for each type. | SELECT TYPE, COUNT(*), SUM(enrollment) FROM institution GROUP BY TYPE | CREATE TABLE institution (TYPE VARCHAR(255), enrollment INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 1122
} |
Show the institution type with the largest number of institutions. | SELECT TYPE FROM institution GROUP BY TYPE ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE institution (TYPE VARCHAR(255), institution_id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 1123
} |
Show the institution type with an institution founded after 1990 and an institution with at least 1000 enrollment. | SELECT TYPE FROM institution WHERE founded > 1990 AND enrollment >= 1000 | CREATE TABLE institution (TYPE VARCHAR(255), founded VARCHAR(255), enrollment VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1124
} |
Show the name of buildings that do not have any institution. | SELECT name FROM building WHERE NOT building_id IN (SELECT building_id FROM institution) | CREATE TABLE building (name VARCHAR(255), building_id VARCHAR(255)); CREATE TABLE institution (name VARCHAR(255), building_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 1125
} |
For each building, show the name of the building and the number of institutions in it. | SELECT T1.name, COUNT(*) FROM building AS T1 JOIN institution AS T2 ON T1.building_id = T2.building_id GROUP BY T1.building_id | CREATE TABLE building (name VARCHAR(255), building_id VARCHAR(255)); CREATE TABLE institution (building_id VARCHAR(255), institution_id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1127
} |
Show the names and heights of buildings with at least two institutions founded after 1880. | SELECT T1.name, T1.height_feet FROM building AS T1 JOIN institution AS T2 ON T1.building_id = T2.building_id WHERE T2.founded > 1880 GROUP BY T1.building_id HAVING COUNT(*) >= 2 | CREATE TABLE building (name VARCHAR(255), height_feet VARCHAR(255), building_id VARCHAR(255)); CREATE TABLE institution (building_id VARCHAR(255), founded INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 1128
} |
Show all the distinct institution types. | SELECT DISTINCT TYPE FROM institution | CREATE TABLE institution (TYPE VARCHAR(255), institution_id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 1129
} |
Show institution names along with the number of proteins for each institution. | SELECT T1.institution, COUNT(*) FROM institution AS T1 JOIN protein AS T2 ON T1.institution_id = T2.institution_id GROUP BY T1.institution_id | CREATE TABLE institution (institution VARCHAR(255), institution_id VARCHAR(255)); CREATE TABLE protein (institution_id VARCHAR(255), protein_id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1130
} |
How many proteins are associated with an institution founded after 1880 or an institution with type "Private"? | SELECT COUNT(*) FROM institution AS T1 JOIN protein AS T2 ON T1.institution_id = T2.institution_id WHERE T1.founded > 1880 OR T1.type = 'Private' | CREATE TABLE institution (institution_id VARCHAR(255), founded VARCHAR(255), type VARCHAR(255)); CREATE TABLE protein (institution_id VARCHAR(255), protein_id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 1131
} |
Show the protein name and the institution name. | SELECT T2.protein_name, T1.institution FROM institution AS T1 JOIN protein AS T2 ON T1.institution_id = T2.institution_id | CREATE TABLE institution (institution VARCHAR(255), institution_id VARCHAR(255)); CREATE TABLE protein (protein_name VARCHAR(255), institution_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1132
} |
How many proteins are associated with an institution in a building with at least 20 floors? | SELECT COUNT(*) FROM institution AS T1 JOIN protein AS T2 ON T1.institution_id = T2.institution_id JOIN building AS T3 ON T3.building_id = T1.building_id WHERE T3.floors >= 20 | CREATE TABLE institution (institution_id VARCHAR(255), building_id VARCHAR(255)); CREATE TABLE building (building_id VARCHAR(255), floors VARCHAR(255)); CREATE TABLE protein (institution_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 1133
} |
How many institutions do not have an associated protein in our record? | SELECT COUNT(*) FROM institution WHERE NOT institution_id IN (SELECT institution_id FROM protein) | CREATE TABLE protein (institution_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE institution (institution_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 1134
} |
Show all the locations where no cinema has capacity over 800. | SELECT LOCATION FROM cinema EXCEPT SELECT LOCATION FROM cinema WHERE capacity > 800 | CREATE TABLE cinema (LOCATION VARCHAR(255), capacity INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 1135
} |
Show all the locations where some cinemas were opened in both year 2010 and year 2011. | SELECT LOCATION FROM cinema WHERE openning_year = 2010 INTERSECT SELECT LOCATION FROM cinema WHERE openning_year = 2011 | CREATE TABLE cinema (LOCATION VARCHAR(255), openning_year VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 1136
} |
How many cinema do we have? | SELECT COUNT(*) FROM cinema | CREATE TABLE cinema (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 1137
} |
Show name, opening year, and capacity for each cinema. | SELECT name, openning_year, capacity FROM cinema | CREATE TABLE cinema (name VARCHAR(255), openning_year VARCHAR(255), capacity VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 1138
} |
Show the cinema name and location for cinemas with capacity above average. | SELECT name, LOCATION FROM cinema WHERE capacity > (SELECT AVG(capacity) FROM cinema) | CREATE TABLE cinema (name VARCHAR(255), LOCATION VARCHAR(255), capacity INTEGER) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 1139
} |
What are all the locations with a cinema? | SELECT DISTINCT LOCATION FROM cinema | CREATE TABLE cinema (LOCATION 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": 1140
} |
Show all the cinema names and opening years in descending order of opening year. | SELECT name, openning_year FROM cinema ORDER BY openning_year DESC | CREATE TABLE cinema (name VARCHAR(255), openning_year VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1141
} |
What are the name and location of the cinema with the largest capacity? | SELECT name, LOCATION FROM cinema ORDER BY capacity DESC LIMIT 1 | CREATE TABLE cinema (name VARCHAR(255), LOCATION VARCHAR(255), capacity VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1142
} |
Show the average, minimum, and maximum capacity for all the cinemas opened in year 2011 or later. | SELECT AVG(capacity), MIN(capacity), MAX(capacity) FROM cinema WHERE openning_year >= 2011 | CREATE TABLE cinema (capacity INTEGER, openning_year VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 1143
} |
Show each location and the number of cinemas there. | SELECT LOCATION, COUNT(*) FROM cinema GROUP BY LOCATION | CREATE TABLE cinema (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": 1144
} |
What is the location with the most cinemas opened in year 2010 or later? | SELECT LOCATION FROM cinema WHERE openning_year >= 2010 GROUP BY LOCATION ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE cinema (LOCATION VARCHAR(255), openning_year VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 1145
} |
Show all the locations with at least two cinemas with capacity above 300. | SELECT LOCATION FROM cinema WHERE capacity > 300 GROUP BY LOCATION HAVING COUNT(*) >= 2 | CREATE TABLE cinema (LOCATION VARCHAR(255), capacity INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1146
} |
Show the title and director for all films. | SELECT title, directed_by FROM film | CREATE TABLE film (title VARCHAR(255), directed_by VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 1147
} |
Show all directors. | SELECT DISTINCT directed_by FROM film | CREATE TABLE film (directed_by 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": 1148
} |
List all directors along with the number of films directed by each director. | SELECT directed_by, COUNT(*) FROM film GROUP BY directed_by | CREATE TABLE film (directed_by 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": 1149
} |
What is total number of show times per dat for each cinema? | SELECT T2.name, SUM(T1.show_times_per_day) FROM schedule AS T1 JOIN cinema AS T2 ON T1.cinema_id = T2.cinema_id GROUP BY T1.cinema_id | CREATE TABLE schedule (show_times_per_day INTEGER, cinema_id VARCHAR(255)); CREATE TABLE cinema (name VARCHAR(255), cinema_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1150
} |
What are the title and maximum price of each film? | SELECT T2.title, MAX(T1.price) FROM schedule AS T1 JOIN film AS T2 ON T1.film_id = T2.film_id GROUP BY T1.film_id | CREATE TABLE film (title VARCHAR(255), film_id VARCHAR(255)); CREATE TABLE schedule (price INTEGER, film_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1151
} |
Show cinema name, film title, date, and price for each record in schedule. | SELECT T3.name, T2.title, T1.date, T1.price FROM schedule AS T1 JOIN film AS T2 ON T1.film_id = T2.film_id JOIN cinema AS T3 ON T1.cinema_id = T3.cinema_id | CREATE TABLE schedule (date VARCHAR(255), price VARCHAR(255), film_id VARCHAR(255), cinema_id VARCHAR(255)); CREATE TABLE cinema (name VARCHAR(255), cinema_id VARCHAR(255)); CREATE TABLE film (title VARCHAR(255), film_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1152
} |
What are the title and director of the films without any schedule? | SELECT title, directed_by FROM film WHERE NOT film_id IN (SELECT film_id FROM schedule) | CREATE TABLE schedule (title VARCHAR(255), directed_by VARCHAR(255), film_id VARCHAR(255)); CREATE TABLE film (title VARCHAR(255), directed_by VARCHAR(255), film_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 1153
} |
Show director with the largest number of show times in total. | SELECT T2.directed_by FROM schedule AS T1 JOIN film AS T2 ON T1.film_id = T2.film_id GROUP BY T2.directed_by ORDER BY SUM(T1.show_times_per_day) DESC LIMIT 1 | CREATE TABLE schedule (film_id VARCHAR(255), show_times_per_day INTEGER); CREATE TABLE film (directed_by VARCHAR(255), film_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 1154
} |
Find the locations that have more than one movie theater with capacity above 300. | SELECT LOCATION FROM cinema WHERE capacity > 300 GROUP BY LOCATION HAVING COUNT(*) > 1 | CREATE TABLE cinema (LOCATION VARCHAR(255), capacity INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1155
} |
How many films have the word 'Dummy' in their titles? | SELECT COUNT(*) FROM film WHERE title LIKE '%Dummy%' | CREATE TABLE film (title VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1156
} |
Are the customers holding coupons with amount 500 bad or good? | SELECT T1.good_or_bad_customer FROM customers AS T1 JOIN discount_coupons AS T2 ON T1.coupon_id = T2.coupon_id WHERE T2.coupon_amount = 500 | CREATE TABLE discount_coupons (coupon_id VARCHAR(255), coupon_amount VARCHAR(255)); CREATE TABLE customers (good_or_bad_customer VARCHAR(255), coupon_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1157
} |
How many bookings did each customer make? List the customer id, first name, and the count. | SELECT T1.customer_id, T1.first_name, COUNT(*) FROM Customers AS T1 JOIN bookings AS T2 ON T1.customer_id = T2.customer_id GROUP BY T1.customer_id | CREATE TABLE bookings (customer_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Customers (customer_id VARCHAR(255), first_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1158
} |
What is the maximum total amount paid by a customer? List the customer id and amount. | SELECT customer_id, SUM(amount_paid) FROM Payments GROUP BY customer_id ORDER BY SUM(amount_paid) DESC LIMIT 1 | CREATE TABLE Payments (customer_id VARCHAR(255), amount_paid INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 2 | {
"split": "train",
"row_index": 1159
} |
What are the id and the amount of refund of the booking that incurred the most times of payments? | SELECT T1.booking_id, T1.amount_of_refund FROM Bookings AS T1 JOIN Payments AS T2 ON T1.booking_id = T2.booking_id GROUP BY T1.booking_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Payments (booking_id VARCHAR(255), amount_paid INTEGER); CREATE TABLE Bookings (booking_id VARCHAR(255), amount_of_refund VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 1160
} |
What is the id of the product that is booked for 3 times? | SELECT product_id FROM products_booked GROUP BY product_id HAVING COUNT(*) = 3 | CREATE TABLE products_booked (product_id 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": 1161
} |
What is the product description of the product booked with an amount of 102.76? | SELECT T2.product_description FROM products_booked AS T1 JOIN products_for_hire AS T2 ON T1.product_id = T2.product_id WHERE T1.booked_amount = 102.76 | CREATE TABLE products_for_hire (product_description VARCHAR(255), product_id VARCHAR(255)); CREATE TABLE products_booked (product_id VARCHAR(255), booked_amount VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1162
} |
What are the start date and end date of the booking that has booked the product named 'Book collection A'? | SELECT T3.booking_start_date, T3.booking_end_date FROM Products_for_hire AS T1 JOIN products_booked AS T2 ON T1.product_id = T2.product_id JOIN bookings AS T3 ON T2.booking_id = T3.booking_id WHERE T1.product_name = 'Book collection A' | CREATE TABLE bookings (booking_start_date VARCHAR(255), booking_end_date VARCHAR(255), booking_id VARCHAR(255)); CREATE TABLE products_booked (product_id VARCHAR(255), booking_id VARCHAR(255)); CREATE TABLE Products_for_hire (product_id VARCHAR(255), product_name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 1163
} |
What are the names of products whose availability equals to 1? | SELECT T2.product_name FROM view_product_availability AS T1 JOIN products_for_hire AS T2 ON T1.product_id = T2.product_id WHERE T1.available_yn = 1 | CREATE TABLE view_product_availability (product_id VARCHAR(255), available_yn VARCHAR(255)); CREATE TABLE products_for_hire (product_name VARCHAR(255), product_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1164
} |
How many different product types are there? | SELECT COUNT(DISTINCT product_type_code) FROM products_for_hire | CREATE TABLE products_for_hire (product_type_code VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 1165
} |
What are the first name, last name, and gender of all the good customers? Order by their last name. | SELECT first_name, last_name, gender_mf FROM customers WHERE good_or_bad_customer = 'good' ORDER BY last_name | CREATE TABLE customers (first_name VARCHAR(255), last_name VARCHAR(255), gender_mf VARCHAR(255), good_or_bad_customer VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1166
} |
What is the average amount due for all the payments? | SELECT AVG(amount_due) FROM payments | CREATE TABLE payments (amount_due 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": 1167
} |
What are the maximum, minimum, and average booked count for the products booked? | SELECT MAX(booked_count), MIN(booked_count), AVG(booked_count) FROM products_booked | CREATE TABLE products_booked (booked_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": 1168
} |
What are all the distinct payment types? | SELECT DISTINCT payment_type_code FROM payments | CREATE TABLE payments (payment_type_code VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 1169
} |
What are the daily hire costs for the products with substring 'Book' in its name? | SELECT daily_hire_cost FROM Products_for_hire WHERE product_name LIKE '%Book%' | CREATE TABLE Products_for_hire (daily_hire_cost VARCHAR(255), product_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1170
} |
How many products are never booked with amount higher than 200? | SELECT COUNT(*) FROM Products_for_hire WHERE NOT product_id IN (SELECT product_id FROM products_booked WHERE booked_amount > 200) | CREATE TABLE products_booked (product_id VARCHAR(255), booked_amount INTEGER); CREATE TABLE Products_for_hire (product_id VARCHAR(255), booked_amount INTEGER) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 1171
} |
What are the coupon amount of the coupons owned by both good and bad customers? | SELECT T1.coupon_amount FROM Discount_Coupons AS T1 JOIN customers AS T2 ON T1.coupon_id = T2.coupon_id WHERE T2.good_or_bad_customer = 'good' INTERSECT SELECT T1.coupon_amount FROM Discount_Coupons AS T1 JOIN customers AS T2 ON T1.coupon_id = T2.coupon_id WHERE T2.good_or_bad_customer = 'bad' | CREATE TABLE Discount_Coupons (coupon_amount VARCHAR(255), coupon_id VARCHAR(255)); CREATE TABLE customers (coupon_id VARCHAR(255), good_or_bad_customer VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 1172
} |
What are the payment date of the payment with amount paid higher than 300 or with payment type is 'Check' | SELECT payment_date FROM payments WHERE amount_paid > 300 OR payment_type_code = 'Check' | CREATE TABLE payments (payment_date VARCHAR(255), amount_paid VARCHAR(255), payment_type_code VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1173
} |
What are the names and descriptions of the products that are of 'Cutlery' type and have daily hire cost lower than 20? | SELECT product_name, product_description FROM products_for_hire WHERE product_type_code = 'Cutlery' AND daily_hire_cost < 20 | CREATE TABLE products_for_hire (product_name VARCHAR(255), product_description VARCHAR(255), product_type_code VARCHAR(255), daily_hire_cost VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 1174
} |
How many phones are there? | SELECT COUNT(*) FROM phone | CREATE TABLE phone (Id VARCHAR(255), Name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 1175
} |
List the names of phones in ascending order of price. | SELECT Name FROM phone ORDER BY Price | CREATE TABLE phone (Name VARCHAR(255), Price VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1176
} |
What are the memories and carriers of phones? | SELECT Memory_in_G, Carrier FROM phone | CREATE TABLE phone (Memory_in_G VARCHAR(255), Carrier VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 1177
} |
List the distinct carriers of phones with memories bigger than 32. | SELECT DISTINCT Carrier FROM phone WHERE Memory_in_G > 32 | CREATE TABLE phone (Carrier VARCHAR(255), Memory_in_G INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1178
} |
Show the names of phones with carrier either "Sprint" or "TMobile". | SELECT Name FROM phone WHERE Carrier = 'Sprint' OR Carrier = 'TMobile' | CREATE TABLE phone (Name VARCHAR(255), Carrier VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1179
} |
What is the carrier of the most expensive phone? | SELECT Carrier FROM phone ORDER BY Price DESC LIMIT 1 | CREATE TABLE phone (Carrier VARCHAR(255), Price 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": 1180
} |
Show different carriers of phones together with the number of phones with each carrier. | SELECT Carrier, COUNT(*) FROM phone GROUP BY Carrier | CREATE TABLE phone (Carrier 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": 1181
} |
Show the most frequently used carrier of the phones. | SELECT Carrier FROM phone GROUP BY Carrier ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE phone (Carrier 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": 1182
} |
Show the carriers that have both phones with memory smaller than 32 and phones with memory bigger than 64. | SELECT Carrier FROM phone WHERE Memory_in_G < 32 INTERSECT SELECT Carrier FROM phone WHERE Memory_in_G > 64 | CREATE TABLE phone (Carrier VARCHAR(255), Memory_in_G 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": 1183
} |
Show the names of phones and the districts of markets they are on. | SELECT T3.Name, T2.District FROM phone_market AS T1 JOIN market AS T2 ON T1.Market_ID = T2.Market_ID JOIN phone AS T3 ON T1.Phone_ID = T3.Phone_ID | CREATE TABLE phone (Name VARCHAR(255), Phone_ID VARCHAR(255)); CREATE TABLE market (District VARCHAR(255), Market_ID VARCHAR(255)); CREATE TABLE phone_market (Market_ID VARCHAR(255), Phone_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": 1184
} |
Show the names of phones and the districts of markets they are on, in ascending order of the ranking of the market. | SELECT T3.Name, T2.District FROM phone_market AS T1 JOIN market AS T2 ON T1.Market_ID = T2.Market_ID JOIN phone AS T3 ON T1.Phone_ID = T3.Phone_ID ORDER BY T2.Ranking | CREATE TABLE market (District VARCHAR(255), Market_ID VARCHAR(255), Ranking VARCHAR(255)); CREATE TABLE phone (Name VARCHAR(255), Phone_ID VARCHAR(255)); CREATE TABLE phone_market (Market_ID VARCHAR(255), Phone_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 1185
} |
Show the names of phones that are on market with number of shops greater than 50. | SELECT T3.Name FROM phone_market AS T1 JOIN market AS T2 ON T1.Market_ID = T2.Market_ID JOIN phone AS T3 ON T1.Phone_ID = T3.Phone_ID WHERE T2.Num_of_shops > 50 | CREATE TABLE market (Market_ID VARCHAR(255), Num_of_shops INTEGER); CREATE TABLE phone (Name VARCHAR(255), Phone_ID VARCHAR(255)); CREATE TABLE phone_market (Market_ID VARCHAR(255), Phone_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 1186
} |
For each phone, show its names and total number of stocks. | SELECT T2.Name, SUM(T1.Num_of_stock) FROM phone_market AS T1 JOIN phone AS T2 ON T1.Phone_ID = T2.Phone_ID GROUP BY T2.Name | CREATE TABLE phone_market (Num_of_stock INTEGER, Phone_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE phone (Name VARCHAR(255), Phone_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1187
} |
Show the names of phones that have total number of stocks bigger than 2000, in descending order of the total number of stocks. | SELECT T2.Name FROM phone_market AS T1 JOIN phone AS T2 ON T1.Phone_ID = T2.Phone_ID GROUP BY T2.Name HAVING SUM(T1.Num_of_stock) >= 2000 ORDER BY SUM(T1.Num_of_stock) DESC | CREATE TABLE phone_market (Phone_ID VARCHAR(255), Num_of_stock INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE phone (Name VARCHAR(255), Phone_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 1188
} |
How many gas companies are there? | SELECT COUNT(*) FROM company | CREATE TABLE company (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 1190
} |
List the company name and rank for all companies in the decreasing order of their sales. | SELECT company, rank FROM company ORDER BY Sales_billion DESC | CREATE TABLE company (company VARCHAR(255), rank VARCHAR(255), Sales_billion VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1191
} |
Show the company name and the main industry for all companies whose headquarters are not from USA. | SELECT company, main_industry FROM company WHERE headquarters <> 'USA' | CREATE TABLE company (company VARCHAR(255), main_industry VARCHAR(255), headquarters VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1192
} |
Show all company names and headquarters in the descending order of market value. | SELECT company, headquarters FROM company ORDER BY market_value DESC | CREATE TABLE company (company VARCHAR(255), headquarters VARCHAR(255), market_value 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": 1193
} |
Show minimum, maximum, and average market value for all companies. | SELECT MIN(market_value), MAX(market_value), AVG(market_value) FROM company | CREATE TABLE company (market_value INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT, company VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 2 | {
"split": "train",
"row_index": 1194
} |
Show all main industry for all companies. | SELECT DISTINCT main_industry FROM company | CREATE TABLE company (main_industry VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT, company VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 1195
} |
List all headquarters and the number of companies in each headquarter. | SELECT headquarters, COUNT(*) FROM company GROUP BY headquarters | CREATE TABLE company (headquarters VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT, company VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1196
} |
Show all main industry and total market value in each industry. | SELECT main_industry, SUM(market_value) FROM company GROUP BY main_industry | CREATE TABLE company (main_industry VARCHAR(255), market_value INTEGER); | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1197
} |
List the main industry with highest total market value and its number of companies. | SELECT main_industry, COUNT(*) FROM company GROUP BY main_industry ORDER BY SUM(market_value) DESC LIMIT 1 | CREATE TABLE company (main_industry VARCHAR(255), market_value INTEGER); | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 2 | {
"split": "train",
"row_index": 1198
} |
Show headquarters with at least two companies in the banking industry. | SELECT headquarters FROM company WHERE main_industry = 'Banking' GROUP BY headquarters HAVING COUNT(*) >= 2 | CREATE TABLE company (headquarters VARCHAR(255), main_industry VARCHAR(255)); | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1199
} |
Show gas station id, location, and manager_name for all gas stations ordered by open year. | SELECT station_id, LOCATION, manager_name FROM gas_station ORDER BY open_year | CREATE TABLE gas_station (station_id VARCHAR(255), LOCATION VARCHAR(255), manager_name VARCHAR(255), open_year VARCHAR(255)); | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1200
} |
How many gas station are opened between 2000 and 2005? | SELECT COUNT(*) FROM gas_station WHERE open_year BETWEEN 2000 AND 2005 | CREATE TABLE gas_station (open_year 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": 1201
} |
Show all locations and the number of gas stations in each location ordered by the count. | SELECT LOCATION, COUNT(*) FROM gas_station GROUP BY LOCATION ORDER BY COUNT(*) | CREATE TABLE gas_station (LOCATION 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": 1202
} |
Show all headquarters with both a company in banking industry and a company in Oil and gas. | SELECT headquarters FROM company WHERE main_industry = 'Banking' INTERSECT SELECT headquarters FROM company WHERE main_industry = 'Oil and gas' | CREATE TABLE company (headquarters VARCHAR(255), main_industry VARCHAR(255)); | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 1203
} |
Show all headquarters without a company in banking industry. | SELECT headquarters FROM company EXCEPT SELECT headquarters FROM company WHERE main_industry = 'Banking' | CREATE TABLE company (headquarters VARCHAR(255), main_industry VARCHAR(255)); | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 1204
} |
Show the company name with the number of gas station. | SELECT T2.company, COUNT(*) FROM station_company AS T1 JOIN company AS T2 ON T1.company_id = T2.company_id GROUP BY T1.company_id | CREATE TABLE station_company (company_id VARCHAR(255), station_id VARCHAR(255)); CREATE TABLE company (company VARCHAR(255), company_id VARCHAR(255)); | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1205
} |
Show company name and main industry without a gas station. | SELECT company, main_industry FROM company WHERE NOT company_id IN (SELECT company_id FROM station_company) | CREATE TABLE station_company (company VARCHAR(255), main_industry VARCHAR(255), company_id VARCHAR(255)); CREATE TABLE company (company VARCHAR(255), main_industry VARCHAR(255), company_id VARCHAR(255)); | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 1206
} |
Show the manager name for gas stations belonging to the ExxonMobil company. | SELECT T3.manager_name FROM station_company AS T1 JOIN company AS T2 ON T1.company_id = T2.company_id JOIN gas_station AS T3 ON T1.station_id = T3.station_id WHERE T2.company = 'ExxonMobil' | CREATE TABLE gas_station (manager_name VARCHAR(255), station_id VARCHAR(255)); CREATE TABLE station_company (company_id VARCHAR(255), station_id VARCHAR(255)); CREATE TABLE company (company_id VARCHAR(255), company VARCHAR(255)); | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 1207
} |
Show all locations where a gas station for company with market value greater than 100 is located. | SELECT T3.location FROM station_company AS T1 JOIN company AS T2 ON T1.company_id = T2.company_id JOIN gas_station AS T3 ON T1.station_id = T3.station_id WHERE T2.market_value > 100 | CREATE TABLE gas_station (location VARCHAR(255), station_id VARCHAR(255)); CREATE TABLE company (company_id VARCHAR(255), market_value INTEGER); CREATE TABLE station_company (company_id VARCHAR(255), station_id VARCHAR(255)); | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 1208
} |
Show the manager name with most number of gas stations opened after 2000. | SELECT manager_name FROM gas_station WHERE open_year > 2000 GROUP BY manager_name ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE gas_station (manager_name VARCHAR(255), open_year INTEGER); | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 1209
} |
order all gas station locations by the opening year. | SELECT LOCATION FROM gas_station ORDER BY open_year | CREATE TABLE gas_station (LOCATION VARCHAR(255), open_year VARCHAR(255)); | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1210
} |
find the rank, company names, market values of the companies in the banking industry order by their sales and profits in billion. | SELECT rank, company, market_value FROM company WHERE main_industry = 'Banking' ORDER BY sales_billion, profits_billion | CREATE TABLE company (rank VARCHAR(255), company VARCHAR(255), market_value VARCHAR(255), main_industry VARCHAR(255), sales_billion VARCHAR(255), profits_billion VARCHAR(255)); | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1211
} |
find the location and Representative name of the gas stations owned by the companies with top 3 Asset amounts. | SELECT T3.location, T3.Representative_Name FROM station_company AS T1 JOIN company AS T2 ON T1.company_id = T2.company_id JOIN gas_station AS T3 ON T1.station_id = T3.station_id ORDER BY T2.Assets_billion DESC LIMIT 3 | CREATE TABLE gas_station (location VARCHAR(255), Representative_Name VARCHAR(255), station_id VARCHAR(255)); CREATE TABLE station_company (company_id VARCHAR(255), station_id VARCHAR(255)); CREATE TABLE company (company_id VARCHAR(255), Assets_billion VARCHAR(255)); | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 1212
} |
How many regions do we have? | SELECT COUNT(*) FROM region | CREATE TABLE region (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 1213
} |
Show all distinct region names ordered by their labels. | SELECT DISTINCT region_name FROM region ORDER BY Label | CREATE TABLE region (region_name VARCHAR(255), Label VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1214
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.