Ch2

Chapter 2: Relational Model

Database System Concepts, 5th Ed.
©Silberschatz, Korth and Sudarshan
See www.dbbook.com for conditions on reuse

Chapter 2: Relational Model
s Structure of Relational Databases
s Fundamental RelationalAlgebraOperations
s Additional RelationalAlgebraOperations
s Extended RelationalAlgebraOperations
s Null Values
s Modification of the Database

Database System Concepts 5th Edition, June 15, 2005 2.<number> ©Silberschatz, Korth and Sudarshan

Example of a Relation


Basic Structure
s Formally, given sets D1, D2, …. Dn a relation r is a subset of
        D1 x  D2  x … x Dn
Thus, a relation is a set of ntuples (a1, a2, …, an) where each ai  ∈ Di

s Example:  If

q customer_name =  {Jones, Smith, Curry, Lindsay, …}
/* Set of all customer names */
q customer_street =  {Main, North, Park, …} /* set of all street names*/
q customer_city     =  {Harrison, Rye, Pittsfield, …} /* set of all city names */
Then r = {        (Jones,   Main,  Harrison),
                   (Smith,    North, Rye),
                   (Curry,    North, Rye),
                   (Lindsay, Park,  Pittsfield) }
is a relation over
customer_name  x  customer_street  x  customer_city

Attribute Types
s Each attribute of a relation has a name
s The set of allowed values for each attribute is called the domain of the
attribute
s Attribute values are (normally) required to be atomic; that is, indivisible
q E.g. the value of an attribute can be an account number,
but cannot be a set of account numbers
s Domain is said to be atomic if all its members are atomic
s The special value null is a member of every domain
s The null value causes complications in the definition of many operations
q We shall ignore the effect of null values in our main presentation and
consider their effect later


Relation Schema
s A1, A2, …, An are attributes

s R = (A1, A2, …, An ) is a relation schema

Example:
Customer_schema = (customer_name, customer_street, customer_city)

s r(R) denotes a relation r on the relation schema R
Example:
customer (Customer_schema)


Relation Instance
s The current values (relation instance) of a relation are specified by a
table
s An element t of r is a tuple, represented by a row in a table

attributes
(or columns)
customer_name customer_street customer_city

Jones Main Harrison
Smith North Rye tuples
Curry North Rye (or rows)
Lindsay Park Pittsfield

customer


Relations are Unordered

s Order of tuples is irrelevant (tuples may be stored in an arbitrary order)
s Example: account relation with unordered tuples


Database
s A database consists of multiple relations
s Information about an enterprise is broken up into parts, with  each relation
storing one part of the information

account :   stores information about accounts
        depositor :   stores information about which customer
                              owns which account
        customer :   stores information about customers
s Storing all information as a single relation such as
   bank(account_number, balance, customer_name, ..)
results in
q repetition of information
 e.g.,if two customers own an account (What gets repeated?)
q the need for null values
 e.g., to represent a customer without an account
s Normalization theory (Chapter 7) deals with how to design relational schemas


The customer Relation


The depositor Relation


Keys
s Let K ⊆ R
s K is a superkey of R if values for K are sufficient to identify a unique tuple of
each possible relation r(R)
q by “possible r ” we mean a relation r that could exist in the enterprise we
are modeling.
q Example:  {customer_name, customer_street} and
                 {customer_name}
are both superkeys of Customer, if no two customers can possibly have
the same name
 In real life, an attribute such as customer_id would be used instead of
customer_name to uniquely identify customers, but we omit it to keep
our examples small, and instead assume customer names are unique.


Keys (Cont.)
s K is a candidate key if K is minimal
Example: {customer_name} is a candidate key for Customer, since it
is a superkey and no subset of it is a superkey.
s Primary key: a candidate key chosen as the principal means of
identifying tuples within a relation
q Should choose an attribute whose value never, or very rarely,
changes.
q E.g. email address is unique, but may change


Foreign Keys
s A relation schema may have an attribute that corresponds to the primary
key of another relation. The attribute is called a foreign key.
q E.g. customer_name and account_number attributes of depositor are
foreign keys to customer and account respectively.
q Only values occurring in the primary key attribute of the referenced
relation may occur in the foreign key attribute of the referencing
relation.
s Schema diagram


Query Languages
s Language in which user requests information from the database.
s Categories of languages
q Procedural
q Nonprocedural, or declarative
s “Pure” languages:
q Relational algebra
q Tuple relational calculus
q Domain relational calculus
s Pure languages form underlying basis of query languages that people
use.


Relational Algebra
s Procedural language
s Six basic operators

