Midterm Review. Winter Lecture 13

Transcription

1 Midterm Review Winter Lecture 13

2 Midterm Overview 3 hours, single sitting Topics: Relational model relations, keys, relational algebra expressions SQL DDL commands CREATE TABLE, CREATE VIEW Specifying integrity constraints SQL DML commands SELECT, INSERT, UPDATE, DELETE Grouping and aggregation, subqueries, etc.

3 Relational Model Relations are sets of tuples unlike SQL tables, which are multisets Relations have a schema Relation schemas are sets of attributes, with associated domains Each tuple specifies a value for each attribute or null if value is unknown or missing Every attribute domain includes null

4 Keys Need a way to uniquely identify tuples within a relation Superkey Any set of attributes that uniquely identifies a tuple If a set of attributes K is a superkey, then so is any superset of K Candidate key A minimalsuperkey If any attribute is removed, no longer a superkey Primary key A particular candidate key, chosen as the primary means of referring to tuples

5 Keys and Constraints Keys constrain the set of tuples that can appear in a relation In a relation r with a candidate key K, no two tuples can have the same values for K Can also have foreign keys A relation contains the key attributes of another relation Referencing relation has a foreign key Referenced relation has a primary (or candidate) key Referencing relation can only contain values of foreign key that also appear in referenced relation Called referential integrity

6 Example Auto insurance database car(license, vin, make, model, year) Primary key: license Candidate key: vin (Vehicle ID Number) customer(name, driverlicense, street, city) Every customer must have a different name owner(name, license) claim(name, license, date, description, amount) Can have multiple claims on one car, but have to occur on different dates

7 A Note about the Example The auto insurance schema specifies a the customer s name as the primary key I decided to leave the examples the same, since it would take too much time to change Plus, that particular auto insurance company happens to have only customers with different names It s part of the company policy

