question string | answer string | context string | dialect string | spider_hardness string | extended_hardness string | classification_status string | syntax_status string | ddl_syntax_status string | schema_status string | syntax_errors list | ddl_syntax_errors list | schema_errors list | classification_errors list | status_history list | correction_status string | component1 int64 | component2 int64 | others int64 | validation_source dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
List the name and residence for players whose occupation is not "Researcher". | SELECT Player_name, residence FROM player WHERE Occupation <> 'Researcher' | CREATE TABLE player (Player_name VARCHAR(255), residence VARCHAR(255), Occupation VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 994
} |
Show the names of sponsors of players whose residence is either "Brandon" or "Birtle". | SELECT Sponsor_name FROM player WHERE Residence = 'Brandon' OR Residence = 'Birtle' | CREATE TABLE player (Sponsor_name VARCHAR(255), Residence VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 995
} |
What is the name of the player with the largest number of votes? | SELECT Player_name FROM player ORDER BY Votes DESC LIMIT 1 | CREATE TABLE player (Player_name VARCHAR(255), Votes VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 996
} |
Show different occupations along with the number of players in each occupation. | SELECT Occupation, COUNT(*) FROM player GROUP BY Occupation | CREATE TABLE player (Occupation 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": 997
} |
Please show the most common occupation of players. | SELECT Occupation FROM player GROUP BY Occupation ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE player (Occupation 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": 998
} |
Show the residences that have at least two players. | SELECT Residence FROM player GROUP BY Residence HAVING COUNT(*) >= 2 | CREATE TABLE player (Residence 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": 999
} |
Show the names of players and names of their coaches. | SELECT T3.Player_name, T2.coach_name FROM player_coach AS T1 JOIN coach AS T2 ON T1.Coach_ID = T2.Coach_ID JOIN player AS T3 ON T1.Player_ID = T3.Player_ID | CREATE TABLE player (Player_name VARCHAR(255), Player_ID VARCHAR(255)); CREATE TABLE coach (coach_name VARCHAR(255), Coach_ID VARCHAR(255)); CREATE TABLE player_coach (Coach_ID VARCHAR(255), Player_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1000
} |
Show the names of players coached by the rank 1 coach. | SELECT T3.Player_name FROM player_coach AS T1 JOIN coach AS T2 ON T1.Coach_ID = T2.Coach_ID JOIN player AS T3 ON T1.Player_ID = T3.Player_ID WHERE T2.Rank = 1 | CREATE TABLE player (Player_name VARCHAR(255), Player_ID VARCHAR(255)); CREATE TABLE coach (Coach_ID VARCHAR(255), Rank VARCHAR(255)); CREATE TABLE player_coach (Coach_ID VARCHAR(255), Player_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 1001
} |
Show the names and genders of players with a coach starting after 2011. | SELECT T3.Player_name, T3.gender FROM player_coach AS T1 JOIN coach AS T2 ON T1.Coach_ID = T2.Coach_ID JOIN player AS T3 ON T1.Player_ID = T3.Player_ID WHERE T1.Starting_year > 2011 | CREATE TABLE player (Player_name VARCHAR(255), gender VARCHAR(255), Player_ID VARCHAR(255)); CREATE TABLE player_coach (Coach_ID VARCHAR(255), Player_ID VARCHAR(255), Starting_year INTEGER); CREATE TABLE coach (Coach_ID VARCHAR(255), coach_name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 1002
} |
Show the names of players and names of their coaches in descending order of the votes of players. | SELECT T3.Player_name, T2.coach_name FROM player_coach AS T1 JOIN coach AS T2 ON T1.Coach_ID = T2.Coach_ID JOIN player AS T3 ON T1.Player_ID = T3.Player_ID ORDER BY T3.Votes DESC | CREATE TABLE coach (coach_name VARCHAR(255), Coach_ID VARCHAR(255)); CREATE TABLE player_coach (Coach_ID VARCHAR(255), Player_ID VARCHAR(255)); CREATE TABLE player (Player_name VARCHAR(255), Player_ID VARCHAR(255), Votes VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 1003
} |
List the names of players that do not have coaches. | SELECT Player_name FROM player WHERE NOT Player_ID IN (SELECT Player_ID FROM player_coach) | CREATE TABLE player (Player_name VARCHAR(255), Player_ID VARCHAR(255)); CREATE TABLE player_coach (Player_name VARCHAR(255), Player_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 1004
} |
Show the residences that have both a player of gender "M" and a player of gender "F". | SELECT Residence FROM player WHERE gender = 'M' INTERSECT SELECT Residence FROM player WHERE gender = 'F' | CREATE TABLE player (Residence VARCHAR(255), gender VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 1005
} |
How many coaches does each club has? List the club id, name and the number of coaches. | SELECT T1.club_id, T1.club_name, COUNT(*) FROM club AS T1 JOIN coach AS T2 ON T1.club_id = T2.club_id GROUP BY T1.club_id | CREATE TABLE club (club_id VARCHAR(255), club_name VARCHAR(255)); CREATE TABLE coach (club_id VARCHAR(255), coach_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1006
} |
How many gold medals has the club with the most coaches won? | SELECT T1.club_id, T1.gold FROM match_result AS T1 JOIN coach AS T2 ON T1.club_id = T2.club_id GROUP BY T1.club_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE match_result (club_id VARCHAR(255), gold VARCHAR(255)); CREATE TABLE coach (club_id VARCHAR(255), coach_name VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 1007
} |
How many gymnasts are there? | SELECT COUNT(*) FROM gymnast | CREATE TABLE gymnast (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 1008
} |
List the total points of gymnasts in descending order. | SELECT Total_Points FROM gymnast ORDER BY Total_Points DESC | CREATE TABLE gymnast (Total_Points VARCHAR(255), gymnast_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1009
} |
List the total points of gymnasts in descending order of floor exercise points. | SELECT Total_Points FROM gymnast ORDER BY Floor_Exercise_Points DESC | CREATE TABLE gymnast (Total_Points VARCHAR(255), Floor_Exercise_Points VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1010
} |
What is the average horizontal bar points for all gymnasts? | SELECT AVG(Horizontal_Bar_Points) FROM gymnast | CREATE TABLE gymnast (Horizontal_Bar_Points 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": 1011
} |
What are the names of people in ascending alphabetical order? | SELECT Name FROM People ORDER BY Name | CREATE TABLE People (Name VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1012
} |
What are the names of gymnasts? | SELECT T2.Name FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID | CREATE TABLE gymnast (Gymnast_ID VARCHAR(255), Name VARCHAR(255)); CREATE TABLE people (Name VARCHAR(255), People_ID VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1013
} |
What are the names of gymnasts whose hometown is not "Santo Domingo"? | SELECT T2.Name FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID WHERE T2.Hometown <> 'Santo Domingo' | CREATE TABLE gymnast (Gymnast_ID VARCHAR(255), Name VARCHAR(255)); CREATE TABLE people (Name VARCHAR(255), People_ID VARCHAR(255), Hometown VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1014
} |
What is the age of the tallest person? | SELECT Age FROM people ORDER BY Height DESC LIMIT 1 | CREATE TABLE people (Age VARCHAR(255), Height VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1015
} |
List the names of the top 5 oldest people. | SELECT Name FROM People ORDER BY Age DESC LIMIT 5 | CREATE TABLE People (Name VARCHAR(255), Age VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1016
} |
What is the total point count of the youngest gymnast? | SELECT T1.Total_Points FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID ORDER BY T2.Age LIMIT 1 | CREATE TABLE people (People_ID VARCHAR(255), Age VARCHAR(255)); CREATE TABLE gymnast (Total_Points VARCHAR(255), Gymnast_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 1017
} |
What is the average age of all gymnasts? | SELECT AVG(T2.Age) FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID | CREATE TABLE people (Age INTEGER, People_ID VARCHAR(255)); CREATE TABLE gymnast (Gymnast_ID VARCHAR(255), Name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1018
} |
What are the distinct hometowns of gymnasts with total points more than 57.5? | SELECT DISTINCT T2.Hometown FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID WHERE T1.Total_Points > 57.5 | CREATE TABLE gymnast (Gymnast_ID VARCHAR(255), Total_Points INTEGER); CREATE TABLE people (Hometown VARCHAR(255), People_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1019
} |
What are the hometowns of gymnasts and the corresponding number of gymnasts? | SELECT T2.Hometown, COUNT(*) FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID GROUP BY T2.Hometown | CREATE TABLE gymnast (Gymnast_ID VARCHAR(255), Name VARCHAR(255)); CREATE TABLE people (Hometown VARCHAR(255), People_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1020
} |
What is the most common hometown of gymnasts? | SELECT T2.Hometown FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID GROUP BY T2.Hometown ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE gymnast (Gymnast_ID VARCHAR(255), Name VARCHAR(255)); CREATE TABLE people (Hometown VARCHAR(255), People_ID VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 1021
} |
What are the hometowns that are shared by at least two gymnasts? | SELECT T2.Hometown FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID GROUP BY T2.Hometown HAVING COUNT(*) >= 2 | CREATE TABLE gymnast (Gymnast_ID VARCHAR(255), Name VARCHAR(255)); CREATE TABLE people (Hometown VARCHAR(255), People_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1022
} |
List the names of gymnasts in ascending order by their heights. | SELECT T2.Name FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID ORDER BY T2.Height | CREATE TABLE gymnast (Gymnast_ID VARCHAR(255), Name VARCHAR(255)); CREATE TABLE people (Name VARCHAR(255), People_ID VARCHAR(255), Height VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1023
} |
Show the hometowns shared by people older than 23 and younger than 20. | SELECT Hometown FROM people WHERE Age > 23 INTERSECT SELECT Hometown FROM people WHERE Age < 20 | CREATE TABLE people (Hometown VARCHAR(255), Age INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 1025
} |
How many distinct hometowns did these people have? | SELECT COUNT(DISTINCT Hometown) FROM people | CREATE TABLE people (Hometown 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": 1026
} |
Show the ages of gymnasts in descending order of total points. | SELECT T2.Age FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID ORDER BY T1.Total_Points DESC | CREATE TABLE people (Age VARCHAR(255), People_ID VARCHAR(255)); CREATE TABLE gymnast (Gymnast_ID VARCHAR(255), Total_Points VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1027
} |
Find the total savings balance of all accounts except the account with name ‘Brown’. | SELECT SUM(T2.balance) FROM accounts AS T1 JOIN savings AS T2 ON T1.custid = T2.custid WHERE T1.name <> 'Brown' | CREATE TABLE accounts (custid VARCHAR(255), name VARCHAR(255)); CREATE TABLE savings (balance INTEGER, custid VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1028
} |
How many accounts are there in total? | SELECT COUNT(*) FROM accounts | CREATE TABLE accounts (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 1029
} |
What is the total checking balance in all accounts? | SELECT SUM(balance) FROM checking | CREATE TABLE checking (balance 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": 1030
} |
Find the average checking balance. | SELECT AVG(balance) FROM checking | CREATE TABLE checking (balance 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": 1031
} |
How many accounts have a savings balance above the average savings balance? | SELECT COUNT(*) FROM savings WHERE balance > (SELECT AVG(balance) FROM savings) | CREATE TABLE savings (balance 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": 1032
} |
What is the checking balance of the account whose owner’s name contains the substring ‘ee’? | SELECT T2.balance FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid WHERE T1.name LIKE '%ee%' | CREATE TABLE checking (balance VARCHAR(255), custid VARCHAR(255)); CREATE TABLE accounts (custid VARCHAR(255), name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 1034
} |
Find the checking balance and saving balance in the Brown’s account. | SELECT T2.balance, T3.balance FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid JOIN savings AS T3 ON T1.custid = T3.custid WHERE T1.name = 'Brown' | CREATE TABLE checking (balance VARCHAR(255), custid VARCHAR(255)); CREATE TABLE accounts (custid VARCHAR(255), name VARCHAR(255)); CREATE TABLE savings (balance VARCHAR(255), custid VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 1035
} |
List all customers’ names in the alphabetical order. | SELECT name FROM accounts ORDER BY name | CREATE TABLE accounts (name VARCHAR(255), custid VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1038
} |
Find the name of account that has the lowest total checking and saving balance. | SELECT T1.name FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid JOIN savings AS T3 ON T1.custid = T3.custid ORDER BY T2.balance + T3.balance LIMIT 1 | CREATE TABLE checking (custid VARCHAR(255), balance VARCHAR(255)); CREATE TABLE savings (custid VARCHAR(255), balance VARCHAR(255)); CREATE TABLE accounts (name VARCHAR(255), custid VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 1039
} |
Find the name and checking balance of the account with the lowest savings balance. | SELECT T1.name, T2.balance FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid JOIN savings AS T3 ON T1.custid = T3.custid ORDER BY T3.balance LIMIT 1 | CREATE TABLE checking (balance VARCHAR(255), custid VARCHAR(255)); CREATE TABLE savings (custid VARCHAR(255), balance VARCHAR(255)); CREATE TABLE accounts (name VARCHAR(255), custid VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 1041
} |
Find the number of checking accounts for each account name. | SELECT COUNT(*), T1.name FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid GROUP BY T1.name | CREATE TABLE checking (custid VARCHAR(255), balance VARCHAR(255)); CREATE TABLE accounts (name VARCHAR(255), custid VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1042
} |
Find the total saving balance for each account name. | SELECT SUM(T2.balance), T1.name FROM accounts AS T1 JOIN savings AS T2 ON T1.custid = T2.custid GROUP BY T1.name | CREATE TABLE savings (balance INTEGER, custid VARCHAR(255)); CREATE TABLE accounts (name VARCHAR(255), custid VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1043
} |
Find the saving balance of the account with the highest checking balance. | SELECT T3.balance FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid JOIN savings AS T3 ON T1.custid = T3.custid ORDER BY T2.balance DESC LIMIT 1 | CREATE TABLE savings (balance VARCHAR(255), custid VARCHAR(255)); CREATE TABLE checking (custid VARCHAR(255), balance VARCHAR(255)); CREATE TABLE accounts (custid VARCHAR(255), name VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 1045
} |
Find the total checking and saving balance of all accounts sorted by the total balance in ascending order. | SELECT T1.balance + T2.balance FROM checking AS T1 JOIN savings AS T2 ON T1.custid = T2.custid ORDER BY T1.balance + T2.balance | CREATE TABLE checking (balance VARCHAR(255), custid VARCHAR(255)); CREATE TABLE savings (balance VARCHAR(255), custid VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1046
} |
Find the name and checking balance of the account with the lowest saving balance. | SELECT T2.balance, T1.name FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid JOIN savings AS T3 ON T1.custid = T3.custid ORDER BY T3.balance LIMIT 1 | CREATE TABLE checking (balance VARCHAR(255), custid VARCHAR(255)); CREATE TABLE savings (custid VARCHAR(255), balance VARCHAR(255)); CREATE TABLE accounts (name VARCHAR(255), custid VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 1047
} |
Find the name, checking balance and saving balance of all accounts in the bank. | SELECT T2.balance, T3.balance, T1.name FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid JOIN savings AS T3 ON T1.custid = T3.custid | CREATE TABLE checking (balance VARCHAR(255), custid VARCHAR(255)); CREATE TABLE savings (balance VARCHAR(255), custid VARCHAR(255)); CREATE TABLE accounts (name VARCHAR(255), custid VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1048
} |
Find the name, checking balance and savings balance of all accounts in the bank sorted by their total checking and savings balance in descending order. | SELECT T2.balance, T3.balance, T1.name FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid JOIN savings AS T3 ON T1.custid = T3.custid ORDER BY T2.balance + T3.balance DESC | CREATE TABLE checking (balance VARCHAR(255), custid VARCHAR(255)); CREATE TABLE savings (balance VARCHAR(255), custid VARCHAR(255)); CREATE TABLE accounts (name VARCHAR(255), custid VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 1049
} |
Find the name of accounts whose checking balance is higher than corresponding saving balance. | SELECT T1.name FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid JOIN savings AS T3 ON T1.custid = T3.custid WHERE T2.balance > T3.balance | CREATE TABLE savings (custid VARCHAR(255), balance INTEGER); CREATE TABLE accounts (name VARCHAR(255), custid VARCHAR(255)); CREATE TABLE checking (custid VARCHAR(255), balance INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 1050
} |
Find the name and total checking and savings balance of the accounts whose savings balance is lower than corresponding checking balance. | SELECT T1.name, T3.balance + T2.balance FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid JOIN savings AS T3 ON T1.custid = T3.custid WHERE T3.balance < T2.balance | CREATE TABLE checking (balance INTEGER, custid VARCHAR(255)); CREATE TABLE savings (balance INTEGER, custid VARCHAR(255)); CREATE TABLE accounts (name VARCHAR(255), custid VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 1051
} |
Find the name and savings balance of the top 3 accounts with the highest saving balance sorted by savings balance in descending order. | SELECT T1.name, T2.balance FROM accounts AS T1 JOIN savings AS T2 ON T1.custid = T2.custid ORDER BY T2.balance DESC LIMIT 3 | CREATE TABLE savings (balance VARCHAR(255), custid VARCHAR(255)); CREATE TABLE accounts (name VARCHAR(255), custid VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 1052
} |
How many main stream browsers whose market share is at least 5 exist? | SELECT COUNT(*) FROM browser WHERE market_share >= 5 | CREATE TABLE browser (market_share 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": 1053
} |
List the name of browsers in descending order by market share. | SELECT name FROM browser ORDER BY market_share DESC | CREATE TABLE browser (name VARCHAR(255), market_share VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1054
} |
List the ids, names and market shares of all browsers. | SELECT id, name, market_share FROM browser | CREATE TABLE browser (id VARCHAR(255), name VARCHAR(255), market_share VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 1055
} |
What is the maximum, minimum and average market share of the listed browsers? | SELECT MAX(market_share), MIN(market_share), AVG(market_share) FROM browser | CREATE TABLE browser (market_share 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": 1056
} |
What is the id and market share of the browser Safari? | SELECT id, market_share FROM browser WHERE name = 'Safari' | CREATE TABLE browser (id VARCHAR(255), market_share VARCHAR(255), name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1057
} |
What are the name and os of web client accelerators that do not work with only a 'Broadband' type connection? | SELECT name, operating_system FROM web_client_accelerator WHERE CONNECTION <> 'Broadband' | CREATE TABLE web_client_accelerator (name VARCHAR(255), operating_system VARCHAR(255), CONNECTION VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1058
} |
What is the name of the browser that became compatible with the accelerator 'CProxy' after year 1998 ? | SELECT T1.name FROM browser AS T1 JOIN accelerator_compatible_browser AS T2 ON T1.id = T2.browser_id JOIN web_client_accelerator AS T3 ON T2.accelerator_id = T3.id WHERE T3.name = 'CProxy' AND T2.compatible_since_year > 1998 | CREATE TABLE accelerator_compatible_browser (browser_id VARCHAR(255), accelerator_id VARCHAR(255), compatible_since_year VARCHAR(255)); CREATE TABLE web_client_accelerator (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE browser (name VARCHAR(255), id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 1059
} |
What are the ids and names of the web accelerators that are compatible with two or more browsers? | SELECT T1.id, T1.Name FROM web_client_accelerator AS T1 JOIN accelerator_compatible_browser AS T2 ON T2.accelerator_id = T1.id GROUP BY T1.id HAVING COUNT(*) >= 2 | CREATE TABLE accelerator_compatible_browser (accelerator_id VARCHAR(255), browser_id VARCHAR(255)); CREATE TABLE web_client_accelerator (id VARCHAR(255), Name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1060
} |
What is the id and name of the browser that is compatible with the most web accelerators? | SELECT T1.id, T1.name FROM browser AS T1 JOIN accelerator_compatible_browser AS T2 ON T1.id = T2.browser_id GROUP BY T1.id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE browser (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE accelerator_compatible_browser (browser_id VARCHAR(255), accelerator_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 1061
} |
When did the web accelerator 'CACHEbox' and browser 'Internet Explorer' become compatible? | SELECT T1.compatible_since_year FROM accelerator_compatible_browser AS T1 JOIN browser AS T2 ON T1.browser_id = T2.id JOIN web_client_accelerator AS T3 ON T1.accelerator_id = T3.id WHERE T3.name = 'CACHEbox' AND T2.name = 'Internet Explorer' | CREATE TABLE accelerator_compatible_browser (compatible_since_year VARCHAR(255), browser_id VARCHAR(255), accelerator_id VARCHAR(255)); CREATE TABLE browser (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE web_client_accelerator (id VARCHAR(255), name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 1062
} |
How many different kinds of clients are supported by the web clients accelerators? | SELECT COUNT(DISTINCT client) FROM web_client_accelerator | CREATE TABLE web_client_accelerator (client 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": 1063
} |
How many accelerators are not compatible with the browsers listed ? | SELECT COUNT(*) FROM web_client_accelerator WHERE NOT id IN (SELECT accelerator_id FROM accelerator_compatible_browser) | CREATE TABLE accelerator_compatible_browser (id VARCHAR(255), accelerator_id VARCHAR(255)); CREATE TABLE web_client_accelerator (id VARCHAR(255), accelerator_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 1064
} |
What distinct accelerator names are compatible with the browswers that have market share higher than 15? | SELECT DISTINCT T1.name FROM web_client_accelerator AS T1 JOIN accelerator_compatible_browser AS T2 ON T2.accelerator_id = T1.id JOIN browser AS T3 ON T2.browser_id = T3.id WHERE T3.market_share > 15 | CREATE TABLE web_client_accelerator (name VARCHAR(255), id VARCHAR(255)); CREATE TABLE accelerator_compatible_browser (accelerator_id VARCHAR(255), browser_id VARCHAR(255)); CREATE TABLE browser (id VARCHAR(255), market_share INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 1065
} |
List the names of the browser that are compatible with both 'CACHEbox' and 'Fasterfox'. | SELECT T3.name FROM web_client_accelerator AS T1 JOIN accelerator_compatible_browser AS T2 ON T2.accelerator_id = T1.id JOIN browser AS T3 ON T2.browser_id = T3.id WHERE T1.name = 'CACHEbox' INTERSECT SELECT T3.name FROM web_client_accelerator AS T1 JOIN accelerator_compatible_browser AS T2 ON T2.accelerator_id = T1.id... | CREATE TABLE accelerator_compatible_browser (accelerator_id VARCHAR(255), browser_id VARCHAR(255)); CREATE TABLE web_client_accelerator (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE browser (name VARCHAR(255), id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 1 | 0 | {
"split": "train",
"row_index": 1066
} |
Which accelerator name contains substring "Opera"? | SELECT name FROM web_client_accelerator WHERE name LIKE '%Opera%' | CREATE TABLE web_client_accelerator (name VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1068
} |
Find the number of web accelerators used for each Operating system. | SELECT Operating_system, COUNT(*) FROM web_client_accelerator GROUP BY Operating_system | CREATE TABLE web_client_accelerator (Operating_system 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": 1069
} |
give me names of all compatible browsers and accelerators in the descending order of compatible year | SELECT T2.name, T3.name FROM accelerator_compatible_browser AS T1 JOIN browser AS T2 ON T1.browser_id = T2.id JOIN web_client_accelerator AS T3 ON T1.accelerator_id = T3.id ORDER BY T1.compatible_since_year DESC | CREATE TABLE accelerator_compatible_browser (browser_id VARCHAR(255), accelerator_id VARCHAR(255), compatible_since_year VARCHAR(255)); CREATE TABLE web_client_accelerator (name VARCHAR(255), id VARCHAR(255)); CREATE TABLE browser (name VARCHAR(255), id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 1070
} |
How many wrestlers are there? | SELECT COUNT(*) FROM wrestler | CREATE TABLE wrestler (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 1071
} |
List the names of wrestlers in descending order of days held. | SELECT Name FROM wrestler ORDER BY Days_held DESC | CREATE TABLE wrestler (Name VARCHAR(255), Days_held VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1072
} |
What is the name of the wrestler with the fewest days held? | SELECT Name FROM wrestler ORDER BY Days_held LIMIT 1 | CREATE TABLE wrestler (Name VARCHAR(255), Days_held VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1073
} |
What are the distinct reigns of wrestlers whose location is not "Tokyo,Japan" ? | SELECT DISTINCT Reign FROM wrestler WHERE LOCATION <> 'Tokyo , Japan' | CREATE TABLE wrestler (Reign VARCHAR(255), LOCATION VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1074
} |
What are the names and location of the wrestlers? | SELECT Name, LOCATION FROM wrestler | CREATE TABLE wrestler (Name VARCHAR(255), LOCATION VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 1075
} |
What are the elimination moves of wrestlers whose team is "Team Orton"? | SELECT Elimination_Move FROM Elimination WHERE Team = 'Team Orton' | CREATE TABLE Elimination (Elimination_Move VARCHAR(255), Team VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1076
} |
What are the names of wrestlers and the elimination moves? | SELECT T2.Name, T1.Elimination_Move FROM elimination AS T1 JOIN wrestler AS T2 ON T1.Wrestler_ID = T2.Wrestler_ID | CREATE TABLE wrestler (Name VARCHAR(255), Wrestler_ID VARCHAR(255)); CREATE TABLE elimination (Elimination_Move VARCHAR(255), Wrestler_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1077
} |
List the names of wrestlers and the teams in elimination in descending order of days held. | SELECT T2.Name, T1.Team FROM elimination AS T1 JOIN wrestler AS T2 ON T1.Wrestler_ID = T2.Wrestler_ID ORDER BY T2.Days_held DESC | CREATE TABLE elimination (Team VARCHAR(255), Wrestler_ID VARCHAR(255)); CREATE TABLE wrestler (Name VARCHAR(255), Wrestler_ID VARCHAR(255), Days_held VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1078
} |
List the time of elimination of the wrestlers with largest days held. | SELECT T1.Time FROM elimination AS T1 JOIN wrestler AS T2 ON T1.Wrestler_ID = T2.Wrestler_ID ORDER BY T2.Days_held DESC LIMIT 1 | CREATE TABLE wrestler (Wrestler_ID VARCHAR(255), Days_held VARCHAR(255)); CREATE TABLE elimination (Time VARCHAR(255), Wrestler_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 1079
} |
Show times of elimination of wrestlers with days held more than 50. | SELECT T1.Time FROM elimination AS T1 JOIN wrestler AS T2 ON T1.Wrestler_ID = T2.Wrestler_ID WHERE T2.Days_held > 50 | CREATE TABLE wrestler (Wrestler_ID VARCHAR(255), Days_held INTEGER); CREATE TABLE elimination (Time VARCHAR(255), Wrestler_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1080
} |
Show different teams in eliminations and the number of eliminations from each team. | SELECT Team, COUNT(*) FROM elimination GROUP BY Team | CREATE TABLE elimination (Team 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": 1081
} |
Show teams that have suffered more than three eliminations. | SELECT Team FROM elimination GROUP BY Team HAVING COUNT(*) > 3 | CREATE TABLE elimination (Team 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": 1082
} |
Show the reign and days held of wrestlers. | SELECT Reign, Days_held FROM wrestler | CREATE TABLE wrestler (Reign VARCHAR(255), Days_held VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 1083
} |
What are the names of wrestlers days held less than 100? | SELECT Name FROM wrestler WHERE Days_held < 100 | CREATE TABLE wrestler (Name VARCHAR(255), Days_held INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1084
} |
Please show the most common reigns of wrestlers. | SELECT Reign FROM wrestler GROUP BY Reign ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE wrestler (Reign 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": 1085
} |
List the locations that are shared by more than two wrestlers. | SELECT LOCATION FROM wrestler GROUP BY LOCATION HAVING COUNT(*) > 2 | CREATE TABLE wrestler (LOCATION VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1086
} |
List the names of wrestlers that have not been eliminated. | SELECT Name FROM wrestler WHERE NOT Wrestler_ID IN (SELECT Wrestler_ID FROM elimination) | CREATE TABLE elimination (Name VARCHAR(255), Wrestler_ID VARCHAR(255)); CREATE TABLE wrestler (Name VARCHAR(255), Wrestler_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 1087
} |
Show the teams that have both wrestlers eliminated by "Orton" and wrestlers eliminated by "Benjamin". | SELECT Team FROM Elimination WHERE Eliminated_By = 'Orton' INTERSECT SELECT Team FROM Elimination WHERE Eliminated_By = 'Benjamin' | CREATE TABLE Elimination (Team VARCHAR(255), Eliminated_By VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 1088
} |
What is the number of distinct teams that suffer elimination? | SELECT COUNT(DISTINCT team) FROM elimination | CREATE TABLE elimination (team 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": 1089
} |
Show the times of elimination by "Punk" or "Orton". | SELECT TIME FROM elimination WHERE Eliminated_By = 'Punk' OR Eliminated_By = 'Orton' | CREATE TABLE elimination (TIME VARCHAR(255), Eliminated_By VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 1090
} |
How many schools are there? | SELECT COUNT(*) FROM school | CREATE TABLE school (Id VARCHAR(255), school_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 1091
} |
Show all school names in alphabetical order. | SELECT school_name FROM school ORDER BY school_name | CREATE TABLE school (school_name VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1092
} |
List the name, location, mascot for all schools. | SELECT school_name, LOCATION, mascot FROM school | CREATE TABLE school (school_name VARCHAR(255), LOCATION VARCHAR(255), mascot VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 1093
} |
What are the total and average enrollment of all schools? | SELECT SUM(enrollment), AVG(enrollment) FROM school | CREATE TABLE school (enrollment 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": 1094
} |
What are the mascots for schools with enrollments above the average? | SELECT mascot FROM school WHERE enrollment > (SELECT AVG(enrollment) FROM school) | CREATE TABLE school (mascot VARCHAR(255), enrollment INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 1095
} |
List the name of the school with the smallest enrollment. | SELECT school_name FROM school ORDER BY enrollment LIMIT 1 | CREATE TABLE school (school_name VARCHAR(255), enrollment VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 1096
} |
Show the average, maximum, minimum enrollment of all schools. | SELECT AVG(enrollment), MAX(enrollment), MIN(enrollment) FROM school | CREATE TABLE school (enrollment 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": 1097
} |
How many budgets are above 3000 in year 2001 or before? | SELECT COUNT(*) FROM budget WHERE budgeted > 3000 AND YEAR <= 2001 | CREATE TABLE budget (budgeted VARCHAR, YEAR VARCHAR, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 1106
} |
Show all donor names. | SELECT DISTINCT donator_name FROM endowment | CREATE TABLE endowment (donator_name VARCHAR, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 1108
} |
How many budget record has a budget amount smaller than the invested amount? | SELECT COUNT(*) FROM budget WHERE budgeted < invested | CREATE TABLE budget (budgeted INTEGER, invested VARCHAR, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 1109
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.