Date post: | 19-Dec-2015 |
Category: |
Documents |
View: | 230 times |
Download: | 0 times |
1
Relational Query LanguagesRelational Query Languages
Relational Algebra (procedural)
Relational Calculus (non-procedural)
Relational LanguagesRelational Languages
• Relational Algebra (procedural)– defines operations on tables
• Relational Calculus (declarative)– based on first-order predicate calculus
• Every relational algebra query can be translated to relational calculus
• Every safe relational calculus query can be translated to relational algebra.
• Any language that is atleast as expressive as relational algebra is said to be relationally complete.
3
Relational Algebra OperatorsRelational Algebra Operators
• Select: given a relation R and a predicate P, select tuples from R that satisfy P.
• Project: given a relation R and a subset of its attributes X, return a relation which is the same as R except that all columns not in X are left out.
• Rename: given a relation R and a name N, return a relation that is exactly the same as R except that it has a name N.
• Cartesian Product: Given 2 relations R1and R2,.return a relation R3 whose tuples are the concatenation of tuples in R1 and R2
• Union: Given relations R1 and R2, return a relation R3 which contains all tuples in R1 and R2
• Set Difference: Given relations R1 and R2, return a relation R3 containing all tuples in R1 that are not in R2
4
• selection cond(R) or select[selection cond]R
• Example: Employee(name, dept, sal)
Employee select [sal > 20,000] Employee
name dept saljane pharmacy 30,000
jack hardware 30,000
jill pharmacy 75,000
select [(dept = toy) or (sal < 20,000)] Employee
name dept sal
joe toy 20,000
bill toy 12,000
Selection OperationSelection Operation
name dept sal
jane pharmacy 30,000
jack hardware 30,000
jill pharmacy 75,000
joe toy 20,000
bill toy 12,000
5
ProjectionProjection
• Proj [list of attr of R] (R ) or list of attr of R (R)
R A B C S A C
Jane Toy 10,000 Jane Toy
Jim Toy 20,000 John Complaint
June Complaint 20,000
Proj[A]R Proj[CB]R
A C B
Jane 10,000 Toy
Jim 20,000 Complaint
June 20,000 Toy
6
Cartesian ProductCartesian Product
• Denoted by R x S
R: A B C S: A D
joe toy 10K joe jill
jack com 20K jack jill
RxS: R.A B C S.A D
joe toy 10K joe jill
joe toy 10K jack jill
jack com 20K joe jill
jack com 20K jack jill
• Notice attribute naming strategy to disambiguate attribute names
attributes get the name, R.A, where A is attrib name, and R is the relation name from which attrib originates. If there is no possible ambiguity, relation name is dropped!
7
Set DifferenceSet Difference
• Denoted by R - S( Illegal if R & S have different numbers of attributes or if respective domains
mismatch!)
R A B S A C
Jane Toy Jane Toy
Jim Toy John Complaint
June Complaint
R - S = A B Jim Toy
June Complaint
Note attributes in resulting relation take name from the first relation
8
Rename OperatorRename Operator
• Strategy used to disambiguate attribute names:– For union and set difference operators, the resulting relation takes
the attribute names of the first relation
– For cartesian product, attributes are named as Relation-name.attribute-name, where Relation name refers to the relation from which the attribute originally came.
– Strategy will not disambiguate when the same relation appears multiple times in the relational query.
• Let R(A,B) be a relation. Consider R x R ---- what to name the attributes of the resulting relation?
• Define a rename operator:• denoted by rename[N]R or by N(R)
– returns a relation which is exactly same as R except it has the name N
9
Rename OperatorRename Operator
• Consider relation Employee(name, dept, sal)
• List all the employees who work in the same department as Jill
• We first find the department(s) for which Jill works
– Proj[dept](select[name = Jill] Employee) ---list of departments for which Jill works
• To find out about all Employees working for this department, we need to reference the Employee table again:
– select[P] ( Employee x Proj[dept](select[name = Jill] Employee) )
– where P is a selection predicate which requires dept values to be equal.
• If we use Employee.dept in P it is ambiguous which instance of Employee relation in the query the attribute refers to.
• To disambiguate, use rename operator:
• Proj[Employee.name](select[Employee.dept = Employee2.dept]
Employee x (Proj[dept] (select[name = Jill](
rename[Employee2](Employee))))
10
Formal Definition of Relational AlgebraFormal Definition of Relational Algebra
• Basic Expressions:– Relation in a database
– Constant Relations
• General Expressions: constructed from basic ones. Let E1 and E2 be relational algebra expressons. Then the following are also expressions:– E1 U E2, if arity of E1 = E2 and corresponding attributes are of the
same type
– E1 - E2, if arity of E1 = E2 and corresponding attributes are of the same type
– E1 x E2, if attributes in E1 and E2 have different names
– Select[P](E1), where P is a predicate on attributes in E1
– Proj[S](E1), where S is a list of some attributes in E1
– rename[X](E1), where X is a new name for relation E1
11
AdditionalAdditional OperatorsOperators
Basic Relational Algebra operators are like assembly language.
Define more powerful operators that make the task of writing relational algebra queries easier
Each of these operators can be expressed in relational algebra and do not increase the expressibility of the language
Example: Intersection
R S = R - (R - S)
= { t | t R & t S }
12
R join condition S = select[ join condition] (R x S)
join condition is of the form:
<condition> AND <condition> AND <condition>
where each condiition is of the form Ai Bj, where
– Ai is attribute of R
– Bj is attribute of S
– is a comparison operator {=, <, >, <=, >=, <>}
JoinsJoins
Example:
E(emp, dept) M(dept, mgr)
List all employees and their managers.
Proj[emp, mgr](select[E.dept = M.dept] (ExM))
can be represented as:
Proj[emp,mgr] ( E E.dept = M.dept M )
13
Types of JoinsTypes of Joins
• Theta-Join: if a join condition uses some comparison operator other than equality.
– E.g., list names of all managers who manage departments other than Jill’s– Proj[mgr]( select[emp = Jill](E ) (E.dept M.dept) M)
• Equi-Join: if join conditions use only equality operator.– E.g., list the manager’s name of Jill’s department– Proj[mgr]( select[emp = Jill](E ) (E.dept M.dept) M)
• Natural Join: special type of equi-join..– Let R and S be relations. Let attributes of R and S be denoted by R and S
respectively. – Denote by R U S the union of the list of attributes of R and S– Let list of attributes common to both R and S be {A1, A2, …, An}– Natural join of R and S (denoted R S) is:– Proj[R U S ] (R R.A1 = S.A1 and R.A2 = S.A2 and … and R.An = S.An S)– E.g., Proj[mgr]( select[emp = Jill](E ) M)
14
Assignment OperatorAssignment Operator
• Lots of time convenient to write relational algebra expressions in parts using assignment to temporary relational variables.
• For this purpose use assignment operator, denoted by :=
• E.g., Who makes more than their manager?
E(emp, dept, sal) M(mgr, dept)
ESM(emp, sal, mgr) := Proj[emp, sal, mgr] (E M)
(Proj[ESM.emp](ESM [mgr = E.emp & ESM.sal >E.sal] E) )
• With the assignment operator, a query can be written as a sequential program consisting of a series of assignments followed by an expression whose value is the result of the query.
ExamplesExamples
• A query is a composition of basic relational algebra operators
• Consider relations:– customer(ssno, name, street, city)
– account(acctno, custid, balance)
• list account balance of Sharad
• list names of all customers who have a higher balance than all customers in Champaign
balance ssnocustid
customeraccount ))((
)))))))((
)(((()((
(
, .1,.1 1..1
customercustomeraccount
acctaccount
Champaigncityssnocustid
custidacctno custidacctacctnoacct acctbalanceacctbalanceacct
name ssnocustid
16
Diag Pat Dis
Winslett Strep
Liu Mono
Harandi Meningitis
Harandi Hepatitis
Liu Hepatitis
Outcome Pat Test Outcome
Winslett a T
Winslett b F
Liu b T
Harandi f T
Winslett e F
Harandi e F
Harandi g F
Winslett e T
ToDiag Dis Test
Strep A
Mono B
Meningitis C
Hepatitis D
Encehhalitis E
Meningitis F
Meningitis G
17
1. Who has what disease?Diag
2. Who has a disease they have been tested for?– Proj[pat](Diag | ToDiag | Outcome)
3. Who has a disease they tested positively for?Proj[pat](Diag | ToDiag | (select[outcome = ‘T’])Outcome))
4. Who has a disease that they tested both positively & negatively for?
Temp1(pat, dis) := Proj[pat,dis](Diag | ToDiag select[outcome = ‘T’])Outcome)
Temp2(pat, dis) : = Proj[pat,dis](Diag | ToDiag select[outcome = ‘F’])Outcome)
Proj[pat](Temp1 Temp2)
Use better names!!
18
Example of Queries in Relational AlgebraExample of Queries in Relational Algebra
5. Who tested both positively and negatively for a disease, whether or not they have it?
Testpos(pat, dis) = Proj[pat,dis](ToDiag | select[outcome = ‘T’]) Outcome)
Testneg(pat, dis) = Proj[pat,dis](ToDiag | select[outcome = ‘F’]) Outcome)
(Testpos Testneg)[pat]
6. Who tested both positively & negatively for the same test? (Winslett)
Proj[pat](Outcome | condition (rename[Outcome2](Outcome))
where condition is:
[Outcome.pat = Outcome2.pat & Outcome.test = Outcome2.test & Outcome.outcome = Outcome2. outcome]
19
7. What testable disease does no one have?
(encephalitis)
Proj[dis]ToDiag Proj[dis]Diag
Note technique: compute opposite of what you want, take a difference. Use in hard queries with negation (‘no one’)
8. What disease does more than one person have?
Proj[dis](Diag condition rename[Diag2](Diag))
where, condition is [Diag.pat Diag2.pat & Diag.dis = Diag2dis]
9. What disease does everyone have?
clue that query is very hard
Disease(dis) := diag[dis]
Patients(pat) := diag[pat]
DiseasesNotEveryoneHas(dis) := Proj[dis]((Patients x Disease) - Diag)
Disease - Diseases Not Everyone Has
Note technique used! A very hard query might require taking the difference several times.
Outer JoinsOuter Joins
E emp dept sal M mgr dept
Jones Missiles 10K Mendez Tanks
Chu Tanks 20K Frank Explosive
Swami Tanks 50K Jones Missiles
Barth Revolver 100K
Right outer join of E with M
emp dept sal mgr Jones Missiles 10K JonesChu Tanks 20K Mendeznull Explosives null Frank
left outer join of E with M
emp dept sal mgr Jones Missiles 10K JonesChu Tanks 20K MendezSwami Tanks 50K MendezBarth Revolver 100K null
Full outer join of E with M
emp dept sal mgr Jones Missiles 10K JonesChu Tanks 20K MendezSwami Tanks 50K MendezBarth Revolver 100K nullnull Explosives null Frank
21
Aggretate FunctionsAggretate Functions
• Mathematical aggregate functions (e.g., sum, count, average, min, max)
on a collection of values from the database.• [grouping attributes] F [function list] (<relation expression>)
where
grouping attributes specify how to group the tuples
function list specify the aggregate functions to be applied to the individual groups
relation expression is the expression that results in a relation.• Example:
Consider a relation Employee(dno, ssno, sal).
An expression
[dno] F [COUNT ssno, AVERAGE salary] (Employee)
results in a relation:
dno #employee average_salary
1 10 10,000
2 23 8000
Queries involving aggregate functions cannot be expressed in pure relational algebra!
22
Recursive Closure QueriesRecursive Closure Queries
Consider parent relation
parent Child Mom Dad
sam Anda Chuck
Chuck Donna Harvey
Harvey Betty Reggie
Reggie Cristie John
It may be interesting to query the relation for the following:
retrieve all the female anscestors of sam.
retrieve all male ansestors of chuck
retrieve harvey’s family tree
retrieve all the descendants of cristie
Such queries (in general) require an unbounded application of
joins of the parent relation to itself and CANNOT be represented
in relational algebra.