SQL as Data Manipulation Language (DML)

Insert and update data

Simple SQL queries
Advanced SQL queries
Views
 SQL / DML: Overview

 Insert, update, delete data

 Query data
Interactively
(Embedded in host language)

 Data presentation to users

Output improvements
Views
FU-Berlin, DBS I 2006, Hinze / Scholz

2
 SQL / DML: Insert data

 Complete form:
Predefined order of values

INSERT INTO Customer

VALUES (001, 'Mller', 'Tina', NULL,NULL);

 Incomplete form:
Free order of values
FU-Berlin, DBS I 2006, Hinze / Scholz

INSERT INTO Customer

(last_name, mem_no) VALUES ('Mller', 001);

3
 SQL / DML: Insert data
 Inserting dates
INSERT INTO movie
VALUES (95, 'Psycho', 'suspense',
TO_DATE('1969', 'yyyy'),
'Hitchcock', 2.00, NULL);

 Conversion functions
String to date
TO_DATE(<string>[,<format>]) ORACLE/Postgres
FU-Berlin, DBS I 2006, Hinze / Scholz

Date to string

TO_CHAR(<date>[,<format>]) ORACLE/Postgres

4
 SQL / DML: Insert data
 Loading data from files
System dependent
 Oracle:
INSERT INTO
Bulk load from file: SQL loader
Bulk load from other database: export / import tool

 MySQL:
INSERT INTO
Bulk load: LOAD DATA
Bulk load from other database:
SELECT INTO OUTFILE, LOAD DATA
FU-Berlin, DBS I 2006, Hinze / Scholz

 Postgres:
INSERT INTO
Bulk load: Copy
Bulk load from other database: Copy
5
 SQL / DML: Implementations of bulk load
 Oracle SQL loader
control file data file

SQL*Loader
rejected
field processing
rows
discarded
rows record selection
bad file
FU-Berlin, DBS I 2006, Hinze / Scholz

(discard file) log file Oracle server

6
 SQL / DML: Implementations of bulk load
loadtest.dat
 Example: CREATE TABLE loadtest(
name varchar(20), 'four'
'four' ,, 44
num number(10,2)); 'five'
'five' ,, 55
'six'
'six' ,, 66

 Oracle Syntax:
sqlldr <user>/<password> <controlfile>
<logfile> <badfile> <datafile>

loadtest.ctl
load
load data
data
infile
infile 'loadtest.dat'
'loadtest.dat'
badfile
badfile 'loadtest.bad'
'loadtest.bad'
FU-Berlin, DBS I 2006, Hinze / Scholz

discardfile
discardfile 'loadtest.dis'
'loadtest.dis'
APPEND
APPEND INTOINTO table
table loadtest
loadtest
fields
fields terminated
terminated byby "" ,, ""
optionally
optionally enclosed
enclosed by
by "" '' ""
(name
(name char,
char, numnum integer
integer external)
external)
7
 SQL / DML: Implementations of bulk load
 MySQL Example:

Mysql>
Mysql> LOAD
LOAD DATA
DATA INFILE
INFILE 'loadtest.dat'
'loadtest.dat'
->
-> IGNORE
IGNORE
->
-> INTO
INTO TABLE
TABLE loadtest
loadtest
->
-> FIELDS
FIELDS
->
-> TERMINATED
TERMINATED BYBY ","
","
->
-> OPTIONALLY
OPTIONALLY ENCLOSED
ENCLOSED BYBY ''
''
->
-> (name,
(name, num
num );
);
Query
Query OK,
OK, 33 rows
rows affected
affected (0.01
(0.01 sec)
sec)
Records:
Records: 33 Deleted:0
Deleted:0 Skipped:
Skipped: 00 Warnings:
Warnings: 00
FU-Berlin, DBS I 2006, Hinze / Scholz

8
 SQL / DML: Insert unique data
 For synthetic keys, e.g. tapeId,

 Counter-variables in application not sufficient

Session dependent
Concurrent access problematic

 Counter relation in database

Expensive

 Proprietary solutions in existing DBMS

FU-Berlin, DBS I 2006, Hinze / Scholz

MySQL: autoincrement keyword

SQL-Server: identity keyword
PostgreSQL: serial type and sequence
Oracle: sequence-object
9
 SQL / DML: Insert unique data - sequence
 Abstract sequence-object (Oracle)
Creates unique integer values

 Syntax: CREATE SEQUENCE <seqName>

[START WITH <integer>]
[INCREMENT BY <integer>]
[MAXVALUE <integer> | NOMINVALUE]
[MINVALUE <integer> | NOMAXVALUE]
[CYCLE | NOCYCLE]
[CACHE <integer> | NOCACHE]
[ORDER | NOORDER];
FU-Berlin, DBS I 2006, Hinze / Scholz

 Example: create sequence tape_sequence;

10
 SQL / DML: Insert unique data - sequence
 Value Access
<seqName>.NEXTVAL = value of last call + increment
<seqName>.CURRVAL = value of last call

SELECT <seqName>.CURRVAL FROM DUAL;

DUAL is Oracle pseudo-table

 Example:
INSERT INTO tape
FU-Berlin, DBS I 2006, Hinze / Scholz

VALUES(tape_sequence.nextval, 'DVD', 95);

11
 SQL / DML: Delete data
 Syntax:
DELETE from <tableName>
[WHERE <predicate>];

Delete all rows :

DELETE from <tableName>;

 Example:
DELETE from tape
FU-Berlin, DBS I 2006, Hinze / Scholz

WHERE format= 'Beta';

12
 SQL / DML: Update data
 Syntax:
UPDATE <tableName>
SET <attr> = <value>
{,<attr> = <value> }
WHERE <predicate>

 Examples: UPDATE Customer

SET telephone = 456789
WHERE mem_no = 200;

UPDATE Rental
SET until_date = SYSDATE
FU-Berlin, DBS I 2006, Hinze / Scholz

WHERE tape_ID = 3
AND mem_no = 200
AND TO_CHAR(from_date,'yyyy-mm-dd')='2002-05-01';

13
 SQL / DML: Example database
insert into customer values (001, 'Mller', 'Tina', NULL,NULL);
insert into customer values (007, 'Katz', 'Anna', NULL,NULL);
insert into customer values (002, 'Maus', 'Carla', NULL,NULL);
....

insert into movie values (95, 'Psycho', 'suspense',

to_date('1969', 'yyyy'), 'Hitchcock', 2.00, NULL);
insert into movie values (112, 'ET', 'comedy',
to_date('1982', 'yyyy'), 'Spielberg', 1.50, NULL);
....

