1. Chapter 7 Relational Algebra

2. Topics in this Chapter Closure Revisited The Original Algebra: Syntax and Semantics What is the Algebra For? Further Points and Additional Operators Grouping and Ungrouping

3. Relational Algebra The relational algebra is a collection of operators that take relations as their operands and return a relation as their result Eight operators, in two groups of four Union, intersect, difference, Cartesian product Restrict, project, join, divide The set of possible relational operators is essentially unlimited The operators are “read only”

4. Fig. 7.1 The original eight operators (overview)

5. Closure Revisited The output from any relation operator is another relation: the closure property Relation expressions can be nested (analogously to arithmetic expressions) Every relation has a head and a body; relational algebra must address both Attribute type inference must be supported RENAME changes the name of an attribute without changing its type or content

6. RENAME S RENAME CITY AS SCITY +------+-------+--------+--------+ | S# | SNAME | STATUS | SCITY | +------+-------+--------+--------+ | S1 | Smith | 20 | London | | S2 | Jones | 10 | Paris | | S3 | Blake | 30 | Paris | | S4 | Clark | 20 | London | | S5 | Adams | 30 | Athens | +------+-------+--------+--------+

7. RENAME (S RENAME CITY AS SCITY) +------+-------+--------+--------+ | S# | SNAME | STATUS | SCITY | +------+-------+--------+--------+ | S1 | Smith | 20 | London | | S2 | Jones | 10 | Paris | | S3 | Blake | 30 | Paris | | S4 | Clark | 20 | London | | S5 | Adams | 30 | Athens | +------+-------+--------+--------+ expression value

8. The Syntax of the Original Algebra The algebra exists because of the nature and definition of relations. The algebra is independent of its description. Note that the Date text defines the algebra using words rather than symbols. Most texts use symbols to describe the syntax of the algebra. Some who prefer that say that it “looks more scientific.” More about the symbols later.

9. The Syntax of the Original Algebra BNF grammar for the relational algebra: ::=“is defined as” to indicate category names |“or” […]to indicate something optional upper case words such as WHERE are elements of the language { and } are symbols in the language, not BNF use of “commalist” for repetition

10. The Syntax of the Original Algebra Each operator returns a relation, and operates on a relation Each operator assigns a relation value to the new relation, based on alterations to the tables being operated upon Generically: := RELATION { }

11. The Syntax of the Original Algebra – General Format := RELATION { } | | ( )

12. ::= | :: = { [ ALL BUT ] } (The must not be a ) ::= | | | | | | |

13. ::= RENAME (The must not be a ) ::= UNION (The s must not be s, except either or both can be another )

14. ::= INTERSECT (The s must not be s) (Except either or both can be another ) ::= MINUS (The s must not be s) ::= TIMES (The s must not be s) (Except either or both can be another )

15. ::= WHERE (The must not be a ) ::= JOIN (The s must not be s) (Except either or both can be another )

16. ::= DIVIDEBY PER (The s must not be s) ::= | (, ) (The s must not be s) ::= WITH : ::= AS

17. Semantics of the Original Algebra – Union Union operates on two sets and returns a set that contains all elements belonging to either Both sets must be of the same type - formerly known as union compatibility Relations cannot have duplicate tuples; we say loosely that UNION “eliminates duplicates”

18. Semantics of the Original Algebra – Intersect and Difference Intersect operates on two sets and returns a set that contains all tuples belonging to both Difference operates on two sets and returns a set containing all tuples occuring in one but not the other, using MINUS For both Intersect and Difference, the sets operated upon must be of the same type - formerly known as union compatibility

19. Semantics of the Original Algebra – Cartesian Product A Cartesian Product is the set of all ordered pairs such that in each pair, the first element comes from the first set, and the second element comes from the second set However, since the result of a relational operator is a relation, the result of each pair is a single tuple containing all the elements of both of the source tuples Uses keyword TIMES

20. Semantics of the Original Algebra – Restrict Yields a horizontal subset – a/k/a “SELECT” a WHERE p p is called the restriction condition p is a predicate, and returns boolean If it can be evaluated by examining a single tuple it is simple; otherwise it is nonsimple

21. Semantics of the Original Algebra – Project Yields a vertical subset The general form is a commalist of attributes to be kept in the result For all attributes kept, all tuples are kept An alternative specification is to name the attributes to be excluded: P { ALL BUT WEIGHT}

22. Semantics of the Original Algebra – Join – Natural Join When unqualified, join means “natural join” For any two relations with at least one matching attribute, the join operator returns a relation with a single tuple of all the attributes for each match Attributes that do not match from each source relation are retained If no attributes match, result is a Cartesian product If all attributes match, result is an Intersect

23. Semantics of the Original Algebra – Join – Theta Join Used to join relations based on matching attributes, where the values are not equal Given relations a and b, and attributes X and Y, this can be expressed as follows: (a TIMES b) WHERE X theta Y When theta is set to = the result can be made to be that of natural join (project away the duplicate attribute, and rename the kept one)

