` CIS 450/550 Database and Information Systems Actual Midterm 2 with Answers . - University of Penns

downloaded from

Scholarfriends

https://scholarfriends.com Downloaded by: writerforacademic@gmail.com | https://scholarfriends.com/singlePaper/314885/cis-450550-database-and-informationsystems-actual-midterm-2-with-answers-university-of-penn Distribution of this document is illegal.

`

CIS 450/550 Database and Information Systems Actual Midterm 2 with Answers

Instructions: The exam is closed book (and closed friend/other source of advice). Electronic devices (such as cell phones) must be turned off and stored away; you cannot use the internet, except to download the exam and upload your answers to Gradescope.

However you may use a “cheat sheet” prepared according to the guidelines given.

Part#

Topic

Max. Points

1

General MC

8

2

Transactions

13

3

B+ Trees

8

4

Relational Algebra

11

5

Query Cost Estimation - Part 1

9

6

Query Cost Estimation - Part 2

5

7

MongoDB

3

8

Neo4J

8

9

Cheat Sheet

0

Total:

65

Your Score

Part 1. (8 points, General MC) Select the best answer or answers for each of the following questions. In each question, select all that apply.

1. (2 points) When estimating the cost of a join implementation in Block Nested Loop Join and Merge Join, what is typically being counted? a. The number of comparisons performed in main memory. b. The estimated time it takes to retrieve all pages accessed, including the seek time, rotational delay and transfer time. c. The number of pages moved between main memory and disk. d. All of the above.

ANSWER: C The cost is typically calculated by counting only the I/O cost, i.e. the estimated number of pages moved between main memory and disk. A refinement of this will also consider the number of comparisons performed in main memory (e.g. the hash join will build a hash index in memory using a secondary hash function to speed up comparisons).

Typically, the seek time and rotational delay are not considered.

2. (2 points) State for each of the below whether it best represents a characteristic of an RDBMS (relational database system) or MongoDB (NoSQL database system). a. b. c. d. e.

More flexible schema: MongoDB Stronger consistency guarantees: RDBMS Supports storage for hierarchical data: MongoDB Data must fit on single machine: RDBMS Queries are optimized for joins: RDBMS

3. (2 points) Suppose a DBMS ensures “legal” schedules (i.e. never grants any conflicting locks), and requires that all read-write transactions be well-formed and two-phase.

However, the DBMS allows read-only transactions to execute without acquiring any locks. Which of the following is true? a. All executions are guaranteed to be serializable. b. All executions which include a read-only transaction are not serializable. c. All executions which include only read-write transactions (i.e. no read-only transactions) are serializable. d. All executions which include only read-only transactions (i.e. no read-write transactions) are conflict-serializable.

ANSWER: C, D

The 2-Phase Locking Theorem states that if all transactions are well-formed and twophase, then any legal schedule is serializable. However, if some transaction is not wellformed or two-phase, then some legal schedule may fail to be serializable. The requirement for well-formed and two-phase is for both read-write and read-only transactions.

4. (2 points) Suppose there is a B+ index on [A, B, C] for R(A,B,C,D). For which of the following selections is the index useful?

A. C=12 B. A=15 ⋀ D>3 C. B>10 ⋀ A>5 D. C=12 ⋀ B > 10 ANSWER: B, C A and D are false because there must be a condition on a prefix of the search key. A condition on A is missing for both A and B.

Part 2. (13 points, Transactions) Consider the following execution E1 of transaction T1 (column 2), in which the time of each action is shown in column 1.

Time

T1

1

SLOCK(B)

2

XLOCK(A)

3 4 5

READ(B)

6

REL(B)

7 8

WRITE(A)

9 10

COMMIT REL(A)

11 For the following, consider each question independent of the questions that precede it.

1. (2 points) At time 3, transaction T2 requests an SLOCK(B). What is the earliest time in E1 that the request can be granted in a legal schedule? () 3 () 7 () 9 () 11 ANSWER: time 3 Two transactions can gain SLOCK at the same time.

2. (2 points) Is T1 a two-phased transaction in E1? Is it strict? Explain your answer.

ANSWER: Yes, no lock is acquired after some lock is released. No, it is not strict because the SLOCK is released early.

Now, consider the following schedule E2, unrelated to E1 T1 : R1(A), W1(A), R1(B), R1(C), W1(C) T2 : R2(A), R2(B), R2(C) T3 : R3(B), W3(C) are executed in the following schedule, where lock acquisitions (Si for shared lock, Xi for exclusive lock) and releases (RELi) are given, with subscripts i indicating the transaction performing the operation: S : X1(A), S1(B), R1(A), W1(A), R2(A), R1(B), S3(B), R3(B), R2(B), REL1(B), X1(C), R1(C), W1(C), R2(C), REL1(A, C), commit1, X3(C), W3(C), commit3, REL3(B, C) 3. (2 points) In S, is T1 two-phase? Why or why not?

