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 description of the claim status "Open"? | SELECT claim_status_description FROM claims_processing_stages WHERE claim_status_name = 'Open' | CREATE TABLE claims_processing_stages (claim_status_description VARCHAR(255), claim_status_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 883
} |
How many distinct claim outcome codes are there? | SELECT COUNT(DISTINCT claim_outcome_code) FROM claims_processing | CREATE TABLE claims_processing (claim_outcome_code VARCHAR(255), id INTEGER PRIMARY KEY AUTOINCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 884
} |
Show the id, the date of account opened, the account name, and other account detail for all accounts. | SELECT account_id, date_account_opened, account_name, other_account_details FROM Accounts | CREATE TABLE Accounts (account_id VARCHAR(255), date_account_opened VARCHAR(255), account_name VARCHAR(255), other_account_details VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 886
} |
Show the id, the account name, and other account details for all accounts by the customer with first name 'Meaghan'. | SELECT T1.account_id, T1.date_account_opened, T1.account_name, T1.other_account_details FROM Accounts AS T1 JOIN Customers AS T2 ON T1.customer_id = T2.customer_id WHERE T2.customer_first_name = 'Meaghan' | CREATE TABLE Accounts (account_id VARCHAR(255), date_account_opened VARCHAR(255), account_name VARCHAR(255), other_account_details VARCHAR(255), customer_id VARCHAR(255)); CREATE TABLE Customers (customer_id VARCHAR(255), customer_first_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 887
} |
Show the account name and other account detail for all accounts by the customer with first name Meaghan and last name Keeling. | SELECT T1.account_name, T1.other_account_details FROM Accounts AS T1 JOIN Customers AS T2 ON T1.customer_id = T2.customer_id WHERE T2.customer_first_name = 'Meaghan' AND T2.customer_last_name = 'Keeling' | CREATE TABLE Customers (customer_id VARCHAR(255), customer_first_name VARCHAR(255), customer_last_name VARCHAR(255)); CREATE TABLE Accounts (account_name VARCHAR(255), other_account_details VARCHAR(255), customer_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 2 | {
"split": "train",
"row_index": 888
} |
Show the first name and last name for the customer with account name 900. | SELECT T2.customer_first_name, T2.customer_last_name FROM Accounts AS T1 JOIN Customers AS T2 ON T1.customer_id = T2.customer_id WHERE T1.account_name = '900' | CREATE TABLE Accounts (customer_id VARCHAR(255), account_name VARCHAR(255)); CREATE TABLE Customers (customer_first_name VARCHAR(255), customer_last_name VARCHAR(255), customer_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 889
} |
Show the unique first names, last names, and phone numbers for all customers with any account. | SELECT DISTINCT T1.customer_first_name, T1.customer_last_name, T1.phone_number FROM Customers AS T1 JOIN Accounts AS T2 ON T1.customer_id = T2.customer_id | CREATE TABLE Accounts (customer_id VARCHAR(255), id INTEGER PRIMARY KEY AUTOINCREMENT); CREATE TABLE Customers (customer_first_name VARCHAR(255), customer_last_name VARCHAR(255), phone_number VARCHAR(255), customer_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 890
} |
Show customer ids who don't have an account. | SELECT customer_id FROM Customers EXCEPT SELECT customer_id FROM Accounts | CREATE TABLE Customers (customer_id VARCHAR(255), name VARCHAR(255)); CREATE TABLE Accounts (customer_id VARCHAR(255), account_type VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 891
} |
How many accounts does each customer have? List the number and customer id. | SELECT COUNT(*), customer_id FROM Accounts GROUP BY customer_id | CREATE TABLE Accounts (customer_id VARCHAR(255), account_type VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 892
} |
What is the customer id, first and last name with most number of accounts. | SELECT T1.customer_id, T2.customer_first_name, T2.customer_last_name FROM Accounts AS T1 JOIN Customers AS T2 ON T1.customer_id = T2.customer_id GROUP BY T1.customer_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Accounts (customer_id VARCHAR(255), account_status VARCHAR(255)); CREATE TABLE Customers (customer_first_name VARCHAR(255), customer_last_name VARCHAR(255), customer_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 893
} |
Show id, first name and last name for all customers and the number of accounts. | SELECT T1.customer_id, T2.customer_first_name, T2.customer_last_name, COUNT(*) FROM Accounts AS T1 JOIN Customers AS T2 ON T1.customer_id = T2.customer_id GROUP BY T1.customer_id | CREATE TABLE Accounts (customer_id VARCHAR(255), account_status VARCHAR(255)); CREATE TABLE Customers (customer_first_name VARCHAR(255), customer_last_name VARCHAR(255), customer_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 894
} |
Show first name and id for all customers with at least 2 accounts. | SELECT T2.customer_first_name, T1.customer_id FROM Accounts AS T1 JOIN Customers AS T2 ON T1.customer_id = T2.customer_id GROUP BY T1.customer_id HAVING COUNT(*) >= 2 | CREATE TABLE Customers (customer_first_name VARCHAR(255), customer_id VARCHAR(255), customer_last_name VARCHAR(255)); CREATE TABLE Accounts (customer_id VARCHAR(255), account_type VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 895
} |
Show the number of customers for each gender. | SELECT gender, COUNT(*) FROM Customers GROUP BY gender | CREATE TABLE Customers (gender VARCHAR(255), customer_id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 896
} |
How many transactions do we have? | SELECT COUNT(*) FROM Financial_transactions | CREATE TABLE Financial_transactions (Id VARCHAR(255), transaction_amount INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 897
} |
How many transaction does each account have? Show the number and account id. | SELECT COUNT(*), account_id FROM Financial_transactions | CREATE TABLE Financial_transactions (account_id VARCHAR(255), transaction_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 898
} |
How many transaction does account with name 337 have? | SELECT COUNT(*) FROM Financial_transactions AS T1 JOIN Accounts AS T2 ON T1.account_id = T2.account_id WHERE T2.account_name = '337' | CREATE TABLE Accounts (account_id VARCHAR(255), account_name VARCHAR(255)); CREATE TABLE Financial_transactions (account_id VARCHAR(255), transaction_amount INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 899
} |
What is the average, minimum, maximum, and total transaction amount? | SELECT AVG(transaction_amount), MIN(transaction_amount), MAX(transaction_amount), SUM(transaction_amount) FROM Financial_transactions | CREATE TABLE Financial_transactions (transaction_amount INTEGER, transaction_id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 2 | {
"split": "train",
"row_index": 900
} |
Show ids for all transactions whose amounts are greater than the average. | SELECT transaction_id FROM Financial_transactions WHERE transaction_amount > (SELECT AVG(transaction_amount) FROM Financial_transactions) | CREATE TABLE Financial_transactions (transaction_id VARCHAR(255), transaction_amount INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 901
} |
Show the transaction types and the total amount of transactions. | SELECT transaction_type, SUM(transaction_amount) FROM Financial_transactions GROUP BY transaction_type | CREATE TABLE Financial_transactions (transaction_type VARCHAR(255), transaction_amount INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 902
} |
Show the account name, id and the number of transactions for each account. | SELECT T2.account_name, T1.account_id, COUNT(*) FROM Financial_transactions AS T1 JOIN Accounts AS T2 ON T1.account_id = T2.account_id GROUP BY T1.account_id | CREATE TABLE Financial_transactions (account_id VARCHAR(255), transaction_id VARCHAR(255)); CREATE TABLE Accounts (account_name VARCHAR(255), account_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 903
} |
Show the account id with most number of transactions. | SELECT account_id FROM Financial_transactions GROUP BY account_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Financial_transactions (account_id VARCHAR(255), transaction_id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 904
} |
Show the account id and name with at least 4 transactions. | SELECT T1.account_id, T2.account_name FROM Financial_transactions AS T1 JOIN Accounts AS T2 ON T1.account_id = T2.account_id GROUP BY T1.account_id HAVING COUNT(*) >= 4 | CREATE TABLE Financial_transactions (account_id VARCHAR(255), transaction_amount INTEGER); CREATE TABLE Accounts (account_name VARCHAR(255), account_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 905
} |
Show all product sizes. | SELECT DISTINCT product_size FROM Products | CREATE TABLE Products (product_size VARCHAR(255), product_id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 906
} |
Show all product colors. | SELECT DISTINCT product_color FROM Products | CREATE TABLE Products (product_color 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": 907
} |
Show the invoice number and the number of transactions for each invoice. | SELECT invoice_number, COUNT(*) FROM Financial_transactions GROUP BY invoice_number | CREATE TABLE Financial_transactions (invoice_number VARCHAR(255), transaction_id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 908
} |
What is the invoice number and invoice date for the invoice with most number of transactions? | SELECT T2.invoice_number, T2.invoice_date FROM Financial_transactions AS T1 JOIN Invoices AS T2 ON T1.invoice_number = T2.invoice_number GROUP BY T1.invoice_number ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Invoices (invoice_number VARCHAR(255), invoice_date VARCHAR(255)); CREATE TABLE Financial_transactions (invoice_number VARCHAR(255), transaction_id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 909
} |
How many invoices do we have? | SELECT COUNT(*) FROM Invoices | CREATE TABLE Invoices (Id VARCHAR(255), invoice_date VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 910
} |
Show invoice dates and order id and details for all invoices. | SELECT T1.invoice_date, T1.order_id, T2.order_details FROM Invoices AS T1 JOIN Orders AS T2 ON T1.order_id = T2.order_id | CREATE TABLE Invoices (invoice_date VARCHAR(255), order_id VARCHAR(255)); CREATE TABLE Orders (order_details VARCHAR(255), order_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 911
} |
Show the order ids and the number of invoices for each order. | SELECT order_id, COUNT(*) FROM Invoices GROUP BY order_id | CREATE TABLE Invoices (order_id VARCHAR(255), invoice_number VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 912
} |
What is the order id and order details for the order more than two invoices. | SELECT T2.order_id, T2.order_details FROM Invoices AS T1 JOIN Orders AS T2 ON T1.order_id = T2.order_id GROUP BY T2.order_id HAVING COUNT(*) > 2 | CREATE TABLE Orders (order_id VARCHAR(255), order_details VARCHAR(255)); CREATE TABLE Invoices (order_id VARCHAR(255), invoice_number VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 913
} |
What is the customer last name, id and phone number with most number of orders? | SELECT T2.customer_last_name, T1.customer_id, T2.phone_number FROM Orders AS T1 JOIN Customers AS T2 ON T1.customer_id = T2.customer_id GROUP BY T1.customer_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Orders (customer_id VARCHAR(255), order_id VARCHAR(255)); CREATE TABLE Customers (customer_last_name VARCHAR(255), phone_number VARCHAR(255), customer_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 914
} |
Show all product names and the total quantity ordered for each product name. | SELECT T2.product_name, SUM(T1.product_quantity) FROM Order_items AS T1 JOIN Products AS T2 ON T1.product_id = T2.product_id GROUP BY T2.product_name | CREATE TABLE Products (product_name VARCHAR(255), product_id VARCHAR(255)); CREATE TABLE Order_items (product_quantity INTEGER, product_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 916
} |
Show the order ids and the number of items in each order. | SELECT order_id, COUNT(*) FROM Order_items GROUP BY order_id | CREATE TABLE Order_items (order_id VARCHAR(255), item_id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 917
} |
Show the product ids and the number of unique orders containing each product. | SELECT product_id, COUNT(DISTINCT order_id) FROM Order_items GROUP BY product_id | CREATE TABLE Order_items (product_id VARCHAR(255), order_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 918
} |
Show all product names and the number of customers having an order on each product. | SELECT T2.product_name, COUNT(*) FROM Order_items AS T1 JOIN Products AS T2 ON T1.product_id = T2.product_id JOIN Orders AS T3 ON T3.order_id = T1.order_id GROUP BY T2.product_name | CREATE TABLE Order_items (product_id VARCHAR(255), order_id VARCHAR(255)); CREATE TABLE Orders (order_id VARCHAR(255), order_date VARCHAR(255)); CREATE TABLE Products (product_name VARCHAR(255), product_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 919
} |
Show order ids and the number of products in each order. | SELECT order_id, COUNT(DISTINCT product_id) FROM Order_items GROUP BY order_id | CREATE TABLE Order_items (order_id VARCHAR(255), product_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 920
} |
Show order ids and the total quantity in each order. | SELECT order_id, SUM(product_quantity) FROM Order_items GROUP BY order_id | CREATE TABLE Order_items (order_id VARCHAR(255), product_quantity INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 921
} |
How many products were not included in any order? | SELECT COUNT(*) FROM products WHERE NOT product_id IN (SELECT product_id FROM Order_items) | CREATE TABLE products (product_id VARCHAR(255), product_name VARCHAR(255)); CREATE TABLE Order_items (product_id VARCHAR(255), quantity INTEGER) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 922
} |
How many churches opened before 1850 are there? | SELECT COUNT(*) FROM Church WHERE Open_Date < 1850 | CREATE TABLE Church (Open_Date INTEGER, church_id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 923
} |
Show the name, open date, and organizer for all churches. | SELECT name, open_date, organized_by FROM Church | CREATE TABLE Church (name VARCHAR(255), open_date VARCHAR(255), organized_by VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 924
} |
List all church names in descending order of opening date. | SELECT name FROM church ORDER BY open_date DESC | CREATE TABLE church (name VARCHAR(255), open_date VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 925
} |
Show the opening year in whcih at least two churches opened. | SELECT open_date FROM church GROUP BY open_date HAVING COUNT(*) >= 2 | CREATE TABLE church (open_date 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": 926
} |
Show the organizer and name for churches that opened between 1830 and 1840. | SELECT organized_by, name FROM church WHERE open_date BETWEEN 1830 AND 1840 | CREATE TABLE church (organized_by VARCHAR(255), name VARCHAR(255), open_date INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 927
} |
Show all opening years and the number of churches that opened in that year. | SELECT open_date, COUNT(*) FROM church GROUP BY open_date | CREATE TABLE church (open_date 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": 928
} |
Show the name and opening year for three churches that opened most recently. | SELECT name, open_date FROM church ORDER BY open_date DESC LIMIT 3 | CREATE TABLE church (name VARCHAR(255), open_date VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 929
} |
How many female people are older than 30 in our record? | SELECT COUNT(*) FROM people WHERE is_male = 'F' AND age > 30 | CREATE TABLE people (is_male VARCHAR(255), age VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 930
} |
Show the country where people older than 30 and younger than 25 are from. | SELECT country FROM people WHERE age < 25 INTERSECT SELECT country FROM people WHERE age > 30 | CREATE TABLE people (country VARCHAR(255), age INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 931
} |
Show the minimum, maximum, and average age for all people. | SELECT MIN(age), MAX(age), AVG(age) FROM people | CREATE TABLE people (age 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": 932
} |
Show the name and country for all people whose age is smaller than the average. | SELECT name, country FROM people WHERE age < (SELECT AVG(age) FROM people) | CREATE TABLE people (name VARCHAR(255), country VARCHAR(255), age INTEGER) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 933
} |
Show the pair of male and female names in all weddings after year 2014 | SELECT T2.name, T3.name FROM wedding AS T1 JOIN people AS T2 ON T1.male_id = T2.people_id JOIN people AS T3 ON T1.female_id = T3.people_id WHERE T1.year > 2014 | CREATE TABLE wedding (male_id VARCHAR(255), female_id VARCHAR(255), year INTEGER); CREATE TABLE people (name VARCHAR(255), people_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 934
} |
Show the name and age for all male people who don't have a wedding. | SELECT name, age FROM people WHERE is_male = 'T' AND NOT people_id IN (SELECT male_id FROM wedding) | CREATE TABLE wedding (name VARCHAR(255), age VARCHAR(255), is_male VARCHAR(255), people_id VARCHAR(255), male_id VARCHAR(255)); CREATE TABLE people (name VARCHAR(255), age VARCHAR(255), is_male VARCHAR(255), people_id VARCHAR(255), male_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 2 | {
"split": "train",
"row_index": 935
} |
Show all church names that have hosted least two weddings. | SELECT T1.name FROM church AS T1 JOIN wedding AS T2 ON T1.church_id = T2.church_id GROUP BY T1.church_id HAVING COUNT(*) >= 2 | CREATE TABLE wedding (church_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE church (name VARCHAR(255), church_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 937
} |
Show the names for all females from Canada having a wedding in year 2016. | SELECT T2.name FROM wedding AS T1 JOIN people AS T2 ON T1.female_id = T2.people_id WHERE T1.year = 2016 AND T2.is_male = 'F' AND T2.country = 'Canada' | CREATE TABLE people (name VARCHAR(255), people_id VARCHAR(255), country VARCHAR(255), is_male VARCHAR(255)); CREATE TABLE wedding (female_id VARCHAR(255), year VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 938
} |
How many weddings are there in year 2016? | SELECT COUNT(*) FROM wedding WHERE YEAR = 2016 | CREATE TABLE wedding (YEAR VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 939
} |
Show the church names for the weddings of all people older than 30. | SELECT T4.name FROM wedding AS T1 JOIN people AS T2 ON T1.male_id = T2.people_id JOIN people AS T3 ON T1.female_id = T3.people_id JOIN church AS T4 ON T4.church_id = T1.church_id WHERE T2.age > 30 OR T3.age > 30 | CREATE TABLE church (name VARCHAR(255), church_id VARCHAR(255)); CREATE TABLE people (people_id VARCHAR(255), age VARCHAR(255)); CREATE TABLE wedding (male_id VARCHAR(255), female_id VARCHAR(255), church_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 5 | 0 | 1 | {
"split": "train",
"row_index": 940
} |
Show all countries and the number of people from each country. | SELECT country, COUNT(*) FROM people GROUP BY country | CREATE TABLE people (country 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": 941
} |
How many churches have a wedding in year 2016? | SELECT COUNT(DISTINCT church_id) FROM wedding WHERE YEAR = 2016 | CREATE TABLE wedding (church_id VARCHAR(255), YEAR VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 942
} |
How many artists do we have? | SELECT COUNT(*) FROM artist | CREATE TABLE artist (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 943
} |
Show all artist name, age, and country ordered by the yeared they joined. | SELECT name, age, country FROM artist ORDER BY Year_Join | CREATE TABLE artist (name VARCHAR(255), age VARCHAR(255), country VARCHAR(255), Year_Join VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 944
} |
What are all distinct country for artists? | SELECT DISTINCT country FROM artist | CREATE TABLE artist (country 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": 945
} |
Show all artist names and the year joined who are not from United States. | SELECT name, year_join FROM artist WHERE country <> 'United States' | CREATE TABLE artist (name VARCHAR(255), year_join VARCHAR(255), country VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 946
} |
How many artists are above age 46 and joined after 1990? | SELECT COUNT(*) FROM artist WHERE age > 46 AND year_join > 1990 | CREATE TABLE artist (age VARCHAR(255), year_join VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 947
} |
What is the average and minimum age of all artists from United States. | SELECT AVG(age), MIN(age) FROM artist WHERE country = 'United States' | CREATE TABLE artist (age INTEGER, country VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 948
} |
What is the name of the artist who joined latest? | SELECT name FROM artist ORDER BY year_join DESC LIMIT 1 | CREATE TABLE artist (name VARCHAR(255), year_join VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 949
} |
How many exhibition are there in year 2005 or after? | SELECT COUNT(*) FROM exhibition WHERE YEAR >= 2005 | CREATE TABLE exhibition (YEAR VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 950
} |
Show theme and year for all exhibitions with ticket prices lower than 15. | SELECT theme, YEAR FROM exhibition WHERE ticket_price < 15 | CREATE TABLE exhibition (theme VARCHAR(255), YEAR VARCHAR(255), ticket_price INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 951
} |
Show all artist names and the number of exhibitions for each artist. | SELECT T2.name, COUNT(*) FROM exhibition AS T1 JOIN artist AS T2 ON T1.artist_id = T2.artist_id GROUP BY T1.artist_id | CREATE TABLE artist (name VARCHAR(255), artist_id VARCHAR(255)); CREATE TABLE exhibition (artist_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": 952
} |
What is the name and country for the artist with most number of exhibitions? | SELECT T2.name, T2.country FROM exhibition AS T1 JOIN artist AS T2 ON T1.artist_id = T2.artist_id GROUP BY T1.artist_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE exhibition (artist_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE artist (name VARCHAR(255), country VARCHAR(255), artist_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 953
} |
Show names for artists without any exhibition. | SELECT name FROM artist WHERE NOT artist_id IN (SELECT artist_id FROM exhibition) | CREATE TABLE artist (name VARCHAR(255), artist_id VARCHAR(255)); CREATE TABLE exhibition (name VARCHAR(255), artist_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 954
} |
Show theme and year for all exhibitions in an descending order of ticket price. | SELECT theme, YEAR FROM exhibition ORDER BY ticket_price DESC | CREATE TABLE exhibition (theme VARCHAR(255), YEAR VARCHAR(255), ticket_price VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 957
} |
What is the theme, date, and attendance for the exhibition in year 2004? | SELECT T2.theme, T1.date, T1.attendance FROM exhibition_record AS T1 JOIN exhibition AS T2 ON T1.exhibition_id = T2.exhibition_id WHERE T2.year = 2004 | CREATE TABLE exhibition_record (date VARCHAR(255), attendance VARCHAR(255), exhibition_id VARCHAR(255)); CREATE TABLE exhibition (theme VARCHAR(255), exhibition_id VARCHAR(255), year VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 958
} |
Show the theme for exhibitions with both records of an attendance below 100 and above 500. | SELECT T2.theme FROM exhibition_record AS T1 JOIN exhibition AS T2 ON T1.exhibition_id = T2.exhibition_id WHERE T1.attendance < 100 INTERSECT SELECT T2.theme FROM exhibition_record AS T1 JOIN exhibition AS T2 ON T1.exhibition_id = T2.exhibition_id WHERE T1.attendance > 500 | CREATE TABLE exhibition (theme VARCHAR(255), exhibition_id VARCHAR(255)); CREATE TABLE exhibition_record (exhibition_id VARCHAR(255), attendance INTEGER) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 960
} |
How many exhibitions have a attendance more than 100 or have a ticket price below 10? | SELECT COUNT(*) FROM exhibition_record AS T1 JOIN exhibition AS T2 ON T1.exhibition_id = T2.exhibition_id WHERE T1.attendance > 100 OR T2.ticket_price < 10 | CREATE TABLE exhibition_record (exhibition_id VARCHAR(255), attendance VARCHAR(255)); CREATE TABLE exhibition (exhibition_id VARCHAR(255), ticket_price VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 961
} |
Show all artist names with an average exhibition attendance over 200. | SELECT T3.name FROM exhibition_record AS T1 JOIN exhibition AS T2 ON T1.exhibition_id = T2.exhibition_id JOIN artist AS T3 ON T3.artist_id = T2.artist_id GROUP BY T3.artist_id HAVING AVG(T1.attendance) > 200 | CREATE TABLE artist (name VARCHAR(255), artist_id VARCHAR(255)); CREATE TABLE exhibition (exhibition_id VARCHAR(255), artist_id VARCHAR(255)); CREATE TABLE exhibition_record (exhibition_id VARCHAR(255), attendance INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 962
} |
Find the id of the item whose title is "orange". | SELECT i_id FROM item WHERE title = 'orange' | CREATE TABLE item (i_id VARCHAR(255), title VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 963
} |
Find the number of reviews. | SELECT COUNT(*) FROM review | CREATE TABLE review (Id VARCHAR(255), review_text VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 965
} |
How many users are there? | SELECT COUNT(*) FROM useracct | CREATE TABLE useracct (Id VARCHAR(255), username VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 966
} |
Find the average and maximum rating of all reviews. | SELECT AVG(rating), MAX(rating) FROM review | CREATE TABLE review (rating 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": 967
} |
Find the highest rank of all reviews. | SELECT MIN(rank) FROM review | CREATE TABLE review (rank 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": 968
} |
How many different users wrote some reviews? | SELECT COUNT(DISTINCT u_id) FROM review | CREATE TABLE review (u_id VARCHAR(255), rating INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 969
} |
How many different items were reviewed by some users? | SELECT COUNT(DISTINCT i_id) FROM review | CREATE TABLE review (i_id VARCHAR(255), rating INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 970
} |
Find the number of items that did not receive any review. | SELECT COUNT(*) FROM item WHERE NOT i_id IN (SELECT i_id FROM review) | CREATE TABLE review (i_id VARCHAR(255), rating INTEGER); CREATE TABLE item (i_id VARCHAR(255), title VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 971
} |
Find the names of users who did not leave any review. | SELECT name FROM useracct WHERE NOT u_id IN (SELECT u_id FROM review) | CREATE TABLE review (name VARCHAR(255), u_id VARCHAR(255)); CREATE TABLE useracct (name VARCHAR(255), u_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 972
} |
Find the names of goods that receive a rating of 10. | SELECT T1.title FROM item AS T1 JOIN review AS T2 ON T1.i_id = T2.i_id WHERE T2.rating = 10 | CREATE TABLE item (title VARCHAR(255), i_id VARCHAR(255)); CREATE TABLE review (i_id VARCHAR(255), rating VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 973
} |
Find the titles of items that received any rating below 5. | SELECT T1.title FROM item AS T1 JOIN review AS T2 ON T1.i_id = T2.i_id WHERE T2.rating < 5 | CREATE TABLE item (title VARCHAR(255), i_id VARCHAR(255)); CREATE TABLE review (i_id VARCHAR(255), rating INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 975
} |
Find the titles of items that received both a rating higher than 8 and a rating below 5. | SELECT T1.title FROM item AS T1 JOIN review AS T2 ON T1.i_id = T2.i_id WHERE T2.rating > 8 INTERSECT SELECT T1.title FROM item AS T1 JOIN review AS T2 ON T1.i_id = T2.i_id WHERE T2.rating < 5 | CREATE TABLE item (title VARCHAR(255), i_id VARCHAR(255)); CREATE TABLE review (i_id VARCHAR(255), rating INTEGER) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 976
} |
Find the names of items whose rank is higher than 3 and whose average rating is above 5. | SELECT T1.title FROM item AS T1 JOIN review AS T2 ON T1.i_id = T2.i_id WHERE T2.rank > 3 INTERSECT SELECT T1.title FROM item AS T1 JOIN review AS T2 ON T1.i_id = T2.i_id GROUP BY T2.i_id HAVING AVG(T2.rating) > 5 | CREATE TABLE item (title VARCHAR(255), i_id VARCHAR(255)); CREATE TABLE review (i_id VARCHAR(255), rank INTEGER, rating INTEGER) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 977
} |
Find the name of the item with the lowest average rating. | SELECT T1.title FROM item AS T1 JOIN review AS T2 ON T1.i_id = T2.i_id GROUP BY T2.i_id ORDER BY AVG(T2.rating) LIMIT 1 | CREATE TABLE item (title VARCHAR(255), i_id VARCHAR(255)); CREATE TABLE review (i_id VARCHAR(255), rating INTEGER) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 978
} |
List the titles of all items in alphabetic order . | SELECT title FROM item ORDER BY title | CREATE TABLE item (title 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": 979
} |
Find the name of the user who gives the most reviews. | SELECT T1.name FROM useracct AS T1 JOIN review AS T2 ON T1.u_id = T2.u_id GROUP BY T2.u_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE useracct (name VARCHAR(255), u_id VARCHAR(255)); CREATE TABLE review (u_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 980
} |
Find the name and id of the item with the highest average rating. | SELECT T1.title, T1.i_id FROM item AS T1 JOIN review AS T2 ON T1.i_id = T2.i_id GROUP BY T2.i_id ORDER BY AVG(T2.rating) DESC LIMIT 1 | CREATE TABLE item (title VARCHAR(255), i_id VARCHAR(255)); CREATE TABLE review (i_id VARCHAR(255), rating INTEGER) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 981
} |
Find the name and id of the good with the highest average rank. | SELECT T1.title, T1.i_id FROM item AS T1 JOIN review AS T2 ON T1.i_id = T2.i_id GROUP BY T2.i_id ORDER BY AVG(T2.rank) DESC LIMIT 1 | CREATE TABLE review (i_id VARCHAR(255), rank INTEGER); CREATE TABLE item (title VARCHAR(255), i_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 982
} |
For each user, return the name and the average rating of reviews given by them. | SELECT T1.name, AVG(T2.rating) FROM useracct AS T1 JOIN review AS T2 ON T1.u_id = T2.u_id GROUP BY T2.u_id | CREATE TABLE review (rating INTEGER, u_id VARCHAR(255)); CREATE TABLE useracct (name VARCHAR(255), u_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 983
} |
For each user, find their name and the number of reviews written by them. | SELECT T1.name, COUNT(*) FROM useracct AS T1 JOIN review AS T2 ON T1.u_id = T2.u_id GROUP BY T2.u_id | CREATE TABLE useracct (name VARCHAR(255), u_id VARCHAR(255)); CREATE TABLE review (u_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 984
} |
Find the name of the user who gave the highest rating. | SELECT T1.name FROM useracct AS T1 JOIN review AS T2 ON T1.u_id = T2.u_id ORDER BY T2.rating DESC LIMIT 1 | CREATE TABLE review (u_id VARCHAR(255), rating VARCHAR(255)); CREATE TABLE useracct (name VARCHAR(255), u_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 985
} |
Find the names of the items that did not receive any review. | SELECT title FROM item WHERE NOT i_id IN (SELECT i_id FROM review) | CREATE TABLE item (title VARCHAR(255), i_id VARCHAR(255)); CREATE TABLE review (title VARCHAR(255), i_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 989
} |
Find the number of users who did not write any review. | SELECT COUNT(*) FROM useracct WHERE NOT u_id IN (SELECT u_id FROM review) | CREATE TABLE review (u_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE useracct (u_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": 990
} |
How many players are there? | SELECT COUNT(*) FROM player | CREATE TABLE player (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 991
} |
List the names of players in ascending order of votes. | SELECT Player_name FROM player ORDER BY Votes | CREATE TABLE player (Player_name VARCHAR(255), Votes VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 992
} |
What are the gender and occupation of players? | SELECT Gender, Occupation FROM player | CREATE TABLE player (Gender VARCHAR(255), Occupation VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 993
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.