q select: σ
q project: ∏
q union: ∪
q set difference: –
q Cartesian product: x
q rename: ρ
s The operators take one or two relations as inputs and produce a new
relation as a result.


Select Operation – Example
s Relation r
A B C D

α α 1 7
α β 5 7
β β 12 3
β β 23 10

σA=B ^ D > 5 (r)
A B C D

α α 1 7
β β 23 10


Select Operation
s Notation:  σ p(r)
s p is called the selection predicate
s Defined as:

σp(r) = {t | t ∈ r and p(t)}

Where p is a formula in propositional calculus consisting of terms
connected by : ∧ (and), ∨ (or), ¬ (not)
Each term is one of:
<attribute> op <attribute> or <constant>
     where op is one of:  =, ≠, >, ≥. <. ≤

s Example of selection:

   σ branch_name=“Perryridge”(account)


Project Operation – Example
s Relation r: A B C

α 10 1
α 20 1
β 30 1
β 40 2

∏A,C (r) A C A C

α 1 α 1
α 1 = β 1
β 1 β 2
β 2


Project Operation
s Notation:
∏ A ,A ,,A (r )
1 2 k

where A1, A2 are attribute names and r is a relation name.
s The result is defined as the relation of k columns obtained by erasing
the columns that are not listed
s Duplicate rows removed from result, since relations are sets
s Example: To eliminate the branch_name attribute of account

∏account_number, balance (account)


Union Operation – Example
s Relations r, s:
A B A B

α 1 α 2
α 2 β 3
β 1 s
r

A B

s r ∪ s: α 1
α 2
β 1
β 3


Union Operation
s Notation:  r ∪ s
s Defined as:
r  ∪ s = {t | t ∈ r or t ∈ s}
s For r ∪ s to be valid.
1.  r, s must have the same arity (same number of attributes)
2.  The attribute domains must be compatible (example: 2nd column
     of r deals with the same type of values as does the 2nd
     column of s)

s Example: to find all customers with either an account or a loan

    ∏customer_name (depositor)   ∪  ∏customer_name (borrower)


Set Difference Operation – Example
s Relations r, s:
A B A B

α 1 α 2
α 2 β 3
β 1 s
r

s r – s:
A B

α 1
β 1


Set Difference Operation
s Notation r – s
s Defined as:
r – s = {t | t ∈ r and t ∉ s}

s Set differences must be taken between compatible
relations.
q r and s must have the same arity
q attribute domains of r and s must be compatible


CartesianProduct Operation – Example
s Relations r, s:
A B C D E

α 1 α 10 a
β 10 a
β 2 β 20 b
r γ 10 b
s
s r x s:
A B C D E
α 1 α 10 a
α 1 β 10 a
α 1 β 20 b
α 1 γ 10 b
β 2 α 10 a
β 2 β 10 a
β 2 β 20 b
β 2 γ 10 b


CartesianProduct Operation
s Notation r x s
s Defined as:
r x s = {t q | t ∈ r and q ∈ s}

s Assume that attributes of r(R) and s(S) are disjoint. (That is, R ∩ S = ∅).
s If attributes of r(R) and s(S) are not disjoint, then renaming must be
used.


Composition of Operations
s Can build expressions using multiple operations
s Example: σA=C(r x s)
s r x s
A B C D E
α 1 α 10 a
α 1 β 10 a
α 1 β 20 b
α 1 γ 10 b
β 2 α 10 a
β 2 β 10 a
β 2 β 20 b
β 2 γ 10 b

s σA=C(r x s)

A B C D E

α 1 α 10 a
β 2 β 10 a
β 2 β 20 b


Rename Operation
s Allows us to name, and therefore to refer to, the results of relational
algebra expressions.
s Allows us to refer to a relation by more than one name.
s Example:

ρ x (E)

returns the expression E under the name X
s If a relationalalgebra expression E has arity n, then

ρ (E )
x ( A1 , A2 ,..., An )

returns the result of expression E under the name X, and with the
attributes renamed to A1 , A2 , …., An .


Banking Example
branch (branch_name, branch_city, assets)

customer (customer_name, customer_street, customer_city)

account (account_number, branch_name, balance)

loan (loan_number, branch_name, amount)

depositor (customer_name, account_number)

borrower (customer_name, loan_number)


Example Queries
s Find all loans of over $1200

σamount > 1200 (loan)

s Find the loan number for each loan of an amount greater than
             $1200

∏loan_number (σamount > 1200 (loan))

s Find the names of all customers who have a loan, an account, or both,
from the bank

∏customer_name (borrower) ∪ ∏customer_name (depositor)


