CMPS Database Systems I- CMPS 180, Final Exams- Fall 2016, 2017, 2018 & 2019 (Combined in 114 Pages)

downloaded from

Scholarfriends

https://scholarfriends.com Downloaded by: browsegrades@gmail.com | https://scholarfriends.com/singlePaper/303818/university-of-california-santa-cruz-cmps-databasesystems-i-cmps-180-final-exams-fall-2016-20 Distribution of this document is illegal.

CMPS 180, Final Exam, Fall 2016, Shel Finkelstein Student Name: ____________________________________________________ Student ID: ____________________________________________________ UCSC Email: ____________________________________________________

Final Points

Part I II III IV V Total

Max Points 18 24 18 20 21 101

Points

The exam is double-sided, so you have extra space to write answers. If you use that extra space, please be sure to write the number of the problem that you’re solving next to your answer.

At the end of the exam, please show your UCSC id when you hand in your exam booklet.

Part I: (18 Points, 3 each) For questions in Part I, use relations with the following schemas. Underlined attributes are keys.

Sailors(sid, sname, rating, age) // For each sid, gives the sailor’s name, rating and age Boats(bid, bname, color) // For each bid, give the boat’s name and color Reservations(sid, bid, day) // For each reservation of a boat by a sailor, gives day sailor reserved boat Some questions ask you to write SQL queries. Others ask you to write relational algebra expressions.

Question 1: Write a SQL statement that finds the sid and age for sailors who reserved at least one boat.

Answer 1: Here are some of the ways to answer this question. a) SELECT s.sid, s.age FROM Sailors s WHERE EXISTS ( SELECT * FROM Reservations r WHERE s.sid = r.sid ); b) SELECT DISTINCT s.sid, s.age FROM Sailors s, Reservations r WHERE s.sid = r.sid; c) SELECT s.sid, s.age FROM Sailors s, WHERE ( SELECT COUNT(*) FROM Reservations r WHERE s.sid = r.sid ) > 0;

Question 2: Write a relational algebra expression that finds the sid and age for sailors who reserved at least one boat.

Answer 2: Πsailors.sid, sailors.age( σsailors.sid = reservations.sid(Sailors X Reservations) )

Question 3: Write a SQL statement that finds the bid and color for boats that weren’t reserved by any sailor.

Answer 3: Here’s the simplest way to write this, similar to Question 1 Answer a): SELECT b.bid, b.color FROM Boats b WHERE NOT EXISTS ( SELECT * FROM Reservations r WHERE b.bid = r.bid ); Some people did additional checks in the subquery to see if the sailor in the reservation wasn’t null (r.sid IS NOT NULL). That wasn’t required, but it was good.

Question 4: Write a relational algebra expression that finds the bid and color for boats that weren’t reserved by any sailor.

Answer 4: Πbid, color (Boats) - ΠBoats.bid, color (σBoats.bid=Reservations.bid (Boats X Reservations)) The part of Answer 4 after the “minus” is very similar to Answer 2.

Question 5: Explain what the following relational algebra expression computes, where ⨝ is Natural Join. ( πrating ( (σcolor=’red’ Boats) ⨝ (σday=’11/07/2016’ Reservations) ⨝ Sailors ) ) ∩ ( πrating ( (σcolor=’green’ Boats) ⨝ (σday=’11/07/2016’ Reservations) ⨝ Sailors) ) Answer 5: Find the sailor ratings where there’s a sailor with that rating who reserved a red boat on 11/07/2016, and there’s also a sailor with that rating who reserved a green boat on 11/07/2016.

[Note that for a rating to appear in the answer, there have to be sailors who reserved a red boat and a green boat on 11/07/2016 who have that rating. But they could be different sailors with that rating.]

Question 6: For each equality, answer YES if it is always true, and answer NO if it isn’t always true.

6a):

C1

( C2 (R)) =

C2

( C1 (R))

where C1 and C2 are conditions on relation R’s attributes.

Answer 6a): ___YES_____ We discussed this in class; both are equivalent to 6b):

A1

( A2 (R)) =

A2

(C1 AND C2) (R)

( A1 (R))

where A1 and A2 are sets of attributes of relation R. Answer 6b): _____NO____ Suppose that A2 is (name, address) and A1 is just (name). Then the left-hand side makes sense, producing name. But the right-hand side doesn’t make sense. If you do a projection where you only keep name, then you can’t project name and address.

6c): ( R – S ) – T = R –( S – T ) where R, S and T are union-compatible relations.

Answer 6c): _____NO____ We drew the Venn diagram for this in class. As an example, suppose that S and T are equal. Then the right-hand side will always equal R, but the left-hand side won’t always equal R because of the minus.

Part II: (24 Points, 4 each) Question 7: A database has the relation Employees, with primary key emp_id, and other attributes giving name, department and salary of an employee.

Employees(emp_id, ename, edept, esalary) A programmer writes a SQL query intending to find the name, salary and department for employees who make the most money in their departments.

SELECT e1.ename, e1.salary, e1.edept FROM Employees e1 WHERE e1.salary > ALL ( SELECT e2.salary FROM Employees e2 WHERE e1.edept = e2.edept ); 7a): What error has the programmer made in writing this query? Fix the query so that it does what the programmer intended, making as few changes as possible.

Answer 7a): Every employee is in the same department as herself, but no employee can make more than her own salary. The programmer should have written >= instead of >: SELECT e1.ename, e1.salary, e1.edept FROM Employees e1 WHERE e1.salary >= ALL ( SELECT e2.salary FROM Employees e2 WHERE e1.edept = e2.edept ); 7b): Suppose that there is only one department (‘Marketing’) in Employees, and the employees in that department are ‘Smith’, ‘Jones’ and ‘Brown’. The salary of ‘Smith’ is 50000 and the salaries of ‘Jones’ and ‘Brown” are NULL. What will be the output of the corrected 7a) query that the programmer intended to write?

Answer 7b): The output will be empty. Even though Smith makes 50000, a comparison of his salary to a NULL salary yields truth value UNKNOWN. So Smith’s salary is not greater or equal to the salary of all the employees in his Marketing department.

Question 8a): If S(A,B,C) is a relation where A’s domain is (a1, a2, a3, a4) but A can’t be NULL, and B’s domain is (b1, b2, b3, b4) but B can be NULL, and C domain is (c1, c2) but c can be NULL, what is the maximum number of different tuples that can be in relation S? Answer 8a: _____60_______

(4 * 5 * 3 = 60)

8b): Write a SQL statement that updates tuples of S in which B has the value NULL but C does not, setting the B value for those tuples to be b2.

Answer 8b: UPDATE S SET B = b2 WHERE B IS NULL AND C IS NOT NULL;

Question 9: Define the Transaction Isolation levels Read Committed, and Repeatable Read, explaining the difference between them.

Answer 9: For Read Committed, only values written by transactions that committed are read; there are no Dirty Reads, where values written by transactions that have not yet committed are read.

For Repeatable Read, once again only values written by transaction that committed are read. However, with Repeatable Read, if you read a tuple’s value multiple times during a transaction, you’ll always read exactly the same value for that tuple.

With Read Committed, although you’ll only read committed values for a tuple, you might read different values for that tuple during a transaction, e.g., because other transactions changing that tuple committed.

Question 10: Briefly explain two different advantages of using Stored Procedures versus other Application Programming approaches.

Answer 10: Here are the three principal advantages of Stored Procedures over other Application Programming approaches. You were only asked to provide two. a) Avoid round trips: Performing computation inside the database is faster and cheaper than moving data back and forth between the database and the application. b) Encapsulation. Once a Stored Procedure has been written, many programs can use that stored procedure. Re-use is often better than having different programmers writing and maintaining code themselves. c) Security/Authorization. A user may be authorized to see the results of a Stored Procedure (e.g., a procedure that finds the average salary for people in a company), even though that user may not run a query that looks at the salaries of the individuals in the company.

Question 11: For the following table.

CREATE TABLE Beers ( name CHAR(20) PRIMARY KEY, manf CHAR(20) ); CREATE TABLE Sells ( bar CHAR(20), beer CHAR(20), price REAL ); Rewrite the CREATE statement for Sells (don’t do an ALTER) so that the beer attribute of Sells is a Foreign Key that correspond to name, the primary key of BEERS. Do the rewrite in 2 different ways for parts a) and b): 11a): First, rewrite the CREATE so that a Beers row can’t be deleted if there is a bar that sells the beer.

11b) Second, rewrite the CREATE so that if a Beers row is deleted, all the Sells rows for bars that sell that beer also are deleted.

(Don’t be concerned about handling of Updates of the name attribute of Beers.)

Answer 11a): CREATE TABLE Sells ( bar CHAR(20), beer CHAR(20) REFERENCES Beers(name), price REAL );

Answer 11b): CREATE TABLE Sells ( bar CHAR(20), beer CHAR(20) REFERENCES Beers(name) ON DELETE CASCADE, price REAL );

Question 12: 12a): Explain in words exactly what the regular expression (in bold) for person in the following address book DTD requires. <!DOCTYPE addressbook [ <!ELEMENT addressbook (person*)> <!ELEMENT person (name, address?, ( homephone | ( workphone, mobile )* ), email+)> <!ELEMENT name (#PCDATA)> <!ELEMENT address (#PCDATA)> <!ELEMENT homephone (#PCDATA)> <!ELEMENT workphone (#PCDATA)> <!ELEMENT mobile (#PCDATA)> <!ELEMENT email (#PCDATA)> ]> Answer 12a): According to this DTD, a person: • must have a single name, • can have 0 or 1 address, • has either a single homephone, or else has any number of workphones and mobile phones which can appear in any order … but not both, • and has 1 or more emails.

12b): Does the following data conform to that DTD? (YES or NO) <person> <name> MacNiel, John </name> <addr> Rome, OH 98765 </addr> <homephone> 718 555 3089 </homephone> <workphone> (903) 555 9876 </workphone> <mobile> (321) 555 2543 </mobile> <email> macniel@ucsc.edu </email> </person> Answer 12b): _____NO_______ The data does not correspond to the DTD because the person has both a homephone, as well as one or more workphone/mobile numbers (actually, one of each). The DTD says that the person can have either a homephone or else any number of workphone/mobile numbers in any other … but not both.

Another reason that the data does not correspond to the DTD is that there should be opening and closing addressbook tags: <addressbook> <person> <name> MacNiel, John </name> <addr> Rome, OH 98765 </addr> <homephone> 718 555 3089 </homephone> <workphone> (903) 555 9876 </workphone> <mobile> (321) 555 2543 </mobile> <email> macniel@ucsc.edu </email> </person> </addressbook>

Part III: (18 points, 3 each): Answer the following questions with YES/TRUE or NO/FALSE. Question 13: For a database with the following relations, with primary keys underlined: Employees(emp_id, ename, edept, salary) Departments(dept_id, dmanager, daddress) Are the following two queries always equivalent?

SELECT ename, dmanager, SUM(salary), FROM Employees, Departments WHERE edept = dept_id AND dmanager<> ‘Turing’ GROUP BY ename, dmanager; SELECT ename, dmanager, SUM(salary), FROM Employees, Departments WHERE edept = dept_id GROUP BY ename, dmanager HAVING dmanager <> ‘Turing’; Answer 13: ___YES_______ Question 14: When optimizing a query tree for execution, it is a good idea to push selection predicates and projections as far down in the tree as possible, to avoid extraneous rows and attributes. But you can’t rid of an attribute if it will be needed later to evaluate a predicate, or as part of a query answer.

Answer 14: ____YES_______ Question 15: The 5 relational algebra operators product (x), projection ( ), selection ( ), union (∪) and difference (–) are independent of each other, meaning that none of those can be expressed using the other. However, it’s possible to express join, natural join, intersection and division using the 5 relational algebra operators.

Answer 15: _____YES______

Question 16: Is every binary relation R(A,B) in Boyce Codd Normal Form, no matter what functional dependencies R has?

Answer 16: ____YES_______ Question 17: A set F of Functional Dependencies (FDs) implies an FD F (written F ⊨ F) if every instance r that satisfies FDs F must also satisfy the FD F. Now suppose that we find an instance r that satisfies F and that also satisfies F. YES or NO, does that prove that F ⊨ F? Answer 17: _____NO_______ Question 18: For OLAP, with a star schema, there is a foreign key constraint between the Fact table and each of the Dimension tables. However, there can be combinations of Dimension table values for which there is no row in the Fact table.

Answer 18: ____YES_______

Part IV: (20 points, 5 each): The questions in Part III are about the following tables, which should be familiar: Stores (store_id, name, address, manager) Customers (customer_id, name, address, email) Products (product_id, name, category, manufacturer) Sales (store_id, customer_id, product_id, purchase_date, quantity, unit_price, shipped) Question 19: Write a SQL statement that creates the Products table with product_id as a primary key. Ensure that there can’t be two products that have both the same manufacturer and name. The default manufacturer should be ‘Apple’.

Category can be NULL, but the other attributes can’t be NULL. product_id is an integer, and name category and manufacturer are character strings of length 20.

Answer 19: CREATE TABLE Products ( product_id INT PRIMARY KEY, name CHAR(20) NOT NULL, category CHAR(20), manufacturer CHAR(20) NOT NULL DEFAULT ‘Apple’, UNIQUE (name, manufacturer) );

Question 20: Here is a Create Statement for the Sales Table.

CREATE TABLE Sales ( store_id INT, customer_id INT, product_id INT, purchase_date DATE, quantity INT, unit_price DECIMAL(6,2), shipped BOOLEAN, PRIMARY KEY(store_id, customer_id, product_id, purchase_date) ); Rewrite this CREATE statement (don’t do an ALTER) so that store_id, customer_id and product_id are Foreign Keys that correspond to the keys of Stores, Customers and Products, respectively. The policies for referential integrity should be: • • •

Deleting a customer also deletes all Sales involving that customer.

Products can’t be deleted if there are Sales of that product.

Deleting a store deletes all Sales that were made in that store.

Also, the total price for any sale (which is quantity multiplied by unit_price) must be less than 2000.

Answer 20: CREATE TABLE Sales ( store_id int references Stores(store_id) ON DELETE CASCADE, customer_id int references Customers(customer_id) ON DELETE CASCADE, product_id int references Products(product_id), purchase_date date, quantity INT, unit_price DECIMAL(6,2), shipped BOOLEAN, PRIMARY KEY(store_id, customer_id, product_id, purchase_date), CHECK (quantity * unit_price < 2000) );

Question 21: 21a): Write a view BacklogProds that finds the product_id and product name for all products whose manufacturer is ‘Kelloggs’ where that product has at least one sale in Sales that has not been shipped. Each product should be listed only once, even if there are multiple unshipped sales of that product.

Answer 21a): CREATE VIEW BacklogProds AS SELECT p.product_id, p.name FROM Products p WHERE manufacturer = 'Kelloggs' AND EXISTS ( SELECT * FROM Sales s WHERE p.product_id = s.product_id AND NOT shipped );

