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 number of scientists involved for each project name. | SELECT COUNT(*), T1.name FROM projects AS T1 JOIN assignedto AS T2 ON T1.code = T2.project GROUP BY T1.name | CREATE TABLE assignedto (project VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE projects (name VARCHAR(255), code 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": 3688
} |
Find the number of scientists involved for the projects that require more than 300 hours. | SELECT COUNT(*), T1.name FROM projects AS T1 JOIN assignedto AS T2 ON T1.code = T2.project WHERE T1.hours > 300 GROUP BY T1.name | CREATE TABLE assignedto (project VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE projects (name VARCHAR(255), code VARCHAR(255), hours INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 3689
} |
Find the number of projects which each scientist is working on and scientist's name. | SELECT COUNT(*), T1.name FROM scientists AS T1 JOIN assignedto AS T2 ON T1.ssn = T2.scientist GROUP BY T1.name | CREATE TABLE scientists (name VARCHAR(255), ssn VARCHAR(255)); CREATE TABLE assignedto (scientist 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": 3690
} |
Find the name of scientists who are assigned to some project. | SELECT T2.name FROM assignedto AS T1 JOIN scientists AS T2 ON T1.scientist = T2.ssn | CREATE TABLE assignedto (scientist VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE scientists (name VARCHAR(255), ssn VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3692
} |
Select the project names which are not assigned yet. | SELECT Name FROM Projects WHERE NOT Code IN (SELECT Project FROM AssignedTo) | CREATE TABLE Projects (Name VARCHAR(255), Code VARCHAR(255), Project VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE AssignedTo (Name VARCHAR(255), Code VARCHAR(255), Project VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 3693
} |
Find the name of scientists who are not assigned to any project. | SELECT Name FROM scientists WHERE NOT ssn IN (SELECT scientist FROM AssignedTo) | CREATE TABLE scientists (Name VARCHAR(255), ssn VARCHAR(255), scientist VARCHAR(255)); CREATE TABLE AssignedTo (Name VARCHAR(255), ssn VARCHAR(255), scientist VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 3694
} |
Find the number of scientists who are not assigned to any project. | SELECT COUNT(*) FROM scientists WHERE NOT ssn IN (SELECT scientist FROM AssignedTo) | CREATE TABLE AssignedTo (ssn VARCHAR(255), scientist VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE scientists (ssn VARCHAR(255), scientist VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 3695
} |
List all the scientists' names, their projects' names, and the hours worked by that scientist on each project, in alphabetical order of project name, and then scientist name. | SELECT T1.Name, T3.Name, T3.Hours FROM Scientists AS T1 JOIN AssignedTo AS T2 ON T1.SSN = T2.Scientist JOIN Projects AS T3 ON T2.Project = T3.Code ORDER BY T3.Name, T1.Name | CREATE TABLE AssignedTo (Scientist VARCHAR(255), Project VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Projects (Name VARCHAR(255), Hours VARCHAR(255), Code VARCHAR(255)); CREATE TABLE Scientists (Name VARCHAR(255), SSN VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 3697
} |
What is the name of the highest rated wine? | SELECT Name FROM WINE ORDER BY Score LIMIT 1 | CREATE TABLE WINE (Name VARCHAR(255), Score 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": 3699
} |
Which winery is the wine that has the highest score from? | SELECT Winery FROM WINE ORDER BY SCORE LIMIT 1 | CREATE TABLE WINE (Winery VARCHAR(255), SCORE 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": 3700
} |
Find the names of all wines produced in 2008. | SELECT Name FROM WINE WHERE YEAR = '2008' | CREATE TABLE WINE (Name VARCHAR(255), YEAR VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3701
} |
List the grapes and appelations of all wines. | SELECT Grape, Appelation FROM WINE | CREATE TABLE WINE (Grape VARCHAR(255), Appelation VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 3702
} |
List the names and scores of all wines. | SELECT Name, Score FROM WINE | CREATE TABLE WINE (Name VARCHAR(255), Score VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 3703
} |
List the area and county of all appelations. | SELECT Area, County FROM APPELLATIONS | CREATE TABLE APPELLATIONS (Area VARCHAR(255), County VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 3704
} |
What are the prices of wines produced before the year of 2010? | SELECT Price FROM WINE WHERE YEAR < 2010 | CREATE TABLE WINE (Price VARCHAR(255), YEAR INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3705
} |
List the names of all distinct wines that have scores higher than 90. | SELECT Name FROM WINE WHERE score > 90 | CREATE TABLE WINE (Name VARCHAR(255), score INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3706
} |
List the names of all distinct wines that are made of red color grape. | SELECT DISTINCT T2.Name FROM GRAPES AS T1 JOIN WINE AS T2 ON T1.Grape = T2.Grape WHERE T1.Color = 'Red' | CREATE TABLE GRAPES (Grape VARCHAR(255), Color VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE WINE (Name VARCHAR(255), Grape 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": 3707
} |
Find the names of all distinct wines that have appellations in North Coast area. | SELECT DISTINCT T2.Name FROM APPELLATIONs AS T1 JOIN WINE AS T2 ON T1.Appelation = T2.Appelation WHERE T1.Area = 'North Coast' | CREATE TABLE APPELLATIONs (Appelation VARCHAR(255), Area VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE WINE (Name VARCHAR(255), Appelation 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": 3708
} |
How many wines are produced at Robert Biale winery? | SELECT COUNT(*) FROM WINE WHERE Winery = 'Robert Biale' | CREATE TABLE WINE (Winery 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": 3709
} |
How many appelations are in Napa Country? | SELECT COUNT(*) FROM APPELLATIONS WHERE County = 'Napa' | CREATE TABLE APPELLATIONS (County VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT, Area VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3710
} |
Give me the average prices of wines that are produced by appelations in Sonoma County. | SELECT AVG(T2.Price) FROM APPELLATIONS AS T1 JOIN WINE AS T2 ON T1.Appelation = T2.Appelation WHERE T1.County = 'Sonoma' | CREATE TABLE WINE (Price INTEGER, Appelation VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE APPELLATIONS (Appelation VARCHAR(255), County 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": 3711
} |
What are the names and scores of wines that are made of white color grapes? | SELECT T2.Name, T2.Score FROM GRAPES AS T1 JOIN WINE AS T2 ON T1.Grape = T2.Grape WHERE T1.Color = 'White' | CREATE TABLE GRAPES (Grape VARCHAR(255), Color VARCHAR(255)); CREATE TABLE WINE (Name VARCHAR(255), Score VARCHAR(255), Grape VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3712
} |
Find the maximum price of wins from the appelations in Central Coast area and produced before the year of 2005. | SELECT MAX(T2.Price) FROM APPELLATIONS AS T1 JOIN WINE AS T2 ON T1.Appelation = T2.Appelation WHERE T1.Area = 'Central Coast' AND T2.year < 2005 | CREATE TABLE APPELLATIONS (Appelation VARCHAR(255), Area VARCHAR(255)); CREATE TABLE WINE (Price INTEGER, Appelation VARCHAR(255), year VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3713
} |
Find the the grape whose white color grapes are used to produce wines with scores higher than 90. | SELECT DISTINCT T1.Grape FROM GRAPES AS T1 JOIN WINE AS T2 ON T1.Grape = T2.Grape WHERE T1.Color = 'White' AND T2.score > 90 | CREATE TABLE GRAPES (Grape VARCHAR(255), Color VARCHAR(255)); CREATE TABLE WINE (Grape VARCHAR(255), score VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3714
} |
What are the wines that have prices higher than 50 and made of Red color grapes? | SELECT T2.Name FROM Grapes AS T1 JOIN WINE AS T2 ON T1.Grape = T2.Grape WHERE T1.Color = 'Red' AND T2.price > 50 | CREATE TABLE WINE (Name VARCHAR(255), Grape VARCHAR(255), price VARCHAR(255)); CREATE TABLE Grapes (Grape VARCHAR(255), Color VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3715
} |
What are the wines that have prices lower than 50 and have appelations in Monterey county? | SELECT T2.Name FROM APPELLATIONS AS T1 JOIN WINE AS T2 ON T1.Appelation = T2.Appelation WHERE T1.County = 'Monterey' AND T2.price < 50 | CREATE TABLE APPELLATIONS (Appelation VARCHAR(255), County VARCHAR(255)); CREATE TABLE WINE (Name VARCHAR(255), Appelation VARCHAR(255), price VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3716
} |
What are the numbers of wines for different grapes? | SELECT COUNT(*), Grape FROM WINE GROUP BY Grape | CREATE TABLE WINE (Grape VARCHAR(255), id INTEGER PRIMARY KEY AUTOINCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3717
} |
What are the average prices of wines for different years? | SELECT AVG(Price), YEAR FROM WINE GROUP BY YEAR | CREATE TABLE WINE (YEAR VARCHAR(255), Price INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3718
} |
List the names of all distinct wines in alphabetical order. | SELECT DISTINCT Name FROM WINE ORDER BY Name | CREATE TABLE WINE (Name VARCHAR(255), id INTEGER PRIMARY KEY AUTOINCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3720
} |
List the names of all distinct wines ordered by price. | SELECT DISTINCT Name FROM WINE ORDER BY price | CREATE TABLE WINE (Name VARCHAR(255), price VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3721
} |
What is the area of the appelation that produces the highest number of wines before the year of 2010? | SELECT T1.Area FROM APPELLATIONS AS T1 JOIN WINE AS T2 ON T1.Appelation = T2.Appelation GROUP BY T2.Appelation HAVING T2.year < 2010 ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE WINE (Appelation VARCHAR(255), year VARCHAR(255)); CREATE TABLE APPELLATIONS (Area VARCHAR(255), Appelation VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 3722
} |
Find the distinct names of wines produced before the year of 2000 or after the year of 2010. | SELECT DISTINCT Name FROM WINE WHERE YEAR < 2000 OR YEAR > 2010 | CREATE TABLE WINE (Name VARCHAR(255), YEAR VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3724
} |
Find the distinct winery of wines having price between 50 and 100. | SELECT DISTINCT Winery FROM WINE WHERE Price BETWEEN 50 AND 100 | CREATE TABLE WINE (Winery VARCHAR(255), Price INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3725
} |
What are the average prices and cases of wines produced in the year of 2009 and made of Zinfandel grape? | SELECT AVG(Price), AVG(Cases) FROM WINE WHERE YEAR = 2009 AND Grape = 'Zinfandel' | CREATE TABLE WINE (Price INTEGER, Cases INTEGER, YEAR VARCHAR(255), Grape VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 3 | {
"split": "train",
"row_index": 3726
} |
What are the maximum price and score of wines produced by St. Helena appelation? | SELECT MAX(Price), MAX(Score) FROM WINE WHERE Appelation = 'St. Helena' | CREATE TABLE WINE (Price INTEGER, Score INTEGER, Appelation VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 3727
} |
What are the maximum price and score of wines in each year? | SELECT MAX(Price), MAX(Score), YEAR FROM WINE GROUP BY YEAR | CREATE TABLE WINE (YEAR VARCHAR(255), Price INTEGER, Score INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 3728
} |
What are the average price and score of wines grouped by appelation? | SELECT AVG(Price), AVG(Score), Appelation FROM WINE GROUP BY Appelation | CREATE TABLE WINE (Appelation VARCHAR(255), Price INTEGER, Score INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 3729
} |
Find the wineries that have at least four wines. | SELECT Winery FROM WINE GROUP BY Winery HAVING COUNT(*) >= 4 | CREATE TABLE WINE (Winery 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": 3730
} |
Find the country of all appelations who have at most three wines. | SELECT T1.County FROM APPELLATIONS AS T1 JOIN WINE AS T2 ON T1.Appelation = T2.Appelation GROUP BY T2.Appelation HAVING COUNT(*) <= 3 | CREATE TABLE APPELLATIONS (County VARCHAR(255), Appelation VARCHAR(255)); CREATE TABLE WINE (Appelation 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": 3731
} |
What are the names of wines whose production year are before the year of all wines by Brander winery? | SELECT Name FROM WINE WHERE YEAR < (SELECT MIN(YEAR) FROM WINE WHERE Winery = 'Brander') | CREATE TABLE WINE (Name VARCHAR(255), YEAR INTEGER, Winery VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 3732
} |
What are the names of wines that are more expensive then all wines made in the year 2006? | SELECT Name FROM WINE WHERE Price > (SELECT MAX(Price) FROM WINE WHERE YEAR = 2006) | CREATE TABLE WINE (Name VARCHAR(255), Price INTEGER, YEAR VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 3733
} |
Find the top 3 wineries with the greatest number of wines made of white color grapes. | SELECT T2.Winery FROM GRAPES AS T1 JOIN WINE AS T2 ON T1.GRAPE = T2.GRAPE WHERE T1.Color = 'White' GROUP BY T2.Winery ORDER BY COUNT(*) DESC LIMIT 3 | CREATE TABLE GRAPES (GRAPE VARCHAR(255), Color VARCHAR(255)); CREATE TABLE WINE (Winery VARCHAR(255), GRAPE VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 5 | 0 | 0 | {
"split": "train",
"row_index": 3734
} |
List the grape, winery and year of the wines whose price is bigger than 100 ordered by year. | SELECT Grape, Winery, YEAR FROM WINE WHERE Price > 100 ORDER BY YEAR | CREATE TABLE WINE (Grape VARCHAR(255), Winery VARCHAR(255), YEAR VARCHAR(255), Price INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3735
} |
List the grape, appelation and name of wines whose score is higher than 93 ordered by Name. | SELECT Grape, Appelation, Name FROM WINE WHERE Score > 93 ORDER BY Name | CREATE TABLE WINE (Grape VARCHAR(255), Appelation VARCHAR(255), Name VARCHAR(255), Score INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3736
} |
Find the appelations that produce wines after the year of 2008 but not in Central Coast area. | SELECT Appelation FROM WINE WHERE YEAR > 2008 EXCEPT SELECT Appelation FROM APPELLATIONS WHERE Area = 'Central Coast' | CREATE TABLE WINE (Appelation VARCHAR(255), YEAR INTEGER, Area VARCHAR(255)); CREATE TABLE APPELLATIONS (Appelation VARCHAR(255), YEAR INTEGER, Area VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 3737
} |
Find the county where produces the most number of wines with score higher than 90. | SELECT T1.County FROM APPELLATIONS AS T1 JOIN WINE AS T2 ON T1.Appelation = T2.Appelation WHERE T2.Score > 90 GROUP BY T1.County ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE WINE (Appelation VARCHAR(255), Score INTEGER); CREATE TABLE APPELLATIONS (County VARCHAR(255), Appelation VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 5 | 0 | 0 | {
"split": "train",
"row_index": 3739
} |
How many train stations are there? | SELECT COUNT(*) FROM station | CREATE TABLE station (Id VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3740
} |
Show the name, location, and number of platforms for all stations. | SELECT name, LOCATION, number_of_platforms FROM station | CREATE TABLE station (name VARCHAR(255), LOCATION VARCHAR(255), number_of_platforms VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 3741
} |
What are all locations of train stations? | SELECT DISTINCT LOCATION FROM station | CREATE TABLE station (LOCATION VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3742
} |
Show the names and total passengers for all train stations not in London. | SELECT name, total_passengers FROM station WHERE LOCATION <> 'London' | CREATE TABLE station (name VARCHAR(255), total_passengers VARCHAR(255), LOCATION VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3743
} |
Show the names and main services for train stations that have the top three total number of passengers. | SELECT name, main_services FROM station ORDER BY total_passengers DESC LIMIT 3 | CREATE TABLE station (name VARCHAR(255), main_services VARCHAR(255), total_passengers VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3744
} |
What is the average and maximum number of total passengers for train stations in London or Glasgow? | SELECT AVG(total_passengers), MAX(total_passengers) FROM station WHERE LOCATION = 'London' OR LOCATION = 'Glasgow' | CREATE TABLE station (total_passengers INTEGER, LOCATION VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 3 | {
"split": "train",
"row_index": 3745
} |
Show all locations and the total number of platforms and passengers for all train stations in each location. | SELECT LOCATION, SUM(number_of_platforms), SUM(total_passengers) FROM station GROUP BY LOCATION | CREATE TABLE station (LOCATION VARCHAR(255), number_of_platforms INTEGER, total_passengers INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 3746
} |
Show all locations that have train stations with at least 15 platforms and train stations with more than 25 total passengers. | SELECT DISTINCT LOCATION FROM station WHERE number_of_platforms >= 15 AND total_passengers > 25 | CREATE TABLE station (LOCATION VARCHAR(255), number_of_platforms VARCHAR(255), total_passengers VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3747
} |
Show all locations which don't have a train station with at least 15 platforms. | SELECT LOCATION FROM station EXCEPT SELECT LOCATION FROM station WHERE number_of_platforms >= 15 | CREATE TABLE station (LOCATION VARCHAR(255), number_of_platforms VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 3748
} |
Show the location with most number of train stations. | SELECT LOCATION FROM station GROUP BY LOCATION ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE station (LOCATION VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 3749
} |
Show the name, time, and service for all trains. | SELECT name, TIME, service FROM train | CREATE TABLE train (name VARCHAR(255), TIME VARCHAR(255), service VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 3750
} |
Show the number of trains | SELECT COUNT(*) FROM train | CREATE TABLE train (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3751
} |
Show the name and service for all trains in order by time. | SELECT name, service FROM train ORDER BY TIME | CREATE TABLE train (name VARCHAR(255), service VARCHAR(255), TIME VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3752
} |
Show the station name and number of trains in each station. | SELECT T2.name, COUNT(*) FROM train_station AS T1 JOIN station AS T2 ON T1.station_id = T2.station_id GROUP BY T1.station_id | CREATE TABLE station (name VARCHAR(255), station_id VARCHAR(255)); CREATE TABLE train_station (station_id VARCHAR(255), train_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3753
} |
show the train name and station name for each train. | SELECT T2.name, T3.name FROM train_station AS T1 JOIN station AS T2 ON T1.station_id = T2.station_id JOIN train AS T3 ON T3.train_id = T1.train_id | CREATE TABLE station (name VARCHAR(255), station_id VARCHAR(255)); CREATE TABLE train (name VARCHAR(255), train_id VARCHAR(255), service VARCHAR(255)); CREATE TABLE train_station (station_id VARCHAR(255), train_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3754
} |
Show all train names and times in stations in London in descending order by train time. | SELECT T3.name, T3.time FROM train_station AS T1 JOIN station AS T2 ON T1.station_id = T2.station_id JOIN train AS T3 ON T3.train_id = T1.train_id WHERE T2.location = 'London' ORDER BY T3.time DESC | CREATE TABLE train_station (station_id VARCHAR(255), train_id VARCHAR(255)); CREATE TABLE station (station_id VARCHAR(255), location VARCHAR(255)); CREATE TABLE train (name VARCHAR(255), time VARCHAR(255), train_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 3755
} |
Show the station name with greatest number of trains. | SELECT T2.name FROM train_station AS T1 JOIN station AS T2 ON T1.station_id = T2.station_id GROUP BY T1.station_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE station (name VARCHAR(255), station_id VARCHAR(255)); CREATE TABLE train_station (station_id VARCHAR(255), train_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 3756
} |
Show the station name with at least two trains. | SELECT T2.name FROM train_station AS T1 JOIN station AS T2 ON T1.station_id = T2.station_id GROUP BY T1.station_id HAVING COUNT(*) >= 2 | CREATE TABLE station (name VARCHAR(255), station_id VARCHAR(255)); CREATE TABLE train_station (station_id VARCHAR(255), train_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3757
} |
Show all locations with only 1 station. | SELECT LOCATION FROM station GROUP BY LOCATION HAVING COUNT(*) = 1 | CREATE TABLE station (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": 3758
} |
Show station names without any trains. | SELECT name FROM station WHERE NOT station_id IN (SELECT station_id FROM train_station) | CREATE TABLE station (name VARCHAR(255), station_id VARCHAR(255)); CREATE TABLE train_station (name VARCHAR(255), station_id VARCHAR(255), train_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 3759
} |
What are the names of the stations which serve both "Ananthapuri Express" and "Guruvayur Express" trains? | SELECT T2.name FROM train_station AS T1 JOIN station AS T2 ON T1.station_id = T2.station_id JOIN train AS T3 ON T3.train_id = T1.train_id WHERE T3.Name = 'Ananthapuri Express' INTERSECT SELECT T2.name FROM train_station AS T1 JOIN station AS T2 ON T1.station_id = T2.station_id JOIN train AS T3 ON T3.train_id = T1.train... | CREATE TABLE station (name VARCHAR(255), station_id VARCHAR(255)); CREATE TABLE train (train_id VARCHAR(255), Name VARCHAR(255)); CREATE TABLE train_station (station_id VARCHAR(255), train_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 1 | 0 | {
"split": "train",
"row_index": 3760
} |
List the names and locations of all stations ordered by their yearly entry exit and interchange amounts. | SELECT name, LOCATION FROM station ORDER BY Annual_entry_exit, Annual_interchanges | CREATE TABLE station (name VARCHAR(255), LOCATION VARCHAR(255), Annual_entry_exit VARCHAR(255), Annual_interchanges VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3762
} |
List all vehicle id | SELECT vehicle_id FROM Vehicles | CREATE TABLE Vehicles (vehicle_id VARCHAR(255), type VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3763
} |
How many vehicle in total? | SELECT COUNT(*) FROM Vehicles | CREATE TABLE Vehicles (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3764
} |
Show the detail of vehicle with id 1. | SELECT vehicle_details FROM Vehicles WHERE vehicle_id = 1 | CREATE TABLE Vehicles (vehicle_details VARCHAR(255), vehicle_id VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3765
} |
List the first name middle name and last name of all staff. | SELECT first_name, middle_name, last_name FROM Staff | CREATE TABLE Staff (first_name VARCHAR(255), middle_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 3766
} |
What is the birthday of the staff member with first name as Janessa and last name as Sawayn? | SELECT date_of_birth FROM Staff WHERE first_name = 'Janessa' AND last_name = 'Sawayn' | CREATE TABLE Staff (date_of_birth VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3767
} |
When did the staff member with first name as Janessa and last name as Sawayn join the company? | SELECT date_joined_staff FROM Staff WHERE first_name = 'Janessa' AND last_name = 'Sawayn' | CREATE TABLE Staff (date_joined_staff VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3768
} |
When did the staff member with first name as Janessa and last name as Sawayn leave the company? | SELECT date_left_staff FROM Staff WHERE first_name = 'Janessa' AND last_name = 'Sawayn' | CREATE TABLE Staff (date_left_staff VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3769
} |
How many staff have the first name Ludie? | SELECT COUNT(*) FROM Staff WHERE first_name = 'Ludie' | CREATE TABLE Staff (first_name VARCHAR(255), last_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3770
} |
What is the nickname of staff with first name as Janessa and last name as Sawayn? | SELECT nickname FROM Staff WHERE first_name = 'Janessa' AND last_name = 'Sawayn' | CREATE TABLE Staff (nickname VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3771
} |
How many staff in total? | SELECT COUNT(*) FROM Staff | CREATE TABLE Staff (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3772
} |
Which city does staff with first name as Janessa and last name as Sawayn live? | SELECT T1.city FROM Addresses AS T1 JOIN Staff AS T2 ON T1.address_id = T2.staff_address_id WHERE T2.first_name = 'Janessa' AND T2.last_name = 'Sawayn' | CREATE TABLE Staff (staff_address_id VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)); CREATE TABLE Addresses (city VARCHAR(255), address_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3773
} |
Which country and state does staff with first name as Janessa and last name as Sawayn lived? | SELECT T1.country, T1.state_province_county FROM Addresses AS T1 JOIN Staff AS T2 ON T1.address_id = T2.staff_address_id WHERE T2.first_name = 'Janessa' AND T2.last_name = 'Sawayn' | CREATE TABLE Addresses (country VARCHAR(255), state_province_county VARCHAR(255), address_id VARCHAR(255)); CREATE TABLE Staff (staff_address_id VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 2 | {
"split": "train",
"row_index": 3774
} |
How long is the total lesson time took by customer with first name as Rylan and last name as Goodwin? | SELECT SUM(T1.lesson_time) FROM Lessons AS T1 JOIN Customers AS T2 ON T1.customer_id = T2.customer_id WHERE T2.first_name = 'Rylan' AND T2.last_name = 'Goodwin' | CREATE TABLE Lessons (lesson_time INTEGER, customer_id VARCHAR(255)); CREATE TABLE Customers (customer_id VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3775
} |
What is the zip code of staff with first name as Janessa and last name as Sawayn lived? | SELECT T1.zip_postcode FROM Addresses AS T1 JOIN Staff AS T2 ON T1.address_id = T2.staff_address_id WHERE T2.first_name = 'Janessa' AND T2.last_name = 'Sawayn' | CREATE TABLE Addresses (zip_postcode VARCHAR(255), address_id VARCHAR(255)); CREATE TABLE Staff (staff_address_id VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3776
} |
How many staff live in state Georgia? | SELECT COUNT(*) FROM Addresses WHERE state_province_county = 'Georgia' | CREATE TABLE Addresses (state_province_county 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": 3777
} |
Find out the first name and last name of staff lived in city Damianfort. | SELECT T2.first_name, T2.last_name FROM Addresses AS T1 JOIN Staff AS T2 ON T1.address_id = T2.staff_address_id WHERE T1.city = 'Damianfort' | CREATE TABLE Staff (first_name VARCHAR(255), last_name VARCHAR(255), staff_address_id VARCHAR(255)); CREATE TABLE Addresses (address_id VARCHAR(255), city VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3778
} |
Which city lives most of staffs? List the city name and number of staffs. | SELECT T1.city, COUNT(*) FROM Addresses AS T1 JOIN Staff AS T2 ON T1.address_id = T2.staff_address_id GROUP BY T1.city ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Staff (staff_address_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Addresses (city VARCHAR(255), address_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 2 | {
"split": "train",
"row_index": 3779
} |
List the states which have between 2 to 4 staffs living there. | SELECT T1.state_province_county FROM Addresses AS T1 JOIN Staff AS T2 ON T1.address_id = T2.staff_address_id GROUP BY T1.state_province_county HAVING COUNT(*) BETWEEN 2 AND 4 | CREATE TABLE Addresses (state_province_county VARCHAR(255), address_id VARCHAR(255)); CREATE TABLE Staff (staff_address_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3780
} |
List the first name and last name of all customers. | SELECT first_name, last_name FROM Customers | CREATE TABLE Customers (first_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 3781
} |
List email address and birthday of customer whose first name as Carole. | SELECT email_address, date_of_birth FROM Customers WHERE first_name = 'Carole' | CREATE TABLE Customers (email_address VARCHAR(255), date_of_birth VARCHAR(255), first_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3782
} |
List phone number and email address of customer with more than 2000 outstanding balance. | SELECT phone_number, email_address FROM Customers WHERE amount_outstanding > 2000 | CREATE TABLE Customers (phone_number VARCHAR(255), email_address VARCHAR(255), amount_outstanding INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3783
} |
What is the status code, mobile phone number and email address of customer with last name as Kohler or first name as Marina? | SELECT customer_status_code, cell_mobile_phone_number, email_address FROM Customers WHERE first_name = 'Marina' OR last_name = 'Kohler' | CREATE TABLE Customers (customer_status_code VARCHAR(255), cell_mobile_phone_number VARCHAR(255), email_address VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 2 | {
"split": "train",
"row_index": 3784
} |
When are the birthdays of customer who are classified as 'Good Customer' status? | SELECT date_of_birth FROM Customers WHERE customer_status_code = 'Good Customer' | CREATE TABLE Customers (date_of_birth VARCHAR(255), customer_status_code VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3785
} |
When did customer with first name as Carole and last name as Bernhard became a customer? | SELECT date_became_customer FROM Customers WHERE first_name = 'Carole' AND last_name = 'Bernhard' | CREATE TABLE Customers (date_became_customer VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3786
} |
List all customer status codes and the number of customers having each status code. | SELECT customer_status_code, COUNT(*) FROM Customers GROUP BY customer_status_code | CREATE TABLE Customers (customer_status_code 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": 3787
} |
Which customer status code has least number of customers? | SELECT customer_status_code FROM Customers GROUP BY customer_status_code ORDER BY COUNT(*) LIMIT 1 | CREATE TABLE Customers (customer_status_code VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 3788
} |
How many lessons taken by customer with first name as Rylan and last name as Goodwin were completed? | SELECT COUNT(*) FROM Lessons AS T1 JOIN Customers AS T2 ON T1.customer_id = T2.customer_id WHERE T2.first_name = 'Rylan' AND T2.last_name = 'Goodwin' AND T1.lesson_status_code = 'Completed' | CREATE TABLE Lessons (customer_id VARCHAR(255), lesson_status_code VARCHAR(255)); CREATE TABLE Customers (customer_id VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3789
} |
What is maximum, minimum and average amount of outstanding of customer? | SELECT MAX(amount_outstanding), MIN(amount_outstanding), AVG(amount_outstanding) FROM Customers | CREATE TABLE Customers (amount_outstanding 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": 3790
} |
List the first name and last name of customers have the amount of outstanding between 1000 and 3000. | SELECT first_name, last_name FROM Customers WHERE amount_outstanding BETWEEN 1000 AND 3000 | CREATE TABLE Customers (first_name VARCHAR(255), last_name VARCHAR(255), amount_outstanding INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3791
} |
List first name and last name of customers lived in city Lockmanfurt. | SELECT T1.first_name, T1.last_name FROM Customers AS T1 JOIN Addresses AS T2 ON T1.customer_address_id = T2.address_id WHERE T2.city = 'Lockmanfurt' | CREATE TABLE Customers (first_name VARCHAR(255), last_name VARCHAR(255), customer_address_id VARCHAR(255)); CREATE TABLE Addresses (address_id VARCHAR(255), city VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3792
} |
Which country does customer with first name as Carole and last name as Bernhard lived in? | SELECT T2.country FROM Customers AS T1 JOIN Addresses AS T2 ON T1.customer_address_id = T2.address_id WHERE T1.first_name = 'Carole' AND T1.last_name = 'Bernhard' | CREATE TABLE Addresses (country VARCHAR(255), address_id VARCHAR(255)); CREATE TABLE Customers (customer_address_id VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3793
} |
What is zip code of customer with first name as Carole and last name as Bernhard? | SELECT T2.zip_postcode FROM Customers AS T1 JOIN Addresses AS T2 ON T1.customer_address_id = T2.address_id WHERE T1.first_name = 'Carole' AND T1.last_name = 'Bernhard' | CREATE TABLE Addresses (zip_postcode VARCHAR(255), address_id VARCHAR(255)); CREATE TABLE Customers (customer_address_id VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3794
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.