Chapters 2 & 6 The Relational Model

2  A tabular data structure  Tables (relations) with unique names  rows (tuples/entities/records)  columns (attributes/fields)  Domain (or dom) of an attribute: a set of permitted atomic (non-decomposable) values  Tuples t  r(R), where R = A 1, A 2, …, A n, is an ordered set of values, i.e., t = where v 1  dom(A 1 ), v 2  dom(A 2 ), …, v n  dom(A n ).  Relation r(R): a set of tuples  r(R)  dom(A 1 )  dom(A 2 )  …  dom(A n )  r is a relation instance

3 The Relational Model  Database Schema  a relational DB schema consists of a set of relation schemas  a relation schema has a (i) name and (ii) a finite set of attributes, where each one is associated with a domain  r(R) denotes a relation (instance) on the relation schema R  Definition. A candidate key K is a non-empty set of attributes which has the following properties: a) uniqueness: K uniquely identifies a tuple in a relation, and b) minimality: no proper subset of K satisfies the uniqueness constraint a primary key is a chosen candidate key a superkey satisfies (a) but may not satisfy (b) a relation may have more than one candidate key a foreign key in a relation schema is the primary key of another relation schema  Keys in the relational model  K is a superkey for R if  t 1, t 2  r(R), t 1  t 2, then t 1 [K]  t 2 [K]

4 The Relational Model  Relational Algebra  Operators used for manipulating relations, i.e., specifying retrieval/update requests (queries)  Relations in a relational DBMS are closed under the relational algebraic operations, since a query result is itself is a relation  A procedural query language

5 The Relational Model  Unary relational operators:  select (  )  project (  )  rename (  )  assignment (  )  Binary relational operators:  cartesian produce (  )  union (  )  difference (  )  intersection (  )  natural join (  )  division (  ) Set Operations

6 The Relational Model  Fundamental relational operators:  select (  )  project (  )  cartesian produce (  )  union (  )  difference (  )  rename (  )  Additional relational operators:  intersection (  )  natural join (  )  division (  )  assignment (  )

7 The Relational Model  Select (  )  Selects the tuples (rows) from a relation r satisfying a certain selection condition C, i.e.,  c (r)  C is a Boolean expression on attributes of r  Resulting relation has the same attributes as r e.g.,  (std_major = “CS”  std_major = “Math”)  std_gpa  3.5 (Student)  Project (  )  Keeps only certain attributes specified in an attribute list L from a relation r  Resultant relation has only those attributes of r specified in L e.g.,  std_name, std_phone# (Student)

8 Relational Algebra  A = “a ¹ ” (r ¹ ) ABC a1a1 b1b1 c1c1 a1a1 b3b3 c1c1 A,C (r¹)A,C (r¹) AC a1a1 c1c1 a2a2 c2c2 r¹r¹ ABC a1a1 b1b1 c1c1 a2a2 b2b2 c2c2 a1a1 b3b3 c1c1 Example.

9 The Relational Model  Cartesian Product (  )  combines information from two relations  r ¹ (A ¹, A 2, …, A n )  r 2 (B ¹, B 2, …, B m ) = r 3 (A ¹, …, A n, B ¹, …, B m ), and  t  r 3, t[A ¹, …, A n ]  r 1, t[B ¹, …, B m ]  r 2  if |r ¹ | = i and |r 2 | = j  Union (  )  r 1  r 2 : combines tuples in r 1 with those tuples in r 2  duplicate tuples are eliminated  the two involved relations must be union-compatible  union-compatible: 1) same arity (degree), i.e., same number of attributes 2) attributes in the corresponding columns must have the same domain, then |r 1  r 2 | = i  j