21b): Write a query that does the following: For each product that is in the BacklogProds view, give the product_id, product name, and the total quantity that has been shipped for that product.

Answer 21b): SELECT b.product_id, b.name, SUM(quantity) FROM BacklogProds b, Sales s WHERE b.product_id = s.product_id AND shipped GROUP BY b.product_id, b.name;

Question 22: 22a): Write a statement that creates an index on the attributes purchase_date and unit_price of the Sales table.

Answer 22a): CREATE INDEX SalesDatePrice ON Sales(purchase_date, unit_price);

22b): For which of these queries would the index you created in part a) work best?

Query 1:

Query 2:

SELECT * FROM Sales WHERE purchase_date = ’11/29/2016’ AND unit_price < 20;

SELECT * FROM Sales WHERE unit_price = 20 AND purchase_date < ’11/29/2016’;

Answer 22b): ___Query 1_____ 22c: Indexes help process queries faster, but they also have significant disadvantages. Provide two different disadvantages associated with having indexes.

Answer 22c): Here are several disadvantages of index; you only had to provide 2.

• • •

When you have indexes, they have to be modified when values in underlying tables change (insert, update, delete), extra work that takes extra time.

Accessing indexes uses up additional memory (DRAM, L3, L2, L1).

Indexes take up additional space on disk (or other durable storage).

Part V: (21 points, 7 each): Question 23: Suppose that you have a relation R(A,B,C), and that an instance of R has rows (1,2,3), (4,2,3) and (5,3,3).

23a) Put an X next to a listed functional dependency if you can determine that it does not hold for R? Otherwise, leave the line blank. ________

AÆB

___X____

BC Æ A

________

BÆC

23b): Are there any functional dependencies that you can determine do hold for R? If so, give an example. If not, explain why not.

Answer 23b): There are two good answers to this question: NO: Even if those are all the tuples in the instance, you can’t tell whether a nontrivial Functional Dependency holds by looking at a single instance. A Functional Dependency is a rule that must hold across all instances, and even if that rule holds for one instance, it may not necessarily hold for other instances.

YES: Trivial Functional Dependencies must hold for any database. A trivial dependency is a Functional Dependency of the form X Æ A, where A is one of the attributes in X. [This question should have begun: “Are there any non-trivial functional dependencies that …”.]

Question 24: 24a): As part of design theory, we discussed anomalies, which database designers often try to avoid. Using an example, explain the deletion anomaly problem.

Answer 24a): Consider an Employee relation with the columns shown below, where eid is the primary key, but also where rank Æ salary_scale (rank functionally determines salary_scale). eid

name

addr

rank

salary_scale

34-133

Jane

Elm St.

6

70-90

33-112

Hugh

Pine St.

3

30-40

26-002

Gary

Elm St.

4

35-50

51-994

Ann

South St.

4

35-50

45-990

Jim

Main St.

6

70-90

98-762

Paul

Walnut St.

4

35-50

The tuples with eid 33-112 (name is Hugh) tells us that people who have rank 3 must have salary_scale 30-40. But if that tuple was deleted, then the relation would no longer have information about the salary_scale associated with rank 3. That’s the Deletion Anomaly discussed in the first of the two lectures on Design Theory.

24b): If you have a relation R and a set of functional dependencies F, what is a lossless-join decomposition for R with respect to F? Answer 24b): Here’s the precise definition from our Lecture slides, starting with the definition of decomposition. Answers could be more informal than this.

A Decomposition of a relation R is defined by sets of attributes X1, …, Xk (which don’t have to be disjoint) such that: 1. Each Xi ⊆ attr(R) 2. X1 ∪ X2∪ … ∪ Xk = attr(R) For a decomposition, we will write pXi (R) as Ri, with instance of R written as r and instances of Ri written as ri.

Let R be a relation schema and F be a set of FDs over R. A decomposition of R into k schemas, with attribute sets X1 , …, Xk, is a Lossless Join Decomposition with respect to F if for every instance r of R that satisfies F, we have: r = X1(r) ⋈ … ⋈ Xk(r) = r1 ⋈ r2 ⋈ … ⋈ rk where ⋈ is Natural Join.

The following isn’t the definition of Lossless Join Decomposition, but answers saying this received most of the credit for this problem. (Generalizing from 2 to k was even better, although we didn’t do that in class.)

Let R be a relation and F be set of FDs that hold over R. A decomposition of R into relation schemas R1 and R2 is Lossless if and only if F+ contains either: 1. R1 ∩ R2 → R1, or 2. R1 ∩ R2 → R2 That is, the intersection of the attributes of R 1 and R2 is a superkey of either R1 or R2

24c): Give an example of a relation R with no functional dependencies and a decomposition of R that is not a lossless-join decomposition.

Answer 24c): There are many good answers to this question that give a decomposition with an example that is not lossless. Here’s one of the examples that was discussed in class, where when you do the Natural Join of the relation instances formed from the original instance by the decomposition, the result has tuples in it that were not in the original instance.

Let R(A,B,C) be a relation schema with no functional dependencies. We can decompose R into R1(A,B) and R2(B,C), but the decomposition is not lossless, as we can see from this example with instance ry.

The instance on the far right should be labeled:

A, B(ry) ⋈

B,C(ry)

The tuples (a1, b1, c2) and (a2, b1, c2) were not in the original instance ry, so the decomposition is lossy.

Question 25: Suppose that you have a relation R(A,B,C,D,E), with the following functional dependencies: A Æ B, BC Æ E, and ED Æ A. 25a): Is R in BCNF? Explain your answer.

Answer 25a): No, R is not in BCNF. The FD A Æ B is not trivial, and A+ is AB, so the left-hand side of A Æ B is not a superkey. That’s enough to show that R is not in BCNF. But you could also prove this by looking at (BC)+, which is BCE, or by looking at (ED)+, which is ABDE. None of the left-hand sides of the FDs are superkeys, and none of them is trivial.

Hence any one of these FDs suffices to show that R is not in BCNF; we didn’t have to look at all three.

25b): Is R in 3NF? Explain your answer.

Yes, R is in 3NF. First, note that each of the following is a key for R: ACD, BCD and CDE. Why is each a key? Because the closure for each of them is ABCDE, which makes them superkeys, and we see from the following that no subset of any of them is a superkey, so they are keys for R. (AC)+ = ABCE (AD)+ = ABD (CD)+ = CD (BC)+ = BCE (BD)+ = BD (CE)+ = CE (DE)+ = ABDE Although none of the 3 FDs for R is trivial, and none of their left-hand sides are superkeys (as we saw in 25a), the right-hand sides of all the FDs are parts of keys for R. For A Æ B, B is part of the key BCD. For BC Æ E, E is part of the key CDE. For ED Æ A, A is part of the key ACD.

25c): For each of the following, indicate whether it’s a candidate key for R by writing YES or NO in the blank.

Answer 25c): ___NO______

ABC

Not a key because (ABC)+ = ABCE.

___NO______

ACDE

Not a key because a subset, ACD, is a superkey.

___YES_____

BCD

BCD is a key, as we showed in 25b).

CMPS 180, Final Exam, Fall 2017, Shel Finkelstein Student Name: ____________________________________________________ Student ID: ____________________________________________________ UCSC Email: ____________________________________________________ Final Points

Part

Max Points

I

40

II

30

III

36

Total

106

Points

The first Section (Part I) of the Winter 2017 CMPS 180 Final is multiple choice and is double-sided. Answer all multiple choice questions on your Scantron sheet. You do not have to hand in the first Section of the Exam, but you must hand in the Scantron sheet, with your name, email and student id on that Scantron sheet. Please be sure to use a #2 pencil to mark your choices on this Section of the Final.

This separate second Section (Parts II and III) of the Final is not multiple choice and is single-sided, so that you have extra space to write your answers. If you use that extra space, please be sure to write the number of the problem that you’re solving next to your answer. Please write your name, email and student id on this second Section of the Exam, which you must hand in. You may use any writing implement on this Section of the Exam.

At the end of the Final, please be sure to hand in your Scantron sheet for the first Section of the Exam and also this second Section of the Exam, and show your UCSC id when you hand them in. Also hand in your 8.5 x 11 “cheat sheet”, with your name written in the upper right corner of the sheet.

Part II: (30 points, 6 points each) Question 21: Assume that we already have a Persons table, whose Primary Key is SSN, and a Houses table, whose Primary Key is HouseID. Write a Create statement for another table: Properties(Owner, HouseID, DatePurchased) which describes houses owned by persons. Owner and SSN are integers, and HouseID is an integer in both Houses and Properties; DatePurchased is a date.

The Primary Key of Properties is (Owner, HouseID). In the Properties table that you create, Owner should be a Foreign Key corresponding to the Primary Key of Persons (SSN), and HouseID should be a Foreign Key corresponding to the Primary Key of Houses (which is also called HouseID).

Moreover, when an Owner is deleted, tuples in Properties for that Owner should be deleted. But deletion of a tuple in Houses is not permitted if there is a tuple in Properties for that HouseID. (You don’t have to consider updates in your Create.)

Answer 21: CREATE TABLE Properties ( Owner INTEGER REFERENCES Persons (SSN) ON DELETE CASCADE, HouseID INTEGER REFERENCES Houses (HouseID), DatePurchased DATE, PRIMARY KEY (Owner, HouseID) ); or CREATE TABLE Properties ( Owner INTEGER, HouseID INTEGER, DatePurchased DATE, PRIMARY KEY (Owner, HouseID), FOREIGN KEY (Owner) REFERENCES Persons (SSN) ON DELETE CASCADE, FOREIGN KEY (HouseID) REFERENCES Houses (HouseID) );

Question 22: Assume that Employees(empid, name, dept, salary) is table that has a large number of tuples, with many employees who are in many different departments (dept). For the following query and indexes: SELECT name FROM Employees WHERE dept =’ Engineering’ and salary > 5000; CREATE INDEX IX_dept ON Employees(dept); CREATE INDEX IX_salary ON Employees(salary); CREATE INDEX IX_name ON Employees(name); CREATE INDEX IX _dept_salary ON Employees(dept, salary); 22a): Give each of the four indexes one of the following evaluations: • NotGood (unlikely to help process the query efficiently) • Good (likely to help process the query efficiently) • Best (only one index can get this evaluation) Answer 22a): IX_dept

Evaluation: ____Good_____________

IX_salary

Evaluation: ____Good_____________

IX_name

Evaluation: ____NotGood__________

IX _dept_salary

Evaluation: ____Best_______________

22b): Suppose that those 4 indexes all existed, and there was an UPDATE statement that transferred someone named Edward Lee (who was already in Employees) to the Marketing department. Would any of these 4 indexes have to be updated? If so, which one(s)?

Answer 22b): Yes, just IX_dept and IX_dept_salary

Question 23: We have the following relations: Sailors(sid, sname, rating, age) // sailor id, sailor name, rating, age Boats(bid, bname, color) // boat id, boat name, color of boat Reserves(sid, bid, day) // sailor id, boat id, date that sailor sid reserved boat bid.

Codd’s relational algebra for sets included only the 5 operators Selection(  ), Projection(  ), Product( x ), Union (∪) and Difference (-). Using only those 5 operators, write a Relational Algebra query that finds the names of sailors whose age is more than 20, but who have not reserved any boat whose color is blue.

Very Big Hint: In SQL, you can use NOT EXIST or NOT IN or COUNT, but you can’t use any of those in Relational Algebra.

But you do have Difference. So first, find the names of sailors whose age is more than 20 and who have reserved a boat whose color is blue. Then use Difference to find the answer.

Answer 23: Here’s one correct answer. Other correct answers may push selection and projection closer to the relations.

πSailors.sname(σSailors.age > 20 (Sailors) ) – (πSailors.sname (σSailors.age > 20 AND Boats.color = ’Blue’ AND Sailors.sid = Reserves.sid (Sailors X Reserves) )

Question 24: Suppose that you have a relation CompanyData(Department, Project, Manager) with the following non-trivial functional dependencies: Department, Project  Manager Manager  Project 24a) Is CompanyData in BCNF? Justify why your answer is correct fully and clearly.

Answer 24a): No, CompanyData is not in BCNF. To be in BCNF, each FD would have either be trivial, or have a left-hand side that is a superkey. Trivial FDs are always true, but we don’t bother to specify them.

The second FD is not trivial. Also, for that second FD, the left-hand side, Manager, is not a superkey, since Manager+ is {Manager, Project}, which is not all the attributes of CompanyData.

24b): Is CompanyData in 3NF? Justify why your answer is correct fully and clearly.

Answer 24b): Yes, CompanyData is in 3NF. To be in 3NF, each FD would have either be trivial, or have a left-hand side that is a superkey, or have a right-hand side that is part of a superkey. Trivial FDs are always true, but we don’t bother to specify them.

For the first FD, the left-hand side is a superkey, since {Department, Project} + is {Department, Project, Manager}, which is all the attributes of CompanyData.

For the second FD, the right-hand side (Project) is part of a key, namely (Department, Project). We know that (Department,Project) is a key because it’s attribute close is all the attributes of CompanyData (as we just saw). But Department+ is just Department, while Project+ is {Project,Manager}. Taking an attribute out of the superkey (Department,Project) gives us a result that is not a superkey, so (Department,Project) is a key.

Since all of the FDs satisfy the criteria, CompanyData is in 3NF.

Question 25: The Tickets table, whose Primary Key is TicketID, is as follows: Tickets (TicketID, CustID, AirlineID, FlightNum, SeatNum, Cost, Paid) Here’s part of a PostgreSQL plpsql Stored Function called CostCut. The Stored Function has a float parameter (reduction_limit), and it returns a float value, described below. CostCut should cut the price of some Tickets in half, so (for example) a ticket that cost 500 would instead cost 250, a reduction of 250.

But CostCut shouldn’t reduce the price of all tickets. It should halve the price of the tickets with the highest cost, keeping track of the total reduction of cost as it goes.

When the total reduction becomes ≥ reduction_limit, CostCut shouldn’t do any more reductions. It should just return the total reduction of cost that it has computed.

CREATE FUNCTION costCut (reduction_limit float) RETURNS float AS $$ // Declarations: Fill in the declarations for any local variables and cursors BEGIN // Body: Fill in the body of the code for CostCut // Remember that you can use found to see if cursor found anything END; $$ LANGUAGE plpgsql Answer 25: Write the Declarations and the Body below, clearly saying which is which. You don’t have to repeat the parts of the Stored Function that appear above.

Declarations: DECLARE cursor_c AS cursor FOR SELECT cost FROM tickets ORDER BY cost FOR UPDATE; DECLARE total FLOAT; DECLARE fetched_cost FLOAT; Body: OPEN cursor_c; total := 0; WHILE total < reduction_limit LOOP FETCH cursor_c INTO fetched_cost; UPDATE tickets SET cost = fetched_cost/2 WHERE CURRENT OF cursor_c total := total + fetched_cost/2; END LOOP; CLOSE cursor_c; // Not required, but okay RETURN total;