24. Semantics of the Original Algebra – Divide Used to “divide one relation into another” Small Divide uses one relation expression as divisor, Great Divide uses two For small divide: a DIVIDEDBY b PER c where a is the dividend, b is the divisor, and c is the mediator Used to determine who in a relates to the complete set in b

25. Semantics of the Original Algebra – Divide - Example Let S be a relation of suppliers, P one of parts, and SP the mediator S JOIN ( S {S#} DIVIDEDBY P {P#} PER SP {S#, P#} ) Will return a relation with suppliers who supply all parts, only

26. Examples Get supplier names for suppliers who supply part P2. In SQL: SELECT SNAME FROM S WHERE S# IN (SELECT S# FROM SP WHERE P# = ‘P2’); In relational algebra: ( ( SP JOIN S ) WHERE P# = P# (‘P2’) ) { SNAME }

27. Get supplier names for suppliers who supply at least one red part. SELECT SNAME FROM S WHERE S# IN (SELECT S# FROM SP WHERE P# IN (SELECT P# FROM P WHERE COLOR = ‘RED’) ); ( ( ( P WHERE COLOR = COLOR (‘RED’) ) { P# } JOIN SP ) { S# } JOIN S ) {SNAME}

28. Get supplier names for suppliers who do not supply part P2. SELECT SNAME FROM S WHERE NOT EXISTS ( SELECT S# FROM SP WHERE S# = S.S# AND P# = ‘P2’ ) ; ( ( S {S#} MINUS ( SP WHERE P# = ‘P2’ ) { S# } ) JOIN S ) { SNAME }

29. Get all pairs of supplier numbers where the two suppliers are located in the same city. SELECT FIRST.S#, SECOND.S# FROM S FIRST, S SECOND WHERE FIRST.CITY = SECOND.CITY AND FIRST.S# < SECOND.S#; ( ( ( S RENAME S# AS FIRSTS# ) {FIRSTS#, CITY} JOIN (S RENAME S# AS SECONDS# ) {SECONDS#, CITY} ) WHERE FIRSTS# < SECONDS# ) { FIRSTS#, SECONDS# }

30. Get supplier names for suppliers who do not supply part P2. SELECT SNAME FROM S WHERE NOT EXISTS ( SELECT S# FROM SP WHERE S# = S.S# AND P# = ‘P2’ ) ; ( ( S {S#} MINUS ( SP WHERE P# = ‘P2’ ) { S# } ) JOIN S ) { SNAME }

31. ::= DIVIDEBY PER (The s must not be s) ::= | (, ) (The s must not be s) ::= WITH : ::= AS

32. Semantics of the Original Algebra – Divide Used to “divide one relation into another” Small Divide uses one relation expression as divisor, Great Divide uses two For small divide: a DIVIDEDBY b PER c where a is the dividend, b is the divisor, and c is the mediator Used to determine who in a relates to the complete set in b

33. Fig. 7.8 Division Examples

34. The “Symbolic” Form Names of Suppliers located in Paris: π SNAME ( σ CITY = ‘Paris’ (S) ) (S WHERE CITY = CITY (‘Paris’) ){SNAME} Names of Suppliers of part ‘P2’: π SNAME ( σ P# = ’P2’ (S SP) ) ((S JOIN SP) WHERE P# = ‘P2’) {SNAME}

36. What is the Algebra for? The purpose of the algebra is to allow the writing of relational expressions Applications of the algebra: retrieval, update, defining integrity constraints, derived relvars, stability and security An implemented language can be said to be relationally complete if it is at least as powerful as the algebra

37. The Original Algebra Many operators are associative: Union, intersect, times, join, but not minus Many operators are commutative: Union, intersect, times, join, but not minus Join, union, intersect were originally defined as dyadic, but are now seen to operate on any number of relations, including DEE and DUM

38. Additional Relational Operators Semijoin is used to perform a partial join based on restrictions (Join for a specific part number, for example) Semidifference is similar (Obtain suppliers who do not supply a particular part, e.g.) Extend adds an attribute dynamically, but does not alter the underlying relvar Summarize performs vertical or attribute- wise computations

39. Semijoin A SEMIJOIN B is equivalent to: (A JOIN B) { X, Y } The JOIN of A and B projected over the attributes of A. The tuples of A that have “counterparts” in B.

40. Grouping… Required because relations can have attributes that are themselves relations Provides a map between such relations and “flat” relations SP GROUP {P#, QTY} AS PQ Will return quantities of parts by supplier, which is the unnamed co-conspirator

41. …and Ungrouping Returns the original relation In the example, the original SP relation If you group, you can always ungroup, but the converse is not necessarily true This occurs when the relations being ungrouped were not validly grouped in the first place