STRUCTURE OF PRESENTATION : 1. Basic database concepts ** Entr’acte 2. Relations 8. SQL tables 3. Keys and foreign keys 9. SQL operators I 4. Relational operators I 10. SQL operators II Relational operators II 11. Constraints and predicates 12. The relational model A. SQL constraints SQL vs. the relational model References Copyright C. J. Date 2013

SOME ADDITIONAL OPERATORS : MATCHING and NOT MATCHING EXTEND Image relations Aggregation, summarization, and related matters Copyright C. J. Date 2013

1. MATCHING : Many (most?) queries etc. involving join at all really require semijoin … E.g.: Get supplier information for suppliers who supply at least one part: S MATCHING SP /* result on next page */ Copyright C. J. Date 2013

S MATCHING SP : SNO SNAME STATUS CITY S1 Smith 20 London S2 Jones 10 Paris S3 Blake 30 S4 Clark Copyright C. J. Date 2013

MATCHING (cont.) : Many (most?) queries etc. involving join at all really require semijoin … E.g.: Get supplier information for suppliers who supply at least one part: S MATCHING SP /* result on next page */ Shorthand for ( S JOIN SP ) { SNO , SNAME , STATUS , CITY } rx MATCHING ry  ( rx JOIN ry ) { A1, ..., An } where { A1, ..., An } = heading of rx Copyright C. J. Date 2013

1 (cont.). NOT MATCHING : Many (most?) queries etc. involving difference at all really require semidifference … E.g.: Get supplier information for suppliers who supply no parts at all: S NOT MATCHING SP /* result on next page */ Copyright C. J. Date 2013

S NOT MATCHING SP : SNO SNAME STATUS CITY S5 Adams 30 Athens Copyright C. J. Date 2013

NOT MATCHING (cont.) : Many (most?) queries etc. involving difference at all really require semidifference … E.g.: Get supplier information for suppliers who supply no parts at all: S NOT MATCHING SP /* result on next page */ Shorthand for S MINUS ( S MATCHING SP ) rx NOT MATCHING ry  rx MINUS ( rx MATCHING ry ) Copyright C. J. Date 2013

BY THE WAY : If the relations denoted by rx and ry are of the same type (i.e., have the same heading), then rx NOT MATCHING ry degenerates to rx MINUS ry E.g., consider S { CITY } NOT MATCHING P { CITY } /* analogous remark NOT true of semijoin */ Copyright C. J. Date 2013

2. EXTEND : For each part, get full part information, together with part weight in grams: EXTEND P : { GMWT := WEIGHT * 454 } PNO PNAME COLOR WEIGHT CITY GMWT P1 Nut Red 12.0 London 5448.0 P2 Bolt Green 17.0 Paris 7718.0 P3 Screw Blue Oslo P4 14.0 6356.0 P5 Cam P6 Cog 19.0 8626.0 Copyright C. J. Date 2013

ANOTHER EXAMPLE : Get PNO and gram weight for parts with gram weight > 7000.0: ( ( EXTEND P : { GMWT := WEIGHT * 454 } ) WHERE GMWT > 7000.0 ) { PNO , GMWT } Tutorial D syntax (EXTEND): EXTEND rx : { attribute assignment commalist } Copyright C. J. Date 2013

FURTHER EXAMPLES : EXTEND S : { TAG := 'Supplier' } SNO SNAME STATUS CITY TAG S1 Smith 20 London Supplier S2 Jones 10 Paris S3 Blake 30 S4 Clark S5 Adams Athens Copyright C. J. Date 2013

EXTEND ( P JOIN SP ) : { SHIPWT := WEIGHT * QTY } .. .. PNAME .. .. PNAME Nut . WEIGHT 12.0 SNO PNO QTY SHIPWT S1 P1 300 3600.0 etc., etc. Copyright C. J. Date 2013

RENAME revisited : RENAME is really just shorthand! S RENAME { CITY AS SCITY } Equivalent to: ( EXTEND S : { SCITY := CITY } ) { ALL BUT CITY } SNO SNAME STATUS SCITY S1 Smith 20 London S2 Jones 10 Paris S3 Blake 30 S4 Clark S5 Adams Athens RENAME is really just shorthand! Copyright C. J. Date 2013

What if part weights were recorded in grams, not pounds? EXTEND P : { WEIGHT := WEIGHT * 454 } PNO PNAME COLOR WEIGHT CITY P1 Nut Red 5448.0 London P2 Bolt Green 7718.0 Paris P3 Screw Blue Oslo P4 6356.0 P5 Cam P6 Cog 8626.0 Copyright C. J. Date 2013

3. IMAGE RELATIONS : Image relation = “image” in some relation of some tuple (usually a tuple in some other relation) E.g., image in SP of tuple in S for S4: ( SP WHERE SNO = 'S4' ) { ALL BUT SNO } PNO QTY P2 P4 P5 200 300 400 Very useful and widely applicable concept! So we define a shorthand ... Copyright C. J. Date 2013

S WHERE ( !!SP ) { PNO } = P { PNO } image in SP of “current tuple” in S relational equality “Get suppliers who supply all parts” !!! SNO SNAME STATUS CITY S1 Smith 20 London Copyright C. J. Date 2013