10 Relational Algebra Example (continued). r¹r¹ ABC a1a1 b1b1 c1c1 a2a2 b2b2 c2c2 a1a1 b3b3 c1c1 r2r2 ABC a1a1 b3b3 c1c1 a2a2 b1b1 c1c1 r¹  r2r¹  r2 r¹.Ar¹.Ar2.Ar2.Ar¹.Br¹.Br¹.Cr¹.Cr2.Br2.Br2.Cr2.C a¹a¹ a¹a¹ b¹b¹ c¹c¹ b3b3 c1c1 a¹a¹ a2a2 b¹b¹ c¹c¹ b1b1 c1c1 a2a2 a¹a¹ b2b2 c2c2 b3b3 c1c1 a2a2 a2a2 b2b2 c2c2 b1b1 c1c1 a¹a¹ a¹a¹ b3b3 c¹c¹ b3b3 c1c1 a¹a¹ a2a2 b3b3 c¹c¹ b1b1 c1c1 r ¹  r 2 ABC a1a1 b1b1 c1c1 a2a2 b2b2 c2c2 a1a1 b3b3 c1c1 a2a2 b1b1 c1c1  

11 The Relational Model  Set Difference (  )  r 1  r 2 : contains tuples which occur in r 1 but not in r 2  the two involved relations must be union-compatible  Rename (  )   s (r) returns relation r under the name s, or   B  A (r) returns attribute A under the attribute name B

12 Relational Algebra Example (continued). r¹r¹ ABC a1a1 b1b1 c1c1 a2a2 b2b2 c2c2 a1a1 b3b3 c1c1 r2r2 ABC a1a1 b3b3 c1c1 a2a2 b1b1 c1c1 s(r¹)s(r¹) ABC a1a1 b1b1 c1c1 a2a2 b2b2 c2c2 a1a1 b3b3 c1c1 r¹  r2r¹  r2 ABC a1a1 b1b1 c1c1 a2a2 b2b2 c2c2 =  

13 The Relational Model  Additional Relational Operations  simplify queries constructed by using the fundamental operators  more convenient since less operators involved  do not add expressive power to the relational model  Additional Operations:  Set Intersection (  ) r 1  r 2 contains common tuples in r 1 and r 2 the two involved relations must be union-compatible can be rewritten using set difference, i.e., r  s = r  (r  s)

14 Relational Algebra Example (continued). r¹r¹ ABC a1a1 b1b1 c1c1 a2a2 b2b2 c2c2 a1a1 b3b3 c1c1 r2r2 ABC a1a1 b3b3 c1c1 a2a2 b1b1 c1c1 r 1  r 2 ABC a1a1 b3b3 c1c1

15 The Relational Model – Additional Operators  Natural Join (  ): a combination of , ,  in that order  : merge two relations into one  : select equal values on common attributes  : remove duplicated columns  A “  ” becomes “  ” if the two operand relations have no common attributes, e.g., r(A, B)  s(C, D) = r(A, B)  s(C, D)  Rewrite  using ,  and  : r(R)  s(S) =  R  S (  r. A 1 = s. A 1 ...  r.A n = s.A n (r  s)) where R  S = {A ¹, …, A n }

16 Relational Algebra r¹r¹ ABC a1a1 b1b1 c1c1 a2a2 b2b2 c2c2 a1a1 b3b3 c1c1 r3r3 BD b3b3 d4d4 b1b1 d5d5 b1b1 d3d3 Example (continued). ABC a1a1 b1b1 c1c1 D d3d3 a1a1 b1b1 c1c1 d5d5 a1a1 b3b3 c1c1 d4d4 r1  r3r1  r3

17  Assignment (  )  assigns a relation with a relation variable, a convenient way to express complex queries, e.g., V   R  S (r)  Division (  )  retrieve each (resultant) tuple in the dividend relation that “contain” all the tuple values of the divisor relation  attribute(divisor)  attribute(dividend)  resultant schema has attribute(dividend) – attribute(divisor), e.g., Has_taken(Name, Course#, Status)  Core_course(Course#) The Relational Model – Additional Operators

18 Relational Algebra StatusName Has_taken  Core_course Has_taken Steve NameCourse# Math 112 Status Freshman Dan SteveCS 103 CS 142 Freshman Junior Dan Math 112 CS 143 Junior LindaCS 142Freshman Core_course Course# MATH 112 CS 142 Example. JuniorDan   

19 Division Operation Example. Let r and s be the following r elations: r  s A  B 1212 AB  r s       

20 Division Operation r  sr  s ABC AB  aaaaaaaaaaaaaaaa CD  aabababbaabababb E D abab E 1111 r s Example. Let r and s be the following r elations:   a   a      

21 Division Operation  Suited to queries that include the phrase “for all”.  Let r and s be relations on schemas R and S, respectively where  R = (A 1, …, A m, B 1, …, B n )  S = (B 1, …, B n ) The result of r  s is a relation on schema R – S = (A 1, …, A m ) r  s = { t | t   R-S (r)   u  s ( tu  r ) } r  sr  s

22 Division Operation  Property  Let q = r  s  Then q is the largest relation satisfying q × s  r  Definition in terms of the basic algebra operation. Let r(R) and s(S) be relations, and let S  R r  s =  R-S (r) –  R-S ((  R-S (r) × s) –  R-S,S (r)) To see why   R-S,S (r) simply reorders attributes of r   R-S (  R-S (r) × s) –  R-S,S (r)), i.e., (iii), gives those tuples t in  R-S (r) such that for some tuple u  s, tu  r. (i) (ii) (iii)