insert into format values('DVD', '2.00');

insert into format values('Beta', '0.00');
insert into format values('VHS', '0.00');
FU-Berlin, DBS I 2006, Hinze / Scholz

create sequence tape_sequence;

insert into tape values (tape_sequence.nextval, 'DVD', 95);
insert into tape values (tape_sequence.nextval, 'DVD', 112);
insert into tape values (tape_sequence.nextval, 'VHS', 222);
14
 SQL / DML: Example database
insert into rental values (3, 1,
to_date('2002-05-01','yyyy-mm-dd'), NULL);
insert into rental values (4, 1,
to_date('2002-05-01','yyyy-mm-dd'), NULL);
insert into rental values (5, 3,
to_date('2002-05-01','yyyy-mm-dd'),
to_date('2002-05-02','yyyy-mm-dd'));

insert into actor values ('Hitchcock',

'Hitchcock', to_date(1899-08-13','yyyy-mm-dd'));
insert into actor values ('Harrison Ford',
'Harrison Ford', to_date('1942-07-13','yyyy-mm-dd'));
FU-Berlin, DBS I 2006, Hinze / Scholz

insert into play values(290,'Harrison Ford');

insert into play values(98,'Hitchcock');

15
 SQL / DML: Querying Language
 SQL is relational complete

 Additional query concepts

Advanced search expressions on strings

e.g., find all movies starting with star wars

Arithmetic in expressions,
e.g., number of tapes for each movie

Grouping and predicates over sets

FU-Berlin, DBS I 2006, Hinze / Scholz

e.g., total receipts of each movie within the last year

16
 SQL / DML: Basics
 Basic query pattern:
SELECT [DISTINCT] A1, A2,...,An
FROM R1, R2,...Rm
WHERE predicate P;

A1 , A2 , ..., An attribute names,

R1 , R2 , ..., Rm relation names,
P Boolean predicate on attributes and constants

 Equivalent to relational algebra expression:

A1, A2, ..., An ( P ( R1 X R2 X ... X Rm ))
FU-Berlin, DBS I 2006, Hinze / Scholz

Projection (RA) SELECT (SQL)

Cartesian Product (RA) FROM (SQL)
Selection (RA) WHERE (SQL)
17
 SQL / DML: Basics
 Query result is relation

 Query evaluation order:

1.FROM-clause
2.WHERE-clause
3.SELECT-clause
SQL>
SQL> SELECT
SELECT last_name
last_name
22 FROM Customer;
FROM Customer;
 No duplicate removal
LAST_NAME
(performance!) LAST_NAME
------------------------------
------------------------------
Mller
FU-Berlin, DBS I 2006, Hinze / Scholz

Mller
Katz
Katz
Maus
Maus
Hinz
Hinz
Kunz
Kunz
Mller
Mller
18
 SQL / DML: Basics
 Eliminating duplicates:
Targetlist contains KEY attribute
Targetlist constrains UNIQUE attribute
Targetliste defined with DISTINCT

SELECT mem_no, last_name SELECT DISTINCT last_name

FROM Customer FROM Customer
MEM_NO
MEM_NO LAST_NAME
LAST_NAME LAST_NAME
LAST_NAME
----------
---------- ----------------
---------------- -----------------
-----------------
11 Mller
Mller Hinz
Hinz
77 Katz
Katz Katz
Katz
22 Maus Kunz
FU-Berlin, DBS I 2006, Hinze / Scholz

Maus Kunz
11
11 Hinz
Hinz Maus
Maus
23
23 Kunz
Kunz Mller
Mller
111
111 Mller
Mller

19
 SQL / DML: Basics
 WHERE-clause structure:

Simple Boolean predicates similar to RA and Calculus

Additional simple predicates:

<attribute> BETWEEN <value1> AND <value2>
<attribute> IS [NOT] NULL
<attribute> LIKE <string>
<attribute> SIMILAR TO <string>

Advanced predicated with sub-queries

FU-Berlin, DBS I 2006, Hinze / Scholz

Set-operators (IN, NOT IN, SOME, ALL, EXISTS)

20
 SQL / DML: Simple queries
Example: All customers named Anna
SQL>
SQL> select
select mem_no,
mem_no, last_name,
last_name, first_name
first_name
22 from
from customer
customer
33 where
where first_name='Anna';
first_name='Anna';

MEM_NO
MEM_NO LAST_NAME
LAST_NAME FIRST_NAME
FIRST_NAME
----------
---------- ------------------------------
------------------------------ --------------
--------------
77 Katz
Katz Anna
Anna
23
23 Kunz
Kunz Anna
Anna

Example: All movies by Lucas from 1999 or later

SQL>
SQL> select
select id,
id, title
title
22 from
from movie
movie
33 where
where director='Lucas'
FU-Berlin, DBS I 2006, Hinze / Scholz

director='Lucas'
44 and
and to_char(year,'yyyy')>='1999';
to_char(year,'yyyy')>='1999';

ID
ID TITLE
TITLE
----------
---------- ---------------------------------------------
---------------------------------------------
345
345 Star
Star Wars
Wars II
21
 SQL / DML: Simple queries
 More examples:

All formats with extra charge between 1 and 2 Euro

SELECT *
FROM Format
WHERE charge BETWEEN 1.00 and 2.00;

All tapes currently on loan

SELECT tape_id
FU-Berlin, DBS I 2006, Hinze / Scholz

FROM Rental
WHERE until_date IS NULL;

22
 SQL / DML: Simple queries - expressions
Core
 LIKE - expression SQL:1999
Simple form of regular expression
% : any sequence of characters
_ : exactly one character

 Example:
All star wars movies
SQL>
SQL> select
select id,
id, title,
title, director
director
22 from movie
from movie
33 where
where title
title like
like 'Star
'Star Wars
Wars %';
%';
FU-Berlin, DBS I 2006, Hinze / Scholz

ID
ID TITLE
TITLE DIRECTOR
DIRECTOR
----------
---------- ------------
------------ ---------------
---------------
345 Star Wars I Lucas
345 Star Wars I Lucas
290
290 Star
Star Wars
Wars IV
IV Lucas
Lucas

23
 SQL / DML: Simple queries - expressions
enhanced
 SIMILAR - expression SQL:1999
Advanced form of regular expression

 Example:

All star wars movies

SELECT id, title, director
FROM movie
WHERE title SIMILAR TO
'Star Wars (I | IV | V | VI | 1 | [4-6])';
FU-Berlin, DBS I 2006, Hinze / Scholz

24
 SQL / DML: Simple queries
 Member in set: IN

All movies from Spielberg or Lukas Core

SELECT title, director SQL:1999
FROM Movie
WHERE director IN ('Spielberg','Lucas');

All movies from Lucas in 1999 enhanced

SELECT title, director SQL:1999
FU-Berlin, DBS I 2006, Hinze / Scholz

FROM Movie
WHERE (director, year)
IN (('Lucas',to_date(1999,'yyyy')));

25
 SQL / DML: Simple queries - expressions
 Functions
Expressions may contain functions
Arithmetical and string built-in functions
User defined functions on user defined types

 String function examples:

SOUNDEX (<string>), UPPER (<string>)
SUBSTRING(<string> FROM <integer> FOR <integer>)
SQL>
SQL> SELECT
SELECT title,
title, director
director
22 FROM
FROM Movie
Movie
33 WHERE
WHERE SOUNDEX(director)
SOUNDEX(director) == SOUNDEX('Spilbak');
SOUNDEX('Spilbak');
FU-Berlin, DBS I 2006, Hinze / Scholz

TITLE
TITLE DIRECTOR
DIRECTOR
----------------
---------------- ----------------
----------------
ET
ET Spielberg
Spielberg
Psycho
Psycho Spielberg
Spielberg
Jaws
Jaws Spielberg
Spielberg 26
 SQL / DML: Simple queries - expressions
 Arithmetic function examples
SQRT(<number>)
Basic arithmetic expressions

All tapes, their price and tax

SQL>
SQL> SELECT
SELECT id,
id, pricepday,
pricepday,
22 0.16*pricepday
0.16*pricepday asas tax
tax
33 FROM
FROM Movie;
Movie;

ID
ID PRICEPDAY
PRICEPDAY TAX
TAX
----------
---------- ----------
---------- ----------
----------
95 22 .32
FU-Berlin, DBS I 2006, Hinze / Scholz

95 .32
112
112 1.5
1.5 .24
.24
345
345 22 .32
.32
222
222 2.2
2.2 .352
.352
290
290 22 .32
.32
100
100 1.5
1.5 .24
.24 27
 SQL / DML: Simple queries - expressions
 Date function examples
differ heavily between systems

Oracle: SYSDATE, MONTHS_BETWEEN, ADD_MONTHS

SQL>
SQL> SELECT
SELECT title,
title, to_char(year,'yyyy')
to_char(year,'yyyy') as
as year
year
22 FROM
FROM movie
movie
33 WHERE
WHERE months_BETWEEN(SYSDATE,year)>
months_BETWEEN(SYSDATE,year)> 120
120 ;;

TITLE
TITLE YEAR
YEAR
------------------------
------------------------ ----
----
Psycho 1969
FU-Berlin, DBS I 2006, Hinze / Scholz

Psycho 1969
ET
ET 1982
1982
Jaws
Jaws 1975
1975

28
 SQL / DML: Simple queries
Core
 Combination of relations SQL:1999
Schema compatible relations
UNION, INTERSECT, EXCEPT

 Syntax:
UNION | INTERSECT | EXCEPT
[DISTINCT | ALL]
[CORRESPONDING [BY <attributes>]]

Default DISTINCT
FU-Berlin, DBS I 2006, Hinze / Scholz

Default: all attributes used

CORRESPONDING BY: defines used common attributes
CORRESPONDING: uses all common attributes
29
 SQL / DML: Simple queries
 Example:

All movies from Spielberg or Lukas

(SELECT title, director
FROM Movie
WHERE director like 'Spielberg')
UNION
(SELECT title, director
FROM Movie
WHERE director like 'Lucas');
FU-Berlin, DBS I 2006, Hinze / Scholz

30
 SQL / DML: Simple queries
 More examples:
All movies not by Lucas
(SELECT *
FROM Movie)
EXCEPT
(SELECT * from Movie
WHERE director='Lucas');

All directors and actors in our database

(SELECT director as celebrity
FU-Berlin, DBS I 2006, Hinze / Scholz

FROM Movie)
UNION DISTINCT
(SELECT stage_name as celebrity
FROM Actor);
31
 SQL / DML: Implementations combinations
 Oracle:
UNION
MINUS implements EXCEPT
INTERSECT
CORRESPONDING [BY] not implemented

 PostgreSQL:
UNION
EXCEPT
INTERSECT
CORRESPONDING [BY] not implemented
FU-Berlin, DBS I 2006, Hinze / Scholz

 MySQL:
UNION, EXCEPT, INTERSECT not implemented
32
 SQL / DML: Simple queries with joins
Core
 Simple joins SQL:1999
Search predicates and join conditions mixed

Example: All Tapes and their corresponding movie

SQL>
SQL> SELECT
SELECT t.id,
t.id, t.format,
t.format, m.id,
m.id, m.title
m.title
22 FROM
FROM Tape
Tape t,
t, Movie
Movie mm
33 WHERE
WHERE m.id
m.id == t.movie_id;
t.movie_id;

ID
ID FORMAT
FORMAT ID
ID TITLE
TITLE

----------
---------- -----
----- ----------
---------- ----------------------------
----------------------------
11 DVD
DVD 95
95 Psycho
Psycho
FU-Berlin, DBS I 2006, Hinze / Scholz

22 DVD
DVD 112 ET
112 ET
33 VHS
VHS 222
222 Psycho
Psycho
44 DVD
DVD 345
345 Star
Star Wars
Wars II
55 VHS
VHS 345
345 Star
Star Wars
Wars II
99 VHS
VHS 345
345 Star
Star Wars
Wars II
33
 SQL / DML: Simple queries with joins
enhanced
 Cross join (cross product) SQL:1999

<tableName> CROSS JOIN <tableName>

 Natural inner join

<tableName> NATURAL [INNER] JOIN <tableName>

 Example:
FU-Berlin, DBS I 2006, Hinze / Scholz

SELECT *
FROM Rental NATURAL INNER JOIN Customer;

34
 SQL / DML: Simple queries with joins
enhanced
 Inner join with attribute list SQL:1999

<tableName> [INNER] JOIN <tableName>

USING <attributList>

Subset of attributes in common

 Example:
SELECT *
FROM Rental r JOIN Customer c
FU-Berlin, DBS I 2006, Hinze / Scholz

USING (mem_no);

35
 SQL / DML: Simple queries with joins
enhanced
 Inner join with condition SQL:1999
<tableName> [INNER] JOIN <tableName>
ON <condition>

 Examples:
SELECT *
FROM Tape t JOIN Movie m
ON t.movie_id = m.id;

SELECT *
FU-Berlin, DBS I 2006, Hinze / Scholz

FROM Rental r JOIN Customer c

ON r.mem_no = c.mem_no;

36
 SQL / DML: Simple queries with joins

All Customers who have rented at least one science fiction film

SELECT c.mem_no, c.last_name, c.first_name

FROM ((Customer c
JOIN Rental r ON c.mem_no = r.mem_no)
JOIN Tape t ON t.id = r.tape_id )
JOIN Movie m ON t.movie_id = m.id
WHERE m.category='Scifi';

SELECT c.mem_no, c.last_name, c.first_name

FROM Customer c, Rental r, Tape t, Movie m
FU-Berlin, DBS I 2006, Hinze / Scholz

WHERE c.mem_no=r.mem_no
AND t.id = r.tape_id
AND t.movie_id = m.id
AND m.category='Scifi';
37
 SQL / DML: Simple queries with joins
enhanced
 Natural outer join SQL:1999
<tableName> LEFT|RIGHT|FULL
NATURAL [OUTER] JOIN <tableName>

 Outer join with condition

<tableName> LEFT|RIGHT|FULL [OUTER] JOIN <tableName>
ON <condition>

 Example:
FU-Berlin, DBS I 2006, Hinze / Scholz

SELECT *
FROM Rental r RIGHT OUTER JOIN Customer c
ON r.mem_no = c.mem_no;

38
 SQL / DML: Simple queries with joins
 Example (extended)
SQL>
SQL> SELECT
SELECT r.tape_id,
r.tape_id, r.from_date,
r.from_date, c.mem_no,c.first_name
c.mem_no,c.first_name
22 FROM
FROM Rental
Rental rr RIGHT
RIGHT OUTER
OUTER JOIN
JOIN Customer
Customer cc
33 ONON r.mem_no
r.mem_no == c.mem_no;
c.mem_no;

TAPE_ID
TAPE_ID FROM_DATE
FROM_DATE MEM_NO
MEM_NO FIRST_NAME
FIRST_NAME
----------
---------- ---------
--------- ----------
---------- --------------------
--------------------
33 01-MAY-02
01-MAY-02 11 Tina
Tina
44 01-MAY-02
01-MAY-02 11 Tina
Tina
55 01-MAY-02
01-MAY-02 22 Carla
Carla
23
23 Anna
Anna
111
111 Bert
Bert
11
11 Fritz
Fritz
FU-Berlin, DBS I 2006, Hinze / Scholz

77 Anna
Anna

39
 SQL / DML: Implementations of joins
 Oracle/Postgres:
Simple join
Cross join
(natural) inner join with attribute list, with condition
(natural) Right, left, full outer join with condition

recommends ANSI-syntax for compatibility

 MySQL:
Simple join
Cross join
FU-Berlin, DBS I 2006, Hinze / Scholz

Straight join (left table always read before right one)

Inner join with condition
(natural) left, right outer join with condition
40
 SQL / DML: Improving the output
 Not feature of relational algebra
 Example:
Rename column title for this query
Order tuples

SQL>
SQL> SELECT
SELECT m.title
m.title asas Movies,
Movies, t.id,
t.id, t.format
t.format
22 FROM
FROM Movie
Movie m,
m, Tape
Tape tt
33 WHERE
WHERE m.id
m.id == t.movie_id
t.movie_id
44 ORDER
ORDER BY
BY title;
title;

MOVIES
MOVIES ID
ID FORMAT
FORMAT
------------------------------------
------------------------------------ --------
-------- ------
------
ET 22 DVD
FU-Berlin, DBS I 2006, Hinze / Scholz

ET DVD
Psycho
Psycho 11 DVD
DVD
Psycho
Psycho 33 VHS
VHS
Star
Star Wars
Wars II 44 DVD
DVD
Star
Star Wars
Wars II 55 VHS
VHS
Star
Star Wars
Wars II 99 VHS
VHS
41
 SQL / DML: Improving the output
 Syntax:
ORDER BY <orderexpression> ASC|DESC

 Ordering expression
No advanced expressions (no sub-query, no grouping)
At least one attribute reference
References in order expression result attributes

 Multiple sort attributes:

Primary ordering by first attribute
Secondary ordering by second attribute,
FU-Berlin, DBS I 2006, Hinze / Scholz

SELECT m.title as Movies, t.id, t.format

FROM Movie m, Tape t
WHERE m.id = t.movie_id
ORDER BY title, format;
42
 SQL / DML: Improving the output
 Advanced features system dependent
 Oracle SQL+ Example:
Format column title for all queries
Dont repeat identical titles
SQL>
SQL> BREAK
BREAK ON
ON title
title
SQL>
SQL> COLUMN
COLUMN title
title HEADING
HEADING "Movies"
"Movies" FORMAT
FORMAT A15
A15

SQL>
SQL> SELECT
SELECT m.title,
m.title, t.id,
t.id, t.format
t.format
22 FROM
FROM Movie
Movie m,
m, Tape
Tape tt
33 WHERE
WHERE m.id
m.id == t.movie_id;
t.movie_id;

Movies
Movies ID
ID FORMAT
FORMAT
FU-Berlin, DBS I 2006, Hinze / Scholz

---------------
--------------- ----------
---------- ------
------
Psycho
Psycho 11 DVD
DVD
ET
ET 22 DVD
DVD
Psycho
Psycho 33 VHS
VHS
Star
Star Wars
Wars II 44 DVD
DVD
55 VHS
VHS
99 VHS 43
VHS
 SQL / DML: Sub-queries
Core
 Sub-queries with single results SQL:1999
Operators {=, , , , <, >}
Expressible without sub-query

 Example:
Movies shorter than 'Star Wars I (id 345)

SELECT m.id
FROM Movie m
WHERE m.length <
FU-Berlin, DBS I 2006, Hinze / Scholz

(SELECT m1.length
FROM Movie m1
WHERE m1.id = 345);

44
 SQL / DML: Sub-queries
Core
 Set Operator IN SQL:1999

 Independent sub-query example:

All Tapes for movie Star Wars

SELECT t.id, t.format

FROM Tape t
WHERE t.movie_id
IN (SELECT m.id
FROM Movie m
FU-Berlin, DBS I 2006, Hinze / Scholz

WHERE m.title like 'Star Wars %');

45
 SQL / DML: Sub-queries
Core
 Set Operator IN SQL:1999

 Correlated sub-query example:

Directors playing in their own movies

SELECT m.director
FROM Movie m
WHERE m.director IN
(SELECT p.actor_name
FROM Play p
FU-Berlin, DBS I 2006, Hinze / Scholz

WHERE p.movie_id = m.id);

46
 SQL / DML: Sub-queries
Core
 Alternative syntax: EXISTS SQL:1999

 Example:
SELECT t.id, t.format
FROM Tape t
WHERE EXISTS (SELECT *
FROM Movie m
WHERE t.movie_id = m.id
AND m.title like 'Star Wars %');

SELECT m.director
FU-Berlin, DBS I 2006, Hinze / Scholz

FROM Movie m
WHERE EXISTS (SELECT *
FROM Play p
WHERE p.movie_id = m.id
AND m.director like p.actor_name);
47
 SQL / DML: Query rewriting
 Rewriting possible for IN, EXISTS

 Examples:
SELECT t.id, t.format
FROM Tape t, Movie m
WHERE m.id = t.movie_id
AND m.title like 'Star Wars %';

SELECT m.director
FU-Berlin, DBS I 2006, Hinze / Scholz

FROM Movie m, Play p

WHERE p.movie_id = m.id
AND m.director like p.actor_name;

48
 SQL / DML: Sub-queries
Core
 Negation NOT EXISTS, NOT IN SQL:1999

All tapes that never have been on loan

SELECT t.id
FROM Tape t
WHERE NOT EXISTS (SELECT *
FROM Rental r
WHERE r.tape_id = t.id);

All movies no copy of which are currently on loan

SELECT distinct m.id
FROM Movie m
FU-Berlin, DBS I 2006, Hinze / Scholz

Where NOT EXISTS (SELECT *

FROM Rental r, Tape t
WHERE r.tape_id = t.id
AND m.id = t.movie_id
AND r.until_date IS NULL);
49
 SQL / DML: Quantified sub-queries
enhanced
 Quantified comparison operators SQL:1999
No re-writing without sub-query
Quantification: ALL, SOME (synonym ANY)
Operators {=, , , , <, >}

 Quantification All
Sub-query true if true for all tuples

Most expensive movies

SELECT m.id, m.pricepday
FU-Berlin, DBS I 2006, Hinze / Scholz

FROM Movie m
WHERE m.pricepday >= ALL
(SELECT m1.pricepday
FROM MOVIE m1);
50
 SQL / DML: Quantified sub-queries
enhanced
 Quantification: SOME SQL:1999
Sub-query true if true for at least one tuple

SELECT title, pricePDay

FROM Movie m
WHERE pricePday < SOME
(SELECT m1.pricepday
FROM Movie m1);

= SOME equivalent IN

SELECT m.director
FU-Berlin, DBS I 2006, Hinze / Scholz

FROM Movie m
WHERE m.director = SOME
(SELECT p.actor_name
FROM Play p
WHERE p.movie_id = m.id);
51
 SQL / DML: Implementations of sub-queries

 Oracle:
Sub-queries with single results
Sub-queries with [NOT] IN, [NOT] EXISTS
Quantified comparison ALL, SOME, ANY

 PostgreSQL
Similar to Oracle
FU-Berlin, DBS I 2006, Hinze / Scholz

 MySQL:
No sub-queries supported

52
 SQL / DML: Universal quantifiers
 Quantification
 - Quantification (exactly one)
Describe counterexample
Combine with NOT EXISTS

Movies with only one tape

SELECT m.id
FROM Movie m
WHERE NOT EXISTS
(SELECT *
FROM Tape t1, Tape t2
WHERE t1.movie_id = t2.movie_id
FU-Berlin, DBS I 2006, Hinze / Scholz

AND t1.id <> t2.id

AND t2.movie_id = m.id );

53
 SQL / DML: Universal quantifiers

All Customers whose rented movies all have category suspense

SELECT c.mem_no
FROM Customer c
WHERE NOT EXISTS
(SELECT m.id
FROM Movie m, Rental r, Tape t
WHERE m.id = t.movie_id
AND r.tape_id = t.id
AND c.mem_no = r.mem_no
AND m.category <> 'suspense');
FU-Berlin, DBS I 2006, Hinze / Scholz

54
 SQL / DML: Universal quantifiers

Customers that had rented all movies

SELECT c.mem_no
FROM Customer c
WHERE NOT EXISTS
(SELECT m.id
FROM Movie m
WHERE NOT EXISTS
(SELECT *
FROM Rental r, Tape t
WHERE m.id = t.movie_id
AND r.tape_id = t.id
FU-Berlin, DBS I 2006, Hinze / Scholz

AND c.mem_no = r.mem_no));

55
 SQL / DML: Universal quantifiers

Customers that rented only one movie

SELECT c.mem_no
FROM Customer c, Rental r, Tape t, Movie m
WHERE c.mem_no = r.mem_no
AND r.tape_id = t.id
AND t.movie_id = m.id
AND NOT EXISTS
(SELECT m1.id
FROM Rental r1, Tape t1, Movie m1
WHERE r1.tape_id = t1.id
AND t1.movie_id = m1.id
FU-Berlin, DBS I 2006, Hinze / Scholz

AND c.mem_no = r1.mem_no

AND m1.id <> m.id);

56
 SQL / DML: Aggregate functions
 Mathematical aggregate functions on data sets
 Example: SUM, AVG, MIN, MAX, COUNT
 Not in relational algebra

SQL>
SQL> SELECT
SELECT MIN(pricePDay)
MIN(pricePDay) as
as MIN,
MIN,
22 MAX(pricePDay)
MAX(pricePDay) as
as MAX,
MAX, AVG(pricePDay)
AVG(pricePDay)
33 FROM
FROM Movie;
Movie;

MIN
MIN MAX
MAX AVG(PRICEPDAY)
AVG(PRICEPDAY)
----------
---------- ----------
---------- --------------
--------------
1.5
1.5 2.2
2.2 1.86666667
1.86666667
FU-Berlin, DBS I 2006, Hinze / Scholz

 Target list: only aggregate functions or none

Exception: GROUP BY

57
 SQL / DML: Aggregate functions
 Comparison using aggregates: sub-queries

Movies with price above average

SQL>
SQL> SELECT
SELECT m.id,
m.id, m.Title,
m.Title, m.pricepday
m.pricepday
22 FROM
FROM Movie
Movie mm
33 WHERE
WHERE pricePDay
pricePDay >>
44 (SELECT
(SELECT AVG(pricePDay)
AVG(pricePDay)
55 FROM
FROM Movie);
Movie);

ID
ID TITLE
TITLE PRICEPDAY
PRICEPDAY
------
------ ---------------------------------
--------------------------------- ---------
---------
95
95 Psycho
Psycho 22
FU-Berlin, DBS I 2006, Hinze / Scholz

345
345 Star
Star Wars
Wars II 22
222
222 Psycho
Psycho 2.2
2.2
290
290 Star
Star Wars
Wars IV
IV 22

58
 SQL / DML: Aggregate functions
 Examples:

Movies with minimal price

SELECT m.Title, m.pricepday
FROM Movie m
WHERE pricePDay =
(SELECT MIN(pricePDay)
FROM Movie);

Movie with more than 2 tapes

SELECT m.id, m.title
FU-Berlin, DBS I 2006, Hinze / Scholz

FROM Movie m
WHERE 2 < (SELECT count(t.id)
FROM tape t
WHERE t.movie_id = m.id)

59
 SQL / DML: Aggregate functions
 More examples:

Movies having tapes in one format only

SELECT m.id, m.title
FROM Movie m, Tape t1
WHERE m.id = t1.movie_id
AND 0 =
(SELECT COUNT(*)
FROM Tape t2
WHERE t1.id <> t2.id
AND t1.format <> t2.format
AND t2.movie_id = m.id);
FU-Berlin, DBS I 2006, Hinze / Scholz

60
 SQL / DML: Aggregate functions
 Additional qualification with DISTINCT | ALL

 Example:
Movies that are available in all formats
SELECT DISTINCT t1.movie_id
FROM Tape t1
WHERE
(SELECT COUNT(DISTINCT format)
FROM Tape t2
WHERE t2.movie_id = t1.movie_id)
FU-Berlin, DBS I 2006, Hinze / Scholz

=
(SELECT COUNT(*)
FROM Format);

61
 SQL / DML: Grouping
 Syntax: SELECT <targetlist>
FROM <tablelist>
[WHERE <predicate>]
GROUP BY <attributelist>

 Groups all rows with same values in <attributelist>

 Target list: grouping attributes and aggregates

 Example:
Number of tapes in each format
FU-Berlin, DBS I 2006, Hinze / Scholz

SELECT t.format, count(t.id)

FROM Tape t
GROUP BY t.format;

62
 SQL / DML: Grouping
 Aggregates evaluated over groups

Number of tapes for each movie

SQL>
SQL> SELECT
SELECT t.movie_id,
t.movie_id, count(*)
count(*)
22 FROM
FROM Tape
Tape tt
33 GROUP
GROUP BY
BY t.movie_id;
t.movie_id;

MOVIE_ID
MOVIE_ID COUNT(*)
COUNT(*)
----------
---------- ----------
----------
95
95 11
100
100 11
112 11
FU-Berlin, DBS I 2006, Hinze / Scholz

112
222
222 11
290
290 11
345
345 44

63
 SQL / DML: Grouping

Movie
id title cat. year director price leng.
095 Psycho ... ... Hitchcock 2.00 ...
112 ET ... ... Spielberg 1.50 ...
345 Star Wars I ... ... Lucas 2.00 ...
222 Psycho ... ... Van Sant 2.20 ...
290 Star Wars IV ... ... Lucas 2.00 ...
100 Jaws ... ... Spielberg 1.50 ...
... ... ... ... ... ... ...

SELECT sum(price) 11.2

FU-Berlin, DBS I 2006, Hinze / Scholz

FROM movie;

Implicit group: all tuples in table

64
 SQL / DML: Grouping

Movie
id title cat. year director price leng.
095 Psycho ... ... Hitchcock 2.00 ...
112 ET ... ... Spielberg 1.50 ...
345 Star Wars I ... ... Lucas 2.00 ...
222 Psycho ... ... Van Sant 2.20 ...
290 Star Wars IV ... ... Lucas 2.00 ...
100 Jaws ... ... Spielberg 1.50 ...
... ... ... ... ... ... ...

Hitchcock 2.0
SELECT director, sum(price) Spielberg 3.0
FU-Berlin, DBS I 2006, Hinze / Scholz

FROM movie Lucas 4.0

Group by director;
Van Sant 2.2

65
 SQL / DML: Grouping

Total receipts of each tape within the last year

SQL>
SQL> SELECT
SELECT t.id,
t.id, count(*)
count(*)
22 FROM
FROM Tape
Tape t,
t, Rental
Rental rr
33 WHERE
WHERE t.id
t.id == r.tape_id
r.tape_id
44 AND
AND to_char(r.from_date,'yyyy')
to_char(r.from_date,'yyyy') >=
>= 2005
2005
55 GROUP
GROUP BY
BY t.id;
t.id;

ID
ID COUNT(*)
COUNT(*)
----------
---------- ----------
----------
11 11
22 11
33 22
FU-Berlin, DBS I 2006, Hinze / Scholz

44 22
55 11
11
11 11
12
12 11

66
 SQL / DML: Grouping

Total receipts of each movie within the last year

SQL>
SQL> SELECT
SELECT t.movie_id,
t.movie_id, count(*)
count(*)
22 FROM
FROM Tape
Tape t,
t, Rental
Rental rr
33 WHERE
WHERE t.id
t.id == r.tape_id
r.tape_id
44 AND
AND to_char(r.from_date,'yyyy')
to_char(r.from_date,'yyyy') >=
>= 2005
2005
55 GROUP
GROUP BY
BY t.movie_id;
t.movie_id;

MOVIE_ID
MOVIE_ID COUNT(*)
COUNT(*)
----------
---------- ----------
----------
95
95 11
100
100 11
112
112 11
FU-Berlin, DBS I 2006, Hinze / Scholz

222
222 22
290
290 11
345
345 33

67
 SQL / DML: Grouping + Having
 Qualifying predicate for groups
SQL>
SQL> SELECT
SELECT f.name,
f.name, sum(charge)
sum(charge)
22 FROM
FROM Rental
Rental r,
r, Tape
Tape t,
t, format
format ff
33 WHERE
WHERE t.id
t.id == r.tape_id
r.tape_id
44 AND
AND t.format=f.name
t.format=f.name
55 GROUP
GROUP BY
BY f.name;
f.name;
SQL>
SQL> SELECT
SELECT f.name,
f.name, sum(charge)
sum(charge)
NAME
NAME SUM(CHARGE)
SUM(CHARGE)
22 FROM
FROM Rental
Rental r,
r, Tape
Tape t,
t, format
format ff
-----
----- -----------
-----------
33 WHERE
WHERE t.id
t.id == r.tape_id
r.tape_id
Beta
Beta 00
44 AND
AND t.format=f.name
t.format=f.name
DVD
DVD 88
55 GROUP
GROUP BY
BY f.name
f.name
VHS
VHS 00
66 having
having count(f.name)>2;
FU-Berlin, DBS I 2006, Hinze / Scholz

count(f.name)>2;

NAME
NAME SUM(CHARGE)
SUM(CHARGE)
-----
----- -----------
-----------
DVD
DVD 88
VHS
VHS 00 68
 SQL / DML: Grouping + Having

Movie
id title cat. year director price leng.
095 Psycho ... ... Hitchcock 2.00 ...
112 ET ... ... Spielberg 1.50 ...
345 Star Wars I ... ... Lucas 2.00 ...
222 Psycho ... ... Van Sant 2.20 ...
290 Star Wars IV ... ... Lucas 2.00 ...
100 Jaws ... ... Spielberg 1.50 ...
... ... ... ... ... ... ...

Hitchcock 2.0
SELECT director, sum(price) Spielberg 3.0
FU-Berlin, DBS I 2006, Hinze / Scholz

FROM movie Lucas 4.0

Group by director
Van Sant 2.2
HAVING sum(price)>2.00;

69
 SQL / DML: Grouping + Having

Movie
id title cat. year director price leng.
095 Psycho ... ... Hitchcock 2.00 ...
112 ET ... ... Spielberg 1.50 ...
345 Star Wars I ... ... Lucas 2.00 ...
222 Psycho ... ... Van Sant 2.20 ...
290 Star Wars IV ... ... Lucas 2.00 ...
100 Jaws ... ... Spielberg 1.50 ...
... ... ... ... ... ... ...
max
Hitchcock 2.0 2.0
SELECT director, sum(price) Spielberg 3.0 1.5
FU-Berlin, DBS I 2006, Hinze / Scholz

FROM movie Lucas 4.0 2.0

Group by director
Van Sant 2.2 2.2
HAVING max(price)>2.00;

70
 SQL / DML: Grouping + Having

Movie
id title cat. year director price leng.
095 Psycho ... ... Hitchcock 2.00 ...
112 ET ... ... Spielberg 1.50 ...
345 Star Wars I ... ... Lucas 2.00 ...
222 Psycho ... ... Van Sant 2.20 ...
290 Star Wars IV ... ... Lucas 2.00 ...
100 Jaws ... ... Spielberg 1.50 ...
... ... ... ... ... ... ...
max
Hitchcock, Psycho 2.0 2.0
SELECT director,title, sum(price) Spielberg, ET 1.5 1.5
FU-Berlin, DBS I 2006, Hinze / Scholz

FROM movie Lucas, SW I 2.0 2.0

Group by director, title
Van Sant, Psycho 2.2 2.2
HAVING max(price)>2.00;
Lucas, SW IV 2.0 2.0
Spielberg, Jaws 1.5 1.5
71
 SQL / DML: Grouping + Having
 HAVING without GROUP BY
Implicit single group contains all tuples

SQL>
SQL> SELECT
SELECT sum(charge)
sum(charge)
22 FROM
FROM Rental
Rental r,
r, Tape
Tape t,
t, format
format ff
33 WHERE
WHERE t.id
t.id == r.tape_id
r.tape_id
44 AND
AND t.format=f.name
t.format=f.name
55 having
having count(f.name)>2;
count(f.name)>2;

SUM(CHARGE)
SUM(CHARGE)
-----------
-----------
88
FU-Berlin, DBS I 2006, Hinze / Scholz

72
 SQL / DML: Grouping + Having
 Query evaluation order:
1.FROM-clause
2.WHERE-clause
3.GROUP BYclause
4.HAVING-clause
5.SELECT-clause

Number of rentals for all customers named Anna or Tina,

which rented some tapes more than once
SELECT c.mem_no, count(*)
FROM Rental r, Customer c
FU-Berlin, DBS I 2006, Hinze / Scholz

WHERE r.mem_no= c.mem_no

AND c.first_name ='Anna'
OR c.first_name='Tina'
GROUP BY c.mem_no
HAVING count(DISTINCT r.tape_id)<count(*);
73
 SQL / DML: Nested aggregation with groups
 Nested aggregation using groups

Most loaned movie

SELECT t.movie_id, count(t.movie_id)

FROM Rental r, Tape t
WHERE r.tape_id = t.id
GROUP BY t.movie_id
HAVING COUNT(t.movie_id) > = ALL
(SELECT count(t1.movie_id)
FROM Rental r1, Tape t1
WHERE r1.tape_id = t1.id
FU-Berlin, DBS I 2006, Hinze / Scholz

Group BY t1.movie_id);

74
 SQL / DML: Nested aggregation with groups

Movie with maximal number of tapes, show number of tapes

SELECT m.id, m.title, t1.t_no

FROM (SELECT t.movie_id, count(*) as t_no
FROM tape t
GROUP BY t.movie_id) t1, movie m
WHERE m.id=t1.movie_id
AND t1.t_no = (SELECT max(count(*))
FROM tape t
GROUP by t.movie_id);
FU-Berlin, DBS I 2006, Hinze / Scholz

75
 SQL / DML: Output improvement
Core
 Select values depending an condition SQL:1999
 Complete CASE form:
CASE
WHEN <condition1> THEN <result1>
[ WHEN <condition2> THEN <result2>
[ WHEN <condition3> THEN <result3> ]]
[ ELSE <elseresult>]
END

 Example:
SELECT length,
FU-Berlin, DBS I 2006, Hinze / Scholz

CASE WHEN length is NULL then 'not defined'

WHEN length < 90 THEN 'short'
ELSE 'long'
END
FROM Movie;
76
 SQL / DML: Output improvement
Core
 Simple CASE form SQL:1999
CASE <operand>
WHEN <value1> THEN <result1>
[ WHEN <value2>THEN <result2>
[ WHEN <value3> THEN <result3> ]]
[ ELSE <elseresult>]
END

 Example:
select f.name,
case f.name
when 'DVD' then 'DISC'
FU-Berlin, DBS I 2006, Hinze / Scholz

when 'Beta' then 'TAPE'

when 'VHS' then 'TAPE'
else NULL
end
from Format f;
77
 SQL / DML: Transitive closure
enhanced
 Recursive queries SQL:1999
Name recursion expression
Use name in associated query expression

 SYNTAX:

WITH RECURSIVE
<queryname1> AS <query1>[,
<queryname2> AS <query2>,...]
SELECT ...
FROM <queryname1>[,<queryname2>...]
WHERE...
FU-Berlin, DBS I 2006, Hinze / Scholz

78
 SQL / DML: Transitive closure
enhanced
 Example: All lectures required for lecture XYZ SQL:1999
create table lecture(
lnr integer primary key,
name varchar(20));
create table requires(
pre integer references lecture(lnr),
suc integer references lecture(lnr),
constraint req_pk primary key(pre, suc));

WITH RECURSIVE preLecture(pre, suc)

AS (SELECT pre,suc FROM requires)
FU-Berlin, DBS I 2006, Hinze / Scholz

SELECT l.lnr as prerequisite

FROM preLecture p1, preLecture p2, lecture l
WHERE p2.suc = l.lnr
AND l.name = databases
AND p1.suc = p2.pre;
79
 SQL / DML: Transitive closure
 Different implementation in oracle:
Lecture: LNR NAME Requires: PRE SUC
--- -------------- --- ---
1 databases 2 3
2 algorithms I 3 1
3 algorithms II

SQL>
SQL> SELECT
SELECT r.pre
r.pre
22 FROM
FROM requires
requires r,r, lecture
lecture ll
33 WHERE
WHERE l.name=
l.name= 'databases'
'databases'
44 START
START WITH
WITH r.suc
r.suc == l.lnr
l.lnr
55 CONNECT
CONNECT BY
BY PRIOR
PRIOR pre
pre == suc;
suc;
FU-Berlin, DBS I 2006, Hinze / Scholz

PRE
PRE
----------
----------
33
22
80
 SQL / DML: Structuring
enhanced
 Difficult structuring of complex queries SQL:1999
 No naming of commands / relations for re-use

 Temporary table
CREATE TABLE <tablename>
{global temporary | local temporary }
<table structure>
[ON COMMIT {PRESERVE ROWS | DELETE ROWS}]

Stores temporal query result

LOCAL: Only visible to owner
FU-Berlin, DBS I 2006, Hinze / Scholz

Dropped at end of session

81
 SQL / DML: Temporary table
 Example: Test1:
CREATE TABLE testsource(id integer);
CREATE GLOBAL TEMPORARY TABLE
test1(id integer)
ON COMMIT PRESERVE ROWS; No rows

INSERT INTO testsource values(1); No rows

INSERT INTO test1

SELECT *
FROM testsource; 1
FU-Berlin, DBS I 2006, Hinze / Scholz

INSERT INTO testsource values(2); 1

COMMIT;
1

82
 SQL / DML: Temporary table
 Example: Test2:
CREATE TABLE testsource(id integer);
CREATE GLOBAL TEMPORARY TABLE
test2(id integer)
ON COMMIT DELETE ROWS; No rows

INSERT INTO testsource values(1); No rows

INSERT INTO test2

SELECT *
FROM testsource; 1
FU-Berlin, DBS I 2006, Hinze / Scholz

INSERT INTO testsource values(2); 1

COMMIT; No rows

83
 SQL / DML: View
 SQL-object (virtual relation) Important concept

 Important for
Tailoring database schema for different applications
Access protection, Privacy
Structuring complex queries
 Relational concept for external schema

 Syntax:
CREATE VIEW <viewname> AS <query>;

 Example:
FU-Berlin, DBS I 2006, Hinze / Scholz

CREATE VIEW rental_overview AS

SELECT r.mem_no, c.last_name, r.tape_id
FROM rental r, customer c
WHERE r.mem_no = c.mem_no;
84
 SQL / DML: View updates
Core
 Updateable views: SQL:1999
1. No SELECT DISTINCT
2. No duplicate attribute in target list
3. Only one table reference
4. No GROUP BY
5. No aggregates
6. No set operators (INTERSECT, EXCEPT, UNION)

 Formal:
u (V(B)) = V (cu (B) )
FU-Berlin, DBS I 2006, Hinze / Scholz

V(B) view on base tables B

u(V(B)) update on view
cu : equivalent update(s) on base relations must exist
85
 SQL / DML: View updates
Core
 Examples: SQL:1999
Not updateable ( distinct, group by ):
CREATE VIEW movieformats (movie, numFormats)
AS SELECT movie_id, count(distinct format)
FROM Tape t
GROUP BY movie_id;

Updateable:
CREATE VIEW movies (movie, name)
AS SELECT id, title
FROM Movie
FU-Berlin, DBS I 2006, Hinze / Scholz

WHERE id > 100;

u: INSERT INTO movies VALUES (47,The Fugitive);

cu: INSERT INTO movie (id, title)
VALUES (47,The Fugitive);
86
 SQL / DML: View updates
 Additional conditions:

If u does not have an effect, then cu should not

No side effects: c should only effect tuples in B which are

represented in V

Inverse update: For a view update u there should be an

inverse update w such that w (u ( V( B )) ) = V (B)

No constraint on base tables must be violated by u

FU-Berlin, DBS I 2006, Hinze / Scholz

87
 SQL / DML: View updates
 Views with check option
CHECK OPTION prevent side effects on base tables

 Syntax: CREATE VIEW <viewname>

AS <query>
WITH CHECK OPTION;

 Theoretically more views updateable

e.g. UNIQUE columns in joins
FU-Berlin, DBS I 2006, Hinze / Scholz

 Enhanced SQL:
1999 additional complex conditions for view update

88
 SQL / DML: Remarks about NULL
 NULL treated as "unknown"
 Predicates:
NULL AND TRUE = NULL
NULL OR TRUE = TRUE
predicate evaluates to NULL for row r r not returned

 Arithmetical expression:
If NULL involved expression evaluates to NULL

 Aggregates:
FU-Berlin, DBS I 2006, Hinze / Scholz

Count(*) counts also NULL

avg(*) sum(*)/count(*)

89
 SQL / DML: Summary
 SQL as Data manipulation language
Declarative language
Relational complete query language

 Important terms and concepts:

Insert, update, delete data
Basic query pattern
DISTINCT, ALL
Set combination (UNION, INTERSECT, EXCEPT)
Joins
Sub-queries (IN, EXISTSSOME, ALL)
FU-Berlin, DBS I 2006, Hinze / Scholz

Aggregate functions
GROUP BY, HAVING
View, view updates
90