Example Queries
s Find the names of all customers who have a loan at the Perryridge
branch.

∏customer_name (σbranch_name=“Perryridge”
    (σborrower.loan_number = loan.loan_number(borrower x loan)))

s  Find the names of all customers who have a loan at the
    Perryridge branch but do not have an account at any branch of
    the bank.

∏customer_name (σbranch_name = “Perryridge”

(σborrower.loan_number = loan.loan_number(borrower x loan)))  –

     ∏customer_name(depositor)


Example Queries
s Find the names of all customers who have a loan at the Perryridge branch.

q Query 1

  ∏customer_name (σbranch_name = “Perryridge” (

  σborrower.loan_number = loan.loan_number (borrower x loan)))

q Query 2

∏customer_name(σloan.loan_number = borrower.loan_number (

             (σbranch_name = “Perryridge” (loan)) x  borrower))


Example Queries
s Find the largest account balance
q Strategy:
 Find those balances that are not the largest
– Rename account relation as d so that we can compare each
account balance with all others
 Use set difference to find those account balances that were not found
in the earlier step.
q The query is:

∏balance(account) ∏account.balance
    (σaccount.balance < d.balance (account x ρd (account)))


Formal Definition
s A basic expression in the relational algebra consists of either one of the
following:
q A relation in the database
q A constant relation
s Let E1 and E2 be relationalalgebra expressions; the following are all
relationalalgebra expressions:

q E1 ∪ E2

q E1 – E2

q E1 x E2

q σp (E1), P is a predicate on attributes in E1

q ∏s(E1), S is a list consisting of some of the attributes in E1

q ρ (E ), x is the new name for the result of E1
x 1
Database System Concepts 5th Edition, June 15, 2005
2.<number> ©Silberschatz, Korth and Sudarshan

Additional Operations
We define additional operations that do not add any power to the
relational algebra, but that simplify common queries.

s Set intersection
s Natural join
s Division
s Assignment


SetIntersection Operation
s Notation: r ∩ s
s Defined as:
s r ∩ s = { t | t ∈ r and t ∈ s }
s Assume:
q r, s have the same arity
q attributes of r and s are compatible
s Note: r ∩ s = r – (r – s)


SetIntersection Operation – Example

s Relation r, s:
A       B A       B
α 1 α 2
α 2 β 3
β 1

r s

s r ∩ s

A       B

α      2


NaturalJoin Operation
s    Notation:  r     s
s Let r and s be relations on schemas R and S respectively.
Then,  r     s  is a relation on schema R ∪ S obtained as follows:
q Consider each pair of tuples tr from r and ts from s.

q If tr and ts have the same value on each of the attributes in R ∩ S, add a
tuple t  to the result, where

t has the same value as tr on r


t has the same value as ts on s
s Example:
R = (A, B, C, D)
S = (E, B, D)
q Result schema = (A, B, C, D, E)
q r     s is defined as:

Natural Join Operation – Example
s Relations r, s:

A B C D B D E

α 1 α a 1 a α
β 2 γ a 3 a β
γ 4 β b 1 a γ
α 1 γ a 2 b δ
δ 2 β b 3 b ∈
r s

s r s
A B C D E
α 1 α a α
α 1 α a γ
α 1 γ a α
α 1 γ a γ
δ 2 β b δ


Division Operation

s Notation: r ÷ s
s Suited to queries that include the phrase “for all”.

s Let r and s be relations on schemas R and S respectively
where
q R = (A1, …, Am , B1, …, Bn )
q S = (B1, …, Bn)
The result of  r ÷ s is a relation on schema
R – S = (A1, …, Am)

r ÷ s = { t  |  t ∈ ∏ RS (r) ∧ ∀ u ∈ s ( tu ∈ r ) }

Where tu means the concatenation of tuples t and u to
produce a single tuple


Division Operation – Example
s Relations r, s:
A B B
α 1
1
α 2
α 3 2
β 1 s
γ 1
δ 1
δ 3
δ 4
∈ 6
∈ 1
β 2
s r ÷ s: A r

α
β


Another Division Example
s Relations r, s:
A B C D E D E

α a α a 1 a 1
α a γ a 1 b 1
α a γ b 1 s
β a γ a 1
β a γ b 3
γ a γ a 1
γ a γ b 1
γ a β b 1
r
s r ÷ s:
A B C

α a γ
γ a γ


Division Operation (Cont.)
s Property
q Let q = r  ÷ s
q Then q is the largest relation satisfying q x s  ⊆ r
s Definition in terms of the basic algebra operation
Let r(R) and s(S) be relations, and let S  ⊆ R