ANSWER: No, because it releases a lock on B and then obtains a lock on C. 4. (5 points) S : X1(A), S1(B), R1(A), W1(A), R2(A), R1(B), S3(B), R3(B), R2(B), REL1(B), X1(C), R1(C), W1(C), R2(C), REL1(A, C), commit1, X3(C), W3(C), commit3, REL3(B, C) Draw the precedence graph for this execution. Is S serializable? Why or why not?

ANSWER: T1 −→ T2 because W1(A) precedes R2(A) T1 −→ T2 because W1(C) precedes R2(C)

T2 −→ T3 because R2(C) precedes W3(C) T1 −→ T3 because W1(C) precedes W3(C) The schedule is equivalent to T1, T2, T3.

5. (2 points) S : X1(A), S1(B), R1(A), W1(A), R2(A), R1(B), S3(B), R3(B), R2(B), REL1(B), X1(C), R1(C), W1(C), R2(C), REL1(A, C), commit1, X3(C), W3(C), commit3, REL3(B, C) What isolation levels are T1, T2 and T3 using in S? Explain your answer.

ANSWER: T1 is read committed, since it releases a shared lock early and keeps the exclusive locks to the end of the transaction.

T2 is read uncommitted, since it never obtains locks.

T3 could be repeatable read (or serializable).

Part 3. (8 points, B+ Trees) Consider a relation Customer(ID, name, age, shoesize) with a B+ tree index on age. The minimum capacity of a data entry page is 2 entries; the minimum capacity of an index page is 2 pointers/1 key value. Leaf nodes (data entry pages) point to data pages; each pointer represents a record ID (RID). A data page can store upto 3 data records.

(a) (4 points) Write the key value index entries for the root and the intermediate nodes (index entries) in the tree above.

(b) (2 points) The above index uses (select one choice): 1.

2.

3.

4.

Alternative 1 Alternative 2 Alternative 3 None of them

(c) (2 points) The above index is (select one choice): 1.

2.

3.

4.

Unclustered Dense Clustered Sparse Clustered Dense Unclustered Sparse

Part 4. (11 points, Relational Algebra) For full credit, in all questions below, use ⋈ (natural join) whenever possible as opposed to cross product or ⋈θ (join on condition θ). Further, if R(A,B) and S(B,C) are joined as R ⋈ S, assume that the result has columns named A,B,C. Answer questions (a)-(d) below with respect to the following relational schema. Assume that Restaurant.zip references Place.zip and Serves.name references Restaurant.name.

Restaurant

Serves

Place

name cuisine zip

name meal

zip city

Sway Thai 78745 Dandelion

Sway lunch

78745 Austin

English

Dandelion dinner

19103

Philadelphia

Cole’s dinner

90014

Los

... ...

Angeles ... ...

19103

Cole’s

French 90014 ... ... ...

(a) (4 points) Write a relational algebra query that returns the cuisines of restaurants that serve dinner in Austin. Use parentheses as much as possible for readability.

