Temple University – CIS Dept. CIS616– Principles of Database Systems

Temple University – CIS Dept.CIS616– Principles of Database Systems

V. Megalooikonomou

Relational Model

(based on notes by Silberchatz,Korth, and Sudarshan and notes by C. Faloutsos at CMU)

Overview

history concepts Formal query languages

relational algebra rel. tuple calculus rel. domain calculus

History before: records, pointers, sets etc introduced by E.F. Codd (1923-2003) in 1970 revolutionary!!! first systems: 1977-8 (System R;

Ingres) Turing award in 1981

Concepts

Database: a set of relations (= tables)

rows: tuples columns: attributes (or keys) superkey, candidate key, primary

key

Example

Database:

STUDENTSsn Name Address

123 smith main str234 jones forbes ave

SSN c-id grade123 15-413 A234 15-413 B

Example: cont’d

Database:



rel. schema (attr+domains)

tuple

k-th attribute

(Dk domain)

Example: cont’d




instance

Example: cont’d




instance

•Di: the domain of the I-th attribute (eg., char(10)

•Formally: an instance is a subset of (D1 x D2 x …x Dn)

Example: cont’d

superkey (eg., ‘ssn , name’): determines record

cand. key (eg., ‘ssn’, or ‘st#’): minimal superkey (no subset of

it is a superkey) primary key: one of the cand. keys

Another example Example: if

Customer-name = {Jones, Smith, Curry, Lindsay}Customer-street = {Main, North, Park}Customer-city = {Harrison, Rye, Pittsfield}

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

Relations, tuples Relation Schema:

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

E.g. Customer-schema = (customer-name, customer-street, customer-city)

r(R) is a relation on the relation schema RE.g. customer (Customer-schema)

Relations are unordered Order of tuples is irrelevant (tuples may be stored in an

arbitrary order)

Database A database consists of multiple relations Information about an enterprise is broken up into parts, with each

relation storing one part of the information

E.g.: account : stores information about accounts depositor : stores information about which customer owns which account customer : stores information about customers

Storing all information as a single relation such as bank(account-number, balance, customer-name, ..)results in

repetition of information (e.g. two customers own an account) the need for null values (e.g. represent a customer without an account)

Normalization theory (discuss later) deals with how to design relational schemas

Overview



Formal query languages How do we collect information? Eg., find ssn’s of people in cis331 (recall: everything is a set!) One solution: Relational algebra, i.e.,

set operators (procedural language) Q1: Which operators?? Q2: What is a minimal set of

operators?

. . . set union U set difference ‘-’

Relational operators

Example:

FT-STUDENTSsn Name

129 peters main str239 lee 5th ave

PT-STUDENTSsn Name Address


Q: find all students (part or full time)

A: PT-STUDENT union FT-STUDENT

Observations:

two tables are ‘union compatible’ if they have the same attributes (i.e., same arity: number of attributes and same ‘domains’)

Q: how about intersection ?

U

Observations:

A: redundant: STUDENT intersection STAFF = STUDENT - (STUDENT - STAFF)

STUDENT STAFF

. . . set union set difference ‘-’


U

Other operators?

E.g., find all students on ‘Main street’

A: ‘selection’)('' STUDENTstrmainaddress



Other operators?

Notice: selection (and rest of operators) expect tables, and produce tables

--> can be cascaded!! For selection, in general:

)(RELATIONcondition

Selection - examples

Find all ‘Smiths’ on ‘Forbes Ave’

)('''' STUDENTaveForbesaddressSmithname

‘condition’ can be any boolean combination of ‘=‘, ‘>’, ‘>=‘, ...

selection . . set union set difference R - S


)(Rcondition

R U S

selection picks rows - how about columns?

A: ‘projection’ - eg.: finds all the ‘ssn’ - removing

duplicates


)(STUDENTssn



Cascading: ‘find ssn of students on ‘forbes ave’


))(( '' STUDENTaveforbesaddressssn



selection projection . set union set difference R - S


)(Rcondition)(Rlistatt

R U S

Are we done yet?Q: Give a query we can not answer

yet!


A: any query across two or more tables,eg., ‘find names of students in cis351’

Q: what extra operator do we need??A: surprisingly, the cartesian product is

enough!




TAKESSSN c-id grade

123 cis331 A234 cis331 B

Cartesian product

E.g., dog-breeding: MALE x FEMALE gives all possible couples

MALEnamespikespot

FEMALEnamelassieshiba

x =M.name F.namespike lassiespike shibaspot lassiespot shiba

so what?

Eg., how do we find names of students taking cis351?



TAKESSSN c-id grade

123 cis331 A234 cis331 B

Cartesian product

A:)(......... .. TAKESxSTUDENTssnTAKESssnSTUDENT

Ssn Name Address ssn cid grade123 smith main str 123cis331 A234jones forbes ave 123cis331 A123 smith main str 234cis331 B234jones forbes ave 234cis331 B

Cartesian product


)))(((.. ..351 TAKESxSTUDENTssnTAKESssnSTUDENTciscid


)

)))(((

(

..351 TAKESxSTUDENTssnTAKESssnSTUDENTciscid

name

selection projection cartesian product MALE x

FEMALE set union set difference R - S

FUNDAMENTALRelational operators

)(Rcondition)(Rlistatt

R U S

Relational ops

Surprisingly, they are enough, to help us answer almost any query we want!!

derived operators, for convenience set intersection join (theta join, equi-join, natural join) ‘rename’ operator division

)(' RRSR

Joins

Equijoin: SR bSaR .. )(.. SRbSaR

Cartesian product

A:


)(......... .. TAKESxSTUDENTssnTAKESssnSTUDENT

Joins

Equijoin:

theta-joins: generalization of equi-join - any

condition

SR bSaR ..

SR

)(.. SRbSaR

Joins

very popular: natural join: R S like equi-join, but it drops

duplicate columns: STUDENT(ssn, name, address) TAKES(ssn, cid, grade)

Joins

nat. join has 5 attributes TAKESSTUDENT

TAKESSTUDENT ssnTAKESssnSTUDENT ..


equi-join: 6

Natural Joins - nit-picking

if no attributes in common between R, S:

nat. join -> cartesian product:

Overview - rel. algebra

fundamental operators derived operators

joins etc rename division

examples

rename op.

Q: why? A:

Shorthand (BEFORE can be a relational algebra expression)

self-joins; … for example, find the grand-

parents of ‘Tom’, given PC(parent-id, child-id)

)(BEFOREAFTER

rename op.

PC(parent-id, child-id) PCPC

PCp-id c-idMary TomPeter MaryJohn Tom


rename op.

first, WRONG attempt:

(why? how many columns?)

Second WRONG attempt:

PCPC

PCPC idpPCidcPC ..

rename op.

we clearly need two different names for the same table - hence, the ‘rename’ op.

PCPC idpPCidcPCPC ..11 )(




examples

Division

Rarely used, but powerful. Suited for queries that include the

phrase “for all” Example: find suspicious suppliers,

i.e., suppliers that supplied all the parts in A_BOMB

Division

SHIPMENTs# p#s1 p1s2 p1s1 p2s3 p1s5 p3

ABOMBp#p1p2

BAD_Ss#s1

Division

Observations: ~reverse of cartesian product

It can be derived from the 5 fundamental operators (!!)

How?

Division

Answer:

]))([()( )()()( rsrrsr SRSRSR

]))([( )()( rsrSRSR gives those tuples t in such that for some tuple u in S, tu not in R.

)()( rSR




examples

Sample schema



CLASSc-id c-name unitscis331 d.b. 2cis321 o.s. 2

TAKESSSN c-id grade

123cis331 A234cis331 B

find names of students that take cis351

Examples

find names of students that take cis351

)]([ 351 TAKESSTUDENTcisidcname

Sample schemafind course names of ‘smith’




TAKESSSN c-id grade

123cis331 A234cis331 B

Examples

find course names of ‘smith’

)]

([ ''

CLASSTAKESSTUDENT

smithnamenamec

Examples

find ssn of ‘overworked’ students, ie., that take cis331, cis342,

cis350

Examples

find ssn of ‘overworked’ students, ie., that take cis331, cis342, cis350:

almost correct answer:

)(

)(

)(

350

342

331

TAKES

TAKES

TAKES

namec

namec

namec

Examples

find ssn of ‘overworked’ students, ie., that take cis331, cis342, cis350

- Correct answer:

)]([

)]([

)]([

350

342

331

TAKES

TAKES

TAKES

namecssn

namecssn

namecssn

Examples

find ssn of students that work at least as hard as ssn=123

(ie., they take all the courses of ssn=123, and maybe more)

Sample schema




TAKESSSN c-id grade

123cis331 A234cis331 B

Examples

find ssn of students that work at least as hard as ssn=123 (ie., they take all the courses of ssn=123, and maybe more

)]([)]([ 123, TAKESTAKES ssnidcidcssn

Conclusions

Relational model: only tables (‘relations’)

relational algebra: powerful, minimal:

5 operators can handle almost any query!

most non-trivial op.: join

The bank database


V. Megalooikonomou

Relational Model II


Overview



Extended Relational-Algebra-Operations

Generalized Projection Outer Join Aggregate Functions

Generalized Projection Extends the projection operation by allowing

arithmetic functions to be used in the projection list

F1, F2, …, Fn(E)

E is any relational-algebra expression

Each of F1, F2, …, Fn are arithmetic expressions involving constants and attributes in the schema of E.

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

Aggregation function takes a collection of values and returns a single value as a result ?

Aggregate Functions and Operations

Aggregation function takes a collection of values and returns a single value as a result

avg: average valuemin: minimum valuemax: maximum valuesum: sum of valuescount: number of values

Aggregate operation in relational algebra

G1, G2, …, Gn g F1( A1), F2( A2),…, Fn( An) (E) E is any relational-algebra expression G1, G2 …, Gn is a list of attributes on which to group (can be empty) Each Fi is an aggregate function Each Ai is an attribute name

Aggregate Operation – Example

Relation r :A B

C

7

7

3

10

g sum(c) (r)sum-C

27

Aggregate Operation – Example

Relation account grouped by branch-name:

branch-name g sum(balance) (account)

branch-name account-number balance

PerryridgePerryridgeBrightonBrightonRedwood

A-102A-201A-217A-215A-222

400900750750700

branch-name balance

PerryridgeBrightonRedwood

13001500700

Aggregate Functions (Cont.)

Result of aggregation does not have a name Use rename operation For convenience, we permit renaming

as part of aggregate operation

branch-name g sum(balance) as sum-balance (account)

Outer Join An extension of the join operation that

avoids loss of information Computes the 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 precise meaning of comparisons with nulls later

Outer Join – Example Relation loan

loan-number amount

L-170L-230L-260

300040001700

Relation borrower

customer-name loan-number

JonesSmithHayes

L-170L-230L-155

branch-name

DowntownRedwoodPerryridge

Outer Join – Example Inner Join

loan borrower

loan borrower

Left Outer Join

loan-number amount

L-170L-230

30004000

customer-name

JonesSmith

branch-name

DowntownRedwood

loan-number amount

L-170L-230L-260

300040001700

customer-name

JonesSmithnull

branch-name

DowntownRedwoodPerryridge

Outer Join – Example Right Outer Join

loan borrower

loan borrower

Full Outer Join

loan-number amount

L-170L-230L-155

30004000null

customer-name

JonesSmithHayes

branch-name

DowntownRedwoodnull

loan-number amount

L-170L-230L-260L-155

300040001700null

customer-name

JonesSmithnullHayes

branch-name

DowntownRedwoodPerryridgenull

Null Values It is possible for tuples to have a null value, denoted by

null, for some of their attributes null signifies unknown value or a value that does not exist The result of any arithmetic expression involving null is null Aggregate functions ignore null values

An arbitrary decision. Could have returned null as result instead Follow semantics of SQL in its handling of null values

For duplicate elimination and grouping, null is treated like any other value, and two nulls are assumed to be the same

Alternative: assume each null is different from each other Both arbitrary decisions, we follow SQL

Null Values Comparisons with null values return the special

truth value unknown If false was used instead of unknown, then not (A < 5)

would not be equivalent to A >= 5 Three-valued logic using the truth value

unknown: OR: (unknown or true) = true,

(unknown or false) = unknown (unknown or unknown) = unknown

AND: (true and unknown) = unknown, (false and unknown) = false, (unknown and unknown) = unknown

NOT: (not unknown) = unknown In SQL “P is unknown” evaluates to true if predicate P

evaluates to unknown Result of select predicate is treated as false if it

evaluates to unknown

Modification of the Database

The content of the database may be modified using the following operations: Deletion Insertion Updating

All these operations are expressed using the assignment operator

The bank database

Deletion Expressed similarly to a query Instead of displaying tuples, 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 – Ewhere r is a relation and E is a relational algebra query.

Deletion Examples 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 0and amount 50 (loan)

Delete all accounts at branches located in Needham

r1 branch-city = “Needham” (account branch)

r2 branch-name, account-number, balance (r1)

r3 customer-name, account-number (r2 depositor)

account account – r2

depositor depositor – r3

Insertion To insert data into a relation, we either:

specify a tuple to be inserted write a query whose result is a set of tuples to be

inserted in relational algebra, an insertion is

expressed by?

Insertion To insert data into a relation, we either:

specify a tuple to be inserted 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

Insertion of a single tuple: let E be a constant relation containing one tuple

Insertion Examples

Insert information in the database specifying that Smith has $1200 in account A-973 at the Perryridge branch.

account account {(“Perryridge”, A-973, 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.r1 (branch-name = “Perryridge” (borrower loan))

account account (branch-name, loan-number(r1)) x {(200)})

OR account account branch-name, account-number,200 (r1)

depositor depositor customer-name, loan-number,(r1)

Updating A mechanism to change a value in a tuple

without charging all values in the tuple Use the generalized projection operator

r F1, F2, …, FI, (r)

Each F, is either the i-th attribute of r, if the i-th attribute is not updated, or, 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

Make interest payments by increasing all balances by 5 percent

account AN, BN, BAL * 1.05 (account)where AN, BN and BAL stand for account-number, branch-name and balance, respectively

Pay all accounts with balances over $10,0006 percent interest and pay all others 5 percent

account AN, BN, BAL * 1.06 ( BAL 10000 (account)) AN, BN, BAL * 1.05 (BAL 10000 (account))

Views … if it is not desirable for all users to see the

entire logical model (i.e., all the relations stored in the database)

A person who needs to know a customer’s loan number but has no need to see the loan amount can see the relation:customer-name, loan-number (borrower loan)

Any relation that is not of the conceptual model but is made visible to a user as a “virtual relation” is called a view.

View Definition A view is defined using the create view statement

which has the form

create view v as <query expression>

where <query expression> is any legal relational algebra query expression.

The view name, v, can be used to refer to the virtual relation

View definition creating a new relation by evaluating the query expression. Rather, a view definition causes the saving of an expression to be substituted into queries using the view

Materialized views

View Examples Consider the view (named all-customer) consisting

of branches and their customerscreate view all-customer as

branch-name, customer-name (depositor account)

branch-name, customer-name (borrower loan)

We can find all customers of the Perryridge branch by writing:

customer-name

(branch-name = “Perryridge” (all-customer))

Updates Through View Database modifications expressed as views must be

translated to modifications of the actual relations in the database

E.g., a person who needs to see all loan data in the loan relation except amount. The view is defined as: create view branch-loan as

branch-name, loan-number (loan)

Since we allow a view name to appear wherever a relation name is allowed, the person may write:

branch-loan branch-loan {(“Perryridge”, L-37)}

Updates Through Views (Cont’d.)

The previous insertion must be represented by an insertion into the actual relation loan from which the view branch-loan is constructed

An insertion into loan requires a value for amount. The insertion can be dealt with by either:

rejecting the insertion and returning an error message to the user

inserting a tuple (“L-37”, “Perryridge”, null ) into the loan relation Some updates through views are impossible to translate

into database relation updates create view v as branch-name = “Perryridge” (account)) v v (L-99, Downtown, 23)

Others cannot be translated uniquely all-customer all-customer (Perryridge, John)

Have to choose loan or account, and create a new loan/account number!

Views Defined Using Other Views

One view may be used in the expression defining another view

A view relation v1 is said to depend directly on a view relation v2 if v2 is used in the expression defining v1

A view relation v1 is said to depend on view relation v2 if either v1 depends directly to v2 or there is a path of dependencies from v1 to v2

A view relation v is said to be recursive if it depends on itself

View Expansion

Define the meaning of views in terms of other views… Let view v1 be defined by an expression e1 that may itself

contain uses of view relations View expansion of an expression repeats the following

replacement step:

repeatFind any view relation vi in e1

Replace the view relation vi by the expression defining vi until no more view relations are present in e1

This loop will terminate as long as …?

View Expansion

Define the meaning of views in terms of other views… Let view v1 be defined by an expression e1 that may itself

contain uses of view relations View expansion of an expression repeats the following

replacement step:

repeatFind any view relation vi in e1

Replace the view relation vi by the expression defining vi until no more view relations are present in e1

This loop will terminate as long as the view definitions are not recursive

General Overview - rel. model



Overview - detailed

Relational tuple calculus Why do we need it? Details Examples Equivalence with rel. algebra More examples; ‘safety’ of

expressions Rel. domain calculus + QBE

Motivation

Q: weakness of rel. algebra? A: procedural

describes the steps (i.e., ‘how’) … still useful, for query optimization

though

Solution: rel. calculus describes what we want two equivalent flavors:

‘tuple’ calculus and ‘domain’ calculus

basis for SQL and QBE, resp.

Rel. tuple calculus (RTC)

first order logic

)}(|{ tPt

}|{ STUDENTtt

‘Give me tuples ‘t’, satisfying predicate P – e.g.:

..or Tuple Relational Calculus

A nonprocedural query language, where each query is of the form

{t | P (t) } It is the set of all tuples t such that predicate P

is true for t t is a tuple variable, t [A] denotes the value of

tuple t on attribute A t r denotes that tuple t is in relation r P is a formula similar to that of the predicate

calculus

Details

symbols allowed:

quantifiers: “for all”, “there exists”

Atom:

),(,

,,,,,,

,,,

,

]'[][

][

attrsattrt

constattrt

TABLEt

Specifically

Formula: Atom

if P1, P2 are formulas, so are

if P(s) is a formula, so are

...21;21 PPPP

))((

))((

sPs

sPs

Specifically

Reminders: DeMorgan implication: double negation:

))(())(( sPTABLEssPTABLEs

)21(21 PPPP

2121 PPPP

‘every human is mortal : no human is immortal’

Reminder: our Mini-U db




TAKESSSN c-id grade

123cis331 A234cis331 B

Examples

find all student records

}|{ STUDENTtt

output tuple of type ‘STUDENT’

Examples

(selection) find student record with ssn=123

Examples


}123][|{ ssntSTUDENTtt

Examples

(projection) find name of student with ssn=123

}123][|{ ssntSTUDENTtt

Examples


])}[][

123][(|{

namesnamet

ssnsSTUDENTst

‘t’ has only one column

‘Tracing’

])}[][

123][(|{

namesnamet

ssnsSTUDENTst



s

Nameaaaa….jones…zzzz

t

Examples cont’d

(union) get records of both PT and FT students

Examples cont’d


}_

_|{

STUDENTPTt

STUDENTFTtt

Examples

difference: find students that are not staff

(assuming that STUDENT and STAFF are union-compatible)

Examples


}

|{

STAFFt

STUDENTtt

Cartesian product

e.g., dog-breeding: MALE x FEMALE gives all possible couples

MALEnamespikespot



Cartesian product

find all the pairs of (male, female)

]}[][

][][

|{

namefnameft

namemnamemt

FEMALEf

MALEmt

‘Proof’ of equivalence

rel. algebra <-> rel. tuple calculus

Overview - detailed

rel. tuple calculus why? details examples equivalence with rel. algebra more examples; ‘safety’ of

expressions re. domain calculus + QBE

More examples

join: find names of students taking cis351





TAKESSSN c-id grade

123 cis331 A234 cis331 B

More examples


)}351][

][][

][][(

|{

cisidce

namesnamet

ssnessnsTAKESe

STUDENTst

More examples


)}351][

][][

][][(

|{

cisidce

namesnamet

ssnessnsTAKESe

STUDENTst

projection

selection

join

More examples

3-way join: find names of students taking a 2-unit course




CLASSc-id c-name units15-413 s.e. 215-412 o.s. 2

TAKESSSN c-id grade

123 15-413 A234 15-413 B

More examples


)}2][

][][

][][

][][(

|{

unitsc

namesnamet

idccidce

ssnessnsCLASSc

TAKESeSTUDENTst

selection

projection

join

More examples

3-way join: find names of students taking a 2-unit course - in rel. algebra??

))

(( 2

CLASSTAKESSTUDENTunitsname

Even more examples:

self -joins: find Tom’s grandparent(s)



Even more examples:


)}""][

][][

][][(

|{

Tomidcq

idptidpp

idpqidcp

PCqPCpt

Hard examples: DIVISION

find suppliers that shipped all the ABOMB parts


ABOMBp#p1p2

BAD_Ss#s1



])))}#[]#[

]#[]#[

(

((|{

ppps

ssst

SHIPMENTs

ABOMBppt

General pattern

three equivalent versions: 1) if it’s bad, he shipped it

2)either it was good, or he shipped it

3) there is no bad shipment that he missed

))}(((|{ tPABOMBppt

))}(((|{ tPABOMBppt

))}(((|{ tPABOMBppt

More on division

find (SSNs of) students that take all the courses that ssn=123 does (and maybe even more)find students ‘s’ so that if 123 takes a course => so does ‘s’

More on division

find students that take all the courses that ssn=123 does (and maybe even more)

)}

])[][1

][][1

(1

)123][((|{

ssnossnt

idctidct

TAKESt

ssntTAKEStto

Safety of expressions

FORBIDDEN:

It has infinite output!! Instead, always use

}|{ STUDENTtt

}....|{ TABLESOMEtt

Safety of expressions Possible to write tuple calculus expressions that

generate infinite relations, e.g., {t | t r } results in an infinite relation if the domain of any attribute of relation r is infinite

To guard against the problem, we restrict the set of allowable expressions to safe expressions.

An expression {t | P (t) } in the tuple relational calculus is safe if every component of t appears in one of the relations, tuples, or constants that appear in P

More examples: 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 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 | s loan (t [loan-number] = s [loan-number]

s [amount] 1200}

Notice that a relation on schema [loan-number] is implicitly defined by the query

Example Queries Find the names of all customers having a loan, an

account, or both at the bank{t | s borrower(t[customer-name] = s[customer-name]) u depositor(t[customer-name] = u[customer-name])

Find the names of all customers who have a loan and an account at the bank

{t | s borrower(t[customer-name] = s[customer-name]) u depositor(t[customer-name] = u[customer-name])

Example Queries Find the names of all customers having a loan at the

Perryridge branch{t | s borrower(t[customer-name] = s[customer-name]

u loan(u[branch-name] = “Perryridge” u[loan-number] = s[loan-number]))}

Find the names of all customers who have a loan at the Perryridge branch, but no account at any branch of the bank{t | s borrower(t[customer-name] = s[customer-name] u loan(u[branch-name] = “Perryridge” u[loan-number] = s[loan-number])) not v depositor (v[customer-name] = t[customer-name]) }

Example Queries Find the names of all customers having a loan from

the Perryridge branch, and the cities they live in

{t | s loan(s[branch-name] = “Perryridge” u borrower (u[loan-number] = s[loan-number] t [customer-name] = u[customer-name]) v customer (u[customer-name] = v[customer-name]

t[customer-city] = v[customer-city])))}

Example Queries

Find the names of all customers who have an account at all branches located in Brooklyn:

{t | c customer (t[customer.name] = c[customer-name]) s branch(s[branch-city] = “Brooklyn” u account ( s[branch-name] = u[branch-name] s depositor ( t[customer-name] = s[customer-name] s[account-number] = u[account-number] )) )}


V. Megalooikonomou

Relational Model III


Overview



General Overview - rel. model



Overview - detailed

rel. tuple calculus why? details examples equivalence with rel. algebra more examples; ‘safety’ of

expressions rel. domain calculus + QBE


FORBIDDEN:

It has infinite output!! Instead, always use

}|{ STUDENTtt

}....|{ TABLESOMEtt

Safety of expressions Possible to write tuple calculus expressions that

generate infinite relations, e.g., {t | t r } results in an infinite relation if the domain of any attribute of relation r is infinite

To guard against the problem, we restrict the set of allowable expressions to safe expressions.

An expression {t | P (t) } in the tuple relational calculus is safe if every component of t appears in one of the relations, tuples, or constants that appear in P

More examples: 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 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 | s loan (t [loan-number] = s [loan-number]

s [amount] 1200}

Notice that a relation on schema [loan-number] is implicitly defined by the query


account, or both at the bank{t | s borrower(t[customer-name] = s[customer-name]) u depositor(t[customer-name] = u[customer-name])

Find the names of all customers who have a loan and an account at the bank

{t | s borrower(t[customer-name] = s[customer-name]) u depositor(t[customer-name] = u[customer-name])

Example Queries Find the names of all customers having a loan at the

Perryridge branch{t | s borrower(t[customer-name] = s[customer-name]

u loan(u[branch-name] = “Perryridge” u[loan-number] = s[loan-number]))}

Find the names of all customers who have a loan at the Perryridge branch, but no account at any branch of the bank{t | s borrower(t[customer-name] = s[customer-name] u loan(u[branch-name] = “Perryridge” u[loan-number] = s[loan-number])) not v depositor (v[customer-name] = t[customer-name]) }

Example Queries Find the names of all customers having a loan from

the Perryridge branch, and the cities they live in

{t | s loan(s[branch-name] = “Perryridge” u borrower (u[loan-number] = s[loan-number] t [customer-name] = u[customer-name]) v customer (u[customer-name] = v[customer-name]

t[customer-city] = v[customer-city])))}

Example Queries


{t | c customer (t[customer.name] = c[customer-name]) s branch(s[branch-city] = “Brooklyn” u account ( s[branch-name] = u[branch-name] s depositor ( t[customer-name] = s[customer-name] s[account-number] = u[account-number] )) )}

General Overview

relational model Formal query languages


Overview - detailed

rel. tuple calculus dfn details equivalence to rel. algebra

rel. domain calculus + QBE

Rel. domain calculus (RDC)

Q: why? A: slightly easier than RTC,

although equivalent - basis for QBE idea: domain variables (w/ F.O.L.) –

e.g.: ‘find STUDENT record with

ssn=123’

Rel. Dom. Calculus

}123,,|,,{ sSTUDENTansans

find STUDENT record with ssn=123’

Details

Like R.T.C - symbols allowed:

quantifiers

),(,

,,,,,,

,,,

,

Details

but: domain (= column) variables, as opposed to tuple variables, e.g.:

STUDENTans ,,

ssnname address

Domain Relational Calculus

A nonprocedural query language equivalent in power to the tuple relational calculus

Each query is an expression of the form:

{ x1, x2, …, xn | P (x1, x2, …, xn)}

x1, x2, …, xn represent domain variables P represents a formula similar to that of the

predicate calculus

Example queries Find the branch-name, loan-number, and amount for loans of

over $1200

{ l, b, a | l, b, a loan a > 1200} Find the names of all customers who have a loan of over $1200

{ c | l, b, a ( c, l borrower l, b, a loan a > 1200)}

Find the names of all customers who have a loan from the Perryridge branch and the loan amount:

{ c, a | l ( c, l borrower b( l, b, a loan b = “Perryridge”))}

or { c, a | l ( c, l borrower l, “Perryridge”, a loan)}


account, or both at the Perryridge branch: { c | l ({ c, l borrower

b,a ( l, b, a loan b = “Perryridge”)) a ( c, a depositor b,n ( a, b, n account b = “Perryridge”))}


{ c | n ( c, s, n customer) x,y,z ( x, y, z branch y = “Brooklyn”)

a,b ( x, y, z account c,a depositor)}





TAKESSSN c-id grade

123cis331 A234cis331 B

Examples

find all student records

}|{ STUDENTtt

},,|,,{ STUDENTansans

RTC:

Examples


Examples


}123][|{ ssntSTUDENTttRTC:

},,123|,,123{ STUDENTanan

or

}123,,|,,{ sSTUDENTansans

Examples


},,123|{ STUDENTann

Examples


}),,123(|{ STUDENTanan

need to ‘restrict’ “a”

])}[][

123][(|{

namesnamet

ssnsSTUDENTst

RTC:

Examples cont’d


}_

_|{

STUDENTPTt

STUDENTFTtt

RTC:

Examples cont’d


}_,,

_,,|,,{

STUDENTPTans

STUDENTFTansans

Examples


RTC:

}

|{

STAFFt

STUDENTtt

Examples


},,

,,|,,{

STAFFans

STUDENTansans

Cartesian product

eg., dog-breeding: MALE x FEMALE gives all possible couples

MALEnamespikespot



Cartesian product

find all the pairs of (male, female) - RTC:

]}[][

][][

|{

namefnameft

namemnamemt

FEMALEf

MALEmt

Cartesian product

find all the pairs of (male, female) - RDC:

}

|,{

FEMALEf

MALEmfm

‘Proof’ of equivalence

rel. algebra <-> rel. domain calculus

<-> rel. tuple calculus

Overview - detailed

rel. domain calculus why? details examples equivalence with rel. algebra more examples; ‘safety’ of

expressions

More examples





CLASSc-id c-name units15-413 s.e. 215-412 o.s. 2

TAKESSSN c-id grade

123 15-413 A234 15-413 B

More examples

join: find names of students taking cis351 - in RTC

)}351][

][][

][][(

|{

cisidce

namesnamet

ssnessnsTAKESe

STUDENTst

More examples

join: find names of students taking cis351 - in RDC

)},351,

,,(|{

TAKESgciss

STUDENTansgasn

Sneak preview of QBE:

)},351,

,,(|{

TAKESgciss

STUDENTansgasn

STUDENTSsn Name Address_x P.

TAKESSSN c-id grade_x cis351

Sneak preview of QBE:

STUDENTSsn Name Address_x P.

TAKESSSN c-id grade_x cis351

very user friendly heavily based on RDC very similar to MS Access interface

More examples

3-way join: find names of students taking a 2-unit course - in RTC:

)}2][

][][

][][

][][(

|{

unitsc

namesnamet

idccidce

ssnessnsCLASSc

TAKESeSTUDENTst

selection

projection

join





gradeTAKESSSN c-id

123cis331 A234cis331 B

_x .P

_x _y

_y 2

More examples


}2,,

,,

,,

.............|{

CLASScnc

TAKESgcs

STUDENTans

n

More examples


)}

2,,

,,

,,

(,,,,|{

CLASScnc

TAKESgcs

STUDENTans

cngcasn

Even more examples:




Even more examples:


)}""][

][][

][][(

|{

Tomidcq

idptidpp

idpqidcp

PCqPCpt

Even more examples:


)}""][

][][

][][(

|{

Tomidcq

idptidpp

idpqidcp

PCqPCpt

)}"",

,(|{

PCTomp

PCpgpg

Even more examples:


)}"",

,(|{

PCTomp

PCpgpg




ABOMBp#p1p2

BAD_Ss#s1



])))}#[]#[

]#[]#[

(

((|{

ppps

ssst

SHIPMENTs

ABOMBppt



])))}#[]#[

]#[]#[

(

((|{

ppps

ssst

SHIPMENTs

ABOMBppt

)},

(|{

SHIPMENTps

ABOMBpps

More on division


)}

])[][1

][][1

(1

)123][((|{

ssnossnt

idctidct

TAKESt

ssntTAKEStto

More on division


))})',,('

),,123((|{

TAKESgcsg

TAKESgcgcs


similar to RTC FORBIDDEN:

},,|,,{ STUDENTansans

Safety of Expressions

{ x1, x2, …, xn | P(x1, x2, …, xn)}

is safe if all of the following hold:1. All values that appear in tuples of the expression are values from dom a(P) (that is, the values appear either in P or in a tuple of a relation mentioned in P )

2. For every “there exists” subformula of the form x (P1(x)), the subformula is true if and only if there is a value x in dom (P1) such that P1(x) is true.

3. For every “for all” subformula of the form x (P1 (x)), the subformula is true if and only if P1(x) is true for all values x from dom (P1).

Overview - detailed

rel. domain calculus + QBE dfn details equivalence to rel. algebra

Temple University – CIS Dept. CIS616– Principles of Database Systems

Documents

Transcript of Temple University – CIS Dept. CIS616– Principles of Database Systems