8 Relational Algebra Operations Six fundamental operations: σ select operation Π project operation ( set-union operation set-difference operation Cartesian product operation ρ rename operation Operations take one or two relations as input Each produces another relation as output

9 Additional Relational Operations Several additional operations, defined in terms of fundamental operations: ' set-intersection natural join division assignment Extended relational operations: Π G generalized project operation grouping and aggregation left outer join, right outer join, full outer join

10 Examples Schema: car(license, vin, make, model, year) customer(name, driverlicense, street, city) owner(name, license) claim(name, license, date, description, amount) Find names of all customers living in Los Angeles or New York. Π name (σ city= Los Angeles city= New York (customer)) Select predicate can refer to attributes, constants, or arithmetic expressions using these Conditions combined with and

11 Examples (2) Schema: car(license, vin, make, model, year) customer(name, driverlicense, street, city) owner(name, license) claim(name, license, date, description, amount) Find customer name, street, and city of all Toyota owners Need to join customer, owner, car relations Could use Cartesian product, select, etc. Or, use natural join operation: Π name,street,city (σ make= Toyota (customer owner car)

12 Examples (3) Schema: car(license, vin, make, model, year) customer(name, driverlicense, street, city) owner(name, license) claim(name, license, date, description, amount) Find how many claims each customer has Don t include customers with no claims Simple grouping and aggregation operation nameg count(license) as num_claims (claim) Aggregate operations work on multisets by default

13 Examples (4) Now, include customers with no claims They should have 0 in their values Requires outer join between customer, claim Outer part of join symbol is towards relation whose rows should be null-padded Want all customers, and claim records if they are there, so outer part is towards customer name G count(license) as num_claims (customer claim) Aggregate functions ignore null values

14 Examples (5) Grouping/aggregation operation produces a relation Can t use aggregate functions in select predicates Find customer with the most claims Use grouping/aggregation to find maximum claim count Use Cartesian product to compare this with each customer s number of claims Common subquery: computation of how many claims each customer has

15 Examples (6) Use assignment to store temporary result claim_counts name G count(license) as num_claims (claim) max_count G max(num_claims) as max_claims (claim_counts) σ num_claims=max_claims (claim_counts max_count) In relational algebra, need to use Cartesian product to compare contents of two relations Result of grouping/aggregation is always contained within a relation

16 Rename Operation Mainly used when joining a relation to itself Need to rename one copy of the relation to avoid ambiguities Remember that Π and G both allow names to be specified Can rename attributes Can assign a name to results Often shorter than including extra ρ operation

17 Modifying Relations Can add rows to a relation r r ( { ( ), ( ) } Can delete rows from a relation r r σ P (r) Can modify rows in a relation r Π(r) Uses generalized project operation Remember to include unmodified rows, too! r Π(σ P (r)) ( σ ŸP (r)

18 Structured Query Language SQL is a query language based on relational algebra Largely declarative in nature Tables are like relations, but are multisets Each column has a type (its domain), and possibly other constraints (e.g. NOT NULL) Can issue queries against tables using SELECT statement

19 SELECT Statements Basic SELECT syntax: SELECT A 1, A 2,... FROM r 1, r 2,... WHERE P; Equivalent to: Π (σ P (r 1 r 2 )) A 1,A 2, SELECT is a generalized project operation Can include expressions, etc. SELECT generates a multiset by default Can specify SELECT DISTINCT to eliminate duplicates

20 FROM Clause FROM clause supports JOIN syntax too Examples: FROM t1 JOIN t2 ON t1.a1 = t2.a1 FROM t1 JOIN t2 USING (a1, a2) FROM t1 NATURAL JOIN t2 FROM t1 LEFT JOIN t2 USING (a1, a2) FROM t1 NATURAL LEFT JOIN t2 Some of these remove duplicate columns, and some don t! USING and NATURAL joins coalesce columns

21 WHERE Clause WHERE clause specifies selection predicate Can use AND, OR, NOT to combine conditions NULL values affect comparisons! Can t use = NULL or <> NULL Must use IS NULL or IS NOT NULL Can use BETWEEN to simplify range checks a >= v1 AND a <= v2 a BETWEEN v1 AND v2

22 Subqueries Can include subqueries in FROM clause Called a derived relation Nested SELECT statement in FROM clause, given a name and a set of attribute names Can also use subqueries in WHERE clause Can compare an attribute to a scalar subquery Can also use set-comparison operations to test against a subquery IN, NOT IN set membership tests SOME, ALL comparison against a set EXISTS, NOT EXISTS empty-set tests

23 Grouping and Aggregation SQL supports grouping and aggregation GROUP BY specifies attributes to group on Can apply aggregate functions to other columns, in SELECT clause Can filter results of grouping operation using HAVING clause HAVING clause can use aggregate values too Difference between WHERE and HAVING? WHERE applied before grouping; HAVING after

24 Aggregated Values Schema: car(license, vin, make, model, year) customer(name, driverlicense, street, city) owner(name, license) claim(name, license, date, description, amount) Find customers with more claims than average number of claims An aggregate of another aggregate

25 Aggregate Values (2) Two steps to find average number of claims: Must compute count for each customer SELECT name, COUNT(license) AS num_claims FROM claim GROUP BY name Then, compute average (MySQL syntax): SELECT AVG(num_claims) FROM (SELECT COUNT(license) AS num_claims FROM claim GROUP BY name) AS counts Now, compare this result to each count Need to issue group/count operation again! This query gets complicated fast

26 Aggregated Values (3) Easy solution (for databases without WITH): Define a view, then query against the view CREATE VIEW claim_counts AS SELECT name, COUNT(*) AS num_claims FROM claim GROUP BY name; SELECT name FROM claim_counts WHERE num_claims > (SELECT AVG(num_claims) FROM claim_counts); Can also use WITH syntax for this

27 SQL Data Definition Can specify table schemas using CREATE TABLE syntax Specify each column s name and domain Can specify domain constraint: NOT NULL Can specify key constraints PRIMARY KEY UNIQUE (candidate keys) REFERENCES table (column) Key constraints can go in column declaration Can also specify keys after all column decls. UNIQUE and REFERENCES don t imply NOT NULL!

28 DDL Example Relation schema: car(license, vin, make, model, year) CREATE TABLE statement: CREATE TABLE car ( license CHAR(10) PRIMARY KEY, vin CHAR(30) NOT NULL UNIQUE, make VARCHAR(20) NOT NULL, model VARCHAR(20) NOT NULL, year INTEGER NOT NULL );

29 DDL Example (2) Relation schema: claim(name, license, date, description, amount) CREATE TABLE statement: CREATE TABLE claim ( name VARCHAR(30), license CHAR(10), date TIMESTAMP, description VARCHAR(1000) NOT NULL, amount NUMERIC(8,2), PRIMARY KEY (name, license, date), FOREIGN KEY name REFERENCES customer, FOREIGN KEY license REFERENCES car );

30 Midterm Details Midterm posted online shortly Due next Friday, February 9 No homework to do next week Good luck!