Part III: (36 points, 9 points each) Some familiar tables appear below, with Primary Keys underlined. These tables also appear on the last page of the Final, which you can tear off to help you do questions in Part III of the Final. You don’t have to turn in that last page at the end of the Exam.

Airlines (AirlineID, AirlineName) Airports (AirportID, City, State) Flights (AirlineID, FlightNum, Origin, Destination, DepartureTime, ArrivalTime) Customers (CustID, CustName, Status) Tickets (TicketID, CustID, AirlineID, FlightNum, SeatNum, Cost, Paid) Assume that no attributes can be NULL, and that there are no UNIQUE constraints.

You may assume Referential Integrity as follows: • Each CustID in Tickets appears as a Primary Key in Customers.

• Each (AirlineID, FlightNum) in Tickets appears as a Primary Key in Flights.

• Each Origin and each Destination in Flights appears as a Primary Key in Airports.

• Each AirlineID in Flights appears as a Primary Key in Airlines.

Write legal SQL queries for Questions 26-29. If you want to create and then use views to answer these questions, that’s okay, but views are not required unless the question asks for them.

Don’t use DISTINCT in your queries unless it’s necessary, 0.5 points will be deducted if you use DISTINCT when you don’t have to do so. And some points may be deducted for queries that are very complicated, even if they are correct.

Question 26: There might be airports for which no flights go to that airport; that is, airports where no flight’s destination is that airport. Find the AirportID, City and State of each airport for which no flights go to that airport. The results of your query should appear in reverse alphabetical order by State, and for each State, in reverse alphabetical order by City.

Answer 26: Here are 3 correct answers.

SELECT a.AirportID, a.City, a.State FROM Airports a WHERE NOT EXISTS ( SELECT * FROM Flights f WHERE f.Destination = a.airportID ) ORDER BY a.State DESC, a.City DESC; SELECT a.AirportID, a.City, a.State FROM Airports a WHERE a.airportID NOT IN ( SELECT f. Destination FROM Flights f ) ORDER BY a.State DESC, a.City DESC; SELECT a.AirportID, a.City, a.State FROM Airports a WHERE a.airport <> ALL ( SELECT Destination FROM Flights f ) ORDER BY a.State DESC, a.City DESC;

Question 27: For each ticket that appears in Tickets for which the customer on that ticket has Status ‘B’, your SQL query should output the TicketID, the name of the customer who has that ticket, the State for the Origin of the flight on the ticket, and the State for the Destination of the flight on the ticket. The attribute names that appear in your result are up to you, but they should all be different.

Answer 27: SELECT t.TicketID, c.Custname, a1.State AS origin_state, a2.State AS destination_state FROM Tickets t, Customers c, Flights f, Airports a1, Airports a2 WHERE c.Custid = t.Custid AND c.Status = 'B' AND f.FlightNum = t.FlightNum AND f.Origin = a1.AirportID AND f.Destination = a2.AirportID; DISTINCT is not needed for this query, since TicketID is the primary key for Tickets, and at most one result can appear for each TicketID.

Question 28: We’re looking for flights that go from airport EWR to airport SFO with exactly one stopover airport (so there’s a first flight from EWR to some stopover airport, and a second flight from the same stopover airport to SFO). The time spent at the stopover airport should be at least one hour, but should also be no more than 90 minutes.

Your result should include FlightNum1, DepartureTime1, ArrivalTime1, StopOverAirportID, FlightNum2, DepartureTime2, ArrivalTime2. Use those names for the attributes in your result.

Answer 28: SELECT f1.FlightNum AS FlightNum1, f1.DepartureTime AS DepartureTime1, f1.ArrivalTime AS ArrivalTime1, f1.Destination AS StopOverAirportID, f2.FlightNum AS FlightNum2, f2.DepartureTime AS DepartureTime2, f2.ArrivalTime AS ArrivalTime2 FROM flights f1, flights f2 WHERE f1.Origin = 'EWR' AND f2.Destination = 'SFO' AND f1.Destination = f2.Origin AND f2.DepartureTime - f1.ArrivalTime >= INTERVAL '1 HOUR' AND f2.DepartureTime - f1.ArrivalTime <= INTERVAL '90 MINUTES’; No error whether or not you use DISTINCT, since problem was ambiguous.

Question 29: This question has two parts; be sure to answer both.

29a): Create a SQL view called NonStops. For each pair of airports, the NonStops view should give the first airport, the second airport, and the number of flights whose origin is the first airport and whose destination is the second airport. In your view, the attributes should be called Origin, Destination and FlightCount.

[Hint: Doing this correctly may be difficult, since there could be pairs of Airports that don’t have flights between them. If your view works correctly just for Airports that do have flights between them, you will only lose 1 point for that.]

29b): Using the view NonStops (not the original tables), find the total number of flights that go to each Destination. Your result should have attributes Destination and TotalFlights. But only include a Destination in your result if there are 3 or more tuples in NonStops which have that Destination value.

Answers 29a) and 29b): Answer 29a): The following view gives the result without providing count for Airports that have no flights between them. You would lose only 1 point for this solution.

CREATE VIEW NonStops AS ( SELECT f.Origin, f.Destination, COUNT(*) AS FlightCount FROM Flights f GROUP BY f.Origin, f.Destination ); The following view gives the result and also provides 0 as the count for Airports that have no flights between them. A second way to do this (using Outer Join) follows on the next page.

CREATE VIEW NonStops AS ( SELECT f.Origin, f.Destination, COUNT(*) AS FlightCount FROM Flights f GROUP BY f.Origin, f.Destination ) UNION ( SELECT a1.airportid, a2.airportid, 0 AS FlightCount FROM Airports a1, Airports a2 WHERE NOT EXISTS ( SELECT * FROM Flights f WHERE f.Origin = a1.AirportID) AND f.Destination = a2.AirportID) );

Here’s a view that uses Outer Join instead, also providing 0 as the count for Airports that have no flights between them. To make this relatively easy to undersand, we’ll create another view first that includes all pairs of airports (no WHERE clause, so it’s a Cartesian product). Then we take the Left Outer Join of that with Flights. This seems clearer than writing a query that has both Join and Left Outer Join in it (which also would work).

CREATE VIEW AirportPairs AS ( SELECT a1.AirportID AS firstAirport, a2.AirportID AS secondAirport FROM Airports a1, Airports a2 ); CREATE VIEW NonStops AS ( SELECT ap.firstAirport, ap.secondAirport, COUNT(f.FlightID) AS FlightCount FROM AirportPairs ap LEFT OUTER JOIN Flights f WHERE ap.firstAirport = f.Origin AND ap.secondAirport = f.Destination GROUP BY ap.firstAirport, ap.secondAirport ); For an AirportPair that has no flights between the airports, there will be a single tuple in the Left Outer Join that has NULL as its f.FlightID value. For such a pair of airports, COUNT(f.FlightID) will be 0 in NonStops. So by using Left Outer Join (much the way it can be used for OLAP), we avoided need for Union in previous definition of the NonStops view.

Answer 29b): SELECT n.Destination, SUM(n.FlightCount) AS TotalFlights FROM NonStops n GROUP BY n.Destination HAVING COUNT(*) >= 3 ;

This is extra blank space, in case you need more paper to answer questions.

Write Question number clearly if you use blank pages.

You may tear off this page to help you do Part III of the Final.

Some familiar tables appear below, with Primary Keys underlined. These tables also appear on the last page of the Final, which you can tear off to help you do questions in Part III of the Final. You don’t have to turn in that last page at the end of the Exam.

Airlines (AirlineID, AirlineName) Airports (AirportID, City, State) Flights (AirlineID, FlightNum, Origin, Destination, DepartureTime, ArrivalTime) Customers (CustID, CustName, Status) Tickets (TicketID, CustID, AirlineID, FlightNum, SeatNum, Cost, Paid) Assume that no attributes can be NULL, and that there are no UNIQUE constraints.

You may assume Referential Integrity as follows: • Each CustID in Tickets appears as a Primary Key in Customers.

• Each (AirlineID, FlightNum) in Tickets appears as a Primary Key in Flights.

• Each Origin and each Destination in Flights appears as a Primary Key in Airports.

• Each AirlineID in Flights appears as a Primary Key in Airlines.

Write legal SQL queries for Questions 26-29. If you want to create and then use views to answer these questions, that’s okay, but views are not required unless the question asks for them.

Don’t use DISTINCT in your queries unless it’s necessary, 0.5 points will be deducted

CMPS 180, Final Exam, Winter 2017, Shel Finkelstein Student Name: ____________________________________________________ Student ID: ____________________________________________________ UCSC Email: ____________________________________________________

Final Points

Part

Max Points

I

44

II

30

III

32

Total

106

Points

The first Section (Part I) of the Winter 2017 CMPS 180 Final is multiple choice and is double-sided. Answer all multiple choice questions on your Scantron sheet. You do not have to hand in that first Section of the Exam, but you must hand in the Scantron sheet, with your name, email and student id on that Scantron sheet. Please be sure to use a #2 pencil to mark your choices on this Section of the Final.

The separate second Section (Parts II and III) of the Final is not multiple choice and is single-sided, so that you have extra space to write your answers. If you use that extra space, please be sure to write the number of the problem that you’re solving next to your answer. Please write your name, email and student id on the second Section of the Exam, which you must hand in. You may use any writing implement on this Section of the Exam.

At the end of the Final, please be sure to hand in both your Scantron sheet for the first Section of the Exam and also the second Section of the Exam, and show your UCSC id when you hand them in.

Part I: (44 points, 2 points each) Answer the questions in Part I on your Scantron sheets, which should have your name, email and UCSC id on them. Select the best answer for each of the following.

For some questions, a choice is “All of the Above”, so read answer choices carefully.

Question 1: If an instance of relation R(A,B) has 10 different tuples in it, and an instance of relation S(B,C,D) has 6 different tuples in it, then how many tuples are there in the result if the following SQL query is executed on those instances?

SELECT * FROM R, S WHERE R.B = S.B; a) 0 b) Exactly 16 c) Exactly 60 d) Between 0 and 16 e) Between 0 and 60 Question 2: We discussed ACID properties of transactions. What does Atomicity (the “A” in ACID) refer to for transactions? a) Transaction execution is as if they were executed one at a time. b) Transactions happen completely or not-at-all. c) If a transaction commits, its changes are permanent, even if there are failures. d) Business rules are always maintained by the database system. e) Uncommitted (dirty) values from one transaction are never read by any other transaction.

Question 3: An instance of relation R(A,B) has m tuples in it, all the same, and an instance of relation S(A,B) has n tuples in it, which are all the same as the tuples in R(A,B). If R and S are Union-Compatible, and m and n are both at least 1, then how many tuples are there in the result of the following query? ( SELECT * FROM R ) INTERSECT ( SELECT * FROM S ); a) 1 b) m + n c) m – n (but not less than zero) d) min(m, n) e) max(m, n)

Question 4: Why might there be a runtime error when the following statement is executed on relations Customers(cname, age) and Activities(cname, slopeid, date)?

SELECT Customers.cname FROM Customers WHERE Customers.cname = ( SELECT Activities.cname FROM Activities ); a) Some customer may have participated in no activities. b) Some customer may have participated in exactly one activity. c) Some customer may have participated in more than one activity. d) For some cname in Activities, there might be no customer with that cname in Customers. e) For some cname in Activities, there might be more than one customer with that cname in Customers.

Question 5: For the relation Employees(name, age, salary), suppose that no employees who are 65 or older, but there are employees who are under 65. Which employee names will appear in the result to the following query: SELECT e1.name FROM Employees e1 WHERE e1.salary < ALL ( SELECT e2.salary FROM Employees e2 WHERE e2.age >= 65 ); a) There will be no employee names in the result. b) All of the employee names will be in the result. c) The result will be NULL. d) The result will be UNKNOWN. e) The query will cause a runtime error.

Question 6: Which statement is true for Relational Algebra Operations, where R is a relation and C1 and C2 are conditions on the attributes of R? a)  is Commutative: C1 (C2 (R)) = C2 (C1 (R)) b) C1 (C2 (R)) = C1 AND C2(R) c) Union is Commutative (for union-compatible relations): R ∪ S = S ∪ R d) Union is Associative (for union-compatible relations): (R ∪ S) ∪ T = R ∪ (S ∪ T) e) All of the Above

Question 7: Employees(name, age, salary) is a relation, and the salary for an employee named Smith is 5000. What is Smith’s salary after the following, assuming that this is the only transaction executing?

BEGIN TRANSACTION; UPDATE Employees SET salary = salary + 1000 WHERE name=’Smith’; UPDATE Employees SET salary = 2 * salary WHERE name=’Smith’; ROLLBACK TRANSACTION; a) 5000 b) 6000 c) 12000 d) Could be 5000, 6000 or 12000 e) None of the Above Question 8: Employees(name, age, salary) is a relation, and the salary for an employee named Smith is 5000. Two different transactions T1 and T2 are executed by different people at approximately the same time, with Isolation Level Serializable. Both transactions commit. T1 and T2 are the only transactions executing. What is Smith’s salary afterwards?

T1: BEGIN TRANSACTION; UPDATE Employees SET salary = salary + 1000 WHERE name=’Smith’; COMMIT TRANSACTION; T2: BEGIN TRANSACTION; UPDATE Employees SET salary = 2 * salary WHERE name=’Smith’; COMMIT TRANSACTION; a) Must be 5000 b) Must be 11000 c) Must be 12000 d) Must be either 11000 or 12000 e) Could be something other than 11000 or 12000

Question 9: The Employees(name, age, salary) table has been created with name as the primary key, salary having a default value of 9000, and with age and salary both allowed to be NULL. What is in the tuple with name ‘Chou’ after the following statement is executed, assuming that there was no tuple for ‘Chou’ before the statement was executed?

INSERT INTO EMPLOYEES(name, age) VALUES (‘Chou’, 25); a) ‘Chou’, 25 b) ‘Chou’, 25, NULL c) ‘Chou’, 25, 9000 d) ‘Chou’, NULL, 9000 e) There will be no tuple for Chou because salary was not supplied in the INSERT. Question 10: For the relations Customers(cname, age) and Activities(cname, slopeid, date), what does the following Relational Algebra query do?

ΠCustomers.cname, Customers.age(σCustomers.cname=Activities.cname(Customer X Activities)) a) Finds cname and age for the customers who participated in at least one activity. b) Finds cname and age for the customers who didn’t participate in any activity. c) Finds cname and age for each customer. d) For each customer, gives cname, age and counts the number of activities that the customer participated in. e) None of the Above Question 11: For a table Movies(title, year, length, studio), which index will probably help the most for executing the following query?

SELECT title, year, length FROM Movies WHERE year > 2000 AND studio = ‘Disney”; a) An index on year b) An index on studio c) An index on (year, studio) in that order d) An index on (studio, year) in that order e) Indexes on (year, studio) and (studio, year) are both the most helpful, and they’re equally good.

