ss

A good decomposition must be lossless and dependency preserving 1. Lossless-Join Decomposition Exactly the original information can be recovered by joining 2. Non-Lossless-Join or Lossy Decomposition Partial or inexact information can be recovered A. Dependency Preserving The original dependencies are all found in the decomposition

B. Dependency Non-preserving Original dependencies are not reflected in the decomposition Definition of Decomposition Let r be a relation on relation scheme R and let r i = Ri (r) for i=1,2,. then r r 1 join r 2..join r n The Decomposition of the relational scheme R={A1, A2, A3,, An} is its replacement by a set of relation schemes {R1, R2, R3,., Rn} such that R1 join R2 join R3..Rn = R. Example Lossless-Join Decomposition Given R a relation and F a set of FDs Decompose R into R1 and R2 Decomposition is lossless if F+ contains either Intersection(R1, R2) R1 or Intersection(R1, R2) R2 EmpDept ( empno, empname, job, deptno, dname, dloc) F = { deptno dname deptno dloc empno empname empno deptno empno job } Decompose EmpDept into two relations Emp ( empno, empname, job, deptno ) Dept( deptno, dname, dloc) Intersection(Emp, Dept) = { deptno } Dept Decompose EmpDept into two relations Emp ( empno, empname, job) Ejob( deptno, dname, dloc, job) Decomposition is non-lossless-join Intersection(Emp, Dept) = { job } Emp or Ejob Does not hold Answer 3 b) Closure of a Set of Attributes 1. The set of all attributes that are implied by a given set of attributes S is called the closure of S 2. A superkey implies all the other attributes of a relvar

3. The nonkey attributes of a relvar represent a closure of the superkey, but not necessarily an irreducible one 4. Any group of attributes for which all the other attributes represent a closure is a superkey Algorithm to find closure CLOSURE [F,R]:= F; do forever ; for each FD X Y in S do; if X CLOSURE [F,R] then CLOSURE[F,R] := closure [F,R] Y; end if CLOSURE [F,R] did not change on this iteration then leave the loop; /* computation complete */ end; Algorithm to Computing the closure F+ of F under R Answer. 3 c) Normalization is a process for assigning attributes to entities. It reduces data redundancies and helps eliminate the data anomalies. Normalization is a process of refining table structures into a proper state so that they can store data as efficiently as possible. Normalization works through a series of stages called normal forms: a. First normal form (1NF) b. Second normal form (2NF) c. Third normal form (3NF) d. Fourth normal form (4NF) The highest level of normalization is not always desirable. First Normal Form (1 NF) 1NF Definition The term first normal form (1NF) describes the tabular format in which:» All the key attributes are defined.» There are no repeating groups in the table.» All attributes are dependent on the primary key. A relation R(A1, A2,., An) is said to be in 1 NF if : Values in the domain of each attribute of the relation are atomic. Relational model expects relations to be in 1 NF. STUDENT(name, fname, roll-no, course,grade) Every attribute takes on a simple value.thus it is in 1 NF. EMPLOYEE(name, address, child) child has attributes like child-name,age,sex.it is not atomic and thus is not in 1 NF.

The Second Normal Form, 2NF Eliminate partial functional dependency by having only full functional dependencies. A relation is in 2 NF if it is in 1 NF and if each non-prime field is fully dependent upon each candidate key Represent the offending partial functional dependency as a separate relation by decomposition. Decompose into 2NF Emp(Eno, Ename, Designation, salary) Eno Designation Eno Salary Eno, Ename Designation Eno, Ename Salary PFD of Salary and designation respectively on Eno, Ename Problem: as many tuples as (alias) Enames of an Eno. Option 1 E (Eno, Designation, Salary) E (Eno, Ename) Option 2 E (Eno, Salary) E (Eno, Designation) E (Eno, Ename) Operationally, Option 1 is better.