23  Sample Query: “Find all customers who have an account at all branches located in Brooklyn city.” branch (branch-name, branch-city, assets) depositor (customer-name, account-number) account (account-number, branch-name, balance) Division Operation (  branch-city = “Brooklyn” (branch))  branch-name  (depositor  account)  customer-name, branch-name

24 Outer Join  An extension of the join operation that avoids loss of information.  Computes the (natural) join and then adds tuples from one relation that does not match tuples in the other relation to the result of the join.  Uses null values:  null signifies that the value is unknown or does not exist  All comparisons involving null are (roughly speaking) false by definition. Will study precise meaning of comparisons with nulls later

25 Outer Join  Natural Join: loan  Borrower  Left Outer Join: loan Borrower loan-numberamount L-170 L customer-name Jones Smith branch-name Downtown Redwood loan-numberamount L-170 L-230 L customer-name Jones Smith null branch-name Downtown Redwood Perryridge loan loan-numberamount L-170 L-230 L borrower customer-nameloan-number Jones Smith Hayes L-170 L-230 L-155 branch-name Downtown Redwood Perryridge Example

26 Outer Join n Right Outer Join: loan borrower n Full Outer Join: loan borrower loan-numberamount L-170 L-230 L null customer-name Jones Smith Hayes branch-name Downtown Redwood null loan-numberamount L-170 L-230 L-260 L null customer-name Jones Smith null Hayes branch-name Downtown Redwood Perryridge null loan loan-numberamount L-170 L-230 L borrower customer-nameloan-number Jones Smith Hayes L-170 L-230 L-155 branch-name Downtown Redwood Perryridge Example

27  Left outer join ( ) defined by other algebraic operators  r s = (r  s)  where (null, …, null) is on the schema S - R  Right outer join ( ) defined by other algebraic operators  r s = (r  s)  ( (s -  S (s  r))  { (null, …, null) } ) where (null, …, null) is on the schema R - S  Full outer join ( ) defined by left and right outer joins  r s = (r s)  (r s) Outer Join ( (r -  R (r  s))  { (null, …, null) } )

28 Null Values  It is possible for tuples to have a null value, denoted by null, for some of their attributes.  Null signifies an unknown value or that a value does not exist  The result of any arithmetic expression involving null is null.  For duplicate elimination and grouping, null is treated like a value, and two nulls are assumed to be the same.  Alternative: assume each null is different from each other (adopted)  Both are arbitrary decisions  Relational (comparison) operations (such as >, <, =, etc.) involving null values return the special truth value unknown, which is null.

29 Null Values  Three-valued logic using the truth value unknown: AND: (true and unknown) = unknown (false and unknown) = false (unknown and unknown) = unknown OR: (unknown or true) = true (unknown or false) = unknown (unknown or unknown) = unknown NOT: (not unknown) = unknown

30 Null Values  Selection: Comparisons with null values return the special truth value unknown, i.e., not selected  Natural Join: joining tuples on null values cause mismatch  Projection: treating nulls like any other values when eliminating duplicates; our assumption is: difference  Union, Intersect, Difference: treating nulls just as the projection does, i.e., null values in corresponding columns in two tuples are treated as different  Outer join: behaving just like join operations, except on tuples that do not occur in the join results, which may be added to the result, depending on the operation.