r ÷ s = ∏RS (r ) – ∏RS ( ( ∏RS (r ) x s ) – ∏RS,S(r ))

To see why
q ∏RS,S (r) simply reorders attributes of r

q ∏RS (∏RS (r ) x s ) – ∏RS,S(r) ) gives those tuples t in

∏RS (r ) such that for some tuple u ∈ s, tu ∉ r.


Assignment Operation
s The assignment operation (←) provides a convenient way to express
complex queries.
q Write query as a sequential program consisting of
 a series of assignments
 followed by an expression whose value is displayed as a result of
the query.
q Assignment must always be made to a temporary relation variable.
s Example: Write r ÷ s as

temp1 ← ∏RS (r )
temp2 ← ∏RS ((temp1 x s ) – ∏RS,S (r ))
result = temp1 – temp2
q The result to the right of the ← is assigned to the relation variable on
the left of the ←.
q May use variable in subsequent expressions.


Bank Example Queries
s Find the names of all customers who have a loan and an account at
bank.

∏customer_name (borrower) ∩ ∏customer_name (depositor)

s Find the name of all customers who have a loan at the bank and the
loan amount

∏customer_name, loan_number, amount (borrower loan)


s Find all customers who have an account from at least the “Downtown”
and the Uptown” branches.
q Query 1

∏customer_name (σbranch_name = “Downtown” (depositor      account )) ∩

        ∏customer_name (σbranch_name = “Uptown” (depositor     account))

q Query 2

∏customer_name, branch_name (depositor      account)

        ÷ ρtemp(branch_name) ({(“Downtown” ), (“Uptown” )})

Note that Query 2 uses a constant relation.


s Find all customers who have an account at all branches located in
Brooklyn city.

∏customer_name, branch_name (depositor account)
÷ ∏branch_name (σbranch_city = “Brooklyn” (branch))


Extended RelationalAlgebraOperations
s Generalized Projection
s Aggregate Functions
s Outer Join


Generalized Projection
s Extends the projection operation by allowing arithmetic functions to be
used in the projection list.

∏ F ,F ,..., F (E )
1 2 n

s E is any relationalalgebra expression

s Each of F1, F2, …, Fn are are arithmetic expressions involving constants
and attributes in the schema of E.
s Given relation credit_info(customer_name, limit, credit_balance), find
how much more each person can spend:
∏customer_name, limit – credit_balance (credit_info)


Aggregate Functions and Operations
s Aggregation function takes a collection of values and returns a single
value as a result.
avg:  average value
min:  minimum value
max:  maximum value
sum:  sum of values
count:  number of values
s Aggregate operation in relational algebra