Question 12: Assume that name is the primary key in the Beers table. This use of a CHECK constraint is legal in many SQL systems (but not in PostgreSQL): CREATE TABLE Sells ( bar CHAR(20), beer CHAR(20)

CHECK ( beer IN (SELECT name FROM Beers) ),

price REAL ); For SQL systems in which this use of CHECK is legal, which is the best answer? a) If you INSERT a row into the Sells table whose beer attribute value doesn’t appear as a name in the Beers table, then there will be an error. b) If you DELETE a row from the Beers table, and there is a row in the Sells table whose beer attribute value equals the beer name in the deleted row, then there will be an error. c) If you UPDATE a row in the Sells table, changing its beer attribute value to a different beer whose name appears in the Beers table, then there will be an error. d) Answer a) and b) are both correct, but answer c) is not correct. e) Answer a), b) and c) are all correct.

Question 13: Which operation can an ALTER statement do? a) Create a table b) Drop a table c) Delete all rows from a table d) Add additional columns to a table e) None of the Above Question 14: Which of these is/are advantages of Stored Procedures? a) Can make performance better by enabling operations to be performed on data without moving that data from the database to the client. b) Can make programming easier by allowing code to be written once in a procedure, and then reused by anyone authorized to execute the procedure. c) Can improve security by allowing people to be authorized to execute a procedure without authorizing them to access all the data used by the procedure. d) All of the Above e) None of the Above

Question 15: Sells(bar, beer, price) is a table, and RipoffBars(bar) is another table.

What does this Trigger do, assuming that price represents a dollar amount?

CREATE TRIGGER PriceTrig AFTER UPDATE OF price ON Sells REFERENCING OLD ROW AS old_row NEW ROW AS new_row FOR EACH ROW WHEN(new_row.price – old_row.price > 8.00) INSERT INTO RipoffBars VALUES(new_row.bar); a) If any row in Sells has a beer that costs more than 8 dollars, then the bar in that row is inserted into RipoffBars. b) If a row is inserted into Sells that has a beer that costs more than 8 dollars, then the bar in that inserted row is inserted into RipoffBars. c) If price is updated for a row in Sells, and the new price is more than 8 dollars higher than the old price, then the bar in that updated row is inserted into RipoffBars. d) If price is updated for a row in Sells, and the old price is more than 8 dollars higher than the new price, then the bar in that updated row is inserted into RipoffBars. e) If price is updated for a row in Sells, and the new price is more than 8 dollars higher than the old price, then the update returns an error.

Question 16: Sells(bar, beer, price) is a table, where bar and beer are CHAR(20) and price is FLOAT. Assuming that myCon is a connection, what error appears in the following JDBC, which is supposed to print the beers and prices for Joe''s Bar? Statement stmt = myCon.createStatement(); ResultSet Menu = stmt.executeQuery(“ SELECT beer, price FROM Sells WHERE bar = 'Joe''s Bar' ”); while (Menu.fetch()) { // For each value in result, get values of beer and price, and print them System.out.println(Menu.getString(1), Menu.getFloat(2)); a) Should use PreparedStatement, not Statement b) Should use Menu.next, not Menu.fetch c) Should use System.out.println(ResultSet.Float(1), ResultSet.getString(2)); not System.out.println(Menu.getString(1), Menu.getFloat(2)); d) Should use stmt.updateQuery, not stmt.executeQuery e) In the SELECT statement, 'Joe''s Bar' has the single quote symbol appearing twice (between Joe and s) in 'Joe''s Bar', but it should only appear once, replaced by 'Joe's Bar'

Question 17: R(A,B) and S(A,B) are union-compatible tables which may have duplicates. Here are two queries, Q1 (on the left) and Q2 (on the right) on those tables. Which statement is always correct for the results of those queries?

a) The results of Q1 and Q2 must always be the same. b) Everything in the result of Q1 must always be in the result of Q2, but the results aren’t always the same. c) Everything in the result of Q2 must always be in the result of Q1, but the results aren’t always the same. d) The result of Q1 can never have duplicates. e) None of the Above Question 18: In On-Line Analytic Processing (OLAP), what does the term “roll-up” mean? a) Separating attributes in a Fact table into Dimension attributes and Dependent attributes. b) Joining a Fact table with its underlying Dimension tables. c) Doing an Outer Join to obtain facts that are not in the Fact Table because values for those facts are 0 or NULL. d) Aggregating values along one or more dimensions, e.g., taking a sum. e) Disaggregating a value into its constituent parts, e.g., breaking a sum down into the values that led to the sum.

Question 19: For the following addressbook DTD: <!DOCTYPE addressbook [ <!ELEMENT addressbook (person*)> <!ELEMENT person (name, address+, ( homephone | ( workphone, mobile )* ), email?)> <!ELEMENT name (#PCDATA)> <!ELEMENT address (#PCDATA)> <!ELEMENT homephone (#PCDATA)> <!ELEMENT workphone (#PCDATA)> <!ELEMENT mobile (#PCDATA)> <!ELEMENT email (#PCDATA)> ]> Does the following data correspond to that DTD? <addressbook> <person> <name> Abraham Lincoln </name> <address> Washington D.C. 20500 </address> <workphone> (312) 555 9876 </workphone> <mobile> (773) 555 2543 </mobile> </person> </addressbook> a) Yes, the data corresponds to the DTD. b) No, because there’s only one person. c) No, because there’s no homephone. d) No, because there’s both a workphone and a mobile. e) No, because there’s no email.

Question 20: For the table R(A, B, C), which is a lossless join decomposition?

R1(A, B) is the projection of R on attributes A, B, and R 2(B,C) is the projection of R on attributes B, C. a) R1(A, B) and R2(B, C), if there are no functional dependencies b) R1(A, B) and R2(B, C), if we know that A → B c) R1(A, B) and R2(B, C), if we know that B → A d) R1(A, B) and R2(B, C), if we know that A → C e) R1(A, B) and R2(B, C), if we know that C → A

Question 21: If you want to check whether attributes salary1 and salary2 in a relation are both NULL, which way (or ways) can you write a condition in a SQL WHERE clause to test for that? a) salary1 = NULL AND salary2 = NULL b) salary1 IS NULL AND salary1 = salary2 c) salary1 IS NULL AND salary2 IS NULL d) All of the Above e) None of the Above Question 22: Suppose that R(A, B ,C, D) is a relation, r is an instance of R, and F is a non-trivial Functional Dependency on the attributes of R. Here are two statements: i. ii.

If r satisfies F, then F must hold for R. If r does not satisfy F, then F does not hold for R.

You’re asked to supply the correct answer about these two statements. a) Both statements are True. b) The first statement is True and the second statement is False. c) The first statement is False and the second statement is True. d) Both statements are False. e) All of the Above

Part II: (30 points, 6 points each) Question 23: Assume we have the following tables: • Stores table, with Primary Key store_id • Customers table, with Primary Key customer_id • Products table, with Primary Key product_id These tables have other columns that aren’t important for this question.

Here’s the Create Statement for another table, the Sales Table, which gives information about products sold to customers in stores: CREATE TABLE Sales ( store_id INT, customer_id INT, product_id INT, quantity INT, PRIMARY KEY(store_id, customer_id, product_id) ); Rewrite this CREATE statement (don’t do an ALTER) so that customer_id and product_id are Foreign Keys that correspond to the Primary keys of Customers and Products, respectively. Policies for Referential Integrity should be: • •

A row in Customers can’t be deleted if there are any Sales rows mentioning that customer.

Deleting a row from Products deletes all Sales rows mentioning that product.

Also, the quantity for any row in Sales must be at least 1, but can’t be more than 25.

Answer 23: CREATE TABLE Sales ( store_id INT, customer_id INT REFERENCES Customers(customer_id), product_id INT REFERENCES Products(product_id) ON DELETE CASCADE, quantity INT CHECK (quantity >=1 AND quantity <=25), PRIMARY KEY(store_id, customer_id, product_id) ); The check could also be written as a tuple-based check at the end of the CREATE.

Question 24a): Why have any indexes in a database? Give two different clear reasons.

Answer 24a): Any two of the following reasons are good.

1. Query execution may be faster using indexes, rather than scanning entire tables to find matching tuples. For example, an index on age may improve performance of a query selecting employees whose age is 21.

2. Checking uniqueness of primary keys (or UNIQUE attributes) is much faster for a database system with indexes (on the primary keys, or on the UNIQUE attributes) than without them.

3. Checking Referential Integrity (ensuring that children have parents when there’s a constraint) is much faster for a database system with indexes than without them.

Question 24b): Why not have indexes on every column in a database? Give two different reasons.

Answer 24b): Any two of the following reasons are good.

1. Indexes have to be maintained correctly when there are inserts, deletes and updates affecting the indexes. That makes those statements take longer to execute.

2. Indexes occupy additional storage on disk (or SSD).

3. Accessing indexes uses additional memory on processors.

Question 25a): For the relation Employees(name, age, salary), write a SQL UPDATE statement that finds every employee whose name begins with ‘SHEL’ and increases that employee’s salary by 35.

Answer 25a): UPDATE Employees SET salary = salary + 35 WHERE name LIKE ‘SHEL%’;

25b): For the relation Employees(name, age, salary), write a SQL DELETE statement that deletes all employees who receive the highest salary.

Answer 25b): Here are 3 solutions that work in standard SQL. DELETE FROM Employees WHERE salary = ( SELECT MAX(salary) FROM Employees ); DELETE FROM Employees WHERE salary >= ALL ( SELECT salary FROM Employees ); DELETE FROM Employees e1 WHERE NOT EXISTS ( SELECT * FROM Employees e2 WHERE e2.salary > e1.salary );

Question 26a): Codd’s relational algebra for sets included only the 5 operators Selection, Projection, Product, Union and Difference. But other operators can be defined using those operators.

Show that Intersection can be defined using these 5 operators.

Answer 26a): For two Union-Compatible Relations R and S, either of the following works. Only Difference is needed.

R ⋂ S = R – (R – S) R ⋂ S = S – (S – R)

26b): Armstrong’s Axioms for Functional Dependencies are Reflexivity, Augmentation and Transitivity. Using those axioms, we proved other Rules for Functional Dependencies, including the Union Rule.

The Union Rule is:

If X → Y and X → Z, then X → YZ.

Here’s the proof of the Union Rule, but with explanations missing for 3 steps in that proof. Write one of Reflexivity, Augmentation or Transitivity on each of the 3 empty underlines (starting with ?) below to supply the missing explanations in the proof.

It’s okay to write the same explanation more than once, if that’s correct.

Proof Step -------------------------------

Explanation -----------------------------

X→Z

Given

So we get XY → YZ

? Augmentation

X→Y

Given

So we get X → XY

? Augmentation

Therefore X → YZ

? Transitivity

Question 27: Suppose that you have a relation Inventory(StoreID, StoreName, Part, Quantity) with the following functional dependencies: StoreID, Part  Quantity StoreName, Part  Quantity StoreName  StoreID StoreID  StoreName 27a) Is Inventory in BCNF? Justify your answer fully and clearly.

Answer 27a): No, Inventory is not in Boyce-Codd Normal Form (BCNF).

The Functional Dependency StoreName  Store_Id is not trivial. And the left-hand side of that FD is not a superkey: {StoreName}+ = {StoreName, Store_Id}, and that’s not all the attributes of Inventory.

You can also show that Inventory is not in BCNF the same way using the Functional Dependency StoreID  StoreName. (You only had to do this for one FD.) But the left-hand sides of the first two FDs are superkeys, so you can’t use those FDs to prove that Inventory is not in BCNF.

27b) Is Inventory in 3NF? Justify your answer fully and clearly.

Answer 27b): Yes, Inventory is in Third Normal Form (3NF).

First, let’s note that both {StoreID, Part} and {StoreName, Part} are keys. We can see that they’re both superkeys, since: {StoreID, Part}+ = {StoreID, Part, StoreName, Quantity} using StoreID  StoreName and StoreID, Part  Quantity {StoreName, Part}+ = {StoreName, Part, StoreID, Quantity} using StoreName  StoreID and StoreName, Part  Quantity But they’re also keys, since they aren’t superkeys if they’re “put on a diet”. That is, {StoreName}+ = {StoreName, Store_Id}, {StoreID} + = {StoreID, Store_Name}, and {Part}+ = {Part}, and none of those closures contain all the attributes of Inventory.

None of the FDs is trivial. Now let’s look at each of the FDs in turn and show that either the left-hand side is a superkey or the right-hand side is part of a key.

• • • •

For StoreID, Part  Quantity, the left-hand side is a superkey. Check.

For StoreName, Part  Quantity, the left-hand side is a superkey. Check For StoreName  Store_ID, the left-hand side isn’t a superkey, but the righthand side is part of the key (StoreID, Part). Check.

For StoreID  Store_Name, the left-hand side isn’t a superkey, but the righthand side is part of the key (StoreName, Part). Check.

Since all the FDs check out, Inventory with these FDs is in 3NF.

Part III: (32 points, 8 points each) The familiar relations Persons, Houses and Tenants are shown below, with Primary Keys underlined. Assume Referential Integrity as follows: • • •

Every HouseID that appears in Persons, Ownerships or Tenants also appears as a HouseID in Houses.

Every SSN (OwnerSSN in Landlords, LeaseTenantSSN in Tenants) also appears as an SSN in Persons.

Every LandlordID that appears in Ownerships also appears as a LandlordID in Landlords.

Persons (SSN, Name, HouseID, ApartmentNumber, Salary) Houses (HouseID, HouseAddress, ApartmentCount, Color) Landlords (LandlordID, OwnerSSN, LandlordAddress) Ownerships (LandlordID, HouseID, PurchaseDate, PropertyTax) Tenants (HouseID, ApartmentNumber, LeaseTenantSSN, LeaseStartDate, LeaseExpirationDate, Rent, LastRentPaidDate, RentOverdue) Assume that no attributes can be NULL, and that there are no UNIQUE constraints.

Write SQL queries for each of the following questions. If you want to create and then use views to answer these questions, that’s okay, but views are not required unless a question asks you for them.

Don’t use DISTINCT in your queries unless it’s necessary.

Question 28: Find the names (with no duplicates) of all persons who live in houses whose color is ‘Red’. Names should appear in the result in reverse alphabetical order, so that names starting with ‘Z’ come before names starting with ‘Y’, etc.

Answer 28: SELECT DISTINCT p.name FROM Persons P, Houses H WHERE P.HouseID = H.HouseID AND H.Color = 'Red' ORDER BY P.name DESC;

Question 29: If a landlord owns a house, then there will be a row for that LandlordID and HouseID in the Ownership relation. Find the LandlordID (with no duplicates) of all landlords in the Landlord relation who don’t own any houses.

Answer 29: Here are two correct answers.