Third Normal Form(3NF) Codd s Definition A relation is in 3NF if it satisfies 2NF and no nonprime attribute of R is transitively dependent on the primary key 3NF Decomposition Algorithm If A B and B C in R then create R1(A,B), R2 (B,C) Equivalently, A relation is in 3 NF if for every functional dependency X A, one of the following statements is true: i) it is a trivial FD X is a superkey A is a prime attribute Consider a relation Stdinf (Name, Phoneno, Course, Major, Prof., Grade, Major-Elective) with following FD s Name Course Phoneno Major Prof.. Grade Major-Elective The key of the relation is {Name Course} The partial dependencies are caused by Name Phoneno Name Major and Course Prof. The only transitive dependency is Name Major, Major Major-Elective.

Consider a relation Stdinf (Name, Phoneno, Course, Major, Prof., Grade, Major-Elective) with following FD s Name Course Phoneno Major Prof.. Grade Major-Elective The key of the relation is {Name Course} The partial dependencies are caused by Name Phoneno Name Major and Course Prof. The only transitive dependency is Name Major, Major Major-Elective. 2NF Decomposition: R1(Name, Phoneno, Major, Major-Elective) R2(Course,Prof.) R3(Name,Course,Grade) 3NF Decomposition: R1-1(Name,Phoneno,Major) R1-2(Major, Major-Elective) R2(Course, Prof.) R3(Name,Course,Grade) BCNF

Need For BCNF arises when X A and A B where B is a subset of X Student (Name, Course, Teacher) and Name Course Teacher Note: Name, Course is the primary key of Student Name Course Teacher A C1 T1 B C1 T1 C C2 T2 A relation R is in BCNF if it is in 1NF and for every collection C of fields, if any field not in C is functionally dependent on C, then C R A relation is in BCNF if whenever a functional dependency X A holds then, either i) X is a super key of R, or ii) X A is trivial (A is subset of X) Difference with 3NF: A cannot be a prime attribute Lossless BCNF Decomposition For R(A,B,C) if A,B C and C B, decompose R into R1(C,B) and R2 (R - B) Note: Dependency Non-preserving

Answer 4 a) A transaction is a unit of program execution that accesses and possibly updates various data items. A transaction must see a consistent database. During transaction execution the database may be inconsistent. When the transaction is committed, the database must be consistent. Two main issues to deal with: Failures of various kinds, such as hardware failures and system crashes Concurrent execution of multiple transactions Transaction State 1. Active, the initial state; the transaction stays in this state while it is executing 2. Partially committed, after the final statement has been executed. 3. Failed, after the discovery that normal execution can no longer proceed. 4. Aborted, after the transaction has been rolled back and the database restored to its state prior to the start of the transaction. Two options after it has been aborted: a. restart the transaction only if no internal logical error b. kill the transaction 5. Committed, after successful completion.

Example of Fund Transfer Transaction to transfer $50 from account A to account B: 1. read(a) 2. A := A 50 3. write(a) 4. read(b) 5. B := B + 50 6. write(b) Consistency requirement the sum of A and B is unchanged by the execution of the transaction. Atomicity requirement if the transaction fails after step 3 and before step 6, the system should ensure that its updates are not reflected in the database, else an inconsistency will result. Durability requirement once the user has been notified that the transaction has completed (i.e., the transfer of the $50 has taken place), the updates to the database by the transaction must persist despite failures. Isolation requirement if between steps 3 and 6, another transaction is allowed to access the partially updated database, it will see an inconsistent database (the sum A + B will be less than it should be). Can be ensured trivially by running transactions serially, that is one after the other. However, executing multiple transactions concurrently has significant benefits, as we will see. Answer. 4 b) Schedules 1. When several transactions are executing concurrently the order of execution of various instructions is known as a schedule.