RECALL : t2 := ( t1 { SNO } ) , t3 := ( SP RENAME { PNO AS x } ) ) : Get part numbers for parts supplied by all suppliers in Paris WITH ( t1 := ( S WHERE CITY = 'Paris' ) , t2 := ( t1 { SNO } ) , t3 := ( SP RENAME { PNO AS x } ) ) : ( P WHERE ( t3 WHERE x = PNO ) { SNO } ⊇ t2 ) { PNO } Notes: WITH is just a syntactic trick Note use of relational comparison op “⊇” There’s a neater way to formulate this query /* see image relations, later */ Copyright C. J. Date 2013

Get part numbers for parts supplied by all suppliers in Paris ( P WHERE ( !!SP ) { SNO } ⊇ ( S WHERE CITY = 'Paris' ) { SNO } ) { PNO } Copyright C. J. Date 2013

ANOTHER EXAMPLE : S { SNO } /* suppliers */ SP { SNO , PNO } /* supplier supplies part PJ { PNO , JNO } /* part is used in project J { JNO } /* projects Get all (sno,jno) pairs such that: SNO sno currently appears in S, and ... JNO jno currently appears in J, and … Supplier sno supplies all parts used in project jno ( S JOIN J ) WHERE !!PJ  !!SP Pretty straightforward … Copyright C. J. Date 2013

IMAGE RELATIONS : “Very useful and widely applicable concept!” We’ll see more examples quite soon … Copyright C. J. Date 2013

4. AGGREGATE OPERATORS : An aggregate operator is not, in general, a relational operator (because the result usually isn’t a relation) … It’s an operator that derives a single value from the “aggregate” (i.e., the set or bag) of values of some attribute of some relation—or, for COUNT, from the entire relation. E.g.: X := COUNT ( S ) ; /* X = 5 */ Y := COUNT ( S { STATUS } ) ; /* Y = 3 */ Z := SUM ( SP { QTY } ) ; /* Z = 1000 */ Tutorial D syntax (aggregate operator invocation): agg op name ( rel exp [ , exp ] ) Copyright C. J. Date 2013

Tutorial D EXAMPLES : SUM ( SP { QTY } ) /* 1000 */ ( SP , QTY ) /* 3100 */ AVG ( SP , 3 * QTY ) /* 775 */ Legal agg op names include: COUNT SUM AVG MAX MIN AND OR XOR The exp can include attribute refs (in practice, almost always does) The exp must be omitted for COUNT ... Otherwise, it can be omitted only if the relation denoted by rel exp is of degree one, as in the first example above Copyright C. J. Date 2013

Aggregate operators are useful: In summarizations (i.e., aggregating something for each tuple in some projection of some relation, loosely speaking) In WHERE clauses (“generalized restriction”) Note: In both cases, image relations are almost always involved too Copyright C. J. Date 2013

SUMMARIZATION : For each supplier, get SNO and number of parts supplied: EXTEND S { SNO } : { PCT := COUNT ( !!SP ) } /* note the image relation reference */ SNO PCT S1 6 S2 2 S3 1 S4 3 S5 count of an empty set ... Copyright C. J. Date 2013

SUMMARIZATION (cont.) : For each supplier, get SNO and total shipment quantity: EXTEND S { SNO } : { TOTQ := SUM ( !!SP , QTY ) } /* note the image relation reference */ SNO TOTQ S1 1300 S2 700 S3 200 S4 900 S5 sum of an empty set of integers ... Copyright C. J. Date 2013

SUMMARIZATION (cont.) : For each Paris supplier, get supplier details and total, maximum, and minimum shipment quantity: EXTEND ( S WHERE CITY = 'Paris' ) : { TOTQ := SUM ( !!SP , QTY ) , MAXQ MAX ( !!SP , QTY ) , MINQ MIN ( !!SP , QTY ) } /* note use of “multiple EXTEND” */ Copyright C. J. Date 2013

ASIDE : Tutorial D currently supports explicit SUMMARIZE as well: EXTEND S { SNO } : { PCT := COUNT ( !!SP ) } SUMMARIZE S BY { SNO } : { PCT := COUNT ( ) } EXTEND S { SNO } : { TOTQ := COUNT ( !!SP ) } SUMMARIZE S BY { SNO } : { TOTQ := SUM ( QTY ) } But “summaries” (COUNT(), SUM(QTY)), etc. are somewhat suspect ... Copyright C. J. Date 2013

“GENERALIZED RESTRICTION” : Get suppliers with fewer than three shipments: S WHERE COUNT ( !!SP ) < 3 /* result = S2, S3, S5 */ Copyright C. J. Date 2013

Get suppliers for whom the total shipment quantity is less than 1000: S WHERE SUM ( !!SP , QTY ) < 1000 /* result = S2, S3, S4, S5 */ Copyright C. J. Date 2013

( EXTEND S { SNO } : { TOTQ := SUM ( !!SP , QTY ) } ) Get SNO and total shipment quantity for suppliers where total quantity > 250: ( EXTEND S { SNO } : { TOTQ := SUM ( !!SP , QTY ) } ) WHERE TOTQ > 250 Copyright C. J. Date 2013

ONE FINAL POINT : Result if argument empty for: COUNT 0 SUM AVG MAX MIN AND OR XOR 0 /* of appropriate type */ undefined undefined undefined TRUE FALSE FALSE Copyright C. J. Date 2013

SOME ADDITIONAL OPERATORS : MATCHING and NOT MATCHING EXTEND Image relations Aggregation, summarization, and related matters Copyright C. J. Date 2013

EXERCISES : What do the following expressions denote? P MATCHING S S NOT MATCHING ( SP WHERE PNO = 'P2' ) EXTEND P : { SCT := COUNT (!!SP) } P WHERE SUM ( !!SP , QTY ) < 500 Copyright C. J. Date 2013