DDL_schema
stringlengths 263
8.16k
| query
stringlengths 18
577
| question
stringlengths 3
224
| db_id
stringlengths 3
31
|
|---|---|---|---|
CREATE TABLE "county" (
"County_Id" int,
"County_name" text,
"Population" real,
"Zip_code" text,
PRIMARY KEY ("County_Id")
)
CREATE TABLE "party" (
"Party_ID" int,
"Year" real,
"Party" text,
"Governor" text,
"Lieutenant_Governor" text,
"Comptroller" text,
"Attorney_General" text,
"US_Senate" text,
PRIMARY KEY ("Party_ID")
)
CREATE TABLE "election" (
"Election_ID" int,
"Counties_Represented" text,
"District" int,
"Delegate" text,
"Party" int,
"First_Elected" real,
"Committee" text,
PRIMARY KEY ("Election_ID"),
FOREIGN KEY (`Party`) REFERENCES `party`(`Party_ID`),
FOREIGN KEY (`District`) REFERENCES `county`(`County_Id`)
)
|
SELECT T1.Committee FROM election AS T1 JOIN party AS T2 ON T1.Party = T2.Party_ID WHERE T2.Party = "Democratic" INTERSECT SELECT T1.Committee FROM election AS T1 JOIN party AS T2 ON T1.Party = T2.Party_ID WHERE T2.Party = "Liberal"
|
Which committees have delegates from both democratic party and liberal party?
|
election
|
CREATE TABLE "county" (
"County_Id" int,
"County_name" text,
"Population" real,
"Zip_code" text,
PRIMARY KEY ("County_Id")
)
CREATE TABLE "party" (
"Party_ID" int,
"Year" real,
"Party" text,
"Governor" text,
"Lieutenant_Governor" text,
"Comptroller" text,
"Attorney_General" text,
"US_Senate" text,
PRIMARY KEY ("Party_ID")
)
CREATE TABLE "election" (
"Election_ID" int,
"Counties_Represented" text,
"District" int,
"Delegate" text,
"Party" int,
"First_Elected" real,
"Committee" text,
PRIMARY KEY ("Election_ID"),
FOREIGN KEY (`Party`) REFERENCES `party`(`Party_ID`),
FOREIGN KEY (`District`) REFERENCES `county`(`County_Id`)
)
|
SELECT T1.Committee FROM election AS T1 JOIN party AS T2 ON T1.Party = T2.Party_ID WHERE T2.Party = "Democratic" INTERSECT SELECT T1.Committee FROM election AS T1 JOIN party AS T2 ON T1.Party = T2.Party_ID WHERE T2.Party = "Liberal"
|
Find the committees that have delegates both from from the democratic party and the liberal party.
|
election
|
CREATE TABLE "event" (
"Event_ID" int,
"Date" text,
"Venue" text,
"Name" text,
"Event_Attendance" int,
PRIMARY KEY ("Event_ID")
)
CREATE TABLE "journalist" (
"journalist_ID" int,
"Name" text,
"Nationality" text,
"Age" text,
"Years_working" int,
PRIMARY KEY ("journalist_ID")
)
CREATE TABLE "news_report" (
"journalist_ID" int,
"Event_ID" int,
"Work_Type" text,
PRIMARY KEY ("journalist_ID","Event_ID"),
FOREIGN KEY ("journalist_ID") REFERENCES `journalist`("journalist_ID"),
FOREIGN KEY ("Event_ID") REFERENCES `event`("Event_ID")
)
|
SELECT count(*) FROM journalist
|
How many journalists are there?
|
news_report
|
CREATE TABLE "event" (
"Event_ID" int,
"Date" text,
"Venue" text,
"Name" text,
"Event_Attendance" int,
PRIMARY KEY ("Event_ID")
)
CREATE TABLE "journalist" (
"journalist_ID" int,
"Name" text,
"Nationality" text,
"Age" text,
"Years_working" int,
PRIMARY KEY ("journalist_ID")
)
CREATE TABLE "news_report" (
"journalist_ID" int,
"Event_ID" int,
"Work_Type" text,
PRIMARY KEY ("journalist_ID","Event_ID"),
FOREIGN KEY ("journalist_ID") REFERENCES `journalist`("journalist_ID"),
FOREIGN KEY ("Event_ID") REFERENCES `event`("Event_ID")
)
|
SELECT Name FROM journalist ORDER BY Years_working ASC
|
List the names of journalists in ascending order of years working.
|
news_report
|
CREATE TABLE "event" (
"Event_ID" int,
"Date" text,
"Venue" text,
"Name" text,
"Event_Attendance" int,
PRIMARY KEY ("Event_ID")
)
CREATE TABLE "journalist" (
"journalist_ID" int,
"Name" text,
"Nationality" text,
"Age" text,
"Years_working" int,
PRIMARY KEY ("journalist_ID")
)
CREATE TABLE "news_report" (
"journalist_ID" int,
"Event_ID" int,
"Work_Type" text,
PRIMARY KEY ("journalist_ID","Event_ID"),
FOREIGN KEY ("journalist_ID") REFERENCES `journalist`("journalist_ID"),
FOREIGN KEY ("Event_ID") REFERENCES `event`("Event_ID")
)
|
SELECT Nationality , Age FROM journalist
|
What are the nationalities and ages of journalists?
|
news_report
|
CREATE TABLE "event" (
"Event_ID" int,
"Date" text,
"Venue" text,
"Name" text,
"Event_Attendance" int,
PRIMARY KEY ("Event_ID")
)
CREATE TABLE "journalist" (
"journalist_ID" int,
"Name" text,
"Nationality" text,
"Age" text,
"Years_working" int,
PRIMARY KEY ("journalist_ID")
)
CREATE TABLE "news_report" (
"journalist_ID" int,
"Event_ID" int,
"Work_Type" text,
PRIMARY KEY ("journalist_ID","Event_ID"),
FOREIGN KEY ("journalist_ID") REFERENCES `journalist`("journalist_ID"),
FOREIGN KEY ("Event_ID") REFERENCES `event`("Event_ID")
)
|
SELECT Name FROM journalist WHERE Nationality = "England" OR Nationality = "Wales"
|
Show the names of journalists from "England" or "Wales".
|
news_report
|
CREATE TABLE "event" (
"Event_ID" int,
"Date" text,
"Venue" text,
"Name" text,
"Event_Attendance" int,
PRIMARY KEY ("Event_ID")
)
CREATE TABLE "journalist" (
"journalist_ID" int,
"Name" text,
"Nationality" text,
"Age" text,
"Years_working" int,
PRIMARY KEY ("journalist_ID")
)
CREATE TABLE "news_report" (
"journalist_ID" int,
"Event_ID" int,
"Work_Type" text,
PRIMARY KEY ("journalist_ID","Event_ID"),
FOREIGN KEY ("journalist_ID") REFERENCES `journalist`("journalist_ID"),
FOREIGN KEY ("Event_ID") REFERENCES `event`("Event_ID")
)
|
SELECT avg(Years_working) FROM journalist
|
What is the average number of years spent working as a journalist?
|
news_report
|
CREATE TABLE "event" (
"Event_ID" int,
"Date" text,
"Venue" text,
"Name" text,
"Event_Attendance" int,
PRIMARY KEY ("Event_ID")
)
CREATE TABLE "journalist" (
"journalist_ID" int,
"Name" text,
"Nationality" text,
"Age" text,
"Years_working" int,
PRIMARY KEY ("journalist_ID")
)
CREATE TABLE "news_report" (
"journalist_ID" int,
"Event_ID" int,
"Work_Type" text,
PRIMARY KEY ("journalist_ID","Event_ID"),
FOREIGN KEY ("journalist_ID") REFERENCES `journalist`("journalist_ID"),
FOREIGN KEY ("Event_ID") REFERENCES `event`("Event_ID")
)
|
SELECT Nationality FROM journalist ORDER BY Years_working DESC LIMIT 1
|
What is the nationality of the journalist with the largest number of years working?
|
news_report
|
CREATE TABLE "event" (
"Event_ID" int,
"Date" text,
"Venue" text,
"Name" text,
"Event_Attendance" int,
PRIMARY KEY ("Event_ID")
)
CREATE TABLE "journalist" (
"journalist_ID" int,
"Name" text,
"Nationality" text,
"Age" text,
"Years_working" int,
PRIMARY KEY ("journalist_ID")
)
CREATE TABLE "news_report" (
"journalist_ID" int,
"Event_ID" int,
"Work_Type" text,
PRIMARY KEY ("journalist_ID","Event_ID"),
FOREIGN KEY ("journalist_ID") REFERENCES `journalist`("journalist_ID"),
FOREIGN KEY ("Event_ID") REFERENCES `event`("Event_ID")
)
|
SELECT Nationality , COUNT(*) FROM journalist GROUP BY Nationality
|
Show the different nationalities and the number of journalists of each nationality.
|
news_report
|
CREATE TABLE "event" (
"Event_ID" int,
"Date" text,
"Venue" text,
"Name" text,
"Event_Attendance" int,
PRIMARY KEY ("Event_ID")
)
CREATE TABLE "journalist" (
"journalist_ID" int,
"Name" text,
"Nationality" text,
"Age" text,
"Years_working" int,
PRIMARY KEY ("journalist_ID")
)
CREATE TABLE "news_report" (
"journalist_ID" int,
"Event_ID" int,
"Work_Type" text,
PRIMARY KEY ("journalist_ID","Event_ID"),
FOREIGN KEY ("journalist_ID") REFERENCES `journalist`("journalist_ID"),
FOREIGN KEY ("Event_ID") REFERENCES `event`("Event_ID")
)
|
SELECT Nationality FROM journalist GROUP BY Nationality ORDER BY COUNT(*) DESC LIMIT 1
|
Show the most common nationality for journalists.
|
news_report
|
CREATE TABLE "event" (
"Event_ID" int,
"Date" text,
"Venue" text,
"Name" text,
"Event_Attendance" int,
PRIMARY KEY ("Event_ID")
)
CREATE TABLE "journalist" (
"journalist_ID" int,
"Name" text,
"Nationality" text,
"Age" text,
"Years_working" int,
PRIMARY KEY ("journalist_ID")
)
CREATE TABLE "news_report" (
"journalist_ID" int,
"Event_ID" int,
"Work_Type" text,
PRIMARY KEY ("journalist_ID","Event_ID"),
FOREIGN KEY ("journalist_ID") REFERENCES `journalist`("journalist_ID"),
FOREIGN KEY ("Event_ID") REFERENCES `event`("Event_ID")
)
|
SELECT Nationality FROM journalist WHERE Years_working > 10 INTERSECT SELECT Nationality FROM journalist WHERE Years_working < 3
|
Show the nations that have both journalists with more than 10 years of working and journalists with less than 3 years of working.
|
news_report
|
CREATE TABLE "event" (
"Event_ID" int,
"Date" text,
"Venue" text,
"Name" text,
"Event_Attendance" int,
PRIMARY KEY ("Event_ID")
)
CREATE TABLE "journalist" (
"journalist_ID" int,
"Name" text,
"Nationality" text,
"Age" text,
"Years_working" int,
PRIMARY KEY ("journalist_ID")
)
CREATE TABLE "news_report" (
"journalist_ID" int,
"Event_ID" int,
"Work_Type" text,
PRIMARY KEY ("journalist_ID","Event_ID"),
FOREIGN KEY ("journalist_ID") REFERENCES `journalist`("journalist_ID"),
FOREIGN KEY ("Event_ID") REFERENCES `event`("Event_ID")
)
|
SELECT Date , Name , venue FROM event ORDER BY Event_Attendance DESC
|
Show the dates, places, and names of events in descending order of the attendance.
|
news_report
|
CREATE TABLE "event" (
"Event_ID" int,
"Date" text,
"Venue" text,
"Name" text,
"Event_Attendance" int,
PRIMARY KEY ("Event_ID")
)
CREATE TABLE "journalist" (
"journalist_ID" int,
"Name" text,
"Nationality" text,
"Age" text,
"Years_working" int,
PRIMARY KEY ("journalist_ID")
)
CREATE TABLE "news_report" (
"journalist_ID" int,
"Event_ID" int,
"Work_Type" text,
PRIMARY KEY ("journalist_ID","Event_ID"),
FOREIGN KEY ("journalist_ID") REFERENCES `journalist`("journalist_ID"),
FOREIGN KEY ("Event_ID") REFERENCES `event`("Event_ID")
)
|
SELECT T3.Name , T2.Date FROM news_report AS T1 JOIN event AS T2 ON T1.Event_ID = T2.Event_ID JOIN journalist AS T3 ON T1.journalist_ID = T3.journalist_ID
|
Show the names of journalists and the dates of the events they reported.
|
news_report
|
CREATE TABLE "event" (
"Event_ID" int,
"Date" text,
"Venue" text,
"Name" text,
"Event_Attendance" int,
PRIMARY KEY ("Event_ID")
)
CREATE TABLE "journalist" (
"journalist_ID" int,
"Name" text,
"Nationality" text,
"Age" text,
"Years_working" int,
PRIMARY KEY ("journalist_ID")
)
CREATE TABLE "news_report" (
"journalist_ID" int,
"Event_ID" int,
"Work_Type" text,
PRIMARY KEY ("journalist_ID","Event_ID"),
FOREIGN KEY ("journalist_ID") REFERENCES `journalist`("journalist_ID"),
FOREIGN KEY ("Event_ID") REFERENCES `event`("Event_ID")
)
|
SELECT T3.Name , T2.Name FROM news_report AS T1 JOIN event AS T2 ON T1.Event_ID = T2.Event_ID JOIN journalist AS T3 ON T1.journalist_ID = T3.journalist_ID ORDER BY T2.Event_Attendance ASC
|
Show the names of journalists and the names of the events they reported in ascending order
|
news_report
|
CREATE TABLE "event" (
"Event_ID" int,
"Date" text,
"Venue" text,
"Name" text,
"Event_Attendance" int,
PRIMARY KEY ("Event_ID")
)
CREATE TABLE "journalist" (
"journalist_ID" int,
"Name" text,
"Nationality" text,
"Age" text,
"Years_working" int,
PRIMARY KEY ("journalist_ID")
)
CREATE TABLE "news_report" (
"journalist_ID" int,
"Event_ID" int,
"Work_Type" text,
PRIMARY KEY ("journalist_ID","Event_ID"),
FOREIGN KEY ("journalist_ID") REFERENCES `journalist`("journalist_ID"),
FOREIGN KEY ("Event_ID") REFERENCES `event`("Event_ID")
)
|
SELECT T3.Name , COUNT(*) FROM news_report AS T1 JOIN event AS T2 ON T1.Event_ID = T2.Event_ID JOIN journalist AS T3 ON T1.journalist_ID = T3.journalist_ID GROUP BY T3.Name
|
Show the names of journalists and the number of events they reported.
|
news_report
|
CREATE TABLE "event" (
"Event_ID" int,
"Date" text,
"Venue" text,
"Name" text,
"Event_Attendance" int,
PRIMARY KEY ("Event_ID")
)
CREATE TABLE "journalist" (
"journalist_ID" int,
"Name" text,
"Nationality" text,
"Age" text,
"Years_working" int,
PRIMARY KEY ("journalist_ID")
)
CREATE TABLE "news_report" (
"journalist_ID" int,
"Event_ID" int,
"Work_Type" text,
PRIMARY KEY ("journalist_ID","Event_ID"),
FOREIGN KEY ("journalist_ID") REFERENCES `journalist`("journalist_ID"),
FOREIGN KEY ("Event_ID") REFERENCES `event`("Event_ID")
)
|
SELECT T3.Name FROM news_report AS T1 JOIN event AS T2 ON T1.Event_ID = T2.Event_ID JOIN journalist AS T3 ON T1.journalist_ID = T3.journalist_ID GROUP BY T3.Name HAVING COUNT(*) > 1
|
Show the names of journalists that have reported more than one event.
|
news_report
|
CREATE TABLE "event" (
"Event_ID" int,
"Date" text,
"Venue" text,
"Name" text,
"Event_Attendance" int,
PRIMARY KEY ("Event_ID")
)
CREATE TABLE "journalist" (
"journalist_ID" int,
"Name" text,
"Nationality" text,
"Age" text,
"Years_working" int,
PRIMARY KEY ("journalist_ID")
)
CREATE TABLE "news_report" (
"journalist_ID" int,
"Event_ID" int,
"Work_Type" text,
PRIMARY KEY ("journalist_ID","Event_ID"),
FOREIGN KEY ("journalist_ID") REFERENCES `journalist`("journalist_ID"),
FOREIGN KEY ("Event_ID") REFERENCES `event`("Event_ID")
)
|
SELECT Name FROM journalist WHERE journalist_ID NOT IN (SELECT journalist_ID FROM news_report)
|
List the names of journalists who have not reported any event.
|
news_report
|
CREATE TABLE "event" (
"Event_ID" int,
"Date" text,
"Venue" text,
"Name" text,
"Event_Attendance" int,
PRIMARY KEY ("Event_ID")
)
CREATE TABLE "journalist" (
"journalist_ID" int,
"Name" text,
"Nationality" text,
"Age" text,
"Years_working" int,
PRIMARY KEY ("journalist_ID")
)
CREATE TABLE "news_report" (
"journalist_ID" int,
"Event_ID" int,
"Work_Type" text,
PRIMARY KEY ("journalist_ID","Event_ID"),
FOREIGN KEY ("journalist_ID") REFERENCES `journalist`("journalist_ID"),
FOREIGN KEY ("Event_ID") REFERENCES `event`("Event_ID")
)
|
SELECT avg(Event_Attendance) , max(Event_Attendance) FROM event
|
what are the average and maximum attendances of all events?
|
news_report
|
CREATE TABLE "event" (
"Event_ID" int,
"Date" text,
"Venue" text,
"Name" text,
"Event_Attendance" int,
PRIMARY KEY ("Event_ID")
)
CREATE TABLE "journalist" (
"journalist_ID" int,
"Name" text,
"Nationality" text,
"Age" text,
"Years_working" int,
PRIMARY KEY ("journalist_ID")
)
CREATE TABLE "news_report" (
"journalist_ID" int,
"Event_ID" int,
"Work_Type" text,
PRIMARY KEY ("journalist_ID","Event_ID"),
FOREIGN KEY ("journalist_ID") REFERENCES `journalist`("journalist_ID"),
FOREIGN KEY ("Event_ID") REFERENCES `event`("Event_ID")
)
|
SELECT avg(t1.age) , avg(Years_working) , t2.work_type FROM journalist AS t1 JOIN news_report AS t2 ON t1.journalist_id = t2.journalist_id GROUP BY t2.work_type
|
Find the average age and experience working length of journalists working on different role type.
|
news_report
|
CREATE TABLE "event" (
"Event_ID" int,
"Date" text,
"Venue" text,
"Name" text,
"Event_Attendance" int,
PRIMARY KEY ("Event_ID")
)
CREATE TABLE "journalist" (
"journalist_ID" int,
"Name" text,
"Nationality" text,
"Age" text,
"Years_working" int,
PRIMARY KEY ("journalist_ID")
)
CREATE TABLE "news_report" (
"journalist_ID" int,
"Event_ID" int,
"Work_Type" text,
PRIMARY KEY ("journalist_ID","Event_ID"),
FOREIGN KEY ("journalist_ID") REFERENCES `journalist`("journalist_ID"),
FOREIGN KEY ("Event_ID") REFERENCES `event`("Event_ID")
)
|
SELECT venue , name FROM event ORDER BY Event_Attendance DESC LIMIT 2
|
List the event venues and names that have the top 2 most number of people attended.
|
news_report
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT ResName FROM Restaurant;
|
Show me all the restaurants.
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT Address FROM Restaurant WHERE ResName = "Subway";
|
What is the address of the restaurant Subway?
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT Rating FROM Restaurant WHERE ResName = "Subway";
|
What is the rating of the restaurant Subway?
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT ResTypeName FROM Restaurant_Type;
|
List all restaurant types.
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT ResTypeDescription FROM Restaurant_Type WHERE ResTypeName = "Sandwich";
|
What is the description of the restaurant type Sandwich?
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT ResName , Rating FROM Restaurant ORDER BY Rating DESC LIMIT 1;
|
Which restaurants have highest rating? List the restaurant name and its rating.
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT Age FROM Student WHERE Fname = "Linda" AND Lname = "Smith";
|
What is the age of student Linda Smith?
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT Sex FROM Student WHERE Fname = "Linda" AND Lname = "Smith";
|
What is the gender of the student Linda Smith?
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT Fname , Lname FROM Student WHERE Major = 600;
|
List all students' first names and last names who majored in 600.
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT city_code FROM Student WHERE Fname = "Linda" AND Lname = "Smith";
|
Which city does student Linda Smith live in?
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT count(*) FROM Student WHERE Advisor = 1121;
|
Advisor 1121 has how many students?
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT Advisor , count(*) FROM Student GROUP BY Advisor ORDER BY count(Advisor) DESC LIMIT 1;
|
Which Advisor has most of students? List advisor and the number of students.
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT Major , count(*) FROM Student GROUP BY Major ORDER BY count(Major) ASC LIMIT 1;
|
Which major has least number of students? List the major and the number of students.
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT Major , count(*) FROM Student GROUP BY Major HAVING count(Major) BETWEEN 2 AND 30;
|
Which major has between 2 and 30 number of students? List major and the number of students.
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT Fname , Lname FROM Student WHERE Age > 18 AND Major = 600;
|
Which student's age is older than 18 and is majoring in 600? List each student's first and last name.
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT Fname , Lname FROM Student WHERE Age > 18 AND Major != 600 AND Sex = 'F';
|
List all female students age is older than 18 who is not majoring in 600. List students' first name and last name.
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT count(*) FROM Restaurant JOIN Type_Of_Restaurant ON Restaurant.ResID = Type_Of_Restaurant.ResID JOIN Restaurant_Type ON Type_Of_Restaurant.ResTypeID = Restaurant_Type.ResTypeID GROUP BY Type_Of_Restaurant.ResTypeID HAVING Restaurant_Type.ResTypeName = 'Sandwich'
|
How many restaurant is the Sandwich type restaurant?
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT sum(Spent) FROM Student JOIN Visits_Restaurant ON Student.StuID = Visits_Restaurant.StuID WHERE Student.Fname = "Linda" AND Student.Lname = "Smith";
|
How long does student Linda Smith spend on the restaurant in total?
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT count(*) FROM Student JOIN Visits_Restaurant ON Student.StuID = Visits_Restaurant.StuID JOIN Restaurant ON Visits_Restaurant.ResID = Restaurant.ResID WHERE Student.Fname = "Linda" AND Student.Lname = "Smith" AND Restaurant.ResName = "Subway";
|
How many times has the student Linda Smith visited Subway?
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT TIME FROM Student JOIN Visits_Restaurant ON Student.StuID = Visits_Restaurant.StuID JOIN Restaurant ON Visits_Restaurant.ResID = Restaurant.ResID WHERE Student.Fname = "Linda" AND Student.Lname = "Smith" AND Restaurant.ResName = "Subway";
|
When did Linda Smith visit Subway?
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT Restaurant.ResName , sum(Visits_Restaurant.Spent) FROM Visits_Restaurant JOIN Restaurant ON Visits_Restaurant.ResID = Restaurant.ResID GROUP BY Restaurant.ResID ORDER BY sum(Visits_Restaurant.Spent) ASC LIMIT 1;
|
At which restaurant did the students spend the least amount of time? List restaurant and the time students spent on in total.
|
restaurant_1
|
CREATE TABLE Student (
StuID INTEGER PRIMARY KEY,
LName VARCHAR(12),
Fname VARCHAR(12),
Age INTEGER,
Sex VARCHAR(1),
Major INTEGER,
Advisor INTEGER,
city_code VARCHAR(3)
)
CREATE TABLE Restaurant (
ResID INTEGER PRIMARY KEY,
ResName VARCHAR(100),
Address VARCHAR(100),
Rating INTEGER
)
CREATE TABLE Type_Of_Restaurant (
ResID INTEGER,
ResTypeID INTEGER,
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID),
FOREIGN KEY(ResTypeID) REFERENCES Restaurant_Type(ResTypeID)
)
CREATE TABLE Restaurant_Type (
ResTypeID INTEGER PRIMARY KEY,
ResTypeName VARCHAR(40),
ResTypeDescription VARCHAR(100)
)
CREATE TABLE Visits_Restaurant (
StuID INTEGER,
ResID INTEGER,
Time TIMESTAMP,
Spent FLOAT,
FOREIGN KEY(StuID) REFERENCES Student(StuID),
FOREIGN KEY(ResID) REFERENCES Restaurant(ResID)
)
|
SELECT Student.Fname , Student.Lname FROM Student JOIN Visits_Restaurant ON Student.StuID = Visits_Restaurant.StuID GROUP BY Student.StuID ORDER BY count(*) DESC LIMIT 1;
|
Which student visited restaurant most often? List student's first name and last name.
|
restaurant_1
|
CREATE TABLE `Products` (
`product_id` INTEGER PRIMARY KEY,
`product_name` VARCHAR(20),
`product_price` DECIMAL(19,4),
`product_description` VARCHAR(255)
)
CREATE TABLE `Addresses` (
`address_id` INTEGER PRIMARY KEY,
`address_details` VARCHAR(80),
`city` VARCHAR(50),
`zip_postcode` VARCHAR(20),
`state_province_county` VARCHAR(50),
`country` VARCHAR(50)
)
CREATE TABLE `Customers` (
`customer_id` INTEGER PRIMARY KEY,
`payment_method` VARCHAR(10) NOT NULL,
`customer_name` VARCHAR(80),
`customer_phone` VARCHAR(80),
`customer_email` VARCHAR(80),
`date_became_customer` DATETIME
)
CREATE TABLE `Regular_Orders` (
`regular_order_id` INTEGER PRIMARY KEY,
`distributer_id` INTEGER NOT NULL,
FOREIGN KEY (`distributer_id` ) REFERENCES `Customers`(`customer_id` )
)
CREATE TABLE `Regular_Order_Products` (
`regular_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Orders` (
`actual_order_id` INTEGER PRIMARY KEY,
`order_status_code` VARCHAR(10) NOT NULL,
`regular_order_id` INTEGER NOT NULL,
`actual_order_date` DATETIME,
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Order_Products` (
`actual_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` )
)
CREATE TABLE `Customer_Addresses` (
`customer_id` INTEGER NOT NULL,
`address_id` INTEGER NOT NULL,
`date_from` DATETIME NOT NULL,
`address_type` VARCHAR(10) NOT NULL,
`date_to` DATETIME,
FOREIGN KEY (`customer_id` ) REFERENCES `Customers`(`customer_id` ),
FOREIGN KEY (`address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Delivery_Routes` (
`route_id` INTEGER PRIMARY KEY,
`route_name` VARCHAR(50),
`other_route_details` VARCHAR(255)
)
CREATE TABLE `Delivery_Route_Locations` (
`location_code` VARCHAR(10) PRIMARY KEY,
`route_id` INTEGER NOT NULL,
`location_address_id` INTEGER NOT NULL,
`location_name` VARCHAR(50),
FOREIGN KEY (`location_address_id` ) REFERENCES `Addresses`(`address_id` ),
FOREIGN KEY (`route_id` ) REFERENCES `Delivery_Routes`(`route_id` )
)
CREATE TABLE `Trucks` (
`truck_id` INTEGER PRIMARY KEY,
`truck_licence_number` VARCHAR(20),
`truck_details` VARCHAR(255)
)
CREATE TABLE `Employees` (
`employee_id` INTEGER PRIMARY KEY,
`employee_address_id` INTEGER NOT NULL,
`employee_name` VARCHAR(80),
`employee_phone` VARCHAR(80),
FOREIGN KEY (`employee_address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Order_Deliveries` (
`location_code` VARCHAR(10) NOT NULL,
`actual_order_id` INTEGER NOT NULL,
`delivery_status_code` VARCHAR(10) NOT NULL,
`driver_employee_id` INTEGER NOT NULL,
`truck_id` INTEGER NOT NULL,
`delivery_date` DATETIME,
FOREIGN KEY (`truck_id` ) REFERENCES `Trucks`(`truck_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` ),
FOREIGN KEY (`location_code` ) REFERENCES `Delivery_Route_Locations`(`location_code` ),
FOREIGN KEY (`driver_employee_id` ) REFERENCES `Employees`(`employee_id` )
)
|
SELECT actual_order_id FROM actual_orders WHERE order_status_code = 'Success'
|
Find the ids of orders whose status is 'Success'.
|
customer_deliveries
|
CREATE TABLE `Products` (
`product_id` INTEGER PRIMARY KEY,
`product_name` VARCHAR(20),
`product_price` DECIMAL(19,4),
`product_description` VARCHAR(255)
)
CREATE TABLE `Addresses` (
`address_id` INTEGER PRIMARY KEY,
`address_details` VARCHAR(80),
`city` VARCHAR(50),
`zip_postcode` VARCHAR(20),
`state_province_county` VARCHAR(50),
`country` VARCHAR(50)
)
CREATE TABLE `Customers` (
`customer_id` INTEGER PRIMARY KEY,
`payment_method` VARCHAR(10) NOT NULL,
`customer_name` VARCHAR(80),
`customer_phone` VARCHAR(80),
`customer_email` VARCHAR(80),
`date_became_customer` DATETIME
)
CREATE TABLE `Regular_Orders` (
`regular_order_id` INTEGER PRIMARY KEY,
`distributer_id` INTEGER NOT NULL,
FOREIGN KEY (`distributer_id` ) REFERENCES `Customers`(`customer_id` )
)
CREATE TABLE `Regular_Order_Products` (
`regular_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Orders` (
`actual_order_id` INTEGER PRIMARY KEY,
`order_status_code` VARCHAR(10) NOT NULL,
`regular_order_id` INTEGER NOT NULL,
`actual_order_date` DATETIME,
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Order_Products` (
`actual_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` )
)
CREATE TABLE `Customer_Addresses` (
`customer_id` INTEGER NOT NULL,
`address_id` INTEGER NOT NULL,
`date_from` DATETIME NOT NULL,
`address_type` VARCHAR(10) NOT NULL,
`date_to` DATETIME,
FOREIGN KEY (`customer_id` ) REFERENCES `Customers`(`customer_id` ),
FOREIGN KEY (`address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Delivery_Routes` (
`route_id` INTEGER PRIMARY KEY,
`route_name` VARCHAR(50),
`other_route_details` VARCHAR(255)
)
CREATE TABLE `Delivery_Route_Locations` (
`location_code` VARCHAR(10) PRIMARY KEY,
`route_id` INTEGER NOT NULL,
`location_address_id` INTEGER NOT NULL,
`location_name` VARCHAR(50),
FOREIGN KEY (`location_address_id` ) REFERENCES `Addresses`(`address_id` ),
FOREIGN KEY (`route_id` ) REFERENCES `Delivery_Routes`(`route_id` )
)
CREATE TABLE `Trucks` (
`truck_id` INTEGER PRIMARY KEY,
`truck_licence_number` VARCHAR(20),
`truck_details` VARCHAR(255)
)
CREATE TABLE `Employees` (
`employee_id` INTEGER PRIMARY KEY,
`employee_address_id` INTEGER NOT NULL,
`employee_name` VARCHAR(80),
`employee_phone` VARCHAR(80),
FOREIGN KEY (`employee_address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Order_Deliveries` (
`location_code` VARCHAR(10) NOT NULL,
`actual_order_id` INTEGER NOT NULL,
`delivery_status_code` VARCHAR(10) NOT NULL,
`driver_employee_id` INTEGER NOT NULL,
`truck_id` INTEGER NOT NULL,
`delivery_date` DATETIME,
FOREIGN KEY (`truck_id` ) REFERENCES `Trucks`(`truck_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` ),
FOREIGN KEY (`location_code` ) REFERENCES `Delivery_Route_Locations`(`location_code` ),
FOREIGN KEY (`driver_employee_id` ) REFERENCES `Employees`(`employee_id` )
)
|
SELECT t1.product_name , t1.product_price FROM products AS t1 JOIN regular_order_products AS t2 ON t1.product_id = t2.product_id GROUP BY t2.product_id ORDER BY count(*) DESC LIMIT 1
|
Find the name and price of the product that has been ordered the greatest number of times.
|
customer_deliveries
|
CREATE TABLE `Products` (
`product_id` INTEGER PRIMARY KEY,
`product_name` VARCHAR(20),
`product_price` DECIMAL(19,4),
`product_description` VARCHAR(255)
)
CREATE TABLE `Addresses` (
`address_id` INTEGER PRIMARY KEY,
`address_details` VARCHAR(80),
`city` VARCHAR(50),
`zip_postcode` VARCHAR(20),
`state_province_county` VARCHAR(50),
`country` VARCHAR(50)
)
CREATE TABLE `Customers` (
`customer_id` INTEGER PRIMARY KEY,
`payment_method` VARCHAR(10) NOT NULL,
`customer_name` VARCHAR(80),
`customer_phone` VARCHAR(80),
`customer_email` VARCHAR(80),
`date_became_customer` DATETIME
)
CREATE TABLE `Regular_Orders` (
`regular_order_id` INTEGER PRIMARY KEY,
`distributer_id` INTEGER NOT NULL,
FOREIGN KEY (`distributer_id` ) REFERENCES `Customers`(`customer_id` )
)
CREATE TABLE `Regular_Order_Products` (
`regular_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Orders` (
`actual_order_id` INTEGER PRIMARY KEY,
`order_status_code` VARCHAR(10) NOT NULL,
`regular_order_id` INTEGER NOT NULL,
`actual_order_date` DATETIME,
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Order_Products` (
`actual_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` )
)
CREATE TABLE `Customer_Addresses` (
`customer_id` INTEGER NOT NULL,
`address_id` INTEGER NOT NULL,
`date_from` DATETIME NOT NULL,
`address_type` VARCHAR(10) NOT NULL,
`date_to` DATETIME,
FOREIGN KEY (`customer_id` ) REFERENCES `Customers`(`customer_id` ),
FOREIGN KEY (`address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Delivery_Routes` (
`route_id` INTEGER PRIMARY KEY,
`route_name` VARCHAR(50),
`other_route_details` VARCHAR(255)
)
CREATE TABLE `Delivery_Route_Locations` (
`location_code` VARCHAR(10) PRIMARY KEY,
`route_id` INTEGER NOT NULL,
`location_address_id` INTEGER NOT NULL,
`location_name` VARCHAR(50),
FOREIGN KEY (`location_address_id` ) REFERENCES `Addresses`(`address_id` ),
FOREIGN KEY (`route_id` ) REFERENCES `Delivery_Routes`(`route_id` )
)
CREATE TABLE `Trucks` (
`truck_id` INTEGER PRIMARY KEY,
`truck_licence_number` VARCHAR(20),
`truck_details` VARCHAR(255)
)
CREATE TABLE `Employees` (
`employee_id` INTEGER PRIMARY KEY,
`employee_address_id` INTEGER NOT NULL,
`employee_name` VARCHAR(80),
`employee_phone` VARCHAR(80),
FOREIGN KEY (`employee_address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Order_Deliveries` (
`location_code` VARCHAR(10) NOT NULL,
`actual_order_id` INTEGER NOT NULL,
`delivery_status_code` VARCHAR(10) NOT NULL,
`driver_employee_id` INTEGER NOT NULL,
`truck_id` INTEGER NOT NULL,
`delivery_date` DATETIME,
FOREIGN KEY (`truck_id` ) REFERENCES `Trucks`(`truck_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` ),
FOREIGN KEY (`location_code` ) REFERENCES `Delivery_Route_Locations`(`location_code` ),
FOREIGN KEY (`driver_employee_id` ) REFERENCES `Employees`(`employee_id` )
)
|
SELECT count(*) FROM customers
|
Find the number of customers in total.
|
customer_deliveries
|
CREATE TABLE `Products` (
`product_id` INTEGER PRIMARY KEY,
`product_name` VARCHAR(20),
`product_price` DECIMAL(19,4),
`product_description` VARCHAR(255)
)
CREATE TABLE `Addresses` (
`address_id` INTEGER PRIMARY KEY,
`address_details` VARCHAR(80),
`city` VARCHAR(50),
`zip_postcode` VARCHAR(20),
`state_province_county` VARCHAR(50),
`country` VARCHAR(50)
)
CREATE TABLE `Customers` (
`customer_id` INTEGER PRIMARY KEY,
`payment_method` VARCHAR(10) NOT NULL,
`customer_name` VARCHAR(80),
`customer_phone` VARCHAR(80),
`customer_email` VARCHAR(80),
`date_became_customer` DATETIME
)
CREATE TABLE `Regular_Orders` (
`regular_order_id` INTEGER PRIMARY KEY,
`distributer_id` INTEGER NOT NULL,
FOREIGN KEY (`distributer_id` ) REFERENCES `Customers`(`customer_id` )
)
CREATE TABLE `Regular_Order_Products` (
`regular_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Orders` (
`actual_order_id` INTEGER PRIMARY KEY,
`order_status_code` VARCHAR(10) NOT NULL,
`regular_order_id` INTEGER NOT NULL,
`actual_order_date` DATETIME,
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Order_Products` (
`actual_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` )
)
CREATE TABLE `Customer_Addresses` (
`customer_id` INTEGER NOT NULL,
`address_id` INTEGER NOT NULL,
`date_from` DATETIME NOT NULL,
`address_type` VARCHAR(10) NOT NULL,
`date_to` DATETIME,
FOREIGN KEY (`customer_id` ) REFERENCES `Customers`(`customer_id` ),
FOREIGN KEY (`address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Delivery_Routes` (
`route_id` INTEGER PRIMARY KEY,
`route_name` VARCHAR(50),
`other_route_details` VARCHAR(255)
)
CREATE TABLE `Delivery_Route_Locations` (
`location_code` VARCHAR(10) PRIMARY KEY,
`route_id` INTEGER NOT NULL,
`location_address_id` INTEGER NOT NULL,
`location_name` VARCHAR(50),
FOREIGN KEY (`location_address_id` ) REFERENCES `Addresses`(`address_id` ),
FOREIGN KEY (`route_id` ) REFERENCES `Delivery_Routes`(`route_id` )
)
CREATE TABLE `Trucks` (
`truck_id` INTEGER PRIMARY KEY,
`truck_licence_number` VARCHAR(20),
`truck_details` VARCHAR(255)
)
CREATE TABLE `Employees` (
`employee_id` INTEGER PRIMARY KEY,
`employee_address_id` INTEGER NOT NULL,
`employee_name` VARCHAR(80),
`employee_phone` VARCHAR(80),
FOREIGN KEY (`employee_address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Order_Deliveries` (
`location_code` VARCHAR(10) NOT NULL,
`actual_order_id` INTEGER NOT NULL,
`delivery_status_code` VARCHAR(10) NOT NULL,
`driver_employee_id` INTEGER NOT NULL,
`truck_id` INTEGER NOT NULL,
`delivery_date` DATETIME,
FOREIGN KEY (`truck_id` ) REFERENCES `Trucks`(`truck_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` ),
FOREIGN KEY (`location_code` ) REFERENCES `Delivery_Route_Locations`(`location_code` ),
FOREIGN KEY (`driver_employee_id` ) REFERENCES `Employees`(`employee_id` )
)
|
SELECT count(DISTINCT payment_method) FROM customers
|
How many different payment methods are there?
|
customer_deliveries
|
CREATE TABLE `Products` (
`product_id` INTEGER PRIMARY KEY,
`product_name` VARCHAR(20),
`product_price` DECIMAL(19,4),
`product_description` VARCHAR(255)
)
CREATE TABLE `Addresses` (
`address_id` INTEGER PRIMARY KEY,
`address_details` VARCHAR(80),
`city` VARCHAR(50),
`zip_postcode` VARCHAR(20),
`state_province_county` VARCHAR(50),
`country` VARCHAR(50)
)
CREATE TABLE `Customers` (
`customer_id` INTEGER PRIMARY KEY,
`payment_method` VARCHAR(10) NOT NULL,
`customer_name` VARCHAR(80),
`customer_phone` VARCHAR(80),
`customer_email` VARCHAR(80),
`date_became_customer` DATETIME
)
CREATE TABLE `Regular_Orders` (
`regular_order_id` INTEGER PRIMARY KEY,
`distributer_id` INTEGER NOT NULL,
FOREIGN KEY (`distributer_id` ) REFERENCES `Customers`(`customer_id` )
)
CREATE TABLE `Regular_Order_Products` (
`regular_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Orders` (
`actual_order_id` INTEGER PRIMARY KEY,
`order_status_code` VARCHAR(10) NOT NULL,
`regular_order_id` INTEGER NOT NULL,
`actual_order_date` DATETIME,
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Order_Products` (
`actual_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` )
)
CREATE TABLE `Customer_Addresses` (
`customer_id` INTEGER NOT NULL,
`address_id` INTEGER NOT NULL,
`date_from` DATETIME NOT NULL,
`address_type` VARCHAR(10) NOT NULL,
`date_to` DATETIME,
FOREIGN KEY (`customer_id` ) REFERENCES `Customers`(`customer_id` ),
FOREIGN KEY (`address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Delivery_Routes` (
`route_id` INTEGER PRIMARY KEY,
`route_name` VARCHAR(50),
`other_route_details` VARCHAR(255)
)
CREATE TABLE `Delivery_Route_Locations` (
`location_code` VARCHAR(10) PRIMARY KEY,
`route_id` INTEGER NOT NULL,
`location_address_id` INTEGER NOT NULL,
`location_name` VARCHAR(50),
FOREIGN KEY (`location_address_id` ) REFERENCES `Addresses`(`address_id` ),
FOREIGN KEY (`route_id` ) REFERENCES `Delivery_Routes`(`route_id` )
)
CREATE TABLE `Trucks` (
`truck_id` INTEGER PRIMARY KEY,
`truck_licence_number` VARCHAR(20),
`truck_details` VARCHAR(255)
)
CREATE TABLE `Employees` (
`employee_id` INTEGER PRIMARY KEY,
`employee_address_id` INTEGER NOT NULL,
`employee_name` VARCHAR(80),
`employee_phone` VARCHAR(80),
FOREIGN KEY (`employee_address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Order_Deliveries` (
`location_code` VARCHAR(10) NOT NULL,
`actual_order_id` INTEGER NOT NULL,
`delivery_status_code` VARCHAR(10) NOT NULL,
`driver_employee_id` INTEGER NOT NULL,
`truck_id` INTEGER NOT NULL,
`delivery_date` DATETIME,
FOREIGN KEY (`truck_id` ) REFERENCES `Trucks`(`truck_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` ),
FOREIGN KEY (`location_code` ) REFERENCES `Delivery_Route_Locations`(`location_code` ),
FOREIGN KEY (`driver_employee_id` ) REFERENCES `Employees`(`employee_id` )
)
|
SELECT truck_details FROM trucks ORDER BY truck_licence_number
|
Show the details of all trucks in the order of their license number.
|
customer_deliveries
|
CREATE TABLE `Products` (
`product_id` INTEGER PRIMARY KEY,
`product_name` VARCHAR(20),
`product_price` DECIMAL(19,4),
`product_description` VARCHAR(255)
)
CREATE TABLE `Addresses` (
`address_id` INTEGER PRIMARY KEY,
`address_details` VARCHAR(80),
`city` VARCHAR(50),
`zip_postcode` VARCHAR(20),
`state_province_county` VARCHAR(50),
`country` VARCHAR(50)
)
CREATE TABLE `Customers` (
`customer_id` INTEGER PRIMARY KEY,
`payment_method` VARCHAR(10) NOT NULL,
`customer_name` VARCHAR(80),
`customer_phone` VARCHAR(80),
`customer_email` VARCHAR(80),
`date_became_customer` DATETIME
)
CREATE TABLE `Regular_Orders` (
`regular_order_id` INTEGER PRIMARY KEY,
`distributer_id` INTEGER NOT NULL,
FOREIGN KEY (`distributer_id` ) REFERENCES `Customers`(`customer_id` )
)
CREATE TABLE `Regular_Order_Products` (
`regular_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Orders` (
`actual_order_id` INTEGER PRIMARY KEY,
`order_status_code` VARCHAR(10) NOT NULL,
`regular_order_id` INTEGER NOT NULL,
`actual_order_date` DATETIME,
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Order_Products` (
`actual_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` )
)
CREATE TABLE `Customer_Addresses` (
`customer_id` INTEGER NOT NULL,
`address_id` INTEGER NOT NULL,
`date_from` DATETIME NOT NULL,
`address_type` VARCHAR(10) NOT NULL,
`date_to` DATETIME,
FOREIGN KEY (`customer_id` ) REFERENCES `Customers`(`customer_id` ),
FOREIGN KEY (`address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Delivery_Routes` (
`route_id` INTEGER PRIMARY KEY,
`route_name` VARCHAR(50),
`other_route_details` VARCHAR(255)
)
CREATE TABLE `Delivery_Route_Locations` (
`location_code` VARCHAR(10) PRIMARY KEY,
`route_id` INTEGER NOT NULL,
`location_address_id` INTEGER NOT NULL,
`location_name` VARCHAR(50),
FOREIGN KEY (`location_address_id` ) REFERENCES `Addresses`(`address_id` ),
FOREIGN KEY (`route_id` ) REFERENCES `Delivery_Routes`(`route_id` )
)
CREATE TABLE `Trucks` (
`truck_id` INTEGER PRIMARY KEY,
`truck_licence_number` VARCHAR(20),
`truck_details` VARCHAR(255)
)
CREATE TABLE `Employees` (
`employee_id` INTEGER PRIMARY KEY,
`employee_address_id` INTEGER NOT NULL,
`employee_name` VARCHAR(80),
`employee_phone` VARCHAR(80),
FOREIGN KEY (`employee_address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Order_Deliveries` (
`location_code` VARCHAR(10) NOT NULL,
`actual_order_id` INTEGER NOT NULL,
`delivery_status_code` VARCHAR(10) NOT NULL,
`driver_employee_id` INTEGER NOT NULL,
`truck_id` INTEGER NOT NULL,
`delivery_date` DATETIME,
FOREIGN KEY (`truck_id` ) REFERENCES `Trucks`(`truck_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` ),
FOREIGN KEY (`location_code` ) REFERENCES `Delivery_Route_Locations`(`location_code` ),
FOREIGN KEY (`driver_employee_id` ) REFERENCES `Employees`(`employee_id` )
)
|
SELECT product_name FROM products ORDER BY product_price DESC LIMIT 1
|
Find the name of the most expensive product.
|
customer_deliveries
|
CREATE TABLE `Products` (
`product_id` INTEGER PRIMARY KEY,
`product_name` VARCHAR(20),
`product_price` DECIMAL(19,4),
`product_description` VARCHAR(255)
)
CREATE TABLE `Addresses` (
`address_id` INTEGER PRIMARY KEY,
`address_details` VARCHAR(80),
`city` VARCHAR(50),
`zip_postcode` VARCHAR(20),
`state_province_county` VARCHAR(50),
`country` VARCHAR(50)
)
CREATE TABLE `Customers` (
`customer_id` INTEGER PRIMARY KEY,
`payment_method` VARCHAR(10) NOT NULL,
`customer_name` VARCHAR(80),
`customer_phone` VARCHAR(80),
`customer_email` VARCHAR(80),
`date_became_customer` DATETIME
)
CREATE TABLE `Regular_Orders` (
`regular_order_id` INTEGER PRIMARY KEY,
`distributer_id` INTEGER NOT NULL,
FOREIGN KEY (`distributer_id` ) REFERENCES `Customers`(`customer_id` )
)
CREATE TABLE `Regular_Order_Products` (
`regular_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Orders` (
`actual_order_id` INTEGER PRIMARY KEY,
`order_status_code` VARCHAR(10) NOT NULL,
`regular_order_id` INTEGER NOT NULL,
`actual_order_date` DATETIME,
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Order_Products` (
`actual_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` )
)
CREATE TABLE `Customer_Addresses` (
`customer_id` INTEGER NOT NULL,
`address_id` INTEGER NOT NULL,
`date_from` DATETIME NOT NULL,
`address_type` VARCHAR(10) NOT NULL,
`date_to` DATETIME,
FOREIGN KEY (`customer_id` ) REFERENCES `Customers`(`customer_id` ),
FOREIGN KEY (`address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Delivery_Routes` (
`route_id` INTEGER PRIMARY KEY,
`route_name` VARCHAR(50),
`other_route_details` VARCHAR(255)
)
CREATE TABLE `Delivery_Route_Locations` (
`location_code` VARCHAR(10) PRIMARY KEY,
`route_id` INTEGER NOT NULL,
`location_address_id` INTEGER NOT NULL,
`location_name` VARCHAR(50),
FOREIGN KEY (`location_address_id` ) REFERENCES `Addresses`(`address_id` ),
FOREIGN KEY (`route_id` ) REFERENCES `Delivery_Routes`(`route_id` )
)
CREATE TABLE `Trucks` (
`truck_id` INTEGER PRIMARY KEY,
`truck_licence_number` VARCHAR(20),
`truck_details` VARCHAR(255)
)
CREATE TABLE `Employees` (
`employee_id` INTEGER PRIMARY KEY,
`employee_address_id` INTEGER NOT NULL,
`employee_name` VARCHAR(80),
`employee_phone` VARCHAR(80),
FOREIGN KEY (`employee_address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Order_Deliveries` (
`location_code` VARCHAR(10) NOT NULL,
`actual_order_id` INTEGER NOT NULL,
`delivery_status_code` VARCHAR(10) NOT NULL,
`driver_employee_id` INTEGER NOT NULL,
`truck_id` INTEGER NOT NULL,
`delivery_date` DATETIME,
FOREIGN KEY (`truck_id` ) REFERENCES `Trucks`(`truck_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` ),
FOREIGN KEY (`location_code` ) REFERENCES `Delivery_Route_Locations`(`location_code` ),
FOREIGN KEY (`driver_employee_id` ) REFERENCES `Employees`(`employee_id` )
)
|
SELECT customer_name FROM customers EXCEPT SELECT t1.customer_name FROM customers AS t1 JOIN customer_addresses AS t2 ON t1.customer_id = t2.customer_id JOIN addresses AS t3 ON t2.address_id = t3.address_id WHERE t3.state_province_county = 'California'
|
Find the names of customers who are not living in the state of California.
|
customer_deliveries
|
CREATE TABLE `Products` (
`product_id` INTEGER PRIMARY KEY,
`product_name` VARCHAR(20),
`product_price` DECIMAL(19,4),
`product_description` VARCHAR(255)
)
CREATE TABLE `Addresses` (
`address_id` INTEGER PRIMARY KEY,
`address_details` VARCHAR(80),
`city` VARCHAR(50),
`zip_postcode` VARCHAR(20),
`state_province_county` VARCHAR(50),
`country` VARCHAR(50)
)
CREATE TABLE `Customers` (
`customer_id` INTEGER PRIMARY KEY,
`payment_method` VARCHAR(10) NOT NULL,
`customer_name` VARCHAR(80),
`customer_phone` VARCHAR(80),
`customer_email` VARCHAR(80),
`date_became_customer` DATETIME
)
CREATE TABLE `Regular_Orders` (
`regular_order_id` INTEGER PRIMARY KEY,
`distributer_id` INTEGER NOT NULL,
FOREIGN KEY (`distributer_id` ) REFERENCES `Customers`(`customer_id` )
)
CREATE TABLE `Regular_Order_Products` (
`regular_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Orders` (
`actual_order_id` INTEGER PRIMARY KEY,
`order_status_code` VARCHAR(10) NOT NULL,
`regular_order_id` INTEGER NOT NULL,
`actual_order_date` DATETIME,
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Order_Products` (
`actual_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` )
)
CREATE TABLE `Customer_Addresses` (
`customer_id` INTEGER NOT NULL,
`address_id` INTEGER NOT NULL,
`date_from` DATETIME NOT NULL,
`address_type` VARCHAR(10) NOT NULL,
`date_to` DATETIME,
FOREIGN KEY (`customer_id` ) REFERENCES `Customers`(`customer_id` ),
FOREIGN KEY (`address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Delivery_Routes` (
`route_id` INTEGER PRIMARY KEY,
`route_name` VARCHAR(50),
`other_route_details` VARCHAR(255)
)
CREATE TABLE `Delivery_Route_Locations` (
`location_code` VARCHAR(10) PRIMARY KEY,
`route_id` INTEGER NOT NULL,
`location_address_id` INTEGER NOT NULL,
`location_name` VARCHAR(50),
FOREIGN KEY (`location_address_id` ) REFERENCES `Addresses`(`address_id` ),
FOREIGN KEY (`route_id` ) REFERENCES `Delivery_Routes`(`route_id` )
)
CREATE TABLE `Trucks` (
`truck_id` INTEGER PRIMARY KEY,
`truck_licence_number` VARCHAR(20),
`truck_details` VARCHAR(255)
)
CREATE TABLE `Employees` (
`employee_id` INTEGER PRIMARY KEY,
`employee_address_id` INTEGER NOT NULL,
`employee_name` VARCHAR(80),
`employee_phone` VARCHAR(80),
FOREIGN KEY (`employee_address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Order_Deliveries` (
`location_code` VARCHAR(10) NOT NULL,
`actual_order_id` INTEGER NOT NULL,
`delivery_status_code` VARCHAR(10) NOT NULL,
`driver_employee_id` INTEGER NOT NULL,
`truck_id` INTEGER NOT NULL,
`delivery_date` DATETIME,
FOREIGN KEY (`truck_id` ) REFERENCES `Trucks`(`truck_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` ),
FOREIGN KEY (`location_code` ) REFERENCES `Delivery_Route_Locations`(`location_code` ),
FOREIGN KEY (`driver_employee_id` ) REFERENCES `Employees`(`employee_id` )
)
|
SELECT customer_email , customer_name FROM customers WHERE payment_method = 'Visa'
|
List the names and emails of customers who payed by Visa card.
|
customer_deliveries
|
CREATE TABLE `Products` (
`product_id` INTEGER PRIMARY KEY,
`product_name` VARCHAR(20),
`product_price` DECIMAL(19,4),
`product_description` VARCHAR(255)
)
CREATE TABLE `Addresses` (
`address_id` INTEGER PRIMARY KEY,
`address_details` VARCHAR(80),
`city` VARCHAR(50),
`zip_postcode` VARCHAR(20),
`state_province_county` VARCHAR(50),
`country` VARCHAR(50)
)
CREATE TABLE `Customers` (
`customer_id` INTEGER PRIMARY KEY,
`payment_method` VARCHAR(10) NOT NULL,
`customer_name` VARCHAR(80),
`customer_phone` VARCHAR(80),
`customer_email` VARCHAR(80),
`date_became_customer` DATETIME
)
CREATE TABLE `Regular_Orders` (
`regular_order_id` INTEGER PRIMARY KEY,
`distributer_id` INTEGER NOT NULL,
FOREIGN KEY (`distributer_id` ) REFERENCES `Customers`(`customer_id` )
)
CREATE TABLE `Regular_Order_Products` (
`regular_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Orders` (
`actual_order_id` INTEGER PRIMARY KEY,
`order_status_code` VARCHAR(10) NOT NULL,
`regular_order_id` INTEGER NOT NULL,
`actual_order_date` DATETIME,
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Order_Products` (
`actual_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` )
)
CREATE TABLE `Customer_Addresses` (
`customer_id` INTEGER NOT NULL,
`address_id` INTEGER NOT NULL,
`date_from` DATETIME NOT NULL,
`address_type` VARCHAR(10) NOT NULL,
`date_to` DATETIME,
FOREIGN KEY (`customer_id` ) REFERENCES `Customers`(`customer_id` ),
FOREIGN KEY (`address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Delivery_Routes` (
`route_id` INTEGER PRIMARY KEY,
`route_name` VARCHAR(50),
`other_route_details` VARCHAR(255)
)
CREATE TABLE `Delivery_Route_Locations` (
`location_code` VARCHAR(10) PRIMARY KEY,
`route_id` INTEGER NOT NULL,
`location_address_id` INTEGER NOT NULL,
`location_name` VARCHAR(50),
FOREIGN KEY (`location_address_id` ) REFERENCES `Addresses`(`address_id` ),
FOREIGN KEY (`route_id` ) REFERENCES `Delivery_Routes`(`route_id` )
)
CREATE TABLE `Trucks` (
`truck_id` INTEGER PRIMARY KEY,
`truck_licence_number` VARCHAR(20),
`truck_details` VARCHAR(255)
)
CREATE TABLE `Employees` (
`employee_id` INTEGER PRIMARY KEY,
`employee_address_id` INTEGER NOT NULL,
`employee_name` VARCHAR(80),
`employee_phone` VARCHAR(80),
FOREIGN KEY (`employee_address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Order_Deliveries` (
`location_code` VARCHAR(10) NOT NULL,
`actual_order_id` INTEGER NOT NULL,
`delivery_status_code` VARCHAR(10) NOT NULL,
`driver_employee_id` INTEGER NOT NULL,
`truck_id` INTEGER NOT NULL,
`delivery_date` DATETIME,
FOREIGN KEY (`truck_id` ) REFERENCES `Trucks`(`truck_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` ),
FOREIGN KEY (`location_code` ) REFERENCES `Delivery_Route_Locations`(`location_code` ),
FOREIGN KEY (`driver_employee_id` ) REFERENCES `Employees`(`employee_id` )
)
|
SELECT t1.customer_name , t1.customer_phone FROM customers AS t1 JOIN customer_addresses AS t2 ON t1.customer_id = t2.customer_id JOIN addresses AS t3 ON t2.address_id = t3.address_id WHERE t3.state_province_county = 'California'
|
Find the names and phone numbers of customers living in California state.
|
customer_deliveries
|
CREATE TABLE `Products` (
`product_id` INTEGER PRIMARY KEY,
`product_name` VARCHAR(20),
`product_price` DECIMAL(19,4),
`product_description` VARCHAR(255)
)
CREATE TABLE `Addresses` (
`address_id` INTEGER PRIMARY KEY,
`address_details` VARCHAR(80),
`city` VARCHAR(50),
`zip_postcode` VARCHAR(20),
`state_province_county` VARCHAR(50),
`country` VARCHAR(50)
)
CREATE TABLE `Customers` (
`customer_id` INTEGER PRIMARY KEY,
`payment_method` VARCHAR(10) NOT NULL,
`customer_name` VARCHAR(80),
`customer_phone` VARCHAR(80),
`customer_email` VARCHAR(80),
`date_became_customer` DATETIME
)
CREATE TABLE `Regular_Orders` (
`regular_order_id` INTEGER PRIMARY KEY,
`distributer_id` INTEGER NOT NULL,
FOREIGN KEY (`distributer_id` ) REFERENCES `Customers`(`customer_id` )
)
CREATE TABLE `Regular_Order_Products` (
`regular_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Orders` (
`actual_order_id` INTEGER PRIMARY KEY,
`order_status_code` VARCHAR(10) NOT NULL,
`regular_order_id` INTEGER NOT NULL,
`actual_order_date` DATETIME,
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Order_Products` (
`actual_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` )
)
CREATE TABLE `Customer_Addresses` (
`customer_id` INTEGER NOT NULL,
`address_id` INTEGER NOT NULL,
`date_from` DATETIME NOT NULL,
`address_type` VARCHAR(10) NOT NULL,
`date_to` DATETIME,
FOREIGN KEY (`customer_id` ) REFERENCES `Customers`(`customer_id` ),
FOREIGN KEY (`address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Delivery_Routes` (
`route_id` INTEGER PRIMARY KEY,
`route_name` VARCHAR(50),
`other_route_details` VARCHAR(255)
)
CREATE TABLE `Delivery_Route_Locations` (
`location_code` VARCHAR(10) PRIMARY KEY,
`route_id` INTEGER NOT NULL,
`location_address_id` INTEGER NOT NULL,
`location_name` VARCHAR(50),
FOREIGN KEY (`location_address_id` ) REFERENCES `Addresses`(`address_id` ),
FOREIGN KEY (`route_id` ) REFERENCES `Delivery_Routes`(`route_id` )
)
CREATE TABLE `Trucks` (
`truck_id` INTEGER PRIMARY KEY,
`truck_licence_number` VARCHAR(20),
`truck_details` VARCHAR(255)
)
CREATE TABLE `Employees` (
`employee_id` INTEGER PRIMARY KEY,
`employee_address_id` INTEGER NOT NULL,
`employee_name` VARCHAR(80),
`employee_phone` VARCHAR(80),
FOREIGN KEY (`employee_address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Order_Deliveries` (
`location_code` VARCHAR(10) NOT NULL,
`actual_order_id` INTEGER NOT NULL,
`delivery_status_code` VARCHAR(10) NOT NULL,
`driver_employee_id` INTEGER NOT NULL,
`truck_id` INTEGER NOT NULL,
`delivery_date` DATETIME,
FOREIGN KEY (`truck_id` ) REFERENCES `Trucks`(`truck_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` ),
FOREIGN KEY (`location_code` ) REFERENCES `Delivery_Route_Locations`(`location_code` ),
FOREIGN KEY (`driver_employee_id` ) REFERENCES `Employees`(`employee_id` )
)
|
SELECT state_province_county FROM addresses WHERE address_id NOT IN (SELECT employee_address_id FROM Employees)
|
Find the states which do not have any employee in their record.
|
customer_deliveries
|
CREATE TABLE `Products` (
`product_id` INTEGER PRIMARY KEY,
`product_name` VARCHAR(20),
`product_price` DECIMAL(19,4),
`product_description` VARCHAR(255)
)
CREATE TABLE `Addresses` (
`address_id` INTEGER PRIMARY KEY,
`address_details` VARCHAR(80),
`city` VARCHAR(50),
`zip_postcode` VARCHAR(20),
`state_province_county` VARCHAR(50),
`country` VARCHAR(50)
)
CREATE TABLE `Customers` (
`customer_id` INTEGER PRIMARY KEY,
`payment_method` VARCHAR(10) NOT NULL,
`customer_name` VARCHAR(80),
`customer_phone` VARCHAR(80),
`customer_email` VARCHAR(80),
`date_became_customer` DATETIME
)
CREATE TABLE `Regular_Orders` (
`regular_order_id` INTEGER PRIMARY KEY,
`distributer_id` INTEGER NOT NULL,
FOREIGN KEY (`distributer_id` ) REFERENCES `Customers`(`customer_id` )
)
CREATE TABLE `Regular_Order_Products` (
`regular_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Orders` (
`actual_order_id` INTEGER PRIMARY KEY,
`order_status_code` VARCHAR(10) NOT NULL,
`regular_order_id` INTEGER NOT NULL,
`actual_order_date` DATETIME,
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Order_Products` (
`actual_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` )
)
CREATE TABLE `Customer_Addresses` (
`customer_id` INTEGER NOT NULL,
`address_id` INTEGER NOT NULL,
`date_from` DATETIME NOT NULL,
`address_type` VARCHAR(10) NOT NULL,
`date_to` DATETIME,
FOREIGN KEY (`customer_id` ) REFERENCES `Customers`(`customer_id` ),
FOREIGN KEY (`address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Delivery_Routes` (
`route_id` INTEGER PRIMARY KEY,
`route_name` VARCHAR(50),
`other_route_details` VARCHAR(255)
)
CREATE TABLE `Delivery_Route_Locations` (
`location_code` VARCHAR(10) PRIMARY KEY,
`route_id` INTEGER NOT NULL,
`location_address_id` INTEGER NOT NULL,
`location_name` VARCHAR(50),
FOREIGN KEY (`location_address_id` ) REFERENCES `Addresses`(`address_id` ),
FOREIGN KEY (`route_id` ) REFERENCES `Delivery_Routes`(`route_id` )
)
CREATE TABLE `Trucks` (
`truck_id` INTEGER PRIMARY KEY,
`truck_licence_number` VARCHAR(20),
`truck_details` VARCHAR(255)
)
CREATE TABLE `Employees` (
`employee_id` INTEGER PRIMARY KEY,
`employee_address_id` INTEGER NOT NULL,
`employee_name` VARCHAR(80),
`employee_phone` VARCHAR(80),
FOREIGN KEY (`employee_address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Order_Deliveries` (
`location_code` VARCHAR(10) NOT NULL,
`actual_order_id` INTEGER NOT NULL,
`delivery_status_code` VARCHAR(10) NOT NULL,
`driver_employee_id` INTEGER NOT NULL,
`truck_id` INTEGER NOT NULL,
`delivery_date` DATETIME,
FOREIGN KEY (`truck_id` ) REFERENCES `Trucks`(`truck_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` ),
FOREIGN KEY (`location_code` ) REFERENCES `Delivery_Route_Locations`(`location_code` ),
FOREIGN KEY (`driver_employee_id` ) REFERENCES `Employees`(`employee_id` )
)
|
SELECT customer_name , customer_phone , customer_email FROM Customers ORDER BY date_became_customer
|
List the names, phone numbers, and emails of all customers sorted by their dates of becoming customers.
|
customer_deliveries
|
CREATE TABLE `Products` (
`product_id` INTEGER PRIMARY KEY,
`product_name` VARCHAR(20),
`product_price` DECIMAL(19,4),
`product_description` VARCHAR(255)
)
CREATE TABLE `Addresses` (
`address_id` INTEGER PRIMARY KEY,
`address_details` VARCHAR(80),
`city` VARCHAR(50),
`zip_postcode` VARCHAR(20),
`state_province_county` VARCHAR(50),
`country` VARCHAR(50)
)
CREATE TABLE `Customers` (
`customer_id` INTEGER PRIMARY KEY,
`payment_method` VARCHAR(10) NOT NULL,
`customer_name` VARCHAR(80),
`customer_phone` VARCHAR(80),
`customer_email` VARCHAR(80),
`date_became_customer` DATETIME
)
CREATE TABLE `Regular_Orders` (
`regular_order_id` INTEGER PRIMARY KEY,
`distributer_id` INTEGER NOT NULL,
FOREIGN KEY (`distributer_id` ) REFERENCES `Customers`(`customer_id` )
)
CREATE TABLE `Regular_Order_Products` (
`regular_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Orders` (
`actual_order_id` INTEGER PRIMARY KEY,
`order_status_code` VARCHAR(10) NOT NULL,
`regular_order_id` INTEGER NOT NULL,
`actual_order_date` DATETIME,
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Order_Products` (
`actual_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` )
)
CREATE TABLE `Customer_Addresses` (
`customer_id` INTEGER NOT NULL,
`address_id` INTEGER NOT NULL,
`date_from` DATETIME NOT NULL,
`address_type` VARCHAR(10) NOT NULL,
`date_to` DATETIME,
FOREIGN KEY (`customer_id` ) REFERENCES `Customers`(`customer_id` ),
FOREIGN KEY (`address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Delivery_Routes` (
`route_id` INTEGER PRIMARY KEY,
`route_name` VARCHAR(50),
`other_route_details` VARCHAR(255)
)
CREATE TABLE `Delivery_Route_Locations` (
`location_code` VARCHAR(10) PRIMARY KEY,
`route_id` INTEGER NOT NULL,
`location_address_id` INTEGER NOT NULL,
`location_name` VARCHAR(50),
FOREIGN KEY (`location_address_id` ) REFERENCES `Addresses`(`address_id` ),
FOREIGN KEY (`route_id` ) REFERENCES `Delivery_Routes`(`route_id` )
)
CREATE TABLE `Trucks` (
`truck_id` INTEGER PRIMARY KEY,
`truck_licence_number` VARCHAR(20),
`truck_details` VARCHAR(255)
)
CREATE TABLE `Employees` (
`employee_id` INTEGER PRIMARY KEY,
`employee_address_id` INTEGER NOT NULL,
`employee_name` VARCHAR(80),
`employee_phone` VARCHAR(80),
FOREIGN KEY (`employee_address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Order_Deliveries` (
`location_code` VARCHAR(10) NOT NULL,
`actual_order_id` INTEGER NOT NULL,
`delivery_status_code` VARCHAR(10) NOT NULL,
`driver_employee_id` INTEGER NOT NULL,
`truck_id` INTEGER NOT NULL,
`delivery_date` DATETIME,
FOREIGN KEY (`truck_id` ) REFERENCES `Trucks`(`truck_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` ),
FOREIGN KEY (`location_code` ) REFERENCES `Delivery_Route_Locations`(`location_code` ),
FOREIGN KEY (`driver_employee_id` ) REFERENCES `Employees`(`employee_id` )
)
|
SELECT customer_name FROM Customers ORDER BY date_became_customer LIMIT 5
|
Find the name of the first 5 customers.
|
customer_deliveries
|
CREATE TABLE `Products` (
`product_id` INTEGER PRIMARY KEY,
`product_name` VARCHAR(20),
`product_price` DECIMAL(19,4),
`product_description` VARCHAR(255)
)
CREATE TABLE `Addresses` (
`address_id` INTEGER PRIMARY KEY,
`address_details` VARCHAR(80),
`city` VARCHAR(50),
`zip_postcode` VARCHAR(20),
`state_province_county` VARCHAR(50),
`country` VARCHAR(50)
)
CREATE TABLE `Customers` (
`customer_id` INTEGER PRIMARY KEY,
`payment_method` VARCHAR(10) NOT NULL,
`customer_name` VARCHAR(80),
`customer_phone` VARCHAR(80),
`customer_email` VARCHAR(80),
`date_became_customer` DATETIME
)
CREATE TABLE `Regular_Orders` (
`regular_order_id` INTEGER PRIMARY KEY,
`distributer_id` INTEGER NOT NULL,
FOREIGN KEY (`distributer_id` ) REFERENCES `Customers`(`customer_id` )
)
CREATE TABLE `Regular_Order_Products` (
`regular_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Orders` (
`actual_order_id` INTEGER PRIMARY KEY,
`order_status_code` VARCHAR(10) NOT NULL,
`regular_order_id` INTEGER NOT NULL,
`actual_order_date` DATETIME,
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Order_Products` (
`actual_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` )
)
CREATE TABLE `Customer_Addresses` (
`customer_id` INTEGER NOT NULL,
`address_id` INTEGER NOT NULL,
`date_from` DATETIME NOT NULL,
`address_type` VARCHAR(10) NOT NULL,
`date_to` DATETIME,
FOREIGN KEY (`customer_id` ) REFERENCES `Customers`(`customer_id` ),
FOREIGN KEY (`address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Delivery_Routes` (
`route_id` INTEGER PRIMARY KEY,
`route_name` VARCHAR(50),
`other_route_details` VARCHAR(255)
)
CREATE TABLE `Delivery_Route_Locations` (
`location_code` VARCHAR(10) PRIMARY KEY,
`route_id` INTEGER NOT NULL,
`location_address_id` INTEGER NOT NULL,
`location_name` VARCHAR(50),
FOREIGN KEY (`location_address_id` ) REFERENCES `Addresses`(`address_id` ),
FOREIGN KEY (`route_id` ) REFERENCES `Delivery_Routes`(`route_id` )
)
CREATE TABLE `Trucks` (
`truck_id` INTEGER PRIMARY KEY,
`truck_licence_number` VARCHAR(20),
`truck_details` VARCHAR(255)
)
CREATE TABLE `Employees` (
`employee_id` INTEGER PRIMARY KEY,
`employee_address_id` INTEGER NOT NULL,
`employee_name` VARCHAR(80),
`employee_phone` VARCHAR(80),
FOREIGN KEY (`employee_address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Order_Deliveries` (
`location_code` VARCHAR(10) NOT NULL,
`actual_order_id` INTEGER NOT NULL,
`delivery_status_code` VARCHAR(10) NOT NULL,
`driver_employee_id` INTEGER NOT NULL,
`truck_id` INTEGER NOT NULL,
`delivery_date` DATETIME,
FOREIGN KEY (`truck_id` ) REFERENCES `Trucks`(`truck_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` ),
FOREIGN KEY (`location_code` ) REFERENCES `Delivery_Route_Locations`(`location_code` ),
FOREIGN KEY (`driver_employee_id` ) REFERENCES `Employees`(`employee_id` )
)
|
SELECT payment_method FROM Customers GROUP BY payment_method ORDER BY count(*) DESC LIMIT 1
|
Find the payment method that is used most frequently.
|
customer_deliveries
|
CREATE TABLE `Products` (
`product_id` INTEGER PRIMARY KEY,
`product_name` VARCHAR(20),
`product_price` DECIMAL(19,4),
`product_description` VARCHAR(255)
)
CREATE TABLE `Addresses` (
`address_id` INTEGER PRIMARY KEY,
`address_details` VARCHAR(80),
`city` VARCHAR(50),
`zip_postcode` VARCHAR(20),
`state_province_county` VARCHAR(50),
`country` VARCHAR(50)
)
CREATE TABLE `Customers` (
`customer_id` INTEGER PRIMARY KEY,
`payment_method` VARCHAR(10) NOT NULL,
`customer_name` VARCHAR(80),
`customer_phone` VARCHAR(80),
`customer_email` VARCHAR(80),
`date_became_customer` DATETIME
)
CREATE TABLE `Regular_Orders` (
`regular_order_id` INTEGER PRIMARY KEY,
`distributer_id` INTEGER NOT NULL,
FOREIGN KEY (`distributer_id` ) REFERENCES `Customers`(`customer_id` )
)
CREATE TABLE `Regular_Order_Products` (
`regular_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Orders` (
`actual_order_id` INTEGER PRIMARY KEY,
`order_status_code` VARCHAR(10) NOT NULL,
`regular_order_id` INTEGER NOT NULL,
`actual_order_date` DATETIME,
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Order_Products` (
`actual_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` )
)
CREATE TABLE `Customer_Addresses` (
`customer_id` INTEGER NOT NULL,
`address_id` INTEGER NOT NULL,
`date_from` DATETIME NOT NULL,
`address_type` VARCHAR(10) NOT NULL,
`date_to` DATETIME,
FOREIGN KEY (`customer_id` ) REFERENCES `Customers`(`customer_id` ),
FOREIGN KEY (`address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Delivery_Routes` (
`route_id` INTEGER PRIMARY KEY,
`route_name` VARCHAR(50),
`other_route_details` VARCHAR(255)
)
CREATE TABLE `Delivery_Route_Locations` (
`location_code` VARCHAR(10) PRIMARY KEY,
`route_id` INTEGER NOT NULL,
`location_address_id` INTEGER NOT NULL,
`location_name` VARCHAR(50),
FOREIGN KEY (`location_address_id` ) REFERENCES `Addresses`(`address_id` ),
FOREIGN KEY (`route_id` ) REFERENCES `Delivery_Routes`(`route_id` )
)
CREATE TABLE `Trucks` (
`truck_id` INTEGER PRIMARY KEY,
`truck_licence_number` VARCHAR(20),
`truck_details` VARCHAR(255)
)
CREATE TABLE `Employees` (
`employee_id` INTEGER PRIMARY KEY,
`employee_address_id` INTEGER NOT NULL,
`employee_name` VARCHAR(80),
`employee_phone` VARCHAR(80),
FOREIGN KEY (`employee_address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Order_Deliveries` (
`location_code` VARCHAR(10) NOT NULL,
`actual_order_id` INTEGER NOT NULL,
`delivery_status_code` VARCHAR(10) NOT NULL,
`driver_employee_id` INTEGER NOT NULL,
`truck_id` INTEGER NOT NULL,
`delivery_date` DATETIME,
FOREIGN KEY (`truck_id` ) REFERENCES `Trucks`(`truck_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` ),
FOREIGN KEY (`location_code` ) REFERENCES `Delivery_Route_Locations`(`location_code` ),
FOREIGN KEY (`driver_employee_id` ) REFERENCES `Employees`(`employee_id` )
)
|
SELECT route_name FROM Delivery_Routes ORDER BY route_name
|
List the names of all routes in alphabetic order.
|
customer_deliveries
|
CREATE TABLE `Products` (
`product_id` INTEGER PRIMARY KEY,
`product_name` VARCHAR(20),
`product_price` DECIMAL(19,4),
`product_description` VARCHAR(255)
)
CREATE TABLE `Addresses` (
`address_id` INTEGER PRIMARY KEY,
`address_details` VARCHAR(80),
`city` VARCHAR(50),
`zip_postcode` VARCHAR(20),
`state_province_county` VARCHAR(50),
`country` VARCHAR(50)
)
CREATE TABLE `Customers` (
`customer_id` INTEGER PRIMARY KEY,
`payment_method` VARCHAR(10) NOT NULL,
`customer_name` VARCHAR(80),
`customer_phone` VARCHAR(80),
`customer_email` VARCHAR(80),
`date_became_customer` DATETIME
)
CREATE TABLE `Regular_Orders` (
`regular_order_id` INTEGER PRIMARY KEY,
`distributer_id` INTEGER NOT NULL,
FOREIGN KEY (`distributer_id` ) REFERENCES `Customers`(`customer_id` )
)
CREATE TABLE `Regular_Order_Products` (
`regular_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Orders` (
`actual_order_id` INTEGER PRIMARY KEY,
`order_status_code` VARCHAR(10) NOT NULL,
`regular_order_id` INTEGER NOT NULL,
`actual_order_date` DATETIME,
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Order_Products` (
`actual_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` )
)
CREATE TABLE `Customer_Addresses` (
`customer_id` INTEGER NOT NULL,
`address_id` INTEGER NOT NULL,
`date_from` DATETIME NOT NULL,
`address_type` VARCHAR(10) NOT NULL,
`date_to` DATETIME,
FOREIGN KEY (`customer_id` ) REFERENCES `Customers`(`customer_id` ),
FOREIGN KEY (`address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Delivery_Routes` (
`route_id` INTEGER PRIMARY KEY,
`route_name` VARCHAR(50),
`other_route_details` VARCHAR(255)
)
CREATE TABLE `Delivery_Route_Locations` (
`location_code` VARCHAR(10) PRIMARY KEY,
`route_id` INTEGER NOT NULL,
`location_address_id` INTEGER NOT NULL,
`location_name` VARCHAR(50),
FOREIGN KEY (`location_address_id` ) REFERENCES `Addresses`(`address_id` ),
FOREIGN KEY (`route_id` ) REFERENCES `Delivery_Routes`(`route_id` )
)
CREATE TABLE `Trucks` (
`truck_id` INTEGER PRIMARY KEY,
`truck_licence_number` VARCHAR(20),
`truck_details` VARCHAR(255)
)
CREATE TABLE `Employees` (
`employee_id` INTEGER PRIMARY KEY,
`employee_address_id` INTEGER NOT NULL,
`employee_name` VARCHAR(80),
`employee_phone` VARCHAR(80),
FOREIGN KEY (`employee_address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Order_Deliveries` (
`location_code` VARCHAR(10) NOT NULL,
`actual_order_id` INTEGER NOT NULL,
`delivery_status_code` VARCHAR(10) NOT NULL,
`driver_employee_id` INTEGER NOT NULL,
`truck_id` INTEGER NOT NULL,
`delivery_date` DATETIME,
FOREIGN KEY (`truck_id` ) REFERENCES `Trucks`(`truck_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` ),
FOREIGN KEY (`location_code` ) REFERENCES `Delivery_Route_Locations`(`location_code` ),
FOREIGN KEY (`driver_employee_id` ) REFERENCES `Employees`(`employee_id` )
)
|
SELECT t1.route_name FROM Delivery_Routes AS t1 JOIN Delivery_Route_Locations AS t2 ON t1.route_id = t2.route_id GROUP BY t1.route_id ORDER BY count(*) DESC LIMIT 1
|
Find the name of route that has the highest number of deliveries.
|
customer_deliveries
|
CREATE TABLE `Products` (
`product_id` INTEGER PRIMARY KEY,
`product_name` VARCHAR(20),
`product_price` DECIMAL(19,4),
`product_description` VARCHAR(255)
)
CREATE TABLE `Addresses` (
`address_id` INTEGER PRIMARY KEY,
`address_details` VARCHAR(80),
`city` VARCHAR(50),
`zip_postcode` VARCHAR(20),
`state_province_county` VARCHAR(50),
`country` VARCHAR(50)
)
CREATE TABLE `Customers` (
`customer_id` INTEGER PRIMARY KEY,
`payment_method` VARCHAR(10) NOT NULL,
`customer_name` VARCHAR(80),
`customer_phone` VARCHAR(80),
`customer_email` VARCHAR(80),
`date_became_customer` DATETIME
)
CREATE TABLE `Regular_Orders` (
`regular_order_id` INTEGER PRIMARY KEY,
`distributer_id` INTEGER NOT NULL,
FOREIGN KEY (`distributer_id` ) REFERENCES `Customers`(`customer_id` )
)
CREATE TABLE `Regular_Order_Products` (
`regular_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Orders` (
`actual_order_id` INTEGER PRIMARY KEY,
`order_status_code` VARCHAR(10) NOT NULL,
`regular_order_id` INTEGER NOT NULL,
`actual_order_date` DATETIME,
FOREIGN KEY (`regular_order_id` ) REFERENCES `Regular_Orders`(`regular_order_id` )
)
CREATE TABLE `Actual_Order_Products` (
`actual_order_id` INTEGER NOT NULL,
`product_id` INTEGER NOT NULL,
FOREIGN KEY (`product_id` ) REFERENCES `Products`(`product_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` )
)
CREATE TABLE `Customer_Addresses` (
`customer_id` INTEGER NOT NULL,
`address_id` INTEGER NOT NULL,
`date_from` DATETIME NOT NULL,
`address_type` VARCHAR(10) NOT NULL,
`date_to` DATETIME,
FOREIGN KEY (`customer_id` ) REFERENCES `Customers`(`customer_id` ),
FOREIGN KEY (`address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Delivery_Routes` (
`route_id` INTEGER PRIMARY KEY,
`route_name` VARCHAR(50),
`other_route_details` VARCHAR(255)
)
CREATE TABLE `Delivery_Route_Locations` (
`location_code` VARCHAR(10) PRIMARY KEY,
`route_id` INTEGER NOT NULL,
`location_address_id` INTEGER NOT NULL,
`location_name` VARCHAR(50),
FOREIGN KEY (`location_address_id` ) REFERENCES `Addresses`(`address_id` ),
FOREIGN KEY (`route_id` ) REFERENCES `Delivery_Routes`(`route_id` )
)
CREATE TABLE `Trucks` (
`truck_id` INTEGER PRIMARY KEY,
`truck_licence_number` VARCHAR(20),
`truck_details` VARCHAR(255)
)
CREATE TABLE `Employees` (
`employee_id` INTEGER PRIMARY KEY,
`employee_address_id` INTEGER NOT NULL,
`employee_name` VARCHAR(80),
`employee_phone` VARCHAR(80),
FOREIGN KEY (`employee_address_id` ) REFERENCES `Addresses`(`address_id` )
)
CREATE TABLE `Order_Deliveries` (
`location_code` VARCHAR(10) NOT NULL,
`actual_order_id` INTEGER NOT NULL,
`delivery_status_code` VARCHAR(10) NOT NULL,
`driver_employee_id` INTEGER NOT NULL,
`truck_id` INTEGER NOT NULL,
`delivery_date` DATETIME,
FOREIGN KEY (`truck_id` ) REFERENCES `Trucks`(`truck_id` ),
FOREIGN KEY (`actual_order_id` ) REFERENCES `Actual_Orders`(`actual_order_id` ),
FOREIGN KEY (`location_code` ) REFERENCES `Delivery_Route_Locations`(`location_code` ),
FOREIGN KEY (`driver_employee_id` ) REFERENCES `Employees`(`employee_id` )
)
|
SELECT t2.state_province_county , count(*) FROM customer_addresses AS t1 JOIN addresses AS t2 ON t1.address_id = t2.address_id GROUP BY t2.state_province_county
|
List the state names and the number of customers living in each state.
|
customer_deliveries
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT count(*) FROM authors
|
How many authors are there?
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT count(*) FROM authors
|
Count the number of authors.
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT count(*) FROM inst
|
How many institutions are there?
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT count(*) FROM inst
|
Count the number of institutions.
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT count(*) FROM papers
|
How many papers are published in total?
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT count(*) FROM papers
|
Count the number of total papers.
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT t3.title FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid WHERE t1.fname = "Jeremy" AND t1.lname = "Gibbons"
|
What are the titles of papers published by "Jeremy Gibbons"?
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT t3.title FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid WHERE t1.fname = "Jeremy" AND t1.lname = "Gibbons"
|
Find the titles of all the papers written by "Jeremy Gibbons"
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT t3.title FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid WHERE t1.fname = "Aaron" AND t1.lname = "Turon"
|
Find all the papers published by "Aaron Turon".
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT t3.title FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid WHERE t1.fname = "Aaron" AND t1.lname = "Turon"
|
Find the titles of all the papers written by "Aaron Turon".
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT count(*) FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid WHERE t1.fname = "Atsushi" AND t1.lname = "Ohori"
|
How many papers have "Atsushi Ohori" published?
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT count(*) FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid WHERE t1.fname = "Atsushi" AND t1.lname = "Ohori"
|
How many papers are "Atsushi Ohori" the author of?
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT DISTINCT t3.name FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN inst AS t3 ON t2.instid = t3.instid WHERE t1.fname = "Matthias" AND t1.lname = "Blume"
|
What is the name of the institution that "Matthias Blume" belongs to?
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT DISTINCT t3.name FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN inst AS t3 ON t2.instid = t3.instid WHERE t1.fname = "Matthias" AND t1.lname = "Blume"
|
Which institution is the author "Matthias Blume" belong to? Give me the name of the institution.
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT DISTINCT t3.name FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN inst AS t3 ON t2.instid = t3.instid WHERE t1.fname = "Katsuhiro" AND t1.lname = "Ueno"
|
Which institution does "Katsuhiro Ueno" belong to?
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT DISTINCT t3.name FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN inst AS t3 ON t2.instid = t3.instid WHERE t1.fname = "Katsuhiro" AND t1.lname = "Ueno"
|
What is the name of the institution the author "Katsuhiro Ueno" belongs to?
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT DISTINCT t1.fname , t1.lname FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN inst AS t3 ON t2.instid = t3.instid WHERE t3.name = "University of Oxford"
|
Who belong to the institution "University of Oxford"? Show the first names and last names.
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT DISTINCT t1.fname , t1.lname FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN inst AS t3 ON t2.instid = t3.instid WHERE t3.name = "University of Oxford"
|
Find the first names and last names of the authors whose institution affiliation is "University of Oxford".
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT DISTINCT t1.fname , t1.lname FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN inst AS t3 ON t2.instid = t3.instid WHERE t3.name = "Google"
|
Which authors belong to the institution "Google"? Show the first names and last names.
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT DISTINCT t1.fname , t1.lname FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN inst AS t3 ON t2.instid = t3.instid WHERE t3.name = "Google"
|
Find the first names and last names of the authors whose institution affiliation is "Google".
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT t1.lname FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid WHERE t3.title = "Binders Unbound"
|
What are the last names of the author of the paper titled "Binders Unbound"?
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT t1.lname FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid WHERE t3.title = "Binders Unbound"
|
Who is the author of the paper titled "Binders Unbound"? Give me the last name.
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT t1.fname , t1.lname FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid WHERE t3.title = "Nameless , Painless"
|
Find the first and last name of the author(s) who wrote the paper "Nameless, Painless".
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT t1.fname , t1.lname FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid WHERE t3.title = "Nameless , Painless"
|
What are the first and last name of the author who published the paper titled "Nameless, Painless"?
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT DISTINCT t1.title FROM papers AS t1 JOIN authorship AS t2 ON t1.paperid = t2.paperid JOIN inst AS t3 ON t2.instid = t3.instid WHERE t3.name = "Indiana University"
|
What are the papers published under the institution "Indiana University"?
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT DISTINCT t1.title FROM papers AS t1 JOIN authorship AS t2 ON t1.paperid = t2.paperid JOIN inst AS t3 ON t2.instid = t3.instid WHERE t3.name = "Indiana University"
|
List the titles of the papers whose authors are from the institution "Indiana University".
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT DISTINCT t1.title FROM papers AS t1 JOIN authorship AS t2 ON t1.paperid = t2.paperid JOIN inst AS t3 ON t2.instid = t3.instid WHERE t3.name = "Google"
|
Find all the papers published by the institution "Google".
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT DISTINCT t1.title FROM papers AS t1 JOIN authorship AS t2 ON t1.paperid = t2.paperid JOIN inst AS t3 ON t2.instid = t3.instid WHERE t3.name = "Google"
|
Which papers were written by authors from the institution "Google"?
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT count(DISTINCT t1.title) FROM papers AS t1 JOIN authorship AS t2 ON t1.paperid = t2.paperid JOIN inst AS t3 ON t2.instid = t3.instid WHERE t3.name = "Tokohu University"
|
How many papers are published by the institution "Tokohu University"?
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT count(DISTINCT t1.title) FROM papers AS t1 JOIN authorship AS t2 ON t1.paperid = t2.paperid JOIN inst AS t3 ON t2.instid = t3.instid WHERE t3.name = "Tokohu University"
|
Find the number of papers published by authors from the institution "Tokohu University".
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT count(DISTINCT t1.title) FROM papers AS t1 JOIN authorship AS t2 ON t1.paperid = t2.paperid JOIN inst AS t3 ON t2.instid = t3.instid WHERE t3.name = "University of Pennsylvania"
|
Find the number of papers published by the institution "University of Pennsylvania".
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT count(DISTINCT t1.title) FROM papers AS t1 JOIN authorship AS t2 ON t1.paperid = t2.paperid JOIN inst AS t3 ON t2.instid = t3.instid WHERE t3.name = "University of Pennsylvania"
|
How many papers are written by authors from the institution "University of Pennsylvania"?
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT t3.title FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid WHERE t1.fname = "Olin" AND t1.lname = "Shivers"
|
Find the papers which have "Olin Shivers" as an author.
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT t3.title FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid WHERE t1.fname = "Olin" AND t1.lname = "Shivers"
|
Which papers did the author "Olin Shivers" write? Give me the paper titles.
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT t3.title FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid WHERE t1.fname = "Stephanie" AND t1.lname = "Weirich"
|
Which papers have "Stephanie Weirich" as an author?
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT t3.title FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid WHERE t1.fname = "Stephanie" AND t1.lname = "Weirich"
|
Find the titles of the papers the author "Stephanie Weirich" wrote.
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT t3.title FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid JOIN inst AS t4 ON t2.instid = t4.instid WHERE t4.country = "USA" AND t2.authorder = 2 AND t1.lname = "Turon"
|
Which paper is published in an institution in "USA" and have "Turon" as its second author?
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT t3.title FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid JOIN inst AS t4 ON t2.instid = t4.instid WHERE t4.country = "USA" AND t2.authorder = 2 AND t1.lname = "Turon"
|
Find papers whose second author has last name "Turon" and is affiliated with an institution in the country "USA".
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT t3.title FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid JOIN inst AS t4 ON t2.instid = t4.instid WHERE t4.country = "Japan" AND t2.authorder = 1 AND t1.lname = "Ohori"
|
Find the titles of papers whose first author is affiliated with an institution in the country "Japan" and has last name "Ohori"?
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT t3.title FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid JOIN inst AS t4 ON t2.instid = t4.instid WHERE t4.country = "Japan" AND t2.authorder = 1 AND t1.lname = "Ohori"
|
Which papers' first author is affiliated with an institution in the country "Japan" and has last name "Ohori"? Give me the titles of the papers.
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT t1.lname FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid GROUP BY t1.fname , t1.lname ORDER BY count(*) DESC LIMIT 1
|
What is the last name of the author that has published the most papers?
|
icfp_1
|
CREATE TABLE Inst (
instID INTEGER,
name TEXT,
country TEXT, -- the home country of the institution (this is obviously an impoverished model)
PRIMARY KEY (instID)
)
CREATE TABLE Authors (
authID INTEGER,
lname TEXT,
fname TEXT,
PRIMARY KEY (authID)
)
CREATE TABLE Papers (
paperID INTEGER,
title TEXT,
PRIMARY KEY (paperID)
)
CREATE TABLE Authorship (
authID INTEGER,
instID INTEGER,
paperID INTEGER,
authOrder INTEGER,
PRIMARY KEY (authID, instID, paperID),
FOREIGN KEY (authID) REFERENCES Authors (authID),
FOREIGN KEY (instID) REFERENCES Inst (instID),
FOREIGN KEY (paperID) REFERENCES Papers (paperID)
)
|
SELECT t1.lname FROM authors AS t1 JOIN authorship AS t2 ON t1.authid = t2.authid JOIN papers AS t3 ON t2.paperid = t3.paperid GROUP BY t1.fname , t1.lname ORDER BY count(*) DESC LIMIT 1
|
Which author has written the most papers? Find his or her last name.
|
icfp_1
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.