G1,G2 ,,Gn
ϑF ( A ),F ( A ,,F ( A ) (E )
1 1 2 2 n n

E is any relationalalgebra expression
q G1, G2 …, Gn is a list of attributes on which to group (can be empty)
q Each Fi is an aggregate function
q Each Ai is an attribute name


Aggregate Operation – Example
s Relation r:

A B C

α α 7
α β 7
β β 3
β β 10

s g sum(c) (r) sum(c )

27


Aggregate Operation – Example
s Relation account grouped by branchname:

branch_name account_number balance
Perryridge A102 400
Perryridge A201 900
Brighton A217 750
Brighton A215 750
Redwood A222 700

branch_name g sum(balance) (account)

branch_name sum(balance)
Perryridge 1300
Brighton 1500
Redwood 700


Aggregate Functions (Cont.)
s Result of aggregation does not have a name
q Can use rename operation to give it a name
q For convenience, we permit renaming as part of aggregate
operation

branch_name g sum(balance) as sum_balance (account)


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


Outer Join – Example
s Relation loan

loan_number branch_name amount
L170 Downtown 3000
L230 Redwood 4000
L260 Perryridge 1700

s Relation borrower

customer_name loan_number
Jones L170
Smith L230
Hayes L155


s Join

loan      borrower

loan_number branch_name amount customer_name
L170 Downtown 3000 Jones
L230 Redwood 4000 Smith

s Left Outer Join
    loan          borrower
L260 Perryridge 1700 null


s Right Outer Join
    loan        borrower

L155 null null Hayes
s Full Outer Join
    loan        borrower
L260 Perryridge 1700 null
L155 null null Hayes


Null Values
s It is possible for tuples to have a null value, denoted by null, for some
of their attributes
s null signifies an unknown value or that a value does not exist.

s The result of any arithmetic expression involving null is null.

s Aggregate functions simply ignore null values (as in SQL)

s For duplicate elimination and grouping, null is treated like any other
value, and two nulls are assumed to be the same (as in SQL)


Null Values
s Comparisons with null values return the special truth value: unknown
q If false was used instead of unknown, then    not (A < 5)
               would not be equivalent to               A >= 5
s Threevalued logic using the truth value unknown:
q OR: (unknown or true)         = true,
       (unknown or false)        = unknown
       (unknown or unknown) = unknown
q AND:   (true and unknown)         = unknown,
           (false and unknown)        = false,
           (unknown and unknown) = unknown
q NOT:  (not unknown) = unknown
q In SQL “P is unknown” evaluates to true if predicate P evaluates to
unknown
s Result of select  predicate is treated as false if it evaluates to unknown


Modification of the Database
s The content of the database may be modified using the following
operations:
q Deletion
q Insertion
q Updating
s All these operations are expressed using the assignment
operator.


Deletion
s 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.
s Can delete only whole tuples; cannot delete values on only
particular attributes
s A deletion is expressed in relational algebra by:
r ← r – E
where r is a relation and E is a relational algebra query.


Deletion Examples
s Delete all account records in the Perryridge branch.

account ← account – σ branch_name = “Perryridge” (account )

s   Delete all loan records with amount in the range of 0 to 50

loan ← loan – σ amount ≥ 0 and amount ≤ 50 (loan)

s   Delete all accounts at branches located in Needham.

r1 ← σ branch_city = “Needham” (account      branch )

r2 ← ∏ account_number, branch_name, balance (r1)

r3 ← ∏ customer_name, account_number (r2     depositor)
account ← account – r2
depositor ← depositor – r3


Insertion
s To insert data into a relation, we either:
q specify a tuple to be inserted
q write a query whose result is a set of tuples to be inserted
s in relational algebra, an insertion is expressed by:
r ←  r  ∪  E
where r is a relation and E is a relational algebra expression.
s The insertion of a single tuple is expressed by letting E  be a constant
relation containing one tuple.


Insertion Examples
s Insert information in the database specifying that Smith has $1200 in
account A973 at the Perryridge branch.

account ←  account  ∪  {(“A973”, “Perryridge”, 1200)}
depositor ←  depositor  ∪  {(“Smith”, “A973”)}

s  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.

r1 ← (σbranch_name = “Perryridge” (borrower    loan))
account ← account ∪ ∏loan_number, branch_name, 200 (r1)
depositor ← depositor ∪ ∏customer_name, loan_number (r1)


Updating
s A mechanism to change a value in a tuple without charging all values in
the tuple
s Use the generalized projection operator to do this task

r ← ∏ F1,F2 ,,Fl , ( r )
s Each F is either
i
q the I th attribute of r, if the I th attribute is not updated, or,
q if the attribute is to be updated Fi is an expression, involving only
constants and the attributes of r, which gives the new value for the
attribute


Update Examples

s Make interest payments by increasing all balances by 5 percent.

account ← ∏ account_number, branch_name, balance * 1.05 (account)

s  Pay all accounts with balances over $10,000 6 percent interest
     and pay all others 5 percent

account ←  ∏ account_number, branch_name, balance * 1.06 (σ BAL > 10000 (account ))
                    ∪  ∏ account_number, branch_name, balance * 1.05 (σBAL ≤ 10000 (account))


End of Chapter 2

Database System Concepts, 5th Ed.
©Silberschatz, Korth and Sudarshan
See www.dbbook.com for conditions on reuse

Figure 2.3. The branch relation


Figure 2.6: The loan relation


Figure 2.7: The borrower relation


Figure 2.9
Result of σbranch_name = “Perryridge” (loan)
Result of


Figure 2.10:
Loan number and the amount of the loan


Figure 2.11: Names of all customers who
have either an account or an loan


Figure 2.12:
Customers with an account but no loan


Figure 2.13: Result of borrower |X| loan


Figure 2.14


Figure 2.15


Figure 2.16


Figure 2.17
Largest account balance in the bank


Figure 2.18: Customers who live on the
same street and in the same city as
Smith


Figure 2.19: Customers with both an
account and a loan at the bank


Figure 2.20


Figure 2.21


Figure 2.22


Figure 2.23


Figure 2.24: The credit_info relation


Figure 2.25


Figure 2.26: The pt_works relation


Figure 2.27
The pt_works relation after regrouping


Figure 2.28


Figure 2.29


Figure 2.30
The employee and ft_works relations


Figure 2.31


Figure 2.32


Figure 2.33


Figure 2.34


Ch2

More Related Content

Viewers also liked (15)

Similar to Ch2 (20)

Recently uploaded (20)

Ch2