2. The concept of serializability of schedules is used to identify which schedules are connect when transaction executions have interleaving of their operations in the schedules. 3. Types of schdeules a. Serial schedules b. Non-serial schedules c. Conflict schedules d. View schedules Serial schedules 1. Two schedules T1 and T2 are called serial schedule if the operations of each transaction are executed consecutively, without any interleaved operations from the other transaction. 2. In a serial schedule, entire transaction are performed in serial order T1 and then T2 OR T2 then T1. Non-serial Schedule Two schedules T1 and T2 are called non-serial schedule if the operations of each transaction are executed non-consecutively with interleaved operations from the other transaction.

Conflict schedule The precedence graph contains no cycle is called conflict serializable schedule View Schedule 1. The precedence graph contains a cycle is called view schedule. 2. If the graph contains no cycle, then the schedule S is conflict serializable. 3. If the graph for S has a cycle, then schedule S is not conflict serializable. Conflict Serializability Instructions li and lj of transactions Ti and Tj respectively, conflict if and only if there exists some item Q accessed by both li and lj, and at least one of these instructions wrote Q. 1. li = read(q), lj = read(q). li and lj don t conflict. 2. li = read(q), lj = write(q). They conflict. 3. li = write(q), lj = read(q). They conflict 4. li = write(q), lj = write(q). They conflict Intuitively, a conflict between li and lj forces a (logical) temporal order between them. If li and lj are consecutive in a schedule and they do not conflict, their results would remain the same even if they had been interchanged in the schedule. View Serializability Let S and S be two schedules with the same set of transactions. S and S are view equivalent if the following three conditions are met: 1. For each data item Q, if transaction Ti reads the initial value of Q in schedule S, then transaction Ti must, in schedule S, also read the initial value of Q. 2. For each data item Q if transaction Ti executes read(q) in schedule S, and that value was produced by transaction Tj (if any), then transaction Ti must in schedule S also read the value of Q that was produced by transaction Tj. 3. For each data item Q, the transaction (if any) that performs the final write(q) operation in schedule S must perform the final write(q) operation in schedule S.

As can be seen, view equivalence is also based purely on reads and writes alone. Recoverability Need to address the effect of transaction failures on concurrently running transactions. 1. Recoverable schedule if a transaction Tj reads a data items previously written by a transaction Ti, the commit operation of Ti appears before the commit operation of Tj. 2. The following schedule (Schedule 11) is not recoverable if T9 commits immediately after the read Schedule 11 3. If T8 should abort, T9 would have read (and possibly shown to the user) an inconsistent database state. Hence database must ensure that schedules are recoverable. Cascading rollback a single transaction failure leads to a series of transaction rollbacks. Consider the following schedule where none of the transactions has yet committed (so the schedule is recoverable) Schedule 12 If T10 fails, T11 and T12 must also be rolled back. Can lead to the undoing of a significant amount of work

Cascadeless schedules cascading rollbacks cannot occur; for each pair of transactions Ti and Tj such that Tj reads a data item previously written by Ti, the commit operation of Ti appears before the read operation of Tj. Every cascadeless schedule is also recoverable It is desirable to restrict the schedules to those that are cascadeless Answer 4 C) Distributed Database: A distributed database system consists of loosely coupled sites that share no physical component Database systems that run on each site are independent of each other Transactions may access data at one or more sites Data Replication A relation or fragment of a relation is replicated if it is stored redundantly in two or more sites. Full replication of a relation is the case where the relation is stored at all sites. Fully redundant databases are those in which every site contains a copy of the entire database. Advantages of Replication Availability: failure of site containing relation r does not result in unavailability of r is replicas exist. Parallelism: queries on r may be processed by several nodes in parallel. Reduced data transfer: relation r is available locally at each site containing a replica of r. Disadvantages of Replication Increased cost of updates: each replica of relation r must be updated. Increased complexity of concurrency control: concurrent updates to distinct replicas may lead to inconsistent data unless special concurrency control mechanisms are implemented. One solution: choose one copy as primary copy and apply concurrency control operations on primary copy Data Fragmentation Division of relation r into fragments r1, r2,, rn which contain sufficient information to reconstruct relation r. Horizontal fragmentation: each tuple of r is assigned to one or more fragments Vertical fragmentation: the schema for relation r is split into several smaller schemas o All schemas must contain a common candidate key (or superkey) to ensure lossless join property. o A special attribute, the tuple-id attribute may be added to each schema to serve as a candidate key. Example : relation account with following schema Account = (account_number, branch_name, balance ) Advantages of Fragmentation Horizontal:

o allows parallel processing on fragments of a relation o allows a relation to be split so that tuples are located where they are most frequently accessed Vertical: o allows tuples to be split so that each part of the tuple is stored where it is most frequently accessed o tuple-id attribute allows efficient joining of vertical fragments Vertical and horizontal fragmentation can be mixed. o Fragments may be successively fragmented to an arbitrary depth. Replication and fragmentation can be combined o Relation is partitioned into several fragments: system maintains several identical replicas of each such fragment. Answer. 5 a) Lock: A mechanism to control concurrent access to a data item by competing transactions. Locking protocol: A set of rules followed by all transactions while requesting and releasing locks. Types of Lock Granularity of locks: Can be at the field level, record level, or disk block level, or table level. Less granular locks provides better concurrency, but increases locking overhead since more lock/unlock operations are needed. Types of locks: Read lock or shared lock (lock-s): Data item can be read but not updated by the locking and other transactions. Write lock or exclusive lock (lock-x): Data items can be read and updated by the locking transaction, but not by other transactions. Concurrency control manager can upgrade read locks to write locks, or downgrade write locks to read locks, as requested. All locking operations (read_lock, write_lock) precede the first unlock operation in the transactions. Two phases: expanding phase: new locks on items can be acquired but none can be released shrinking phase: existing locks can be released but no new ones can be acquired

not two-phase locking read_lock(y); read_lock(x); read_item(y); unlock(y); read_item(x); X:=X+Y; write_lock(x); write_item(x); unlock(x); two-phase locking read_lock(x); read_item(x); write_lock(y); unlock(x); read_item(y); Y:=X+Y; write_item(y); unlock(y); Graph Based Protocol 1. To acquire a prior knowledge, we impose a partial ordering on the set D={d1,d2,..dn} of all data item. If di dj, then any transaction accessing both di and dj must access di before accessing dj. 2. The partial ordering implies that the set D may now be viewed as a directed acyclic graph called a database graph. 3. For the sake the simplicity, we will restrict our attention to only those graphs that are rooted trees. 4. Tree protocol is restricted to employ only exclusive locks. 5. In the tree protocol, the only lock instruction allowed is lock-x. Each transaction Ti can lock a data item at,most once, and must observe the following rules: a. The first lock by Ti may be any data item. b. Subsequently, a data item Q can be locked by Ti only if the parent of Q is currently locked by Ti. c. Data items may be unlocked at any item. d. A data item that has been locked and unlocked by Ti cannot subsequently be relocked by Ti. Graph-based protocol Advantages & Disadvantages over two-phase locking Advantages It is deadlock-free so no rollbacks are required. Unlocking may occur earlier. Earlier unlocking may lead to shorter waiting times, and to an increase in concurrency. Disadvantages Transaction may have to lock data items that it does not access. Answer 5 b) Deadlock: when each of two transactions is waiting for the other to release an item. Approaches for solution:

o deadlock prevention protocol: every transaction must lock all items it needs in advance o deadlock detection (if the transaction load is light or transactions are short and lock only a few items): Livelock: a transaction cannot proceed for an indefinite period of time while other transactions in the system continue normally. o Solution: fair waiting schemes (i.e. first-come-first-served) There are two principal methods for dealing with deadlock problems: Deadlock prevention protocol Deadlock detection and recovery process Deadlock prevention protocol This protocol ensures the system will ensure that the system will not go into deadlock state. There are different methods can be used for deadlock prevention: The simplest scheme requires that each transaction locks all its data item before it starts execution. Another method for prevention of deadlock is to impose a partial ordering of all data items and require that a transaction can lock a data item only in the order specified by partial order. Another approach for the prevention of deadlock is to use pre-emption and transaction rollbacks. Deadlock Detection and Recovery If a system does not imply some protocol that ensures deadlock freedom, then a detection and recovery scheme must be used. Deadlock Detection Deadlock can be described previously in terms of a directed graph called a wait a graph. This graph consist of a pair G=(V,E) where V is a set of vertices and E is set of edges. Each element in the set E of edges is an ordered pair Ti Tj. If Ti Tj is in E, then there is a directed edge from transaction Ti+Tj, implying that transaction Ti, is waiting for ransaction Tj to releases a data item that it needs. A deadlock exist in the system if and only if the wait for graph contains a cycle. Each transaction involved in the cycle is said to be deadlocked. Deadlock Recovery When a detection algorithm determines that a deadlock exists, the system must recover from deadlock. The most common solution is to rollback one or more transactions to break the deadlock. There actions need to be taken: 1. Selection of a victim 2. Rollback 3. Starvation As Tanenbaum shows, when the wait-for graph is computed at a central location that collects messages from the various systems involved in

transactions, it is easy to find also false, or spurious, or phantom deadlocks as in the following picture when Q first releases S and then P requests S, but the messages delivered to the coordinator that collects the messages arrive in the wrong order. Then the coordinator believes that a deadlock has arisen and kills unnecessarily P or Q. Of course, if Q was following a 2-phase locking policy, it would not release any lock until it had acquired every lock it needed. Thus phantom deadlocks would not arise if 2-phase locking is followed. Answer 5 c) i) Time stamping protocol for concurrrency control Time stamping ids a concurrency protocol in which the fundamental goal is to order transactions globally in such a way that older transactions get priority in the event of a conflict. In this method, if a transaction attempts to read or write a data item, then a read or write operation is allowed only if the last updated on that data item was carried out by an older transaction. Otherwise the transaction, requesting the read or write is restarted and given a new timestamp. The restarted transaction is assigned a new timestamp to prevent it from continuously aborting and restarting. In this method, sequence of transaction is selected in advance by using time stamping concept. We associate a unique, fixed non-decreasing numbers called the timestamp to each transaction in the system. This number can be the system clock value, i.e. when the transaction enters the system the current value of the clock is assigned to that transaction as the timestamp value. We can also use a logical number that is incremented after a new transaction enters the system. A transaction with a smaller timestamp value is considered to be an adder transaction than another transaction with a larger time stamp value. In other words, if a transaction T1 has been assigned a timestamp S1 and a new transaction T2 enters the system with a time stamp value S2 then S1<S2 and system will allow the transaction T1 to run first followed by the transaction T2. If any conflict is found between transaction using timestamp based system, one of the conflicting transaction is rolled back. There are two types of timestamps: W-time stamp (Q): Denotes the largest time stamp of any transaction that executed write(q) successfully.

R-Time stamp (Q): Denotes the largest time stamp of any transaction that executed read(q) successfully. ii) Checkpoints Storage Structure Volatile storage: does not survive system crashes examples: main memory, cache memory Loss of Volatile Storage- It can be recovered using various methods. e.g., Logbased recovery, Buffer Management, checkpoints, and shadow paging techniques. Checkpoints or syncpoints or save points A checkpoint is a point of synchronization b/w the database and the transaction log file. All buffers are force-written to secondary storage at the checkpoint. Checkpoints are schedules at predetermined interval and involves operations like writing all log records in main memory to secondary storage. If the transactions are executed serially, when a failures occurs, we check the log file to find the transaction that started before the last chcekpoint.