SELECT L.LandlordID FROM Landlords L WHERE NOT EXISTS ( SELECT O.LandlordID FROM Ownerships O WHERE O.LandlordID = L.LandlordID );

SELECT L.LandlordID FROM Landlords L WHERE L.LandlordID <> ALL ( SELECT O.LandlordID FROM Ownerships O );

Question 30: There can be multiple rows in the Tenants table that have the same LeaseTenant. For each person who is a LeaseTenant, find the total of the Rent for all the Tenant rows in which that person is the LeaseTenant, but only include rows in your result if the total Rent is more than 2000.

Your result should include the LeaseTenant’s SSN, his name, his personal address, and the total Rent for all the rows in Tenants in which he is LeaseTenant. In your result, call the total Rent TotalRent. And, as we emphasized above, only include rows in your result if TotalRent is more than 2000.

Answer 30: Here are three correct answers; you only needed to provide one.

Answer #1 to Question 30: SELECT P.SSN, P.name, H.HouseAddress, SUM(T.Rent) AS TotalRent FROM Persons P, Houses H, Tenants T WHERE P.SSN = T.LeaseTenantSSN AND P.HouseId = H.HouseID GROUP BY P.SSN, P.name, H.HouseAddress HAVING SUM(T.Rent) > 2000; You could use T.LeaseTenantSSN instead of P.SSN if that appears in both the GROUP BY and the SELECT, since P.SSN = T.LeaseTenantSSN. Answer #2 to Question 30: This answer uses a view that doesn’t group by P.name because P.name isn’t in its SELECT clause.

CREATE VIEW BigRent(SSN, HouseAddress, TotalRent) AS SELECT P.SSN, H.HouseAddress, SUM(T.Rent) FROM Persons P, Houses H, Tenants T WHERE P.SSN = T.LeaseTenantSSN AND P.HouseId = H.HouseID GROUP BY P.SSN, H.HouseAddress HAVING SUM(T.Rent) > 2000; SELECT P.SSN, P.name, B.HouseAddress, B.TotalRent FROM Persons P, BigRent B WHERE P.SSN = B.SSN;

Answer #3 to Question 30: This answer uses a SELECT in the FROM clause with a tuple variable.

SELECT P.SSN, P.name, H.HouseAddress, T2.TotalRent FROM Persons P, Houses H, ( SELECT T.LeaseTenantSSN, SUM(T.Rent) AS TotalRent FROM Tenants T GROUP BY T.LeaseTenantSSN HAVING SUM(T.Rent) > 2000 ) T2 WHERE P.SSN = T2.LeaseTenantSSN AND P.HouseId = H.HouseID;

Answer #3 could also be handled using a VIEW, and Answer #2 could also be handled using a SELECT in the FROM clause with a tuple variable .

Question 31: This question has two parts; be sure to answer both.

31a) Create a SQL view called Rented. For each house in the Houses relation, the Rented view should give the HouseID and the number of apartments in that house that have rows in Tenants. In the result of your view, the second attribute should be called RentedCount.

(Hint: Doing this correctly requires an Outer Join, since there could be Houses that have no Tenants. You will still get partial credit if you do a Join instead of an Outer Join.]

31b) Write a SQL query that finds all the houses that appear in the Rented view whose RentedCount in the Rented view does not equal the ApartmentCount in Houses for that house. Your result should include the HouseID, the RentedCount and the ApartmentCount for each house in Rented whose RentedCount doesn’t equal its ApartmentCount.

Answers 31a) and 31b): 31a) CREATE VIEW Rented AS SELECT H.HouseID, COUNT(T.ApartmentNumber) AS RentedCount FROM Houses H LEFT OUTER JOIN Tenants T ON H.HouseID = T.HouseID GROUP BY H.HouseID; You can use COALESCE if you want to, but it’s not needed, since NULL is ignored when COUNT is computed (except when you do COUNT(*)), and COUNT on the empty set is 0.

CREATE VIEW Rented AS SELECT H.HouseID, COUNT(COALESCE(T.ApartmentNumber, 0)) AS RentedCount FROM Houses H LEFT JOIN Tenants T ON H.HouseID = T.HouseID GROUP BY H.HouseID;

In this case OUTER JOIN (same as FULL OUTER JOIN) would be equivalent because in the schema, you were told to assume Referential Integrity (every HouseID in Tenants appears in Houses).

Also, you can use COUNT(*), or COUNT of other attributes, instead of COUNT(T.ApartmentNumber).

31b) SELECT R.HouseID, R.RentedCount, H.ApartmentCount FROM Rented R, Houses H WHERE R.HouseID = H.HouseID AND R.RentedCount <> H.ApartmentCount;

CMPS 180, Final Exam, Fall 2018, Shel Finkelstein Student Name: ____________________________________________________ Student ID: ____________________________________________________ UCSC Email: ____________________________________________________ Final Points

Part I II III Total

Max Points 42 24 36 102

Points

The first Section (Part I) of the Fall 2018 CMPS 180 Final is multiple choice and is double-sided. Answer all multiple choice questions on your Scantron sheet. You do not have to hand in the first Section of the Exam, but you must hand in the Scantron sheet, with your name, email and student id on that Scantron sheet. Please be sure to use a #2 pencil to mark your choices on this Section of the Final.

This separate second Section (Parts II and III) of the Final is not multiple choice and is single-sided, so that you have extra space to write your answers. If you use that extra space, please be sure to write the number of the problem that you’re solving next to your answer. Please write your name, email and student id on this second Section of the Exam, which you must hand in. You may use any writing implement on this Section of the Exam.

At the end of the Final, please be sure to hand in both your Scantron sheet for the first Section of the Exam and also this second Section of the Exam, and show your UCSC id when you hand them in.

Part II: (24 points, 6 points each) Question 22: Assume we have the following tables: • Stores table, with Primary Key store_id • Customers table, with Primary Key customer_id • Products table, with Primary Key product_id These tables have other columns that aren’t important for this question.

Here’s the Create Statement for another table, the Sales Table, which gives information about products sold to customers in stores: CREATE TABLE Sales ( store_id INT, customer_id INT, product_id INT, quantity INT, PRIMARY KEY(store_id, customer_id, product_id) ); Rewrite this CREATE statement (don’t do an ALTER) so that store_id and product_id are Foreign Keys that correspond to the Primary keys of Stores and Products, respectively. Policies for Referential Integrity should be: • •

Deleting a row in Stores deletes all Sales rows that mention that store.

A row in Products can’t be deleted if there are any Sales rows mentioning that product.

Also, the quantity for any row in Sales must be at least 2, but can’t be more than 50.

Answer 22: CREATE TABLE Sales ( store_id INT, customer_id INT, product_id INT, quantity INT, PRIMARY KEY( store_id, customer_id, product_id ), FOREIGN KEY store_id REFERENCES Stores( store_id ) ON DELETE CASCADE, FOREIGN KEY product_id REFERENCES Products( product_id ), CHECK( quantity >= 2 AND quantity <= 50 ) );

Alternatively, the Foreign Keys and CHECK can be specified next to their attributes because they involve only single attributes.

CREATE TABLE Sales ( store_id INT REFERENCES Stores( store_id ) ON DELETE CASCADE, customer_id INT, product_id INT REFERENCES Products( product_id ), quantity INT CHECK( quantity >= 2 AND quantity <= 50 ), PRIMARY KEY( store_id, customer_id, product_id ) );

Question 23: For the relation Employees(name, age, salary), write a Serializable SQL transaction that executes 3 SQL statements and then commits.

1. The transaction should insert an employee whose salary is 8000, whose age is 41, and whose name is Jane Doe. 2. After that, the transaction should update the salary of every employee that has the highest salary value, adding 500 to their salary.

3. Then the transaction should delete all employees who make less than the average salary.

Answer 23: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; INSERT INTO Employees(name, age, salary) VALUES ('Jane Doe', 41, 8000); UPDATE Employees SET salary = salary + 500 WHERE salary = ( SELECT MAX(salary) FROM Employees ); DELETE FROM Employees WHERE salary < ( SELECT AVG( salary ) FROM Employees ); COMMIT TRANSACTION; [Writing COMMIT or COMMIT WORK is also okay.]

Question 24a): Codd’s relational algebra for sets included only 5 operators (s , p , x , U , and -). But other operators can be defined using those operators.

Show that ∩ can be defined using these 5 operators.

Answer 24a): If R and S are Union-Compatible relations, then R ∩ S = R – (R – S) Also: R ∩ S = S – (S – R)

24b): Are Codd’s 5 operators independent of each other? Answer just YES or NO. Answer 24b):

______YES_____

24c): Armstrong’s Axioms for Functional Dependencies are Reflexivity, Augmentation and Transitivity. Using those axioms, we proved other Rules for Functional Dependencies, including the Decomposition Rule.

The Decomposition Rule is:

If X → YZ, then X → Y and X → Z.

Here’s the proof of the Decomposition Rule, but with explanations missing for 2 steps in that proof. Write just one of Reflexivity, Augmentation, or Transitivity on each of the 2 empty underlines (starting with ?) below to supply the missing explanations in the proof. It’s okay to write the same explanation more than once, if that’s correct.

Proof Step -------------------------------

Explanation -----------------------------

X → YZ

Given

YZ → Y, and also YZ → Z

?____Reflexivity________

Hence X → Y, and also X → Z

?____Transitivity_______

Question 25: Suppose that you have a relation Products(ProductID, ProductName, Component, Quantity) with the following non-trivial Functional Dependencies: ProductID, Component ® Quantity ProductName, Component ® Quantity ProductName ® ProductID ProductID ® ProductName 25a) Is the Products relation in Boyce-Codd Normal Form? Give a clear detailed proof of your answer.

Answer 25a): No, the Products relation is not in BCNF. For Products to be in BCNF, every Functional Dependency (FD) has to either a) be trivial, or b) have a left-hand side that’s a superkey.

The FD ProductName ® ProductID is non-trivial, since the right-hand side is not a subset of the left-hand side.

The left-hand side of that FD is not a superkey.

If we compute ProductName+ using the Attribute Closure Algorithm, then we start with {ProductName}, then get {ProductName, ProductID} using the third FD, and then stop, since there are no other FDs that we can apply to get additional attributes.

Hence the Products relation in not in BCNF.

25b) Is the Products relation in Third Normal Form? Give a clear detailed proof of your answer.

Answer 25b): Yes, the Products relation is in 3NF. For Products to be in 3NF, every Functional Dependency (FD) has to either a) be trivial, or b) have a left-hand side that’s a superkey or c) have a right-hand side that’s part of a key.

The trivial FDs on Products are trivial. But the 4 FDs specified above are not trivial.

Let’s look at them one by one to see if they all satisfy b) or c).

1. For ProductID, Component ® Quantity, the left-hand side is a superkey. {ProductID, Component}+ includes {ProductID, Component}, then {ProductID, Component, Quantity, ProductName} using the first and fourth FDs, and that’s all the attributes of Product, so the left-hand side is a superkey.

2. For ProductName, Component ® Quantity, the left-hand side is a superkey. {ProductName, Component}+ includes {ProductName, Component}, then {ProductName, Component, Quantity, ProductID} using the second and third FDs, and that’s all the attributes of Product, so the left-hand side is a superkey.

3. For ProductName ® ProductID, the right-hand side is part of a key, namely {ProductID, Component}. We’ve already seen (in #1) that {ProductID, Component}+ equals all the attributes of Products, so {ProductID, Component} is a superkey for Products.

But if we “put that superkey on a diet” by getting rid of either attribute, it’s no longer a superkey: ProductID+ is {ProductID, ProductName}, and Component+ is {Component}. Hence {ProductID, Component} is a key for Products.

4. For ProductID ® ProductName, , the right-hand side is part of a key, namely {ProductName, Component}. We’ve already seen (in #2) that {ProductName, Component}+ equals all the attributes of Products, so {ProductName, Component} is a superkey for Products.

But if we “put that superkey on a diet” by getting rid of either attribute, it’s no longer a superkey: ProductName+ is {ProductName, ProductID}, and Component+ is {Component}. Hence {ProductName, Component} is a key for Products.

Part III: (36 points, 9 points each) Some familiar tables appear below, with the Primary Key of each table underlined.

These tables also appear on the last page of the Final, which you can tear off to help you do questions in Part III of the Final. You don’t have to hand in that last page at the end of the Exam.

Authors(authorID, authorName, address, numBooksWritten, mostRecentPubDate) Books(bookID, authorID, bookName, publisherID, pubDate, price, category, lastOrderDate, totalOrdered) Publishers(publisherID, publisherName, address) Members(memberID, memberName, joinDate, renewalDate, isCurrentMember) Orders(memberID, bookID, orderDate, quantity) Reviews(reviewerID, bookID, reviewDate, reviewStars)

The isCurrentMember attribute of Members can be NULL; all other attributes can’t be NULL. There are no UNIQUE constraints.

You should assume Referential Integrity as follows: • Each authorID in Books appears as an authorID in Authors.

• Each publisherID in Books appears as publisherID in Pubishers.

• Each memberID in Orders appears as a memberID in Members.

• Each bookID in Orders appears as a bookID in Books.

• Each reviewerID in Reviews appears as a memberID in Members.

• Each bookID in Reviews appears as a bookID in Books.

Write SQL queries for each of the following questions. If you want to create and then use views to answer these questions, that’s okay, but views are not required unless a question asks you to create them.

You will lose credit if your queries are correct but overly complex, including if you use DISTINCT, but it was not necessary. You’ll lose more credit if your query is incorrect because you didn’t use DISTINCT, but it was necessary.

Question 26: For each order that was made before August 26, 1990 by a member whose isCurrentMember value isn't null, your result should provide the order date, the quantity, and the date that the member who made the order joined.

The three attributes in your result should appear as dateOrdered, quant, and dateJoined. No duplicates should appear in your result. Rows should appear in reverse time order of dateOrdered, so that a row that has a later date comes before a row that has an earlier date.

Answer 26: SELECT DISTINCT o.orderDate as dateOrdered, o.quantity as quant, m.joinDate AS datejoined FROM Orders o, Members m WHERE o.memberID = m.memberID AND o.orderDate < DATE '1990-08-26' AND m.isCurrentMember IS NOT NULL ORDER BY o.orderDate DESC; DISTINCT is needed because there could be multiple Orders/Members pairs that have the same values for the attributes in the SELECT clause.

DATE '1990-08-26' would also be okay if written as DATE ’08/26/90’

Question 27: Find the authorID, authorName and address for each author whose address has 'QU' anywhere in the address, and who wrote at least one book whose price is less than the price of some book that was written by Charlotte Bronte.

Your result should have attributes authorID, authorName and address. No duplicates should appear in your result.

Answer 27: SELECT DISTINCT a.authorID, a.authorName, a.address FROM Authors a, Books b WHERE a.address like '%QU%' AND a.authorID = b.authorID AND b.price < ANY ( SELECT b2.price FROM Authors a2, Books b2 WHERE a2.authorID = b2.authorID AND a2.authorName = 'Charlotte Bronte'); DISTINCT is necessary because an author with such an address could have written multiple books whose price is less than the price of some book written by Charlotte Bronte.

Another solution; there are others.

SELECT DISTINCT a.authorID, a.authorName, a.address FROM Authors a, Books b WHERE a.address like '%QU%' AND a.authorID = b.authorID AND EXISTS ( SELECT * FROM Authors a2, Books b2 WHERE a2.authorID = b2.authorID AND a2.authorName = 'Charlotte Bronte' AND b.price < b2.price );

Question 28: A Fiction book has category ‘F’. Find the memberID of each member who both a) reviewed 9 or more different Fiction books and b) gave exactly 5 stars (reviewStars) in at least one Fiction book review.