31 Deletion delete  A delete request is expressed similarly to a query, except instead of displaying tuples to the user, the selected tuples are removed from the database.  Can delete only whole tuples; cannot delete values on only particular attributes  A deletion is expressed in relational algebra by: r  r – E where r is a relation and E is a relational algebra query.

32 Deletion  Delete all account records in the Perryridge branch. account  account –  branch-name = “Perryridge” (account)  Delete all loan records with amount in the range of 0 to 50. loan  loan –  amount  0  and amount  50 (loan)  Delete all accounts at branches located in Needham. r 1   branch-city = “Needham” (account branch) r 2   account-number, branch-name, balance (r 1 ) account  account – r 2 r 3   customer-name, account-number (r 2 depositor) depositor  depositor – r 3 Example. branch (branch-name, branch-city, assets) account (account-number, branch-name, balance) loan (loan-number, branch-name, amount) depositor (customer-name, account-number)

33 Insertion  To insert data into a relation, we either:  specify a tuple to be inserted, or  write a query whose result is a set of tuples to be inserted  In relational algebra, an insertion is expressed by: r  r  E where r is a relation and E is a relational algebra expression.  The insertion of a single tuple is expressed by letting E be a constant relation containing one tuple.

34 Insertion  Insert information in the database specifying that “Smith” has $1200 in account A-973 at the “Perryridge” branch. account  account  { (“A-973”, “Perryridge”, 1200) } depositor  depositor  { (“Smith”, “A-973”) }  Provide as a gift for all loan customers in the “Perryridge” branch, a $200 savings account. Let the loan number serve as the account number for the new savings account. r 1  (  branch-name = “Perryridge” (borrower  loan)) account  account   loan-number, branch-name, 200 (r 1 ) depositor  depositor   customer-name, loan-number (r 1 ) Example. account (account-number, branch-name, balance) depositor (customer-name, account-number) borrower (customer-name, loan-number) loan (loan-number, branch-name, amount)

35 Modification  A mechanism to change a value in a tuple without changing all the values in the tuple.  Use the generalized projection operator to do this task. r   F1, F2, …, Fn, (r)  Each F i (1  i  n) is either the i th attribute of r, if the i th attribute is not updated, or a predicate involving the i th attribute, if it is the attribute to be updated.  F i is an expression, involving only constants and the attributes of r, which gives the new value for the attribute.

36 Modification  Make interest payments by increasing all balances by 5% account   account-number, branch-name, balance * 1.05 (account)  Pay all accounts with balances over $10,000 6% interest and pay all others 5% account   account-number, branch-name, balance*1.06 (  balance  (account))   account-number, branch-name, balance*1.05 (  balance  (account)) Example. account (account-number, branch-name, balance)

37 The Relational Model  Database Updates  A DB application provides a mechanism for updating data  Method for updating data: use an interactive query/update language  Updating means inserting, deleting, and modifying db data  Delete Removes selected tuples from db tables Relational algebra expression: r  r  E, where r is a relation & E is a relational algebra query  Insertion Add tuples into db tables  t =, a tuple to be inserted into relation r(A 1,…, A n ), a i  dom(A i ), 1  i  n Relational algebra expression: r  r  E  Modification (  ) Changes a value in a tuple Relational algebra expression:  A  E (r), where A is an attr of relation r, & E is an arithmetic expression which includes constants & attrs of r.

38 The Relational Model  Tuple Relational Calculus  A nonprocedural (declarative) query language  Formal DB language based on 1 st order predicate calculus  Tuple variables range over tuples of a relation  Attribute values: t[A], value of attribute A in tuple variable t  Tuple calculus expressions: { t | P(t) } i.e.,  t: predicate (formula) P is true for t Quantifier:  (universal/for all),  (existential/there exists) Free/bound tuple variable: a variable not quantified/quantified by a quantifier e.g.,  t  r 1  s  r 2 Formulas are made up of atoms

39 The Relational Model  Tuple Relational Calculus  Atoms are of the following types: t  r, where t is a tuple variable and r is a relation t 1 [X]  t 2 [Y], where – t 1 and t 2 are (same) tuple variables – X, an attribute of t 1 and Y, an attribute of t 2 –   {,  } – dom(X) and dom(Y) are  -compatible t[X]  C, where – t is a tuple variable – X, an attribute of t – C, a constant in dom(X) – , same as above, a comparison operator

