Chapter 7 Relational Calculus

Transcription

1 Chapter 7 Relational Calculus Relational algebra tells us how to construct a table, while relational calculus tells us what to get for that table. For example, consider the query Get supplier numbers and cities for suppliers who supply part P2. An algebraic formulation could be the following: ((S JOIN SP) WHERE P#=P#( P2 ){S#, CITY} More specifically, we 1) join supplier and shipment tuples over S#; 2) restrict the result of that join to tuples for part P2; and 3) project the result of the just obtained restriction over S# and CITY. 1

2 What does a Calculusian do? In contrast, a calculus formulation simply states Get S# and CITY for suppliers such that there exists a shipment SP with the same S# value and with the P# value equal to P2. She will write down something like this: (SX.S#, SX.City) Where Exists SPX (SPX.S#=SX.S# and SPX.P#= P2 ); This also immediately leads to the following SQL statement: Select S#, City from S, SP Where SP.S#=S.S# AND SP.P#= P2 ; 2

3 Range variables In the previous expression, both SX and SPX are examples of a range variable, which is basically a variable that goes over some specified table. If a variable V ranges over a table r, then at any time, the value of V has to be a row of r. Thus, the value of SX has to be a row in the table S. We can then make it precise what we want. For example, RANGE OF SX IS S; RETRIEVE (SX.S#) WHERE SX.CITY="London"; means that For ech possible row of table S, retrieve the S# piece, iff its CITY piece equals to London. In SQL, Select S# from S Where S.City= London ; 3

4 What should they look like? We begin with the range variables: <range var definition> ::= RANGEVAR <range var name> RANGES OVER <relational expression commmalist>; For example, RANGEVAR SX RANGERS OVER S; RANGEVAR SPX RANGES OVER SP; A range variable does not need range over a base table. 4

5 A nasty piece? Given the following specification, where, operator indicates a union operation, RANGEVAR SU RANGES OVER (SX WHERE SX.CITY= London ), (SX WHERE EXISTS SPX(SPX.S#=SX.S# AND SPX.P#=P#( P1 ))); SU takes all the suppliers that either live in London or supply P1. In RA, we have (S Where City= London ) UNION ((S Join SP) Where SP.P#= P1 ) while in SQL, we have Select * from S Where City= London Union Select S.* from S, SP Where S.S#=SP.S# and SP.P#= P1 ; 5

6 Free and bound variables All references to SX, PX, and SPX are free in the following comparisons in the sense that they can choose whatever values they want: SX.S#=S#( S1 ) SX.S#=SPX.S# SPX.P#=PX.P# PX.WEIGHT<WEIGHT (15.5) OR PX.CITY= Rome NOT (SX.CITY= London ) PX.COLOR=COLOR( Red ) OR PX.CITY= London The references to SPX and PX in the following two examples are bound, in the sense that the values they can take are rather restricted. EXISTS SPX(SPX.S#=SX.S# AND SPX.P#=P#( P2 )) FORALL PX(PX.COLOR=COLOR( Red )) Homework: Homework: Exercises 8.1(a, c, e), 8.2(b, d, f), 8.3 and

7 Quantifiers Quantifiers, collectively, provides us with convenience and, sometimes, necessity. The existential quantifier EXISTS V P(V ) means that there exists at least one value of V that makes P (V ) true, and the universal quantifier, FORALL V P(V ) means that for all values of V, P (V ) is true. For example, if the range of V is the collection of the members of the US Senate in 2004, and if P (V ) is the statement V is female, then EXISTS VP(V ) is true, but FORALL VP(V ) is false. 7

8 What should it look like? A calculus expression looks like the following: <relational operation> ::=<proto tuple> [WHERE<boolean expression>] <proto tuple> ::=<tuple expression> In other words, we just state what attributes of rows (from what tables) do we want, and what conditions those rows have to satisfy. For example, SX.SNAME WHERE EXISTS SPX (SPX.S#=SX.S# AND SPX.P#=P#( P2 )) 8

9 From Calculus to SQL 1. Get supplier numbers and status for suppliers in Paris with status > 20. (SX.S#, SX.STATUS) WHERE SX.CITY= Paris AND SX.STATUS>20 We can immediately turn it into an SQL expression: Select S#, Status From S Where City= Paris and Status>20; 9

10 2. Get all pairs of supplier numbers such that they are located in the same city. (SX.S# AS SA, SY.S# AS SB) WHERE SX.CITY=SY.CITY AND SX.S#<SY.S# Its SQL format is the following: Select SX.S# AS SA, SY.S# AS SB From S SX, S SY Where SX.CITY=SY.CITY AND SX.S#<SY.S#; We recall that its algebraic expression is as follows: (((S RENAME S# AS SA){SA, CITY} JOIN (S RENAME S# AS SB){SB, CITY}) WHERE SA<SB) {SA, SB} 10

11 3. Get the supplier names for suppliers who supply at least one red part SX.SNAME WHERE EXISTS SPX (SPX.S#=SX.S# AND EXISTS PX(PX.P#=SPX.P# AND PX.COLOR=COLOR( Red ))) Its algebraic expression is the following: ((((S JOIN SP) JOIN P) WHERE COLOR= Red )) {SNAME} and the corresponding SQL query is the following: Select SNAME From S, P, SP Where S.S#=SP.S# AND SP.P#=P.P# AND P.COLOR= Red ; 11

12 4. Get the supplier names for suppliers who supply all parts SX.SNAME WHERE FORALL PX (EXISTS SPX (SX.S#=SPX.S# AND SPX.P#=PX.P#)) Its algebraic expression is the following: (((S{S#} DIVIDEBY P{P#} PER SP{S#,P#}) JOIN S) {SNAME} Comparing them, the calculus expression tells explicitly what kind of rows we want. We can then convert it into an SQL query as we did in Chapter 6 for which you all hated me. 12

13 5. Get full supplier information for suppliers who don t supply P2 SX WHERE NOT EXISTS SPX(SPX.S#=SX.S# AND SPX.P#=P#( P2 )) We can then immediately put it into the following SQL query: Select * From S Where Not Exists ( Select * From SP Where SP.S#=S# and SP.P#= P2 ; ); 13

14 Remember this piece? The algebraic expression is the following: ((S{SNAME} MINUS (SP WHERE P#=P#( P2 )){S#}) JOIN S) {SNAME} Below is its conversion: Select SNAME from S MINUS Select SNAME from S, SP where S.S#=SP.S# and SP.P#= P2 ; Question: Which one do you prefer? 14

15 Calculus vs. Algebra It can be shown that any calculus expression can be mechanically converted to an algebraic expression. Thus, anything we can do with Calculus can be done with algebra, as well. Thus, we say RA is relational complete. So is SQL. The other direction is also true. Thus, the two are really equivalent to each other in terms of their capability. Another point is that RA is a procedural language, while RC is a non-procedural language, thus closer to SQL. To use which one as a guide to come up with the SQL, or nothing at all, is really a personal choice. 15

16 In addition to... It is nice for a language to be computationally complete as well, i.e., it is capable of computing all computable functions. We added such operators as EXTEND AND SUMMARIZE to make relational algebra to be more computationally capable. We might want to do the same for the calculus, but it already includes analogs of the algebraic EXTEND AND SUM- MARIZE operators. For examples, 1. Get the part number of those parts with weight>6000 grams, and their weight in grams. (PX.P#,PX.WEIGHT*454 AS GMWT) WHERE PX.WEIGHT*454>WEIGHT(6000) We already saw its SQL format as follows: select P.*, P.WEIGHT*454 AS GMWT from P where P.WEIGHT*454>6000; 16

17 2. For each shipment, get full shipment details, including total shipment weight. (SPX, SPX.QTY * PX.WEIGHT AS SHIPWT) WHERE PX.P#=SPX.P# Its algebraic expression is as follows: EXTEND (P JOIN SP) ADD (WEIGHT*QTY) AS SHIPWT We also saw its SQL format as follows: select SP.*, SP.QTY*P.Weight as SHWT from sp, p where sp.p#=p.p#; 17

18 3. For each part, get the part number and the total shipment quantity (PX.P#, SUM(SPX WHERE SPX.P#=PX.P#, QTY) AS TOTQTY) Question: What is its SQL format? Select P#, Sum(QTY) From P, SP Where P.P#=SP.P# Group by P#; 4. For each supplier, get the supplier number and the total number of parts supplied. (SX.S#, COUNT (SPX WHERE SPX.S#=SX.S#) AS #_PARTS) Question: What is its SQL format? Select S#, Count(*) From SP Group by S#; 18

19 It is your turn 1. Read through all the other examples in 8.6, and self-study Complete at least 10 each, but AMAP, of Exercises 8.13 and