The attributes in your result should be memberID and reviewsCountF, where reviewsCountF is the number of different Fiction books that the member reviewed.

No duplicates should appear in your result.

Answer 28: SELECT m.memberId, COUNT(r.bookID) AS reviewsCountF FROM Members m, Books b, Reviews r WHERE m.memberID = r.reviewerID AND b.bookID = r.bookID AND b.category='F' GROUP BY m.memberID HAVING COUNT(r.bookID) >= 9 AND SOME(r.reviewStars = 5); COUNT(r.bookID) equals COUNT(DISTINCT r.bookID), because (reviewerID, bookID) is the primary key for Reviews, so each member can review each book at most once.

You’re told that every reviewerID in Reviews must be a memberID in Members (Referential Integrity), so this query can be simplified as follows: SELECT r.reviewerID, COUNT(r.bookID) AS reviewsCountF FROM Books b, Reviews r WHERE b.bookID = r.bookID AND b.category='F' GROUP BY r.reviewerID HAVING COUNT(r.bookID) >= 9 AND SOME(r.reviewStars = 5);

Question 29: This question has two parts; be sure to answer both.

29a) Define a view FaithfulAuthors that finds the authors who wrote at least one book, and whose books all had the same publisherID. The attributes of the view should be authorID and publisherID. Duplicates should not appear in the FaithfulAuthors view.

29b) Using the FaithfulAuthors view, define another view, NamedFaithfulAuthors, which outputs authorName, mostRecentPubDate (from Authors) and publisherName (from Publishers) corresponding to the authorID and publisherID for each of the rows in FaithfulAuthors.

Be sure to use the FaithfulAuthors view to do this; you may also use the original tables, if necessary. . Duplicates should not appear in the NamedFaithfulAuthors view.

Answers 29a) and 29b): Answers are on next page.

29a) Here are several solutions. DISTINCT is needed in each of these solutions, because the same author could have written multiple books. No need to include Authors or Publishers in the FROM clause, because of Referential Integrity: Each authorID in Books appears as an authorID in Authors, and each publisherID in Books appears as a publisherID in Publishers.

CREATE VIEW FaithfulAuthors AS SELECT DISTINCT b.authorID, b.publisherID FROM Books b, WHERE b.publisherID = ALL ( SELECT b2.publisherID FROM Books b2 WHERE b.authorID = b2.authorID ); CREATE VIEW FaithfulAuthors AS SELECT DISTINCT b.authorID, b.publisherID FROM Books b, WHERE NOT EXISTS ( SELECT * FROM Books b2 WHERE b.authorID = b2.authorID AND b.publisherID <> b2.publisherID ); CREATE VIEW FaithfulAuthors AS SELECT DISTINCT b.authorID, b.publisherID FROM Books b WHERE ( SELECT COUNT( DISTINCT b2.publisherID FROM Books b2 WHERE b2.authorID = b.authorID ) = 1; CREATE VIEW FaithfulAuthors AS SELECT DISTINCT b.authorID, b.publisherID FROM Books b WHERE b.authorID IN ( SELECT b2.authorID FROM Books b2 GROUP BY b2.authorID HAVING COUNT(DISTINCT b2.publisherID) = 1);

29b) CREATE VIEW NamedFaithfulAuthors AS SELECT DISTINCT a.authorName, a.mostRecentPubDate, p.publisherName FROM FaithfulAuthors f, Authors a, Publishers p WHERE f.authorID = a.authorID AND f.publisherID = p.publisherID; DISTINCT is needed because there could be several authors that have the same name, as well as the same values for other attributes in the SELECT.

You may tear off this page to help you do Part III of the Final.

You don’t have to hand in that last page at the end of the Exam.

Some familiar tables appear below, with the Primary Key of each table underlined.

These tables are used in Part III of this Final Exam.

Authors(authorID, authorName, address, numBooksWritten, mostRecentPubDate) Books(bookID, authorID, bookName, publisherID, pubDate, price, category, lastOrderDate, totalOrdered) Publishers(publisherID, publisherName, address) Members(memberID, memberName, joinDate, renewalDate, isCurrentMember) Orders(memberID, bookID, orderDate, quantity) Reviews(reviewerID, bookID, reviewDate, reviewStars)

The isCurrentMember attribute of Members can be NULL; all other attributes can’t be NULL. There are no UNIQUE constraints.

You should assume Referential Integrity as follows: • Each authorID in Books appears as an authorID in Authors.

• Each publisherID in Books appears as publisherID in Pubishers.

• Each memberID in Orders appears as a memberID in Members.

• Each bookID in Orders appears as a bookID in Books.

• Each memberID in Reviews appears as a memberID in Members.

• Each bookID in Reviews appears as a bookID in Books.

Write SQL queries for each of the following questions. If you want to create and then use views to answer these questions, that’s okay, but views are not required unless a question asks you to create them.

You will lose credit if your queries are correct but overly complex, including if you use DISTINCT, but it was not necessary. You’ll lose more credit if your query is incorrect because you didn’t use DISTINCT, but it was necessary.

CMPS 180, Final Exam, Winter 2018, Shel Finkelstein Student Name: ____________________________________________________ Student ID: ____________________________________________________ UCSC Email: ____________________________________________________ Final Points

Part I II III Total

Max Points 42 24 36 102

Points

The first Section (Part I) of the Winter 2018 CMPS 180 Final is multiple choice and is double-sided. Answer all multiple choice questions on your Scantron sheet. You do not have to hand in the first Section of the Exam, but you must hand in the Scantron sheet, with your name, email and student id on that Scantron sheet. Please be sure to use a #2 pencil to mark your choices on this Section of the Final.

This separate second Section (Parts II and III) of the Final is not multiple choice and is single-sided, so that you have extra space to write your answers. If you use that extra space, please be sure to write the number of the problem that you’re solving next to your answer. Please write your name, email and student id on this second Section of the Exam, which you must hand in. You may use any writing implement on this Section of the Exam.

At the end of the Final, please be sure to hand in your Scantron sheet for the first Section of the Exam and also this second Section of the Exam, and show your UCSC id when you hand them in. Also hand in your 8.5 x 11 “cheat sheet”, with your name written in the upper right corner of the sheet.

Part II: (24 points, 6 points each) Question 21: Here are statements creating two relations R and S: CREATE TABLE S ( c INT PRIMARY KEY, d INT );

CREATE TABLE R ( a INT PRIMARY KEY, b INT, FOREIGN KEY(b) REFERENCES S(c) ON UPDATE CASCADE );

Relation R(a,b) currently contains the four tuples, (0,4), (1,5), (2,4), and (3,5).

Relation S(c,d) currently contains the four tuples, (2,10), (3,11), (4,12), and (5,13).

Indicate all changes that happen to both R and S when the following SQL statements are executed upon the R and S instances that are shown above. That is, you should ignore changes made by earlier parts of this question when you answer later parts.

21a): UPDATE S SET c=7 WHERE d=13; Answer 21a): Changes made to the original R: (1, 5) will be updated to (1, 7), and (3, 5) will be updated to (3, 7).

Changes made to the original S: (5, 13) will be updated to (7, 13).

21b): UPDATE R set b=5 WHERE a=0; Answer 21b): Changes made to the original R: (0, 4) will be updated to (0, 5).

Changes made to the original S: No changes.

21c): DELETE FROM S WHERE c=4; Answer 21c): Changes made to the original R: No changes. Foreign Key violation (DEFAULT RI, since no ON DELETE clause).

Changes made to the original S: No changes. Foreign Key violation (DEFAULT RI, since no ON DELETE clause).

Question 22a): Why have any indexes in a database? Give two different clear reasons. If you give more than two, only first two will be graded.

Answer 22a): Here are the two excellent reasons for having indexes.

1. Indexes speed up access to data if there are conditions that match the index.

2. Maintaining a Primary Key/UNIQUE constraint is much faster when there are indexes on the columns associated with that constraint.

Question 22b): Why not have indexes on every column in a database? Give two different reasons. If you give more than two, only first two will be graded.

Answer 22b): Here are some good reasons for not indexing every column (or combination of columns). Any two different answers would be okay.

• Indexes have to be updated when the underlying columns they are defined on change, including for inserts and deletes, which change all columns.

• Indexes take up space on disk or SSD (persistent storage).

• Indexes take up memory, potentially leaving less memory for data in tables.

• There are so many different indexes (and even worse, index combinations) that having all of the indexes would not be worthwhile, mainly for the first 3 reasons. But we’ll accept this as a different reason.

Question 23: We have the following relations: Sailors(sid, sname, rating, age) // sailor id, sailor name, rating, age Boats(bid, bname, color) // boat id, boat name, color of boat Reserves(sid, bid, day) // sailor id, boat id, date that sailor sid reserved boat bid.

Codd’s relational algebra for sets included only the 5 operators Selection(  ), Projection(  ), Product( x ), Union (∪) and Difference (-). Using only those 5 operators, write a Relational Algebra query that finds the names of red boats that have been reserved by at least two different sailors whose rating is 7.

Reminder: In SQL, you can use NOT EXIST or NOT IN or COUNT, but you can’t use any of those in Relational Algebra.

Big Hint: Besides the 5 Relational Algebra operators, you may also use the renaming operator  which could help you if you want to refer to a relation twice.

Answer 23: Here’s detailed explanation of answer. Students only needed to give correct answer.

If we take Sailors.sid=Reserves.sid AND Sailors.rating=7 ( Sailors X Reserves ), that will give us all the Sailors and Reserves attributes where a sailor whose rating is 7 did the reservation.

Now we can use  to get two such reservations, and check that they involve the same red boat but different sailors. aRreserves1.bid = Reserves2.bid AND Sailors1.sid <> Sailor2.sid ( Sailors1.sid=Reserves1.sid AND Sailors.rating=7 ( Sailors1(Sailors) X Reserves1(Reserves) ) X Sailors2.sid=Reserves2.sid AND Sailors.rating=7 ( Sailors2(Sailors) X Reserves2(Reserves) ) ) And finally, we can project just the boat’s name, which is all that’s requested in the answer. We could get bname from either Reserves1 or Reserves2.; they both have the same bid, and since bid is the key of Reserves, they also have the same bname. Reserve1.bname ( the above expression); fully written out, that’s Reserve1.bname (

) )

Reserves1.bid = Reserves2.bid AND Sailors1.sid <> Sailor2.sid ( Sailors1.sid=Reserves1.sid AND Sailors.rating=7 ( Sailors1(Sailors) X Reserves1(Reserves) ) X Sailors2.sid=Reserves2.sid AND Sailors.rating=7 ( Sailors2(Sailors) X Reserves2(Reserves) )

Question 24: For each of the following, answer whether it is in BCNF. Also indicate whether it is in 3NF. You do not have to justify your answers, just answer YES or NO for each.

24a) You have a relation R(A, B, C, D, E), with the following non-trivial functional dependencies: ABC → D ABC → E D→E E→B BE → D BD → C CE → A Answer 24a): Is R in BCNF?

_______YES_____

Is R in 3NF?

_______YES_____

[Explanation, which wasn’t requested: Closure of the left-hand side of every FD above includes all the attributes of R.] 24b) You have a relation Company(empid, dept, project, manager), with the following non-trivial functional dependencies: empid → dept empid → project empid → manager dept, project → manager Answer 24b): Is Company in BCNF?

________NO_____

Is Company in 3NF?

________NO_____

[Explanation, which wasn’t requested: The last FD is the problem. It’s not trivial, closure of left-hand side doesn’t include empid, and there’s no key that has manager in it, since empid is needed in any key, but empid is a key by itself.]

Part III: (36 points, 9 points each) Some familiar tables appear below, with Primary Keys underlined. These tables also appear on the last page of the Final, which you can tear off to help you do questions in Part III of the Final. You don’t have to hand in that last page at the end of the Exam.

TaxReturns(taxpayerID, taxYear, kind, dateFiled, income, taxOwed) Payments(taxpayerID, datePaid, amountPaid) Individuals(taxpayerID, name, address, spouseID, lastDateFiled, lastDatePaid, totalTaxOwed) Businesses(taxpayerID, name, address, businessType, lastDateFiled, lastDatePaid, totalTaxOwed) IRSagents(IRSagentID, taxpayerID, jobLevel, active) Delinquents(taxpayerID, IRSagentID, collectionAgencyID) Assume that no attributes can be NULL, and that there are no UNIQUE constraints.

You may assume Referential Integrity as follows: • Each spouseID in Individuals appears as a taxpayerID in Individuals.

• Each taxpayerID in IRSagents appears as a taxpayerID in Individuals.

• Each IRSagentID in Delinquents appears as a Primary Key in IRSagents.

• Each collectionAgencyID in Delinquents appears as a Primary Key in Businesses.

Write legal SQL queries for Questions 25-28. If you want to create and then use views to answer these questions, that’s okay, but views are not required unless the question asks for them.

Don’t use DISTINCT in your queries unless it’s necessary, 0.5 points will be deducted. Some points will also be deducted for unnecessarily complex queries.

Question 25: For every individual in Individuals whose totalTaxOwed is less than the totalTaxOwed for their spouse, your result should include the following: • • • •

name of that individual (as nameIndividual) name of spouse (as nameSpouse) totalTaxOwed for that individual (as owedByIndividual) totalTaxOwed for spouse (as owedBySpouse)

Your result should be ordered in ascending order by owedByIndividual, and then in descending order by nameIndividual.

Answer 25: SELECT i1.name AS nameIndividual, i2.name AS nameSpouse, i1.totalTaxOwed AS owedByIndividual, i2.totalTaxOwed AS owedBySpouse FROM Individuals i1, Individuals i2 WHERE i1.totalTaxOwed < i2.totalTaxOwed AND i1.spouseID = i2.taxpayerID ORDER BY i1.totalTaxOwed, i1.name DESC;

Question 26: Some businesses are collection agencies that collect money from Individuals. They appear in Delinquents, with their taxpayerID as the collectionAgencyID for one or more delinquent Individuals. Some businesses aren’t collection agencies for Individuals.

For each business that is a collection agency for Individuals, your result should include a tuple with the following attributes: • • • •