40 The Relational Model  Tuple Calculus Expressions  Well-formed formula (wff): 1. an atom is wff 2. if P is a wff, then  P is a wff (P) is a wff 3. if P 1 and P 2 are wffs, then P 1  P 2 is a wff P 1  P 2 is a wff P 1  P 2 is a wff 4. if P(t) is a wff, where t is free, then  t  r (P(t)) is a wff  t  r (P(t)) is a wff

41 The Relational Model  Relational Algebra Expressions vs. Tuple Calculus Expressions Relational Alg. Expression Tuple Calculus Expression Select:  C (r) { t | t  r  C’ }, where C’ is the condition C with each appearance of attribute A of r replaced by t[A] Project:  A 1, …, A n (r) { t |  u  r (t[A 1 ] = u[A 1 ] ...  t[A n ] = u[A n ])} Cartesian: r(R)  s(S) { t |  x  r (  y  s (t[A 1 ] = x[A 1 ] ...  t[A n ] = x[A n ]  t[B 1 ] = y[B 1 ]  …  t[B m ] = y[B m ])) } where R = {A 1, …, A n } and S = {B 1, …, B m } Union: r  s { t | t  r  t  s } Difference: r  s { t | t  r   (t  s) } Product

42 Sample Tuple Calculus Queries  Find the loan-number, branch-name, and amount for loans of over $1200. { t | t  loan  t [amount]  1200 }  Find the loan number for each loan of an amount greater than $1200. { t |  n  loan (t[loan-number] = n[loan-number]  n[amount]  1200) } Example. loan (loan-number, branch-name, amount)

43  Find the names of all customers having a loan, an account, or both at the bank. { t |  b  borrower (t [customer-name] = b[customer-name])   d  depositor (t [customer-name] = d[customer-name])}  Find the names of all customers who have a loan and an account at the bank. { t |  b  borrower (t [customer-name] = b[customer-name])   d  depositor (t [customer-name] = d[customer-name]) } Example. borrower (customer-name, loan-number) depositor (customer-name, account-number) Sample Tuple Calculus Queries

44  Find the names of all customers having a loan at the Perryridge branch. { t |  b  borrower (t [customer-name] = b[customer-name]   n  loan (b[loan-number] = n[loan-number]  n[branch-name] = “Perryridge”)) }  Find the names of all customers who have a loan at the Perryridge branch, but no account at any branch of the bank. { t |  b  borrower (t [customer-name] = b[customer-name]   n  loan (b[loan-number] = n[loan-number]  n[branch-name] = “Perryridge”))  d  depositor (d[customer-name] = t [customer-name])} Example. borrower (customer-name, loan-number) loan (loan-number, branch-name, amount) depositor (customer-name, account-number)  / Sample Tuple Calculus Queries

45  Find the names of all customers having a loan from the Perryridge branch, and the cities they live in. { t |  n  loan (n[branch-name] = “Perryridge”   b  borrower (b[loan-number] = n[loan-number]  t [customer-name] = b[customer-name]   c  customer (c[customer-name] = b[customer-name]  t [customer-city] = c[customer-city]))) } Example. loan (loan-number, branch-name, amount) borrower (customer-name, loan-number) customer (customer-name, customer-street, customer-city) Sample Tuple Calculus Queries

46  Find the names and cities of all customers who have an account at all branches located in Brooklyn. { t |  c  customer (t [customer-name] = c[customer-name]  t [customer-city] = c[customer-city]   b  branch (b[branch-city] = “Brooklyn”   a  account (a[branch-name] = b[branch-name]   d  depositor (d[account-number] = a[account-number]  d[customer-name] = c[customer-name]))))} Example. customer (customer-name, customer-street, customer-city) depositor (customer-name, account-number) account (account-number, branch-name, balance) branch (branch-name, branch-city, assets) Sample Tuple Calculus Queries

47 The Relational Model  Safe Tuple Calculus Expressions  Expressions generate infinite relations, e.g., { t |  (t  r) }, is not safe An expression E: { t | P(t) } is safe if each value in E  dom(P) dom(P) = { Constants in P }  { Attribute values of relations in P }