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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Find the total student enrollment for different affiliation type schools. | SELECT SUM(enrollment), affiliation FROM university GROUP BY affiliation | CREATE TABLE university (affiliation VARCHAR(255), enrollment INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 549
} |
How many schools do not participate in the basketball match? | SELECT COUNT(*) FROM university WHERE NOT school_id IN (SELECT school_id FROM basketball_match) | CREATE TABLE university (school_id VARCHAR(255), name VARCHAR(255)); CREATE TABLE basketball_match (school_id VARCHAR(255), match_date DATE) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 550
} |
Find the schools that were either founded after 1850 or public. | SELECT school FROM university WHERE founded > 1850 OR affiliation = 'Public' | CREATE TABLE university (school VARCHAR(255), founded VARCHAR(255), affiliation VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 551
} |
Find how many different affiliation types there are. | SELECT COUNT(DISTINCT affiliation) FROM university | CREATE TABLE university (affiliation VARCHAR(255), school_id VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 552
} |
Find how many school locations have the word 'NY'. | SELECT COUNT(*) FROM university WHERE LOCATION LIKE '%NY%' | CREATE TABLE university (LOCATION VARCHAR(255), school_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 553
} |
Find the number of universities that have over a 20000 enrollment size for each affiliation type. | SELECT COUNT(*), affiliation FROM university WHERE enrollment > 20000 GROUP BY affiliation | CREATE TABLE university (affiliation VARCHAR(255), enrollment INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 555
} |
Find the total number of students enrolled in the colleges that were founded after the year of 1850 for each affiliation type. | SELECT SUM(Enrollment), affiliation FROM university WHERE founded > 1850 GROUP BY affiliation | CREATE TABLE university (affiliation VARCHAR(255), Enrollment INTEGER, founded INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 556
} |
What is the maximum enrollment across all schools? | SELECT MAX(Enrollment) FROM university | CREATE TABLE university (Enrollment 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": 557
} |
List names of all teams in the basketball competition, ordered by all home scores in descending order. | SELECT team_name FROM basketball_match ORDER BY All_Home DESC | CREATE TABLE basketball_match (TEAM_NAME VARCHAR(255), ALL_HOME VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 559
} |
the names of models that launched between 2002 and 2004. | SELECT Model_name FROM chip_model WHERE Launch_year BETWEEN 2002 AND 2004 | CREATE TABLE chip_model (MODEL_NAME VARCHAR(255), LAUNCH_YEAR INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 560
} |
Which model has the least amount of RAM? List the model name and the amount of RAM. | SELECT Model_name, RAM_MiB FROM chip_model ORDER BY RAM_MiB LIMIT 1 | CREATE TABLE chip_model (MODEL_NAME VARCHAR(255), RAM_MIB 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": 561
} |
What are the chip model and screen mode of the phone with hardware model name "LG-P760"? | SELECT chip_model, screen_mode FROM phone WHERE Hardware_Model_name = 'LG-P760' | CREATE TABLE phone (CHIP_MODEL VARCHAR(255), SCREEN_MODE VARCHAR(255), HARDWARE_MODEL_NAME VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 562
} |
How many phone hardware models are produced by the company named "Nokia Corporation"? | SELECT COUNT(*) FROM phone WHERE Company_name = 'Nokia Corporation' | CREATE TABLE phone (COMPANY_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": 563
} |
What is maximum and minimum RAM size of phone produced by company named "Nokia Corporation"? | SELECT MAX(T1.RAM_MiB), MIN(T1.RAM_MiB) FROM chip_model AS T1 JOIN phone AS T2 ON T1.Model_name = T2.chip_model WHERE T2.Company_name = 'Nokia Corporation' | CREATE TABLE phone (CHIP_MODEL VARCHAR(255), COMPANY_NAME VARCHAR(255)); CREATE TABLE chip_model (RAM_MIB INTEGER, MODEL_NAME VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 2 | {
"split": "train",
"row_index": 564
} |
What is the average ROM size of phones produced by the company named "Nokia Corporation"? | SELECT AVG(T1.ROM_MiB) FROM chip_model AS T1 JOIN phone AS T2 ON T1.Model_name = T2.chip_model WHERE T2.Company_name = 'Nokia Corporation' | CREATE TABLE phone (CHIP_MODEL VARCHAR(255), COMPANY_NAME VARCHAR(255)); CREATE TABLE chip_model (ROM_MIB INTEGER, MODEL_NAME VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 565
} |
List the hardware model name and company name for all the phones that were launched in year 2002 or have RAM size greater than 32. | SELECT T2.Hardware_Model_name, T2.Company_name FROM chip_model AS T1 JOIN phone AS T2 ON T1.Model_name = T2.chip_model WHERE T1.Launch_year = 2002 OR T1.RAM_MiB > 32 | CREATE TABLE chip_model (MODEL_NAME VARCHAR(255), LAUNCH_YEAR VARCHAR(255), RAM_MIB VARCHAR(255)); CREATE TABLE phone (HARDWARE_MODEL_NAME VARCHAR(255), COMPANY_NAME VARCHAR(255), CHIP_MODEL VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 2 | {
"split": "train",
"row_index": 566
} |
Find all phones that have word 'Full' in their accreditation types. List the Hardware Model name and Company name. | SELECT Hardware_Model_name, Company_name FROM phone WHERE Accreditation_type LIKE 'Full' | CREATE TABLE phone (HARDWARE_MODEL_NAME VARCHAR(255), COMPANY_NAME VARCHAR(255), ACCREDITATION_TYPE VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 567
} |
Find the Char cells, Pixels and Hardware colours for the screen of the phone whose hardware model name is "LG-P760". | SELECT T1.Char_cells, T1.Pixels, T1.Hardware_colours FROM screen_mode AS T1 JOIN phone AS T2 ON T1.Graphics_mode = T2.screen_mode WHERE T2.Hardware_Model_name = 'LG-P760' | CREATE TABLE phone (SCREEN_MODE VARCHAR(255), HARDWARE_MODEL_NAME VARCHAR(255)); CREATE TABLE screen_mode (CHAR_CELLS VARCHAR(255), PIXELS VARCHAR(255), HARDWARE_COLOURS VARCHAR(255), GRAPHICS_MODE VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 568
} |
List the hardware model name and company name for the phone whose screen mode type is "Graphics." | SELECT T2.Hardware_Model_name, T2.Company_name FROM screen_mode AS T1 JOIN phone AS T2 ON T1.Graphics_mode = T2.screen_mode WHERE T1.Type = 'Graphics' | CREATE TABLE phone (HARDWARE_MODEL_NAME VARCHAR(255), COMPANY_NAME VARCHAR(255), SCREEN_MODE VARCHAR(255)); CREATE TABLE screen_mode (GRAPHICS_MODE VARCHAR(255), TYPE VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 569
} |
Find the name of the company that has the least number of phone models. List the company name and the number of phone model produced by that company. | SELECT Company_name, COUNT(*) FROM phone GROUP BY Company_name ORDER BY COUNT(*) LIMIT 1 | CREATE TABLE phone (COMPANY_NAME VARCHAR(255), ID INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 2 | {
"split": "train",
"row_index": 570
} |
List the name of the company that produced more than one phone model. | SELECT Company_name FROM phone GROUP BY Company_name HAVING COUNT(*) > 1 | CREATE TABLE phone (COMPANY_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": 571
} |
List the maximum, minimum and average number of used kb in screen mode. | SELECT MAX(used_kb), MIN(used_kb), AVG(used_kb) FROM screen_mode | CREATE TABLE screen_mode (USED_KB 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": 572
} |
List the name of the phone model launched in year 2002 and with the highest RAM size. | SELECT T2.Hardware_Model_name FROM chip_model AS T1 JOIN phone AS T2 ON T1.Model_name = T2.chip_model WHERE T1.Launch_year = 2002 ORDER BY T1.RAM_MiB DESC LIMIT 1 | CREATE TABLE chip_model (Model_name VARCHAR(255), Launch_year VARCHAR(255), RAM_MiB VARCHAR(255)); CREATE TABLE phone (Hardware_Model_name VARCHAR(255), chip_model VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 573
} |
What are the wifi and screen mode type of the hardware model named "LG-P760"? | SELECT T1.WiFi, T3.Type FROM chip_model AS T1 JOIN phone AS T2 ON T1.Model_name = T2.chip_model JOIN screen_mode AS T3 ON T2.screen_mode = T3.Graphics_mode WHERE T2.Hardware_Model_name = 'LG-P760' | CREATE TABLE phone (chip_model VARCHAR(255), screen_mode VARCHAR(255), Hardware_Model_name VARCHAR(255)); CREATE TABLE chip_model (WiFi VARCHAR(255), Model_name VARCHAR(255)); CREATE TABLE screen_mode (Type VARCHAR(255), Graphics_mode VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 574
} |
List the hardware model name for the phones that have screen mode type "Text" or RAM size greater than 32. | SELECT T2.Hardware_Model_name FROM chip_model AS T1 JOIN phone AS T2 ON T1.Model_name = T2.chip_model JOIN screen_mode AS T3 ON T2.screen_mode = T3.Graphics_mode WHERE T3.Type = 'Text' OR T1.RAM_MiB > 32 | CREATE TABLE chip_model (Model_name VARCHAR(255), RAM_MiB VARCHAR(255)); CREATE TABLE phone (Hardware_Model_name VARCHAR(255), chip_model VARCHAR(255), screen_mode VARCHAR(255)); CREATE TABLE screen_mode (Graphics_mode VARCHAR(255), Type VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 575
} |
List the phone hardware model and company name for the phones whose screen usage in kb is between 10 and 15. | SELECT DISTINCT T2.Hardware_Model_name, T2.Company_name FROM screen_mode AS T1 JOIN phone AS T2 ON T1.Graphics_mode = T2.screen_mode WHERE T1.used_kb BETWEEN 10 AND 15 | CREATE TABLE phone (Hardware_Model_name VARCHAR(255), Company_name VARCHAR(255), screen_mode VARCHAR(255)); CREATE TABLE screen_mode (Graphics_mode VARCHAR(255), used_kb INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 578
} |
Find the number of phones for each accreditation type. | SELECT Accreditation_type, COUNT(*) FROM phone GROUP BY Accreditation_type | CREATE TABLE phone (Accreditation_type 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": 579
} |
Find the accreditation level that more than 3 phones use. | SELECT Accreditation_level FROM phone GROUP BY Accreditation_level HAVING COUNT(*) > 3 | CREATE TABLE phone (Accreditation_level 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": 580
} |
How many models do not have the wifi function? | SELECT COUNT(*) FROM chip_model WHERE wifi = 'No' | CREATE TABLE chip_model (wifi 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": 582
} |
List all the model names sorted by their launch year. | SELECT model_name FROM chip_model ORDER BY launch_year | CREATE TABLE chip_model (model_name VARCHAR(255), launch_year VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 583
} |
Find the average ram mib size of the chip models that are never used by any phone. | SELECT AVG(RAM_MiB) FROM chip_model WHERE NOT model_name IN (SELECT chip_model FROM phone) | CREATE TABLE chip_model (RAM_MiB INTEGER, model_name VARCHAR(255), chip_model VARCHAR(255)); CREATE TABLE phone (RAM_MiB INTEGER, model_name VARCHAR(255), chip_model VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 584
} |
Find the names of the chip models that are not used by any phone with full accreditation type. | SELECT model_name FROM chip_model EXCEPT SELECT chip_model FROM phone WHERE Accreditation_type = 'Full' | CREATE TABLE chip_model (model_name VARCHAR(255), chip_model VARCHAR(255), Accreditation_type VARCHAR(255)); CREATE TABLE phone (model_name VARCHAR(255), chip_model VARCHAR(255), Accreditation_type VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 585
} |
Find the pixels of the screen modes that are used by both phones with full accreditation types and phones with Provisional accreditation types. | SELECT t1.pixels FROM screen_mode AS t1 JOIN phone AS t2 ON t1.Graphics_mode = t2.screen_mode WHERE t2.Accreditation_type = 'Provisional' INTERSECT SELECT t1.pixels FROM screen_mode AS t1 JOIN phone AS t2 ON t1.Graphics_mode = t2.screen_mode WHERE t2.Accreditation_type = 'Full' | CREATE TABLE phone (screen_mode VARCHAR(255), Accreditation_type VARCHAR(255)); CREATE TABLE screen_mode (pixels VARCHAR(255), Graphics_mode VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 586
} |
How many countries are there in total? | SELECT COUNT(*) FROM country | CREATE TABLE country (Id VARCHAR(255), Country_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 587
} |
Show the country name and capital of all countries. | SELECT Country_name, Capital FROM country | CREATE TABLE country (Country_name VARCHAR(255), Capital VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 588
} |
Show all official native languages that contain the word "English". | SELECT Official_native_language FROM country WHERE Official_native_language LIKE '%English%' | CREATE TABLE country (Official_native_language 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": 589
} |
Show all distinct positions of matches. | SELECT DISTINCT POSITION FROM match_season | CREATE TABLE match_season (POSITION 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": 590
} |
Show the players from college UCLA. | SELECT Player FROM match_season WHERE College = 'UCLA' | CREATE TABLE match_season (Player VARCHAR(255), College VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 591
} |
Show the distinct position of players from college UCLA or Duke. | SELECT DISTINCT POSITION FROM match_season WHERE College = 'UCLA' OR College = 'Duke' | CREATE TABLE match_season (POSITION VARCHAR(255), College VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 592
} |
Show the draft pick numbers and draft classes of players whose positions are defenders. | SELECT Draft_Pick_Number, Draft_Class FROM match_season WHERE POSITION = 'Defender' | CREATE TABLE match_season (Draft_Pick_Number VARCHAR(255), Draft_Class VARCHAR(255), POSITION VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 593
} |
How many distinct teams are involved in match seasons? | SELECT COUNT(DISTINCT Team) FROM match_season | CREATE TABLE match_season (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": 594
} |
Show the players and the years played. | SELECT Player, Years_Played FROM player | CREATE TABLE player (Player VARCHAR(255), Years_Played VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 595
} |
Show all team names. | SELECT Name FROM Team | CREATE TABLE Team (Name 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": 596
} |
Show the season, the player, and the name of the country that player belongs to. | SELECT T2.Season, T2.Player, T1.Country_name FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country | CREATE TABLE match_season (Season VARCHAR(255), Player VARCHAR(255), Country VARCHAR(255)); CREATE TABLE country (Country_name VARCHAR(255), Country_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 597
} |
Which players are from Indonesia? | SELECT T2.Player FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T1.Country_name = 'Indonesia' | CREATE TABLE country (Country_id VARCHAR(255), Country_name VARCHAR(255)); CREATE TABLE match_season (Player VARCHAR(255), Country VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 598
} |
What are the distinct positions of the players from a country whose capital is Dublin? | SELECT DISTINCT T2.Position FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T1.Capital = 'Dublin' | CREATE TABLE country (Country_id VARCHAR(255), Capital VARCHAR(255)); CREATE TABLE match_season (Position VARCHAR(255), Country VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 599
} |
What are the official languages of the countries of players from Maryland or Duke college? | SELECT T1.Official_native_language FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T2.College = 'Maryland' OR T2.College = 'Duke' | CREATE TABLE country (Official_native_language VARCHAR(255), Country_id VARCHAR(255)); CREATE TABLE match_season (Country VARCHAR(255), College VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 600
} |
How many distinct official languages are there among countries of players whose positions are defenders. | SELECT COUNT(DISTINCT T1.Official_native_language) FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T2.Position = 'Defender' | CREATE TABLE country (Official_native_language VARCHAR(255), Country_id VARCHAR(255)); CREATE TABLE match_season (Country VARCHAR(255), Position VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 601
} |
Show the season, the player, and the name of the team that players belong to. | SELECT T1.Season, T1.Player, T2.Name FROM match_season AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id | CREATE TABLE team (Name VARCHAR(255), Team_id VARCHAR(255)); CREATE TABLE match_season (Season VARCHAR(255), Player VARCHAR(255), Team VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 602
} |
Show the positions of the players from the team with name "Ryley Goldner". | SELECT T1.Position FROM match_season AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id WHERE T2.Name = 'Ryley Goldner' | CREATE TABLE match_season (Position VARCHAR(255), Team VARCHAR(255)); CREATE TABLE team (Team_id VARCHAR(255), Name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 603
} |
How many distinct colleges are associated with players from the team with name "Columbus Crew". | SELECT COUNT(DISTINCT T1.College) FROM match_season AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id WHERE T2.Name = 'Columbus Crew' | CREATE TABLE match_season (College VARCHAR(255), Team VARCHAR(255)); CREATE TABLE team (Team_id VARCHAR(255), Name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 604
} |
Show the players and years played for players from team "Columbus Crew". | SELECT T1.Player, T1.Years_Played FROM player AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id WHERE T2.Name = 'Columbus Crew' | CREATE TABLE player (Player VARCHAR(255), Years_Played VARCHAR(255), Team VARCHAR(255)); CREATE TABLE team (Team_id VARCHAR(255), Name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 605
} |
Show the position of players and the corresponding number of players. | SELECT POSITION, COUNT(*) FROM match_season GROUP BY POSITION | CREATE TABLE match_season (POSITION 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": 606
} |
Show the country names and the corresponding number of players. | SELECT Country_name, COUNT(*) FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country GROUP BY T1.Country_name | CREATE TABLE match_season (Country VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE country (Country_name VARCHAR(255), Country_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 607
} |
Return all players sorted by college in ascending alphabetical order. | SELECT player FROM match_season ORDER BY College | CREATE TABLE match_season (player VARCHAR(255), College VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 608
} |
Show the most common position of players in match seasons. | SELECT POSITION FROM match_season GROUP BY POSITION ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE match_season (POSITION 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": 609
} |
Show the top 3 most common colleges of players in match seasons. | SELECT College FROM match_season GROUP BY College ORDER BY COUNT(*) DESC LIMIT 3 | CREATE TABLE match_season (College 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": 610
} |
Show the name of colleges that have at least two players. | SELECT College FROM match_season GROUP BY College HAVING COUNT(*) >= 2 | CREATE TABLE match_season (College 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": 611
} |
Show the name of colleges that have at least two players in descending alphabetical order. | SELECT College FROM match_season GROUP BY College HAVING COUNT(*) >= 2 ORDER BY College DESC | CREATE TABLE match_season (College 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": 612
} |
What are the names of teams that do no have match season record? | SELECT Name FROM team WHERE NOT Team_id IN (SELECT Team FROM match_season) | CREATE TABLE match_season (Name VARCHAR(255), Team_id VARCHAR(255), Team VARCHAR(255)); CREATE TABLE team (Name VARCHAR(255), Team_id VARCHAR(255), Team VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 613
} |
What are the names of countries that have both players with position forward and players with position defender? | SELECT T1.Country_name FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T2.Position = 'Forward' INTERSECT SELECT T1.Country_name FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T2.Position = 'Defender' | CREATE TABLE country (Country_name VARCHAR(255), Country_id VARCHAR(255)); CREATE TABLE match_season (Country VARCHAR(255), Position VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 614
} |
Which college have both players with position midfielder and players with position defender? | SELECT College FROM match_season WHERE POSITION = 'Midfielder' INTERSECT SELECT College FROM match_season WHERE POSITION = 'Defender' | CREATE TABLE match_season (College VARCHAR(255), POSITION VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 615
} |
How many climbers are there? | SELECT COUNT(*) FROM climber | CREATE TABLE climber (Id VARCHAR(255), Name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 616
} |
List the names of climbers in descending order of points. | SELECT Name FROM climber ORDER BY Points DESC | CREATE TABLE climber (Name VARCHAR(255), Points VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 617
} |
List the names of climbers whose country is not Switzerland. | SELECT Name FROM climber WHERE Country <> 'Switzerland' | CREATE TABLE climber (Name VARCHAR(255), Country VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 618
} |
What is the maximum point for climbers whose country is United Kingdom? | SELECT MAX(Points) FROM climber WHERE Country = 'United Kingdom' | CREATE TABLE climber (Points INTEGER, Country VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 619
} |
How many distinct countries are the climbers from? | SELECT COUNT(DISTINCT Country) FROM climber | CREATE TABLE climber (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": 620
} |
What are the names of mountains in ascending alphabetical order? | SELECT Name FROM mountain ORDER BY Name | CREATE TABLE mountain (Name VARCHAR(255), Height INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 621
} |
What are the countries of mountains with height bigger than 5000? | SELECT Country FROM mountain WHERE Height > 5000 | CREATE TABLE mountain (Country VARCHAR(255), Height INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 622
} |
What is the name of the highest mountain? | SELECT Name FROM mountain ORDER BY Height DESC LIMIT 1 | CREATE TABLE mountain (Name VARCHAR(255), Height VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 623
} |
List the distinct ranges of the mountains with the top 3 prominence. | SELECT DISTINCT Range FROM mountain ORDER BY Prominence DESC LIMIT 3 | CREATE TABLE mountain (Range VARCHAR(255), Prominence VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 624
} |
Show names of climbers and the names of mountains they climb. | SELECT T1.Name, T2.Name FROM climber AS T1 JOIN mountain AS T2 ON T1.Mountain_ID = T2.Mountain_ID | CREATE TABLE mountain (Name VARCHAR(255), Mountain_ID VARCHAR(255)); CREATE TABLE climber (Name VARCHAR(255), Mountain_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 625
} |
Show the names of climbers and the heights of mountains they climb. | SELECT T1.Name, T2.Height FROM climber AS T1 JOIN mountain AS T2 ON T1.Mountain_ID = T2.Mountain_ID | CREATE TABLE mountain (Height VARCHAR(255), Mountain_ID VARCHAR(255)); CREATE TABLE climber (Name VARCHAR(255), Mountain_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 626
} |
Show the height of the mountain climbed by the climber with the maximum points. | SELECT T2.Height FROM climber AS T1 JOIN mountain AS T2 ON T1.Mountain_ID = T2.Mountain_ID ORDER BY T1.Points DESC LIMIT 1 | CREATE TABLE climber (Mountain_ID VARCHAR(255), Points VARCHAR(255)); CREATE TABLE mountain (Height VARCHAR(255), Mountain_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 627
} |
Show the distinct names of mountains climbed by climbers from country "West Germany". | SELECT DISTINCT T2.Name FROM climber AS T1 JOIN mountain AS T2 ON T1.Mountain_ID = T2.Mountain_ID WHERE T1.Country = 'West Germany' | CREATE TABLE mountain (Name VARCHAR(255), Mountain_ID VARCHAR(255)); CREATE TABLE climber (Mountain_ID VARCHAR(255), Country VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 628
} |
Show the times used by climbers to climb mountains in Country Uganda. | SELECT T1.Time FROM climber AS T1 JOIN mountain AS T2 ON T1.Mountain_ID = T2.Mountain_ID WHERE T2.Country = 'Uganda' | CREATE TABLE mountain (Mountain_ID VARCHAR(255), Country VARCHAR(255)); CREATE TABLE climber (Time VARCHAR(255), Mountain_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 629
} |
Please show the countries and the number of climbers from each country. | SELECT Country, COUNT(*) FROM climber GROUP BY Country | CREATE TABLE climber (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": 630
} |
List the countries that have more than one mountain. | SELECT Country FROM mountain GROUP BY Country HAVING COUNT(*) > 1 | CREATE TABLE mountain (Country 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": 631
} |
List the names of mountains that do not have any climber. | SELECT Name FROM mountain WHERE NOT Mountain_ID IN (SELECT Mountain_ID FROM climber) | CREATE TABLE mountain (Name VARCHAR(255), Mountain_ID VARCHAR(255)); CREATE TABLE climber (Name VARCHAR(255), Mountain_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 632
} |
Show the countries that have mountains with height more than 5600 stories and mountains with height less than 5200. | SELECT Country FROM mountain WHERE Height > 5600 INTERSECT SELECT Country FROM mountain WHERE Height < 5200 | CREATE TABLE mountain (Country VARCHAR(255), Height INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 633
} |
Show the range that has the most number of mountains. | SELECT Range FROM mountain GROUP BY Range ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE mountain (Range 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": 634
} |
Show the names of mountains with height more than 5000 or prominence more than 1000. | SELECT Name FROM mountain WHERE Height > 5000 OR Prominence > 1000 | CREATE TABLE mountain (Name VARCHAR(255), Height VARCHAR(255), Prominence VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 635
} |
How many body builders are there? | SELECT COUNT(*) FROM body_builder | CREATE TABLE body_builder (Id VARCHAR(255), Name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 636
} |
List the total scores of body builders in ascending order. | SELECT Total FROM body_builder ORDER BY Total | CREATE TABLE body_builder (Total 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": 637
} |
List the snatch score and clean jerk score of body builders in ascending order of snatch score. | SELECT Snatch, Clean_Jerk FROM body_builder ORDER BY Snatch | CREATE TABLE body_builder (Snatch VARCHAR(255), Clean_Jerk VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 638
} |
What is the average snatch score of body builders? | SELECT AVG(Snatch) FROM body_builder | CREATE TABLE body_builder (Snatch INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 639
} |
What are the clean and jerk score of the body builder with the highest total score? | SELECT Clean_Jerk FROM body_builder ORDER BY Total DESC LIMIT 1 | CREATE TABLE body_builder (Clean_Jerk VARCHAR(255), Total 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": 640
} |
What are the birthdays of people in ascending order of height? | SELECT Birth_Date FROM People ORDER BY Height | CREATE TABLE People (Birth_Date VARCHAR(255), Height 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": 641
} |
What are the names of body builders? | SELECT T2.Name FROM body_builder AS T1 JOIN people AS T2 ON T1.People_ID = T2.People_ID | CREATE TABLE body_builder (People_ID VARCHAR(255), Total INTEGER); 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": 642
} |
What are the names of body builders whose total score is higher than 300? | SELECT T2.Name FROM body_builder AS T1 JOIN people AS T2 ON T1.People_ID = T2.People_ID WHERE T1.Total > 300 | CREATE TABLE people (Name VARCHAR(255), People_ID VARCHAR(255)); CREATE TABLE body_builder (People_ID VARCHAR(255), Total INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 643
} |
What is the name of the body builder with the greatest body weight? | SELECT T2.Name FROM body_builder AS T1 JOIN people AS T2 ON T1.People_ID = T2.People_ID ORDER BY T2.Weight DESC LIMIT 1 | CREATE TABLE body_builder (People_ID VARCHAR(255), Total INTEGER); CREATE TABLE people (Name VARCHAR(255), People_ID VARCHAR(255), Weight VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 644
} |
What are the birth date and birth place of the body builder with the highest total points? | SELECT T2.Birth_Date, T2.Birth_Place FROM body_builder AS T1 JOIN people AS T2 ON T1.People_ID = T2.People_ID ORDER BY T1.Total DESC LIMIT 1 | CREATE TABLE body_builder (People_ID VARCHAR(255), Total VARCHAR(255)); CREATE TABLE people (Birth_Date VARCHAR(255), Birth_Place VARCHAR(255), People_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 645
} |
What are the heights of body builders with total score smaller than 315? | SELECT T2.Height FROM body_builder AS T1 JOIN people AS T2 ON T1.People_ID = T2.People_ID WHERE T1.Total < 315 | CREATE TABLE people (Height VARCHAR(255), People_ID VARCHAR(255)); CREATE TABLE body_builder (People_ID VARCHAR(255), Total INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 646
} |
What is the average total score of body builders with height bigger than 200? | SELECT AVG(T1.Total) FROM body_builder AS T1 JOIN people AS T2 ON T1.People_ID = T2.People_ID WHERE T2.Height > 200 | CREATE TABLE people (People_ID VARCHAR(255), Height INTEGER); CREATE TABLE body_builder (Total INTEGER, People_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 647
} |
What are the names of body builders in descending order of total scores? | SELECT T2.Name FROM body_builder AS T1 JOIN people AS T2 ON T1.People_ID = T2.People_ID ORDER BY T1.Total DESC | CREATE TABLE body_builder (People_ID VARCHAR(255), Total VARCHAR(255)); CREATE TABLE people (Name VARCHAR(255), People_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 648
} |
List each birth place along with the number of people from there. | SELECT Birth_Place, COUNT(*) FROM people GROUP BY Birth_Place | CREATE TABLE people (Birth_Place 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": 649
} |
What is the most common birth place of people? | SELECT Birth_Place FROM people GROUP BY Birth_Place ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE people (Birth_Place 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": 650
} |
What are the birth places that are shared by at least two people? | SELECT Birth_Place FROM people GROUP BY Birth_Place HAVING COUNT(*) >= 2 | CREATE TABLE people (Birth_Place 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": 651
} |
List the height and weight of people in descending order of height. | SELECT Height, Weight FROM people ORDER BY Height DESC | CREATE TABLE people (Height VARCHAR(255), Weight VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 652
} |
How many distinct birth places are there? | SELECT COUNT(DISTINCT Birth_Place) FROM people | CREATE TABLE people (Birth_Place 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": 655
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.