the collection agency’s taxpayerID (as collectionAgencyID) the collection agency’s address (as collectionAgencyAddress) the number of delinquent individuals for whom it’s a collection agency (as delinqIndividuals), and the smallest (earliest) lastDatePaid of the delinquent individuals for which it’s a collection agency (as earliestDate).

Answer 26: SELECT b.taxpayerID AS collectionAgencyID, b.address AS collectionAgencyAddress, COUNT(*) AS delinqIndividuals, MIN(i.lastDatefile) AS earliestDate FROM Delinquents d, Businesses b, Individuals i WHERE d.collectionAgencyID = b.taxpayerID AND d.taxpayerID = i.taxpayerID GROUP BY b.taxpayerID, b.address; For this question, you could use any attribute that can't be NULL (and is legal in the SELECT) in the COUNT instead of COUNT(*). And since no attribute can be NULL, any attribute works.

Since b.taxpayerID is the key of Businesses, we gave full credit to students who wrote GROUP BY b.taxpayerID instead of GROUP BY b.taxpayerID, b.address. That would be allowed in most SQL systems, even though b.address appears in SELECT. Some students created a view on Delinquents and Indivduals, which they then joined with Businesses; that’s fine.

Question 27: Several individuals might live at the same address. Find the taxpayerID, name, address and totalTaxOwed for each individual that has the maximum totalTaxOwed of any individual who lives at their address. (totalTaxOwed is an attribute in the Individuals table.) But your result should only include those individuals if they have the capital letter ‘X’ appearing somewhere in their names.

Answer 27: Here are some answers that are correct; there are others.

SELECT i1.taxpayerID, i1.name, i1.address, i1.totalTaxOwed FROM Individuals i1 WHERE i1.name LIKE '%X%' AND NOT EXISTS ( SELECT * FROM Individuals i2 WHERE i1.address = i2. address AND i2.totalTaxPaid > i1.totalTaxPaid ); SELECT i1.taxpayerID, i1.name, i1.address, i1.totalTaxOwed FROM Individuals i1 WHERE i1.name LIKE '%X%' AND i1.totalTaxPaid >= ALL ( SELECT i2.totalTaxPaid FROM Individuals i2 WHERE i1.address = i2. address ); ANY is incorrect. Also >= is needed because there could be multiple individuals that have the maximum totalTaxOwed of any individual who lives at their address.

SELECT i1.taxpayerID, i1.name, i1.address, i1.totalTaxOwed FROM Individuals i1 WHERE i1.name LIKE '%X%' AND i1.totalTaxPaid = ( SELECT MAX(i2.totalTaxPaid) FROM Individuals i2 WHERE i1.address = i2. address ); The subquery only return one value, so this is legal SQL. It would also be okay to use i1.totalTaxPaid IN before the subquery, even though it returns only one value.

Question 28: This question has three parts; be sure to answer all three.

28a): Create a view named TaxDebts. For each taxpayerID in TaxReturns, this view should provide taxpayerID and the sum of taxOwed in the TaxReturns for that taxpayerID. In your result, the second attribute should be called debt.

28b): Create a second view named PaymentCredits. For each taxpayerID in Payments, this view should provide taxpayerID, the biggest value of datePaid for that taxpayerID in Payments, and the total of amountPaid for that taxpayerID in Payments. In your result, the attributes should be called taxpayerID, biggestDatePaid and credit. But only include a tuple for a taxpayerID if that taxpayerID has at least 3 different amountPaid values in Payments.

28c): Some tax payers have tuples appearing in the Delinquents table and also in the TaxDebts and PaymentCredits views. For each tax payer that has tuples appearing in all 3, output that tax payer’s taxpayerID, their debt (from TaxDebts) and their credit (from PaymentCredits).

Answers 28a), 28b) and 28c): Q28 was very similar to the Lab 3 VIEW questions.

28a): CREATE VIEW TaxDebts AS SELECT taxpayerID, SUM(taxOwed) AS debt FROM taxReturns GROUP BY taxpayerID; 28b): CREATE VIEW PaymentCredits AS SELECT taxpayerID, MAX(datePaid) AS biggestDatePaid, SUM(amountPaid) AS credit FROM Payments GROUP BY taxpayerID HAVING COUNT(DISTINCT amountPaid) >= 3; 28c): SELECT d.taxpayerID, td.debt, pc.credit FROM delinquents d, taxDebts td, paymentCredits pc WHERE d.taxpayerID = td.taxpayerID AND d.taxpayerID = pc.taxpayerID;

This is extra blank space, in case you need more paper to answer questions.

Write Question number clearly if you use blank pages.

You may tear off this page to help you do Part III of the Final.

Some familiar tables appear below, with Primary Keys underlined. These tables also appear on the last page of the Final, which you can tear off to help you do questions in Part III of the Final. You don’t have to hand in that last page at the end of the Exam.

TaxReturns(taxpayerID, taxYear, kind, dateFiled, income, taxOwed) Payments(taxpayerID, datePaid, amountPaid) Individuals(taxpayerID, name, address, spouseID, lastDateFiled, lastDatePaid, totalTaxOwed) Businesses(taxpayerID, name, address, businessType, lastDateFiled, lastDatePaid, totalTaxOwed) IRSagents(IRSagentID, taxpayerID, jobLevel, active) Delinquents(taxpayerID, IRSagentID, collectionAgencyID) Assume that no attributes can be NULL, and that there are no UNIQUE constraints.

You may assume Referential Integrity as follows: • Each spouseID in Individuals appears as a taxpayerID in Individuals.

• Each taxpayerID in IRSagents appears as a taxpayerID in Individuals.

• Each IRSagentID in Delinquents appears as a Primary Key in IRSagents.

• Each collectionAgencyID in Delinquents appears as a Primary Key in Businesses.

Write legal SQL queries for Questions 25-28. If you want to create and then use views to answer these questions, that’s okay, but views are not required unless the question asks for them.

Don’t use DISTINCT in your queries unless it’s necessary, 0.5 points will be deducted. Some points will also be deducted for unnecessarily complex queries.

CSE 180, Final Exam, Fall 2019, Shel Finkelstein Student Name: ____________________________________________________ Student ID: ____________________________________________________ UCSC Email: ____________________________________________________ Final Points

Part

Max Points

I

42

II

24

III

36

Total

102

Points

The first Section (Part I) of the Fall 2019 CSE 180 Final is multiple choice and is double-sided. Answer all multiple choice questions on your Scantron sheet. You do not have to hand in the first Section of the Exam, but you must hand in the Scantron sheet, with your name, email and student id on that Scantron sheet. Please be sure to use a #2 pencil to mark your choices on this Section of the Final.

This separate second Section (Parts II and III) of the Final is not multiple choice and is single-sided, so that you have extra space to write your answers. If you use that extra space, please be sure to write the number of the problem that you’re solving next to your answer. Please write your name, email and student id on this second Section of the Exam, which you must hand in. You may use any writing implement on this Section of the Exam.

At the end of the Final, please be sure to hand in your Scantron sheet for the first Section of the Exam and also this second Section of the Exam, and show your UCSC id when you hand them in. Also hand in your 8.5 x 11 “cheat sheet”, with your name written in the upper right corner of the sheet.

Part II: (24 points, 6 points each) Question 22: Assume that we already have: • a person table, whose Primary Key is SSN, and • a house table, whose Primary Key is houseID. Write a Create statement for another table: property(owner, houseID, datePurchased) A property tuple indicates that a person (owner) purchased a house (houseID) on the specified datePurchased. owner and SSN are integers, and houseID is an integer in both house and property; datePurchased is a date.

The Primary Key of property is (owner, houseID). In the property table that you create, owner should be a Foreign Key corresponding to the Primary Key of person (SSN), and houseID should be a Foreign Key corresponding to the Primary Key of house (also called houseID).

Moreover, when a person is deleted, tuples in property which that person owns should be deleted. But deletion of a tuple in house is not permitted if there is a tuple in property for that houseID. (You don’t have to consider updates in your Create.)

Answer 22: CREATE TABLE property ( owner INTEGER, houseID INTEGER, datePurchased DATE, PRIMARY KEY (owner, houseID), FOREIGN KEY (owner) REFERENCES person(SSN) ON DELETE CASCADE, ); The second FOREIGN KEY line could just read: FOREIGN KEY (houseID) REFERENCES house Another correct answer: CREATE TABLE property ( owner INTEGER REFERENCES person(SSN) ON DELETE CASCADE, houseID INTEGER REFERENCES house(houseID), datePurchased DATE, PRIMARY KEY (owner, houseID) );

Question 23: 23a): Explain the meaning of Physical Independence for Relational Database.

Answer 23a): Physical independence means that the actual physical representation of the data in tables doesn’t affect the SQL statements that can be executed, except for performance. For example, data might be stored in a row-oriented manner or in a column-oriented manner, and queries don’t have to be changed to reflect this.

Moreover, queries don’t have to be changed when access structures such as indexes are created or dropped.

23b): Why are Relational Database queries described as Declarative?

Answer 23b): Relational database queries, which are written in SQL, describe what should be in the answers; they don’t describe an execution plan for computing the answers. So queries are described as Declarative (or Non-Procedural) because the database management system is responsible for figuring out an execution plan that computes a query response that corresponds to the description in a SQL query.

23c): What’s the connection between Physical Independence and Declarative queries for Relational Database?

Answer 23c): The connection between Physical Independence and Declarative queries for Relational database is that the database management system (and in particular, the optimizer) figures out an execution plan based on the physical structure of the data that does what the Declarative query describes. The optimizer tries to choose an execution plan that is not only correct, but also has good performance.

Question 24: We have the following relations: Sailors(sid, sname, rating, age) // sailor id, sailor name, rating, age Boats(bid, bname, color) // boat id, boat name, color of boat Reserves(sid, bid, day) // sailor id, boat id, date that sailor sid reserved boat bid.

Codd’s relational algebra for sets included only the 5 operators Selection(  ), Projection(  ), Product( x ), Union (∪) and Difference (-). Using only those 5 operators, write a Relational Algebra query that finds the names of sailors whose age is more than 20, but who have not reserved any boat whose color is red.

If you’d like, you may also use Rename () and Assignment () in your answer.

Very Big Hint: In SQL, you can use NOT EXIST or NOT IN or COUNT, but you can’t use any of those in Relational Algebra.

But you can use Difference. So first, find the names of sailors whose age is more than 20 and who have reserved a boat whose color is red. Then use Difference to find the answer.

Answer 24: Here’s one correct answer. Other correct answers might push selection and projection closer to the relations.

πSailors.sname ( σSailors.age > 20 (Sailors) ) – ( πSailors.sname ( σSailors.age > 20 AND Boats.color = ’red’ AND Sailors.sid = Reserves.sid AND Boats.bid = Reserves.bid

(Sailors X Reserves X Boats) ) )

Question 25: Suppose that you have a relation: BookInfo(Author, Citizenship, Title, PageCount) with the following Functional Dependencies: Author → Citizenship Author, Title → PageCount 25a) Is {Author, Title} a key for BookInfo? Justify your answer fully and clearly.

Answer 25a): Yes, {Author, Title} is a key for BookInfo.

Using the attribute closure algorithm, {Author, Title} + = {Author, Title, Citizenship, PageCount), which is all the attributes of BookInfo. That shows that {Author, Title} is a superkey for BookInfo.

To show that {Author, Title} is a key for BookInfo, we have to check to see if we’d still have a superkey if we eliminated an attribute from {Author, Title}. {Author}+ is {Author, Citizenship}, and that’s not all the attributes of BookInfo. {Title}+ is {Title}, }, and that’s not all the attributes of BookInfo.

So since {Author, Title} is a superkey which won’t still be a key if it’s “put on a diet”, then {Author, Title} is a key for Bookinfo.

25b) Is BookInfo in BCNF? Justify your answer fully and clearly.

Answer 25b): To be in BCNF, all the Functional Dependencies given for the BookInfo would have to either be trivial, or have left-hand sides that are superkeys. If we can find even one FD that is not trivial and also does not have a left-hand side that’s a superkey, then BookInfo is not in BCNF. Consider the FD: Author → Citizenship.

• This isn’t a trivial FD, since Citizenship is not one of attributes on the lefthand side of the FD. • Is the left-hand side of this FD a superkey? No, since {Author}+ is just {Author, Citizenship}, and that’s not all the attributes of BookInfo.

Hence BookInfo with these FDs is not in BCNF.

25c) Is BookInfo in 3NF? Justify your answer fully and clearly.

Answer 25c): To be in 3NF, all the Functional Dependencies given for the BookInfo would have to either a) be trivial, or b) have left-hand sides that are superkeys, or c) have a right-hand side that is part of some key.

If we can find even one FD that is none of these 3 things, then BookInfo is not in 3NF. Consider the FD: Author → Citizenship. As we’ve already seen in 25b) • This isn’t a trivial FD, since Citizenship is not one of attributes on the lefthand side of the FD. • Is the left-hand side of this FD a superkey? No, since {Author}+ is just {Author, Citizenship}, and that’s not all the attributes of BookInfo.

Well, now let’s see whether the right-hand side of this FD, which is Citizenship, is part of some key for BookInfo. Suppose that we have a set of attributes S that’s a superkey for BookInfo.

• Nothing determines Author except Author, so Author must be in S. • Also, nothing determines Title except Title, so Title must be in S. So any superkey for BookInfo must include Author and Title. Can there be a key that includes Citizenship? Well, such a key must include {Author, Title, Citizenship}, and it is true that {Author, Title, Citizenship} is a superkey, since it’s closure is all the attributes of BookInfo. But {Author, Title, Citizenship} is not a key, since we can eliminate Citizenship an still have a superkey, {Author, Title.} Therefore there cannot be a key that includes Citizenship.

Hence BookInfo with these FDs is not in 3NF.

Part III: (36 points, 9 points each) Some familiar tables appear below, with Primary Keys underlined. These tables also appear on the last page of the Final, which you can tear off to help you do questions in Part III of the Final. You don’t have to turn in that last page at the end of the Exam. customer(custID, name, address, joinDate, status) menuItem(menuItemID, name, description, price) dinnerTable(dinnerTableID, numSeats, InUse) server(serverID, name, level, salary) visit(visitID, custID, dinnerTableID, serverID, numPeople, cost, custArrive, custDepart) billEntry(visitID, menuItemID, quantity)

Assume that no attributes can be NULL, and that there are no UNIQUE constraints.

You may assume Referential Integrity as follows: • Each custID in visit appears as a Primary Key in customer.

• Each dinnerTableID in visit appears as a Primary Key in dinnerTable.

• Each serverID in visit appears as a Primary Key in server.

• Each visitID in billEntry appears as a Primary Key in visit.

• Each menuItemID in billEntry appears as a Primary Key in menuItem.

Write legal SQL queries for Questions 26-29. If you want to create and then use views to answer these questions, that’s okay, but views are not required unless the question asks for them.