π cuisine (((Restaurant ⋈ (σmeal = "dinner" Serves)) ⋈ (σcity = "Austin" Place)) (b) (4 points) Optimize the query you wrote in question (b) above as much as possible so that no intermediate relation contains unnecessary rows or columns. If your answer to that question is already in this form, then just answer “ditto” to this question.

πcuisine ( (π cuisine,zip (Restaurant ⋈ (πname σmeal = "dinner" Serves))) ⋈ (πzip σcity = "Austin" Place) ) (c) (3 points) What does the following relational algebra query do?

πcuisine ((πcuisine (Restaurant) X πzip (Place)) ー πcuisine, zip(Restaurant)) It returns each cuisine such that there exists a city (place) in which no restaurant serves that cuisine. [It is OK to further add that the cuisine must be served by some restaurant in some city (place).]

Part 5 (9 points, Join Cost Estimation) You are given the following statistics: • R has 100,000 tuples on 1,000 pages (100 tuples/page) • S has 10,000 tuples on 500 pages (20 tuples/page)

• There are 52 buffers (a) (4 points) Give the best cost of executing the join of R and S using Block Nested Loop Join.

You should consider both orders, R join S and S join R. Smaller as outer (S), using 50 blocks. One block for scanning the inner relation (R), one block for output.

500 + (500/50)*1,000 = 10,500 pages.

Compare this with R as outer: 1,000 + (1,000/50)*500 = 11,000 pages. (b) (5 points) Assume that R is already sorted on the join key, but that S is not. What is the cost of using a Sort-Merge Join?

Recall: ceiling(log_N(M)) = 1 if 1 < M <= N. We must sort S and then merge R and S. Sorting S: 2 * 500 (1+ log_51 (500/52)) = 2 *500 (1+ log_51 (10)) = 2,000 Merging: one pass over R and S = 1,500 Total cost: 3,500 However, note that after the first pass over S there are only 10 chunks of size 52 pages. So we could use 10 buffers to sort S, one buffer to stream over R, and one buffer for output. That is, we could do the join of R and S during the last pass of sorting S, and never actually produce the sorted version of S. In this way, we avoid the final write of S (sorted version) and read of the sorted version of S for the merge, a savings of 1,000 pages.

Total cost: 2*500 + 500 + 1,000= 2,500.

Either of the answers above are acceptable. It would be incorrect to estimate 3(1,000+500)=4,500 since R is already sorted.

Part 6 (5 points, Select/Project Cost Estimation)

(a) (5 points) As before: ● ● ● ● ●

The query Q is: SELECT B, C FROM R WHERE A=1; R(A, B, C, D) has 100,000 tuples on 1,000 pages (100 tuples/page) Each attribute of R is the same size There are 500 distinct values in the domain of A (call them 1, 2, ..., 500) , each of which is equally likely to occur in a tuple of R There are 10 buffers

R is a hashed file on the key A. The hash function is h(k)=k.

Describe 1) how query Q is evaluated, and 2) what the cost is. You can assume that the bucket directory fits in memory.

All matching records in R must be in the bucket 1. There are 200 tuples that match the selection, meaning that in theory they all fit on two pages; however, we estimate 80% occupancy which mean there are 3 pages. The bucket is then scanned, and attributes B, C are retained as matching tuples are found.

Cost: 3 pages

Part 7. (10 points, MongoDB and Map Reduce) Suppose we have a collection called movies whose documents have a structure similar to the following: myMovie={ _id: 1, title: “Pulp Fiction”, year: 1994, score: 94, director: {last: “Tarantino”, first: “Quentin”}, writers: [{last: “Tarantino”, first: “Quentin”}, {last: “Avary”, first: “Avary”}], genres: [“crime”, “drama”], actors: [{last: “Travolta”, first: “John”}, {last: “Thurman”, first: “Uma”}, … ] }

(a) (3 points) Write a query which returns the title of every movie with actor John Travolta (among other possible actors) appearing in 1994. Do not return _id. db.movies.find({year: 1994, actors: {last: “Travolta”, first: “John”}} {title:1, _id:0})

Part 8. (8 points, Neo4J) Consider the nodes and relationships created by the Neo4j Cypher Code below: CREATE (you:Person {name:"You", age:20}) -[:WORKED_WITH]-> (neo:Database {name:"Neo4j" }), (you) -[:WORKED_WITH]-> (sql:Database {name:"Sql"}), (you) -[:WORKED_WITH]-> (mongo:Database {name:"Mongo"}), (amanda:Person{name:"Amanda", age:30}) -[:WORKED_WITH]-> (neo),

(amanda) -[:WORKED_WITH]-> (mongo), (johan:Person{name:"Johan", age:18}) -[:WORKED_WITH]-> (neo), (johan) [:WORKED_WITH]-> (sql), (johan) -[:WORKED_WITH]-> (mongo), (johan) -[:WORKED_WITH]-> (xml:Database {name:"Xml"}), (julia:Person {name:"Julia", age:25}) -[:WORKED_WITH]-> (sql), (andrew:Person {name:"Andrew", age:21}) -[:WORKED_WITH]-> (neo), (you) -[:KNOWS]-> (johan), (you) -[:KNOWS]-> (julia), (julia) -[:KNOWS]-> (anna:Person {name:"Anna", age:20})

(a) (2 points) Return the names of people whose age is greater than 20.

ANSWER: MATCH (person:Person) WHERE person.age > 20 RETURN person.name; (b) (3 points) Return the number of people you know.

ANSWER: MATCH p = (you:Person {name:"You"})-[:KNOWS]->(:Person) RETURN count(p); (c) (3 points) Return the persons you and Anna both know.

ANSWER: MATCH (you:Person {name:"You"})-[:KNOWS]-> (person:Person)<-[:KNOWS]-(:Person{name:"Anna"}) RETURN person;

Part 9 (3 points, Cheat Sheet) Please upload your cheatsheet here. It can be either a PDF file, an image, or a Word document.