Don’t use DISTINCT in your queries unless it’s necessary, 1 point will be deducted if you use DISTINCT when you don’t have to do so. And some points may be deducted for queries that are very complicated, even if they are correct.

Question 26: Find the menuItemID, name and price for every menuItem that has the highest price of any menuItem. Note that there may be more than one menuItem that has that highest price. Your result should appear in reverse alphabetical order based on name. No duplicates should appear in your result Answer 26: Here are 3 correct solutions.

Solution #1: SELECT m.menuItemID, m.name, m.price FROM menuItem m WHERE m.price >= ALL ( SELECT m2.price FROM menuItem m2 ) ORDER BY m.name DESC; Solution #2: SELECT m.menuItemID, m.name, m.price FROM menuItem m WHERE NOT EXISTS ( SELECT m2.price FROM menuItem m2 WHERE m2.price > m.price ) ORDER BY m.name DESC; Solution #3: SELECT m1.menuItemID, m1.name, m1.price FROM menuItem m1 WHERE m1.price = ( SELECT MAX(price) FROM menuItem ) ORDER BY m1.name DESC;

Question 27: Find the ID and name of each server whose level is ‘B’ and who was the server for a visit in which ‘Apple Pie’ was one of the items on the bill. No duplicates should appear in your result.

Answer 27: Here are 2 correct solutions. DISTINCT is needed in the first solution,, but not in the second.

Solution #1: SELECT DISTINCT s.serverID, s.name FROM server s, billentry b, visit v, menuitem m WHERE s.level = 'B' AND s.serverid = v.serverid AND v.visitid = b.visitid AND m.menuitemid = b.menuitemID AND m.name = 'Apple Pie'; Solution #2: SELECT s.serverID, s.name FROM server s WHERE s.level = 'B' AND s.serverID IN ( SELECT v.serverID FROM visit v, billEntry b, menuItem m WHERE v.visitID = b.visitID AND b.menuItemID = m.menuItemID AND m.name = 'Apple Pie' );

Question 28: For each visit, there may be billEntry tuples for that visit. Let’s define a billedVisit to be a visit for which there is at least one billEntry tuple.

Each billEntry tuple has a quantity, and each billEntry tuple has a menuItemID that identifies a menuItem tuple that has a price. So the calculatedCost of a billedVisit can be computed by adding up price*quantity for all of the billEntry tuples for that billedVisit.

The visit table has a cost attribute. Find all the billedVisits for which the cost of that visit is not equal to the calculated cost of that visit. In your result, the attributes should be visitID, cost and calculatedCost. No duplicates should appear in your result.

Answer 28: Here are 2 solutions, one without a view, and the other with a view.

Solution #1: SELECT b.visitID AS visitID, v.cost AS cost, SUM(b.quantity * m.price) AS calculatedCost FROM visit v, billentry b, menuitem m WHERE v.visitID = b.visitID AND b.menuitemid = m.menuitemid GROUP BY b.visitid, v.cost HAVING SUM(b.quantity * m.price) <> v.cost; Solution #2: CREATE VIEW visitBill AS SELECT b.visitID, SUM(m.price* b.quantity) AS calculatedCost FROM billEntry b, menuItem m WHERE m.menuitemID = b.menuitemID GROUP BY b.visitID; SELECT v.visitID, v.cost, vb.calculatedCost FROM visit v, visitBill vb WHERE v.visitID = vb.visitID AND v.cost <> vb.calculatedCost;

Question 29: This question has two parts; be sure to answer both.

29a): Create a SQL view called custVisitCount. For each customer who joined before December 25, 2018, the custVisitCount view should give the custID, address and the number of visits for that customer. In your view, the attributes should be called theCustomer, theAddress and theVisitCount.

[Hint: There could be customers who have no visits, and theVisitCount for them should be 0. If your view works correctly just for customers who do have visits, you will only lose 1 point for that.]

29b): Use the view custVisitCount to find the address of each customer such that: • the customer visited 8 or more times, and also • no other customer in the customer table has the same address.

[Yes, you’ll also have to use the customer table to do this.]

The only attribute in your result should be theAddress. No duplicates should appear in your result.

Answer 29a): Here are two solutions.

Solution #1: CREATE VIEW custVisitCount AS SELECT c.custID as theCustomer, c.address AS theAddress, COUNT(v.visitid) AS theVisitCount FROM customer c, visit v WHERE c.joinDate < DATE '2018-12-25' AND c.custID = v.custID GROUP BY c.custID, c.address UNION SELECT c.custID as theCustomer, c.address AS theAddress, 0 AS theVisitCount FROM customer c WHERE c.joinDate < DATE '2018-12-25' AND NOT EXISTS ( SELECT * FROM visits WHERE c.custID = v.custID );

29a) Solution #2: CREATE VIEW custVisitCount AS SELECT c.custID AS theCustomer, c.address AS theAddress, COUNT(v.visitID) AS theVisitCount FROM customer c LEFT OUTER JOIN visit v ON c.custID = v.custID WHERE c.joinDate > DATE '2018-12-25' GROUP BY c.custID, c.address;

Answer 29b): Here are two solutions; there are others.

Solution #1: SELECT cvc.theAddress FROM custVisitCount cvc WHERE cvc.theVisitCount >= 8 AND NOT EXISTS ( SELECT c.address FROM customer c WHERE c.custID <> cvc.theCustomer AND c.address = cvc.theAddress ); Solution #2: SELECT cvc.theAddress FROM custVisitCount cvc WHERE cvc.thevisitCount >= 8 AND cvc.theaddress IN ( SELECT c.address FROM Customer c GROUP BY c.address HAVING COUNT(c.address) = 1 );

This is extra blank space, in case you need more paper to answer questions.

Write Question number clearly if you use blank pages.

You may tear off this page to help you do Part III of the Final.

Some familiar tables appear below, with Primary Keys underlined. These tables also appear on the last page of the Final, which you can tear off to help you do questions in Part III of the Final. You don’t have to turn in that last page at the end of the Exam. customer(custID, name, address, joinDate, status) menuItem(menuItemID, name, description, price) dinnerTable(dinnerTableID, numSeats, InUse) server(serverID, name, level, salary) visit(visitID, custID, dinnerTableID, serverID, numPeople, cost, custArrive, custDepart) billEntry(visitID, menuItemID, quantity)

Assume that no attributes can be NULL, and that there are no UNIQUE constraints.

You may assume Referential Integrity as follows: • Each custID in visit appears as a Primary Key in customer.

• Each dinnerTableID in visit appears as a Primary Key in dinnerTable.

• Each serverID in visit appears as a Primary Key in server.

• Each visitID in billEntry appears as a Primary Key in visit.

• Each menuItemID in billEntry appears as a Primary Key in menuItem.

Write legal SQL queries for Questions 26-29. If you want to create and then use views to answer these questions, that’s okay, but views are not required unless the question asks for them.

Don’t use DISTINCT in your queries unless it’s necessary, 1 point will be deducted if you use DISTINCT when you don’t have to do so. And some points may be deducted for queries that are very complicated, even if they are correct.

CMPS 180, Final Exam, Winter 2019, Shel Finkelstein Student Name: ____________________________________________________ Student ID: ____________________________________________________ UCSC Email: ____________________________________________________

Part I II III Total

Max Points 42 24 36 102

Points

The first Section (Part I) of the Winter 2019 CMPS 180 Final is multiple choice and is double-sided. Answer all multiple choice questions on your Scantron sheet. You do not have to hand in the first Section of the Exam, but you must hand in the Scantron sheet, with your name, email and student id on that Scantron sheet. Please be sure to use a #2 pencil to mark your choices on this Section of the Final.

This separate second Section (Parts II and III) of the Final is not multiple choice and is single-sided, so that you have extra space to write your answers. If you use that extra space, please be sure to write the number of the problem that you’re solving next to your answer. Please write your name, email and student id on this second Section of the Exam, which you must hand in. You may use any writing implement on this Section of the Exam.

At the end of the Final, please be sure to hand in your Scantron sheet for the first Section of the Exam and also this second Section of the Exam, and show your UCSC id when you hand them in. Also hand in your 8.5 x 11 “cheat sheet”, with your name written in the upper right corner of the sheet.

Part II: (24 points, 6 points each) Question 22: Here are statements creating two relations R and S: CREATE TABLE S ( c INT PRIMARY KEY, d INT );

CREATE TABLE R ( a INT PRIMARY KEY, b INT, FOREIGN KEY(b) REFERENCES S(c) ON UPDATE CASCADE ON DELETE SET NULL );

Relation R(a,b) currently contains the four tuples, (0,4), (1,6), (2,4), and (3,6).

Relation S(c,d) currently contains the four tuples, (2,80), (3,81), (4,82), and (6,83).

Indicate all changes that happen to both R and S when the following SQL statements are executed upon the R and S instances that are shown above. That is, you should ignore changes made by earlier parts of this question when you answer later parts.

22a): UPDATE R set b=5 WHERE a=0; Answer 22a): Changes made to the original R:

Changes made to the original S:

22b): DELETE FROM S WHERE c=4; Answer 22b): Changes made to the original R:

Changes made to the original S:

22c): UPDATE S SET c=9 WHERE d=83; Answer 22c): Changes made to the original R:

Changes made to the original S:

Question 23a): Why are advantages of having Stored Procedures in a database? Give two clear different reasons. If you give more than two, only the first two will be graded.

Answer 23a): Reason 1:

Reason 2:

Question 23b): What’s the difference between a Stored Procedure and a View?

Answer 23b):

Question 24: Here are relations describing boats and reservations.

Boats(bid, bname, color) Reserves(sid, bid, day)

// boat id, boat name, color of boat // sailor id, boat id, date that sid reserved bid.

Codd’s Relational Algebra included only 5 operators ( ,  , x , U , and -).

Using just those operators (and ρ, Renaming, if you’d like), write a Relational Algebra query that finds the bname of the red boats for which there are no reservations.

Answer 24):

Question 25: You have a relation S(A, B, C, D, E), with the following non-trivial Functional Dependencies: AB → C AB → D CD → A C→E 25a): Is S in BCNF? Justify your answer.

Answer 25a)

25b): Is S in 3NF? Justify your answer.

Answer 25b)

Part III: (36 points, 9 points each) Some familiar tables appear below, with Primary Keys underlined. These tables also appear on the last page of the Final, which you can tear off to help you do questions in Part III of the Final. You don’t have to hand in that last page at the end of the Exam.

Exchanges(exchangeID, exchangeName, address) Stocks(exchangeID, symbol, stockName, address) Customers(customerID, custName, address, category, isValidCustomer) Trades(exchangeID, symbol, tradeTS, buyerID, sellerID, price, volume) Quotes(exchangeID, symbol, quoteTS, price)

Assume that no attributes can be NULL, and that there are no UNIQUE constraints.

Assume Referential Integrity as follows: • Each exchangeID in Stocks appears as an exchangeID in Exchanges • Each buyerID in Trades appears as a customerID in Customer.

• Each sellerID in Trades appears as a customerID in Customer.

• Each (exchangeID, symbol) in Trades appears as an (exchangeID, symbol) in Stocks.

• Each (exchangeID, symbol) in Quotes appears as an (exchangeID, symbol) in Stocks.

Write legal SQL queries for Questions 25-28. If you want to create and then use views to answer these questions, that’s okay, but views are not required unless the question asks for them.

Don’t use DISTINCT in your queries unless it’s necessary; 1 point will be deducted for unnecessary use of DISTINCT. Points will also be deducted for unnecessarily complex queries.

Question 26: Find quoteTS and price for all quotes whose price was greater than or equal to 200 and less than 300. Your result tuples should be ordered with higher price coming first; for tuples with equal price, an earlier quoteTS timestamp should come before a later quoteTS timestamp. Duplicates should not appear in your answer.

Answer 26:

Question 27: A customer is valid if isValidCustomer is true for that customer. The totalCost of a trade is price times volume. A customer can be the buyer for some trades and the seller for some trades. A customer might even be both the buyer and seller for the same trade.

Find the customerID and address of each valid customer who was the buyer for a trade in which totalCost was more than 5000, and who was the seller for a different trade in which totalCost was more than 5000. No duplicates should appear in your result.

Answer 27:

Question 28: Find each day’s closing price for all stocks whose symbol has Q (capital Q) as its second letter. The closing price for a stock on a day is the price in Quotes that has the latest quoteTS for that stock on that day.

If there are no quotes for a stock on a day, don’t include a closing price for that stock on that day. Your results should have attributes exchangeID, symbol, theDay and closingPrice. No duplicates should appear in your result.

As a reminder, if expressionTS is a timestamp, you can get the date in that timestamp by writing either DATE(expressionTS) or expressionTS::DATE to cast it to the date.

Answer 28:

Question 29: This question has two parts; be sure to answer both.

29a): Create a view named DailyExchangeTrades. For each exchange in Exchanges, and each date, this view should provide the exchangeID and the number of trades that occurred on that exchangeID on that date. In your result, the second attribute should be called theDate and the third attribute should be called numberOfTrades. But only include a tuple for an exchangeID and date if there were at least 12 trades on that exchangeID on that date. No duplicates should appear in your result.

29b): For each exchange in Exchanges whose address ends in ‘NY’, find the number of tuples that appear in DailyExchangeTrades for that exchange. Your result should have attributes exchangeID, address and dateCount.

Note that there might be exchanges whose address ends in ‘NY’ for which there are no tuples in DailyExchangeTrades. Your result should include a tuple for each such exchangeID whose dateCount is 0.

No duplicates should appear in your result.

Answers 29a) and 29b):

This is extra blank space, in case you need more paper to answer questions.

Write Question number clearly if you use blank pages.

You may tear off this page to help you do Part III of the Final.

Some familiar tables appear below, with Primary Keys underlined. These tables also appear on the last page of the Final, which you can tear off to help you do questions in Part III of the Final. You don’t have to hand in that last page at the end of the Exam.

Exchanges(exchangeID, exchangeName, address) Stocks(exchangeID, symbol, stockName, address) Customers(customerID, custName, address, category, isValidCustomer) Trades(exchangeID, symbol, tradeTS, buyerID, sellerID, price, volume) Quotes(exchangeID, symbol, quoteTS, price)

Assume that no attributes can be NULL, and that there are no UNIQUE constraints.

Assume Referential Integrity as follows: • Each exchangeID in Stocks appears as an exchangeID in Exchanges • Each buyerID in Trades appears as a customerID in Customer.

• Each sellerID in Trades appears as a customerID in Customer.

• Each (exchangeID, symbol) in Trades appears as an (exchangeID, symbol) in Stocks.

• Each (exchangeID, symbol) in Quotes appears as an (exchangeID, symbol) in Stocks.

Write legal SQL queries for Questions 26-29. If you want to create and then use views to answer these questions, that’s okay, but views are not required unless the question asks for them.

Don’t use DISTINCT in your queries unless it’s necessary; 1 point will be deducted for unnecessary use of DISTINCT. Points will also be deducted for unnecessarily complex queries.