Kapitel 4

Kapitel 4
Objektorientierung und Datenbanken
- Objektrelationaler SQL’99-Standard Dieser Teil der Unterlagen wurde weitgehend
unverändert übernommen von Dr. Can Türker,
ETH Zürich.
Herzlichen Dank für die Überlassung!
Überblick

Motivation

„Klassische SQL-Tabellen“

Erweiterungen des Datenmodells in SQL 1999
–
–
–

neue (Basis-) Datentypen
neue Typkonstruktoren
Objekttypen
… und daraus resultierende Erweiterungen bei den Operationen
4-2
“Advanced applications need advanced data structures!”

Ziel: 1 Anwendungsobjekt in 1 Datenbankobjekt abbilden
“Real
World”
!!!
DBMS
4-3
Beispiel: RDBMS in technischen Anwendungen
Robot
Effector
Rob_ID
Rob_Descr
Eff_ID
Function
Rob1
Rob2
Rob3
:
Speedy 400 ...............
Speedy 600 ...............
Colossus MX-3 .........
:
GR600
GR700
LS1
PS1350
Greifer Typ 600 ..............................
Greifer Typ 700 ..............................
Laserschweißer Typ 1 ....................
Punktschweißer Typ 1350 ..............
PS1380
PS1510
SR200
Punktschweißer Typ 1380 ..............
Punktschweißer Typ 1510 ..............
Schrauber Typ 200 .........................
Axes
has
(1,n)
Robot
(0,n)
can work
with
Rob_I
D
Arm_I
D
Rob1
Rob1
Rob1
:
links
links
links
:
AchsNr
Robot_Arms
GW_min
GW_max
-90
-170
-190
:
90
180
180
1
2
3
:
Masse
:
Beschl
40,0
30,5
20,0
:
1,0
1,5
3,0
:
(0,n)
(1,1)
ArmID
Rob1
Rob1
Rob2
Rob3
links
rechts
solo
links
Rob3
Rob3
mitte
rechts
Effector
Arms
Matrices
(1,n)
consist
of
(1,1)
Axes
Rob_ID
(4,4)
degrees
of
freedom
(1,1)
matrix rows
Rob_ID
Arm_ID
Rob1
Rob1
Rob1
Rob1
Rob1
:
Rob1
links
links
links
links
links
:
links
CanWorkWith
AchsNr
ZNr
Sp1
1
1
1
1
2
:
3
1
2
3
4
1
:
4
1
0
0
0
0
:
0
Sp2
0
0
-1
0
0
:
-1
Sp3
Sp4
0
1
0
1
0
:
0
1
0
80
1
60
:
70
Rob_ID
Eff_ID
Rob1
Rob1
Rob1
Rob1
:
Rob2
Rob2
SR200
SR300
PS1380
GR700
:
SR200
SR300
4-4
Beispiel: SQL Query
SELECT r.Rob_ID, r.Rob_Descr,
ar.Arm_ID, ac.AxisNo,
m.ZNo, m.Sp1, m.Sp2, m.Sp3, m.Sp4,
ac.GW_min, ac.GW_max, ac.Mass, ac.Accel,
re.Eff_ID, e.Function
FROM Robot r, Robot_Arms ar,
Axes ac, Matrices m,
CanWorkWith re, Effectors e
WHERE
r.Rob_ID = 'Rob1' AND
r.Rob_ID = ar.Rob_ID AND
ar.ROB_ID = ac.Rob_ID AND
ar.Arm_ID = ac.Arm_ID AND
ac.Arm_ID = m.Arm_ID AND
ac.Rob_ID = m.Rob_ID AND
ac.AxisNo = m.AxisNo AND
r.Rob_ID = re.Rob_ID AND
re.Eff_ID = e.Eff_ID
4-5
Beispiel: Resultat dieser Anfrage




diese SQL Anfrage liefert eine (“flache”, aber breite) Tabelle
bei 2 Armen á 4 Achsen und 6 Effektoren:
192 Tupel mit insgesamt 2.880 Attributwerten
wegen der relationalen Darstellung des Ergebnisses (1NF Relation):
nur 216 Werte (=8%) aus dieser Flut sind essenziell,
die anderen 92% sind redundant!
Konsequenz: SQL bzw. RDBMSe brauchen andere, zusätzliche
Strukturierungsmöglichkeiten für anspruchsvollere Anwendungen!
4-6
Basiskonstrukte von SQL-92

Tabellen
–
–
–
–

Basisdatentypen
–

INTEGER, SMALLINT, NUMERIC, DECIMAL,REAL,
FLOAT, CHARACTER, DATE, TIME, BIT, ...
MULTISET
ROW
Basisdatentyp
Integritätsbedingungen
–
–

Basistabellen zur Speicherung von Daten
Sichten (Views): abgeleitete Tabellen
Typ eines Attributs ist ein Basisdatentyp (1NF)
Zeilen (Tupel) setzen sich aus Instanzen der
jeweiligen Wertebereiche zusammen
Primär-/Fremdschlüssel, Check-Klauseln
Assertions: Bedingungen über mehrere Tabellen
Zugriffsrechte (Grants)
4-7
Tupeltabelle
•
Eine Tupeltabelle ist eine traditionelle Tabelle im Sinne von SQL-92
•
Eine solche Tabelle besteht aus einer (Multi-)Menge von Tupeln
Tabellenname
Spalten (Columns) = Attribute
R A1 ... An
...
Attributwerte
...
...
Zeilen (Rows) = Tupel
4-8
SQL-99 - Datenmodellerweiterungen

Neue Basisdatentypen: BOOLEAN, BLOB, CLOB

Neue Typkonstruktoren: ROW, ARRAY, REF

Benutzerdefinierte Datentypen (Distinct-Typ und strukturierte Typen)

Typhierarchien (Subtypen)

Typisierte Tabellen und Tabellenhierarchien (Subtabellen)

Typisierte Sichten und Sichthierarchien (Subsichten)
4-9
SQL-99 - Datenmodell
SET
MULTISET
OBJECT
ROW
ARRAY
REF
Einstiegspunkte in die Datenbank:
Typisierte Tabelle:
SET(OBJECT(...))
Untypisierte Tabelle:
MULTISET(ROW(...))
Basisdatentyp
Subtypbeziehung
Untermengenbeziehung
4-10
Neue Basisdatentypen (1)
BOOLEAN:
 3-wertige Logik
–
–
Werte:
 TRUE
 FALSE
 UNKNOWN
Operationen:
 NOT
 AND
 OR
 IS [NOT]
NOT
TRUE
FALSE
AND
TRUE
TRUE
TRUE
FALSE
FALSE
UNKNOWN UNKNOWN
OR
TRUE
FALSE
UNKNOWN
TRUE
TRUE
TRUE
TRUE
IS
TRUE
FALSE
UNKNOWN
TRUE
TRUE
FALSE
FALSE
FALSE
TRUE
UNKNOWN
UNKNOWN
FALSE
FALSE
FALSE
FALSE
UNKNOWN
UNKNOWN
FALSE
UNKNOWN
FALSE
UNKNOWN
TRUE
TRUE
FALSE
UNKNOWN
UNKNOWN UNKNOWN
FALSE
FALSE
TRUE
FALSE
UNKNOWN
FALSE
FALSE
TRUE
4-11
Neue Basisdatentypen (2)
Large Objects
–
–
–
–
BLOB (Binary Large Object)
CLOB (Character Large Object)
Operationen
 SUBSTRING, OVERLAY, || (Konkatenation)
 IS [NOT] NULL, LIKE, EQUALS, POSITION, LENGTH, SIMILAR
Nicht erlaubt
 BLOB/CLOB-Attribute als Teil eines Schlüssels
 GROUP BY, ORDER BY, GREATER/LESS THAN
4-12
Neue Basisdatentypen - Beispiel
Definition einer Tabelle mit BOOLEAN- und LOB-Attributen:
CREATE TABLE MitarbeiterTupelTabelle (
Name
VARCHAR(30),
Vollzeit BOOLEAN,
Bild
BLOB(1M),
Bewerbung CLOB(50k)
);
Verwendung von BOOLEAN- und LOB-Attributen:
SELECT Name
FROM MitarbeiterTupelTabelle
WHERE Vollzeit IS TRUE AND
POSITION ('Datenbanken' IN Bewerbung) > 0;
4-13
Tupeltypkonstruktor - ROW
Erzeugen eines Tupeltyps:
ROW(Feldname_1 Datentyp_1, ..., Feldname_n Datentyp_n)
Beispiel:
ALTER TABLE MitarbeiterTupelTabelle
ADD COLUMN Anschrift ROW(Strasse VARCHAR(30),
Nr DECIMAL(4),
PLZ DECIMAL(5),
Ort VARCHAR(40),
Land VARCHAR(25));
4-14
Operationen auf Tupeltypen
Erzeugen eines Tupels mit dem Tupelkonstruktor (der genauso wie der
Tupeltypkonstruktor heisst): ROW('Seestrasse', 31, 8008, 'Zürich', 'Schweiz')
Zugriff auf ein Tupelfeld
mittels Punktnotation:
SELECT Name, Anschrift.ORT
FROM MitarbeiterTupelTabelle
Vergleich zweier Tupel:
ROW(1, 2, 7) = ROW(1, 2, 7)
-- liefert TRUE
ROW(1, 2, 7) = ROW(1, 3, 7)
-- liefert FALSE
ROW(1, 2, 7) = ROW(1, NULL, 7) -- liefert UNKNOWN
ROW(1, 2, 7) < ROW(1, 3, 5)
ROW(1, 2, 7) < ROW(1, 1, 7)
ROW(1, 2, 7) < ROW(1, NULL, 7)
ROW(1, 2, 7) < ROW(1, 3, NULL)
-- liefert TRUE
-- liefert FALSE
-- liefert UNKNOWN
-- liefert TRUE
4-15
Arraytypkonstruktor - ARRAY
Erzeugen eines Arraytyps:
Elementtyp ARRAY[Maximale-Kardinalität]
Beispiel:
ALTER TABLE MitarbeiterTupelTabelle
ADD COLUMN Sprachkenntnisse VARCHAR(15) ARRAY[8];
4-16
Operationen auf Arraytypen (1)
Erzeugen eines Arrays mit dem Arraykonstruktor (der genauso wie der
Arraytypkonstruktor heisst): ARRAY('Deutsch', 'Englisch')
Direkter Zugriff auf das
i-te Arrayfeld mittels [i]:
SELECT Sprachkenntnisse[2]
FROM MitarbeiterTupelTabelle;
Deklarativer Elementzugriff
mittels Entschachtelung:
SELECT s
FROM MitarbeiterTupelTabelle,
UNNEST(Sprachkenntnisse) s;
4-17
Operationen auf Arraytypen (2)
Änderung eines einzelnen
Arrayelements:
UPDATE MitarbeiterTupelTabelle
SET
Sprachkenntnisse[1] = 'Türkisch';
Änderung des kompletten
Arraywerts:
UPDATE MitarbeiterTupelTabelle
SET
Sprachkenntnisse = ARRAY['Türkisch'];
Kardinalität liefert Anzahl
der Arrayelemente:
CARDINALITY(ARRAY['Deutsch', Türkisch'])
-- liefert den Wert 2
4-18
Operationen auf Arraytypen (3)
Konkatenation zweier Arrays:
ARRAY['Deutsch', 'Türkisch'] ||ARRAY['Englisch']
-- erzeugt ARRAY['Deutsch', 'Türkisch', 'Englisch']
Vergleich zweier Arrays:
—
—
Zwei Arrays sind vergleichbar g.d.w. ihre Elementtypen vergleichbar sind
Zwei vergleichbare Array A1 und A2 sind gleich (A1=A2) g.d.w
(1) sie die gleiche Kardinalität besitzen und
(2) alle Elemente paarweise gleich sind
ARRAY['Deutsch', 'Türkisch'] <> ARRAY['Deutsch', 'Türkisch', 'Englisch']
ARRAY['Deutsch', 'Türkisch'] = ARRAY['Deutsch', 'Türkisch', NULL]
-- liefert TRUE
-- liefert FALSE
4-19
Referenztypkonstruktor - REF
Erzeugen eines Referenztyps:
REF(Strukturierter-Typ) [SCOPE (TypisierteTabelle)]
–
–
referenzierter Typ muss ein strukturierter Typ sein
Instanzen eines Referenztyp können nur dann dereferenziert werden, wenn eine
entsprechend typisierte Tabelle als Wertebereich (Scope) festgelegt wurde
Beispiel:
ALTER TABLE MitarbeiterTupelTabelle
ADD COLUMN Abteilung REF(AbteilungsTyp) SCOPE Abteilungen;
–
AbteilungsTyp sei hier ein strukturierter Typ und Abteilung eine auf diesem Typ
basierende typisierte Tabelle
4-20
Operationen auf Referenztypen
Erzeugen einer Referenz auf ein Objekte durch Zuweisung der zugehörigen OID an ein
Referenzattribut bzw. Referenzvariable
Dereferenzierung mittels PfeilOperator:
SELECT Abteilung->Name
FROM MitarbeiterTupelTabelle;
Referenzauflösung mittels
DEREF-Operator:
SELECT DEREF(Abteilung)
FROM MitarbeiterTupelTabelle;
Vergleich zweier Referenzen:
—
—
Zwei Referenzen sind vergleichbar g.d.w. ihre referenzierten Typen gleich sind
Zwei vergleichbare Referenzen R1 und R2 sind gleich (R1=R2) g.d.w sie
denselben Referenzwert aufweisen (d.h. auf dasselbe Objekte verweisen)
4-21
Neue Typkonstruktoren - Beispiele (1)
Verwendung des Tupel- bzw. Arraytypkonstruktors:
INSERT INTO MitarbeiterTupelTabelle(Name, Sprachkenntnisse)
VALUES (ROW('Billy', 'Clintwood'),
ARRAY['Deutsch', 'Englisch', 'Türkisch']);
Zugriff auf tupelwertige Attribute bzw. Verwendung arraywertiger Attribute:
SELECT Name.Nachname
FROM MitarbeiterTupelTabelle
WHERE Name.Vorname = 'John' AND
'Deutsch' IN (SELECT * FROM UNNEST(Sprachkenntnisse));
4-22
Neue Typkonstruktoren - Beispiele (2)
Änderung einer Tupelkomponente:
UPDATE MitarbeiterTupelTabelle
SET Name.Nachname = 'Türker'
WHERE Name.Nachname = 'Tuerker';
Änderung eines Arrayelements mittels direktem Positionszugriff:
UPDATE MitarbeiterTupelTabelle
SET Sprachkenntnisse[4]= 'Französisch'
WHERE Name.Nachname = 'Türker';
4-23
Distinct-Typen
Kopie eines existierenden Datentyps mit neuem Namen
–
–
–
–
–
Wiederverwendung
Strenge Typisierung (basiert auf Namensäquivalenz)
Nicht-optionales Schlüsselwort FINAL schliesst Subtypbildung aus
Systemdefinierte Vergleichsoperatoren basierend auf dem Quelltyp
Cast-Operatoren zur Konversion zwischen Distinct- und Quelltyp
Erzeugen eines
Distinct-Typs:
Beispiele:
CREATE TYPE Distinct-Typname AS (Quelltyp) FINAL
[CAST (SOURCE AS DISTINCT) WITH Funktionsname]
[CAST (DISTINCT AS SOURCE) WITH Funktionsname]
CREATE TYPE Franken AS DECIMAL(12,2) FINAL;
CREATE TYPE Euro AS DECIMAL(12,2) FINAL;
4-24
Operationen auf Distinct-Typen
Erzeugen einer Instanz eines Distinct-Typs:
Distinct-Typname(Quelltypwert)
z.B. Franken(1311.69) oder
Euro(170470.13)
Vergleich zweier Distinct-Werte:
— Distinct-Typen unterliegen der strengen Typisierung
— Zwei Distinct-Werte sind vergleichbar g.d.w. ihre Distinct-Typen identisch sind
— Beispiel: Franken(1000.00) = Euro(1000.00) ergibt einen Typkonflikt
4-25
Verwendung von Distinct-Typen (1)
Beispiel: Distinct-Typen in Tabellendefinitionen:
CREATE TABLE CHBank(Nr INTEGER, Stand Franken);
CREATE TABLE EuroBank(Nr INTEGER, Stand Euro);
Anfrage basierend auf Distinct-Typen:
SELECT e.Nr
FROM CHBank c, EuroBank e
WHERE c.Nr= 234302 AND
c.Stand > e.Stand;
Anfrage ergibt Typkonflikt:
Schweizer Franken und Euro
sind nicht vergleichbar
→ Typkonvertierung ist notwendig!
→ CAST-Funktionen
4-26
Verwendung von Distinct-Typen (2)
Vorherige Anfrage nun mit expliziter Konvertierung von Euro nach Franken:
SELECT e.Nr
FROM CHBank c, EuroBank e
WHERE c.Nr= 234302 AND
c.Stand > CAST(CAST(e.Stand AS DECIMAL(12,2)) AS Franken);
Problem: Derartige Konvertierungen sind nicht immer "semantisch" sinnvoll!
Oftmals sind benutzerdefinierte Cast-Funktionen notwendig, die nicht nur
den Typ, sondern auch den Wert konvertieren bzw. neu berechnen.
4-27
Benutzerdefinierte Cast-Funktionen

Konversion zwischen unterschiedlichen Datentypen

Syntax:
CREATE CAST (Typ1 AS Typ2)
WITH Konvertierungsfunktion(Parameter Typ1) [AS ASSIGNMENT]
–
–
–
Typ1 oder Typ2 muss ein benutzerdefinierter Typ oder ein Referenztyp sein
Konvertierungsfunktion
– hat genau einen Parameter vom Typ Typ1 und Typ2 als Rückgabetyp
– ist deterministisch und liest und ändert keine SQL-Daten
AS ASSIGNMENT: Implizite Cast-Funktion (wird automatisch aufgerufen)
4-28
Explizite Cast-Funktionen - Beispiel
Definition einer Konvertierungsfunktion:
CREATE FUNCTION Franken(e Euro)
RETURNS Franken
RETURN CAST(CAST(e AS DECIMAL(12,2)) * 1.5 AS Franken);
Definition einer expliziten Cast-Funktion:
CREATE CAST (Euro AS Franken) WITH Franken(Euro);
Vorherige Anfrage nun mit direkter Konvertierung von Euro nach Franken:
SELECT e.Nr
FROM CHBank c, EuroBank e
WHERE c.Nr= 234302 AND
c.Stand > Franken(e.Stand);
4-29
Implizite Cast-Funktionen - Beispiel
Definition einer Konvertierungsfunktion:
CREATE FUNCTION Euro(f Franken)
RETURNS Euro
RETURN CAST(CAST(f AS DECIMAL(12,2)) * 0.65 AS Euro);
Definition einer impliziten Cast-Funktion:
CREATE CAST (Franken AS Euro) WITH Euro(Franken) AS ASSIGNMENT;
Vorherige Anfrage nun mit impliziter Konvertierung von Franken nach Euro:
SELECT e.Nr
FROM CHBank c, EuroBank e
WHERE c.Nr= 234302 AND
c.Stand > e.Stand;
4-30
Strukturierte Typen
Abstrakte Objekttypen mit Verhalten und eingekapselter Struktur
–
–
–
–
–
Optional: Subtypbildung mittels UNDER-Klausel
Optional: Instanziierung verbieten
Nicht-optionales Schlüsselwort NOT FINAL erlaubt Subtypbildung
Optional: Bestimmen der Referenzgenerierung (OID-Erzeugung)
Optional: Objektverhalten in Methoden kodieren
Syntax:
CREATE TYPE Typname [UNDER Supertypname]
AS (Attributdefinitionsliste)
[[NOT] INSTANTIABLE]
NOT FINAL
[Referenzgenerierung [Referenzcasting]]
[Methodendeklarationsliste]
4-31
Attributdefinition
Syntax:
Attributname Typ
[REFERENCES ARE NOT CHECKED
| REFERENCES ARE CHECKED ON DELETE NO ACTION]
[DEFAULT Defaultwert]
–
–
Bei Referenzattributen, die mit einer SCOPE-Klausel versehen sind,
muss auch die REFERENCES-Klausel spezifiziert werden
Default: REFERENCES ARE NOT CHECKED
 Ungültige Referenzen sind möglich
4-32
Strukturierte Typen - Beispiele
Instanzen strukturierter Typen heissen Objekte
CREATE TYPE AdresseTyp AS (
Strasse VARCHAR(30),
Nr
DECIMAL(4),
PLZ
DECIMAL(5),
Ort
VARCHAR(40),
Land
VARCHAR(25)
) NOT FINAL;
Basisdatentypen
CREATE TYPE PersonTyp AS (
Name
VARCHAR(30),
Anschrift
AdresseTyp,
Ehepartner
REF(PersonTyp),
Kinder
REF(PersonTyp) ARRAY[10]
) NOT FINAL;
Strukturierter Typ
Einbettung
Referenz
Konstruierte Typen
4-33
Operationen auf strukturierten Typen (1)
Erzeugen einer Instanz eines strukturierten Typs mit dem Default-Konstruktor, der
genauso heisst wie der zugehörige strukturierte Typ:
z.B. AdresseTyp() oder PersonTyp()
Attributzugriff erfolgt mittels Funktionsaufrufe sowie Punkt-Operator
Vergleich zweier Objekte (Instanzen strukturierter Typen):
— keine Ordnungsrelationen implizit bereitgestellt
— benutzerdefinierte Ordnungsfunktionen können aber definiert werden
4-34
Operationen auf strukturierten Typen (2)
Typtest:
Objekt IS [NOT] OF (Typnamensliste)
Prädikat IS OF wird TRUE, wenn die Liste den Typ des Objekts bzw. einen
Subtyp davon enthält
— Letzteres kann durch die Verwendung von ONLY ausgeschlossen werden, z.B.
—
m IS OF (ONLY(Mitarbeiter))
Temporäre Typanpassung entlang einer Typhierarchie:
(Objekt AS Supertypname)
TREAT(Objekt AS Subtypname)
-- Anpassung nach oben
-- Anpassung nach unten
4-35
Einkapselung von strukturierten Typen

Vollständige Einkapselung
–
–

Attribute nur über Methoden zugreifbar
Attributzugriffe und Methodenaufrufe gleich behandelt
Implizite Observer- und Mutator-Methoden für jedes Attribut
Observer:
FUNCTION Strasse(AdresseTyp) RETURNS VARCHAR(30);
FUNCTION Nr(AdresseTyp)
RETURNS DECIMAL(4);
FUNCTION PLZ(AdresseTyp) RETURNS DECIMAL(5);
FUNCTION Ort(AdresseTyp)
RETURNS VARCHAR(40);
FUNCTION Land(AdresseTyp) RETURNS VARCHAR(25);
Mutator:
FUNCTION Strasse(AdresseTyp, VARCHAR(30))
FUNCTION Nr(AdresseTyp, DECIMAL(5))
FUNCTION PLZ(AdresseTyp, DECIMAL(5))
FUNCTION Ort(AdresseTyp, VARCHAR(40))
FUNCTION Land(AdresseTyp, VARCHAR(25))
RETURNS AdresseTyp;
RETURNS AdresseTyp;
RETURNS AdresseTyp;
RETURNS AdresseTyp;
RETURNS AdresseTyp;
4-36
Attributzugriff bei Instanzen eines strukturierten Typs

Zugriff über Funktionsaufrufe oder Punkt-Operator
–
–

Pfadausdrücke: Nacheinander Anwendung des Punkt-Operators
–

X.Attributname
entspricht Attributname(X)
SET X.Attributname = Wert entspricht Attributname(X, Wert)
Navigierende Zugriffe
Beispiel:
BEGIN
END;
DECLARE p PersonTyp;
SET p.Name = ‘Luke Skywalker’;
SET p.Anschrift.Ort = ‘Hollywood’;
4-37
Erzeugen von Instanzen eines strukturierten Typs


Verwendung des Default-Konstruktors
Initialisierung mittels
–
–

Mutator-Methoden
Redefiniertem Konstruktor (kann beliebig überladen werden)
Beispiel für das Überladen eines Konstruktors:
CREATE FUNCTION PersonTyp (n VARCHAR(30))
RETURNS PersonTyp
BEGIN
DECLARE p PersonTyp;
SET p = PersonTyp();
SET p.Name = n;
RETURN p;
END;
Aufruf des
Default-Konstruktors
4-38
Subtypbildung - Aufbau von Typhierarchien

Subtypdefinition mittels UNDER-Klausel
–
–
–
–

Subtyp erbt alle Attributen und Methoden des Supertyps
Supertyp muss selbst ein strukturierter Typ sein
Subtyp darf maximal einen direkten Supertyp haben
 Keine (direkte) Mehrfachvererbung möglich
Subtyp kann geerbte Methoden überschreiben und überladen
Strukturierte Typen, die keine Subtypen sind, heissen Wurzeltypen
4-39
Subtypen - Beispiele
CREATE TYPE MitarbeiterTyp UNDER PersonTyp AS (
PNr
INTEGER,
Bewerbung
CLOB(50K),
Bild
BLOB(5M),
Vorgesetzter
REF(MitarbeiterTyp),
Projekte
REF(ProjektTyp) ARRAY[50],
Gehalt
Franken
) NOT FINAL;
CREATE TYPE ManagerTyp UNDER MitarbeiterTyp AS (
Leitet
REF(ProjektTyp) ARRAY[100],
Bonus
Franken
) NOT FINAL;
4-40
Referenzgenerierung & Referenzcasting

Nur für Wurzeltypen definierbar

Syntax:
REF USING Typ
| REF FROM (Attributliste)
| REF IS SYSTEM GENERATED
CAST (SOURCE AS REF) WITH Funktionsname
CAST (REF AS SOURCE) WITH Funktionsname
–
REF USING Typ
 OID-Werte sind von einem bestimmten Typ, etwa INTEGER
–
REF FROM (Attributliste)
 OID aus vorhandenen Attributwerten eines Schlüssels funktional bestimmt
–
REF IS SYSTEM GENERATED
 OID-Generierung durch das System (Defaulteinstellung)
4-41
Methoden

Objektverhalten in Methoden kodiert

Methoden sind Funktionen, die zu einem strukturierten Typen gehören
–
–

Deklaration erfolgt innerhalb der Typdefinition
Besitzen impliziten SELF-Parameter
Overloading, Overriding und Late Binding
–
–
Überladen von Methodennamen
 mehrere gleichnamige Methoden mit unterschiedlichen Parametern
Dynamisches Binden von überschriebenen Methoden zur Laufzeit
 Auswahl der Implementierung hängt vom Objekttyp ab
4-42
Methodendeklaration

Syntax: Deklaration einer Methode
[INSTANCE | STATIC]
METHOD Methodenname (Parameter)
RETURNS Rückgabetyp
[Methodencharakteristikaliste]

STATIC definiert Tabellenmethode
Syntax: Deklaration einer "überschreibenden" Methode
OVERRIDING
METHOD Methodenname (Parameter)
RETURNS Rückgabetyp
4-43
Methodencharakteristika (1)

Syntax:
[LANGUAGE {ADA|C|COBOL|FORTRAN|MUMPS|PASCAL|SQL}]
[PARAMETER STYLE {SQL | GENERAL}]
[[NOT] DETERMINISTIC]
[NO SQL | CONTAINS SQL | READS SQL DATA | MODIFIES SQL DATA]
[{RETURNS NULL | CALLED} ON NULL INPUT ]
[TRANSFORM GROUP Gruppenname [FOR TYPE StrukturierterTyp]]
4-44
Methodencharakteristika (2)

Angabe, ob die Berechnung deterministisch ist oder nicht
–
Relevant für CHECK- und CASE-Definition
NOT DETERMINISTIC
Zwei aufeinanderfolgende Aufrufe der Methode mit
den gleichen Argumenten können selbst bei gleichen
DB-Zuständen unterschiedliche Resultate liefern
(Beispiel: Methoden, die DATETIME abfragen)
DETERMINISTIC
Methode hat in zwei aufeinanderfolgenden Aufrufen
mit den gleichen Argumenten auf dem gleichen DBZustand den gleichen Effekt
4-45
Methodencharakteristika (3)

Angabe, ob und welche Art von SQL-Anweisungen eine Methode enhält
NO SQL
Enthält keine SQL-Anweisungen
CONTAINS SQL
Enthält SQL-Anweisungen
READS SQL DATA
Liest SQL-Daten
MODIFIES SQL DATA
Schreibt SQL-Daten
4-46
Methodencharakteristika (4)

Angabe, ob Methode aufrufbar ist, wenn ein Parameter NULL ist
RETURNS NULL
ON NULL INPUT
Ist beim Aufruf der Methode mindestens einer der
Parameter NULL, dann wird die Methode nicht
ausgeführt und NULL zurückgeliefert
CALLED
ON NULL INPUT
Methode wird auch dann ausgeführt, wenn einer der
Parameter NULL ist
4-47
Methodencharakteristika (5)


Transformgruppen enthalten Funktionen, die automatisch aufgerufen
werden, wenn benutzerdefinierte Typen von der SQL-Umgebung in die
Host-Sprachumgebung (und umgekehrt) transferiert werden
Syntax: Definition einer Transformgruppe
CREATE TRANSFORM FOR BDTyp Gruppenname (
FROM SQL WITH Funktionsname(Parameter),
TO SQL WITH Funktionsname(Parameter)
)
4-48
Methodencharakteristika (5)

Defaulteinstellungen
INSTANCE
STATIC schliesst OVERRIDING aus
LANGUAGE SQL
LANGUAGE SQL schliesst NO SQL,
Parameterstyle-Klausel, Transform-Klausel aus
NOT DETERMINISTIC
CONTAINS SQL
CALLED ON NULL INPUT
4-49
Methodenklaration - Beispiele
CREATE TYPE PersonTyp AS (
...
) NOT FINAL
METHOD AnzahlKinder() RETURNS INTEGER;
CREATE TYPE MitarbeiterTyp AS (
...
) NOT FINAL
METHOD Einkommen() RETURNS Franken;
METHOD Gehaltserhöhung() RETURNS Franken;
CREATE TYPE ManagerTyp AS (
...
) NOT FINAL
OVERRIDING METHOD Einkommen() RETURNS Franken;
OVERRIDING METHOD Gehaltserhöhung() RETURNS Franken;
4-50
Methodendefinition

Implementierung einer deklarierten Methode

Syntax:
[INSTANCE | STATIC]
CREATE METHOD Methodenname (Parameter)
RETURNS Rückgabetyp
FOR StrukturierterTyp
Methodenrumpf

Methodenrumpf besteht aus einer SQL-Prozedur-Anweisung
–
–
–
Schemadefinitions- oder Schemamanipulationsanweisung
INSERT, UPDATE, DELETE, SELECT (SQL-Datenänderungsanweisungen)
...
4-51
Methodendefinition - Beispiele

Definition einer "lesenden" Methode
CREATE METHOD Einkommen()
RETURNS Franken
FOR MitarbeiterTyp
RETURN (SELF.Gehalt);

Überschreiben einer "lesenden" Methodendefinition
CREATE METHOD Einkommen()
RETURNS Franken
FOR ManagerTyp
RETURN (SELF.Gehalt + SELF.Bonus);
4-52
Erweiterung von SQL zur Programmiersprache
Compound statement
SQL variable declaration
IF statement
CASE statement
LOOP statement
WHILE statement
REPEAT statement
FOR statement
RETURN statement
CALL statement
Assignment statement
SIGNAL statement
BEGIN [ATOMIC] SQL-Anweisungen END;
DECLARE Variable Datentyp;
IF Prädikat THEN SQL-Anweisungen
ELSE SQL-Anweisungen END IF;
CASE X WHEN Prädikat THEN SQL-Anweisungen
ELSE SQL-Anweisungen END CASE;
LOOP SQL-Anweisungen END LOOP;
WHILE Prädikat DO SQL-Anweisungen END WHILE;
REPEAT SQL-Anweisungen UNTIL Prädikat END REPEAT;
FOR Loop-Variable AS Cursor-Spezifikation
DO SQL-Anweisungen END FOR;
RETURN Rückgabewert;
CALL Routine(Parameterliste);
SET Variable = Wert;
SIGNAL division_by_zero;
4-53
Definition einer "schreibenden" Methode
CREATE METHOD GehaltsErhöhung()
RETURNS Franken
FOR MitarbeiterTyp
BEGIN
DECLARE altesGehalt Franken;
altesGehalt = SELF.Gehalt;
IF (SELF.AnzahlKinder < 3) OR (SELF.AnzahlProjekte < 2) THEN
SET SELF.Gehalt = 1.03 * altesGehalt;
ELSE
SET SELF.Gehalt = 1.05 * altesGehalt;
ENDIF
IF (SELF.Gehalt > 500000) THEN raise_error(…);
RETURN SELF.Gehalt;
END;
4-54
Überschreiben einer "schreibenden" Methode
CREATE METHOD GehaltsErhöhung()
RETURNS Franken
FOR ManagerTyp
BEGIN
DECLARE altesGehalt Franken;
altesGehalt = SELF.Gehalt;
SET SELF.Gehalt = altesGehalt *
(1+0.01*(SELF.AnzahlProjekte
+SELF.AnzahlKinder));
IF (SELF.Gehalt > 25000000) THEN raise_error(…);
RETURN SELF.Gehalt;
END;
4-55
Einsatz strukturierter Typen

Als Attributtyp anderer strukturierter Typen

Als Parametertyp von Methoden, Funktionen und Prozeduren

Als Typ von SQL-Variablen

Als Typ einer typisierten Tabelle

Als Typ von Tabellenspalten
CREATE TABLE PersonTupelTabelle (
Stammdaten
PersonTyp,
Bild
BLOB(1M),
Lebenslauf
CLOB(50k)
);
4-56
Instanziierung und Verwendung strukturierter Typen

Instanziierung mittels (Typ-)Konstruktor
–
Geschachtelte Konstruktoraufrufe möglich
INSERT INTO PersonenTupelTabelle
VALUES (PersonTyp('Billy Bär',
AdresseTyp('Seefeldstrasse', 31, 8008, 'Zurich', 'CH'),
NULL, ARRAY(NULL)),
NULL, NULL);

Zugriff auf Objektattributwerte (und Aufruf von Methoden)
SELECT Stammdaten.Name, Stammdaten.AnzahlKinder
FROM PersonenTupelTabelle
WHERE Stammdaten.Anschrift.Ort = 'Zürich' AND
POSITION('Diplom' IN Lebenslauf) > 0;
4-57
Benutzerdefinierte Gleichheit von Instanzen

Vergleichbarkeit und Ordnung von Instanzen benutzerdefinierter Typen
–
–

Ordnungsformen: NONE, EQUALS ONLY, ORDER FULL
Ordnungskategorien:
 RELATIVE: Ordnungsfunktion ordnet jeweils zwei Instanzen
 MAP: Vergleich bzw. Ordnung basiert auf dem Ergebnis einer
Abbildungfunktion, die Instanzen auf Werte von Basisdatentypen abbildet
 STATE: Vergleich basiert auf paarweise Gleichheit der Attributwerte
Syntax:
CREATE ORDERING FOR BDTyp
{EQUALS ONLY | ORDER FULL} BY
{RELATIVE WITH Ordnungsfunktion(P1 BDTyp, P2 BDTyp)
| MAP WITH Abbildungsfunktion(Parameter BDTyp)
| STATE [Schemaname]}
4-58
Benutzerdefinierte Gleichheit von Instanzen (Forts.)

Einschränkungen
–
–
–
–
–

Alle Typen einer Typhierarchie müssen gleiche Ordnungsform besitzen
FULL erfordert RELATIVE oder MAP
STATE nur für strukturierte Typen definierbar
RELATIVE und STATE nur für Wurzeltypen definierbar
Dintinct-Typen: ORDER FULL
Definition von STATE für PersonTyp erzeugt automatisch:
CREATE FUNCTION EQUALS(p1 PersonTyp, p2 PersonTyp)
RETURNS BOOLEAN
RETURN (SPECIFICTYPE(p1) =SPECIFICTYPE(p2) AND
p1.Name = p2.Name AND p1.Anschrift = p2.Anschrift AND
p1.Ehepartner = p2.Ehepartner AND p1.Kinder = p2.Kinder);
4-59
Ordnungs- und Abbildungsfunktionen

Seien X, Y Instanzen eines benutzerdefinierten Typs Z
– Sei RF eine Ordnungsfunktion für Z. Dann gelten folgende Ordnungsrelationen:
X = Y ⇔ RF(X, Y) = 0
X < Y ⇔ RF(X, Y) = -1
X > Y ⇔ RF(X, Y) = 1
–
X ≠ Y ⇔ RF(X, Y) ≠ 0
X ≤ Y ⇔ RF(X, Y) ∈{-1, 0}
X ≥ Y ⇔ RF(X, Y) ∈{0, 1}
Sei MF eine Abbildungsfunktion für Z. Dann gelten folgende Ordnungsrelationen:
X θ Y ⇔ MF(X) θ MF(Y), wobei θ ∈{<, ≤, =, ≠, ≥, >}
4-60
Ordnung durch benutzerdefinierte Abbildungsfunktionen
Definition einer Abbildungsfunktion für strukturierten Typ AdresseTyp:
CREATE FUNCTION AdresseMap(a AdresseTyp)
RETURNS VARCHAR(104)
RETURN (a.Land || a.Ort || a.Strasse
|| CAST(a.Nr AS VARCHAR(4))
|| CAST(a.PLZ AS VARCHAR(5)));
Definition einer Ordnungsfunktion für strukturierten Typ AdresseTyp:
CREATE ORDERING FOR AdresseTyp
ORDER FULL BY MAP WITH AdresseMap(AdresseTyp);
4-61
Verwendung benutzerdefinierter Ordnungsfunktionen
Beispielanfragen, in denen eine Ordnungsfunktion zum Einsatz kommt:
SELECT Stammdaten.Name, Stammdaten.Anschrift
FROM PersonTupelTabelle
ORDER BY Stammdaten.Anschrift;
SELECT Stammdaten.Name, Stammdaten.Anschrift
FROM PersonTupelTabelle
WHERE Stammdaten.Anschrift < AdresseTyp('Seefeldstrasse', 31,
8008, 'Zürich', 'CH');
4-62
Zusammenfassung - Benutzerdefinierte Typen

Distinct-Typen als Kopien vorhandener Typen
–

Strenge Typisierung (Typkompatibilität über Namensäquivalenz)
Strukturierte Typen als abstrakte Objekttypen
–
–
–
–
–
–
Objekteinbettung vs. Objektreferenzierung (Kopier- vs. Referenzsemantik)
Kapselung (Implizite Observer- und Mutator-Methoden für alle Attribute)
Aggregationshierarchien (Strukturierte Typen zusammengesetzt aus anderen
strukturierten Typen)
Typhierarchien (Subtypbildung)
Overloading und Overriding von Methoden plus dynamisches Binden
Vergleichbarkeit und Ordnung
4-63
Tabellen

Einziges Konzept (Container), um Daten persistent speichern zu können

Bisher in SQL-92
–
–

Tabelle als Multimenge von Tupeln
TYPE(Tabelle) = MULTISET(ROW(TYPE(A1), ..., TYPE(An)))
 wobei TYPE(Ai) ein Basisdatentyp ist
Erweiterungen in SQL-99
–
–
–
Attribute können arraywertig, tupelwertig, objektwertig oder referenzwertig sein
Typ einer Tabelle kann durch einen strukturierten Typ festgelegt werden
 Derartige Tabellen heissen typisierte Tabellen (oft auch Objekttabellen)
 Zeilen entsprechen Objekten (Instanzen) des festgelegten Typs
Subtabellen (Tabellenhierachien)
4-64
Tabellen (Forts.)

Tupel- vs. Objekttabellen
–
–
–

Tupeltabelle = Tabelle, die einer Multimenge von Tupeln entspricht
Objekttabelle = Tabelle, die einer Menge von Objekten
(Instanzen eines strukturierten Typs) entspricht
Typisierte Tabelle = Tabelle, deren Typ ein benutzerdefinierter Typ ist
Aufgepasst
–
–
–
–
Tupeltabellen können objektwertige Attribute enthalten
Prinzipiell sind die gleichen Attributtypen für Tupel- und Objekttabellen erlaubt
SQL-99 verwendet den Begriff Typisierte Tabelle mit Objekttabellensemantik
Prinzipiell kann aber auch eine Tupeltabelle typisiert sein (siehe Informix; Kap.5)
4-65
Definition von Tupeltabellen

Syntax:

Tabellenelement:
–
–
–
CREATE TABLE Tabellenname (Tabellenelementliste)
Attributdefinition
| Tabellenintegritätsbedingung
| LIKE Tabellenname
Attributdefinition beinhaltet Festlegung des Datentyps und eventuell die Angabe
eines Defaultwerts sowie von Attibutbedingungen
 Datentyp ist ein Basisdatentyp, ein mittels (geschachtelter) Anwendung von
Typkonstruktoren konstruierter Typ oder ein benutzerdefinierter Typ
 SCOPE-Festlegung bei Referenzattributen zwingend notwendig
Definition von Tabellenintegritätbedingungen wie bisher in SQL-92
LIKE-Klausel kopiert Attributdefinitionen einer anderen Tabelle (ohne
Attributbedingungen und Defaultwerte)
4-66
Definition von Tupeltabellen - Beispiel
CREATE TABLE PersonTupelTabelle (
Name
ROW(Vorname VARCHAR(15),
Nachname VARCHAR(25)),
Anschrift
AdresseTyp,
Bild
BLOB(1M),
Lebenslauf
CLOB(50k),
Sprachkenntnisse VARCHAR(15) ARRAY[8],
Hobbies
VARCHAR(20) ARRAY[10]
);
• Instanzen einer Tupeltabelle heissen Tupel
4-67
Anfrage an Tupeltabellen - Beispiel
Die Anfrage
SELECT *
FROM PersonTupelTabelle;
liefert ein Ergebnis vom Typ
MULTISET(ROW(ROW(VARCHAR(15), VARCHAR(25)),
AdresseTyp,
BLOB(1M),
CLOB(50k),
ARRAY[8](VARCHAR(15)),
ARRAY[10](VARCHAR(20)))
4-68
Definition von typisierten Tabellen
• Typisierte Tabelle basiert auf einem strukturierten Typ auf
• Syntax:
CREATE TABLE Tabellenname OF StrukturierterTyp [UNDER Supertabelle] [(
[Referenzgenerierungsoption]
[Attributoptionsliste]
)]
• Attributoption: Attributname WITH OPTIONS Optionsliste
• Optionen:
SCOPE TypisierteTabelle
| DEFAULT Wert
| Integritätsbedingung
4-69
Referenzgenerierung

Legt OID-Attribut und die Generierung der OIDs fest

Muss für jede typisierte Wurzeltabelle angegeben werden

Darf nicht bei Subtabellen angegeben werden

Referenzgenerierungsoptionen
–
–
–
REF IS oid USER GENERATED
 OID-Generierung durch den Benutzer
REF IS oid SYSTEM GENERATED
 OID-Generierung durch das System
REF IS oid DERIVED (Attributliste)
 OID aus vorhandenen Attributwerten eines Schlüssels funktional bestimmt
4-70
Definition von typisierten Tabellen - Beispiel
CREATE TABLE Personen OF PersonTyp (
REF IS oid SYSTEM GENERATED,
Ehepartner WITH OPTIONS SCOPE Personen,
Kinder WITH OPTIONS SCOPE Personen
);


Instanzen einer typisierten Tabelle heissen Objekte
Nur Instanzen einer typisierten Tabelle können mittels eines Referenzattributs
referenziert werden!
–
SCOPE-Klausel bestimmt die typisierte Tabelle, die referenziert wird
4-71
Anfrage an typisierte Tabellen - Beispiel
Was ist der Ergebnistyp der folgenden Anfrage?
SELECT *
FROM Personen;
Vielleicht
SET(PersonTyp)
?
Oder doch
MULTISET(ROW(REF(PersonTyp),
VARCHAR(30),
AdresseTyp,
REF(PersonTyp),
ARRAY[10](REF(PersonTyp))))
?
4-72
Einfügen und Ändern in typisierten Tabellen - Beispiel
Erzeugen von Tabelleninhalten (impliziter Aufruf des PersonTyp-Konstruktors):
INSERT INTO Personen
VALUES ('Billy Bär',
AdresseTyp('Seefeldstrasse', 31, 8008, 'Zurich', 'CH'),
(SELECT REF(p) FROM Personen p WHERE p.Name = 'Mama Bär'),
ARRAY(NULL));
Belegen von Referenzattributen:
UPDATE Personen
SET Kinder[1] = (SELECT REF(p)
FROM Personen p
WHERE p.Name = 'Baby Bär')
WHERE Name = 'Billy Bär';
4-73
Selektion auf typisierten Tabellen - Beispiel
Zugriff auf ein Attribut eines eingebetteten Objektes erfolgt (analog zum
Tupelkomponentenzugriff) mittels Dot-Operator:
SELECT Name, Anschrift.Ort
FROM Personen;
Zugriff auf ein Attribut eines referenziertes Objekts erfolgt mittels PfeilOperator (entspricht Dereferenzierung plus Attributselektion):
SELECT Name, Ehepartner->Name
FROM Personen;
4-74
Subtabellenbildung - Aufbau von Tabellenhierarchien

Subtabellendefinition mittels UNDER-Klausel
–
–
–
–

Typ der Subtabelle muss ein direkter Subtyp des Typs der Supertabelle sein
(Tiefe) Extension der Subtabelle muss immer eine Untermenge der (tiefen)
Extension der Supertabelle sein
 Instanzen der Subtabelle sind auch Mitglieder der zugehörigen Supertabellen
Subtabelle darf maximal eine direkte Supertabelle haben
 Keine (direkte) Mehrfachspezialisierung möglich (single inheritance)
Subtabelle kann "geerbte" Integritätsbedingungen verschärfen bzw. neue
hinzudefinieren
Typisierte Tabellen, die keine Subtabellen sind, heissen Wurzeltabellen
4-75
Subtabellenbildung - Beispiele
CREATE TABLE Mitarbeiter OF MitarbeiterTyp UNDER Personen (
Vorgesetzter WITH OPTIONS SCOPE Mitarbeiter,
Projekte WITH OPTIONS SCOPE Projekte
);
CREATE TABLE Manager OF ManagerTyp UNDER Mitarbeiter (
Leitet WITH OPTIONS SCOPE Projekte
);
4-76
Typ- versus Tabellenhierarchie
Typ
CREATE TYPE PersonTyp
Typ
Supertyp
CREATE TYPE MitarbeiterTyp
UNDER PersonTyp
CREATE TABLE Spieler OF PersonTyp
CREATE TABLE Personen OF PersonTyp
Supertabelle
Typ
Typ
CREATE TABLE Mitarbeiter
OF MitarbeiterTyp UNDER Personen
CREATE TABLE Angestellter
OF MitarbeiterTyp
4-77
Einfügungen und Löschungen in Tabellenhierarchien

INSERT an Supertabellen propagiert und DELETE wirkt auf Sub- und Supertabellen
Personen
INSERT INTO Personen(Name) VALUES('Billy');
PersonTyp
('Billy', ...)
('Joe', ...)
('Jim', ...)
DELETE FROM Personen WHERE Name='Joe';
UNDER
Mitarbeiter
INSERT INTO Mitarbeiter(Name) VALUES('Joe');
INSERT INTO Mitarbeiter(Name) VALUES('Jim');
MitarbeiterTyp
('Joe', ...)
('Jim', ...)
DELETE FROM Mitarbeiter WHERE Name='Jim';
4-78
Anfragen an Tabellenhierarchien
SELECT * FROM Personen;
Zugriff auf tiefe Extension einer Supertabelle
liefert alle Personen, auch die Mitarbeiter
SELECT * FROM Mitarbeiter;
Zugriff auf tiefe Extension einer Subtabelle
liefert alle Mitarbeiter-Objekte mit den geerbten Personen-Attributen
SELECT * FROM ONLY(Personen);
Zugriff auf flache Extension einer Supertabelle
liefert alle Personen, die keine “speziellen” Personen (z.B. Mitarbeiter) sind
SELECT *
FROM Personen EXCEPT Mitarbeiter;
Zugriff auf Teil einer tiefen Extension
einer Supertabelle
liefert alle Personen, die keine Mitarbeiter sind
4-79
Dereferenzierung und Navigation
Dereferenzierung mittels DEREF (liefert Attributwerte eines referenzierten Objekts):
SELECT DEREF(Vorgesetzter)
FROM Mitarbeiter;
Dereferenzierung (von Referenzattributwerten) über Pfeil-Operator:
SELECT *
FROM Mitarbeiter
WHERE Vorgesetzter->Name = 'Billy';
Dereferenzierung mit anschliessendem Komponentenzugriff:
SELECT *
FROM Mitarbeiter
WHERE Vorgesetzter->Anschrift.PLZ = 65307;
4-80
Typinformation und Konversion
Explizite Konversion vom Sub- zum Supertyp:
SELECT Einkommen(m AS MitarbeiterTyp)
FROM Manager m;
Explizite Konversion vom Super- zum Subtyp:
SELECT Einkommen(TREAT(m AS ManagerTyp))
FROM Mitarbeiter m
WHERE m IS OF (ManagerTyp);
Zugriff auf allgemeinere
Einkommensmethode des
Typs MitarbeiterTyp
Zugriff auf speziellere
Einkommensmethode des
Typs ManagerTyp
Sei t eine Instanz eines benutzerdefinierten Typs und T eine Menge von
benutzerdefinierten Typen (inklusive all derer Subtypen), dann liefert das
Typprädikat t IS OF (T) TRUE g.d.w. der speziellste Typ von t Element von T ist
4-81
Substituierbarkeit

Instanz eines Subtyps kann in jedem Kontext benutzt werden, wo eine
Instanz eines Supertyps nutzbar ist
–
–
–
Eingabeargumente für Methoden, deren formale Parameter auf dem Supertyp
definiert sind
Rückgabewert einer Methode oder Funktion, für das der Supertyp als formaler
Typ definiert wurde
Zuweisungen zu Variablen oder Attributen des Supertyps
4-82
Overloading, Overriding und dynamisches Binden

Mehrere Methoden mit demselben Namen
–
–

Dynamisches Binden zur Laufzeit ("dynamic dispatch")
Bei identischer Methodensignatur wird die spezielleste Methodenimplementierung ausgewählt
Beispiel: Folgende Anfrage berechnet das Einkommen von Personen, wobei sich die
Berechnungsfunktionen entsprechend dem Typ der Person unterscheiden kann
SELECT Einkommen
FROM Personen;
4-83
Definition von typisierten Sichten
• Typisierte Sichten basieren analog zu typisierten Tabellen auf einem
strukturierten Typen
• Syntax:
CREATE VIEW Sichtenname OF StrukturierterTyp [UNDER Supersicht] [(
[Referenzgenerierungsoption]
[Attributoptionsliste]
)]
AS Anfrageausdruck
[WITH CHECK OPTION]
• Attributoption: Attributname WITH OPTIONS SCOPE TypisierteSicht
4-84
Definition von typisierten Sichten - Beispiele
CREATE VIEW GutBezahlteMitarbeiter OF MitarbeiterTyp
(REF IS oid USER GENERATED)
AS (SELECT * FROM ONLY(Mitarbeiter)
WHERE Gehalt > Franken(10000));
CREATE VIEW GuteManager OF ManagerTyp
(REF IS oid USER GENERATED)
AS (SELECT * FROM ONLY(Manager)
WHERE CARDINALITY(Leitet) > 3);
CREATE VIEW MehrsprachigePersonen OF PersonTyp
(REF IS oid USER GENERATED)
AS (SELECT * FROM ONLY(Personen)
WHERE CARDINALITY(Sprachkenntnisse) > 1);
4-85
Subsichtenbildung - Aufbau von Sichtenhierarchien

Subsichtendefinition mittels UNDER-Klausel
–
–
–

Typ der Subsicht muss ein direkter Subtyp des Typs der Supersicht sein
Extension der Subsicht ist immer eine Untermenge der Extension der Supersicht
 Genauer: Subsicht erweitert die Extension der Supersicht
Subsicht darf nur maximal eine direkte Supersicht haben
 Keine (direkte) Mehrfachspezialisierung möglich
Typisierte Sichten, die keine Subsichten sind, heissen Wurzelsichten
–
Benötigen Angabe der Referenzgenerierung
 SYSTEM GENERATED nicht erlaubt
 USER GENERATED notwendig, falls Subsichten erzeugt werden sollen
4-86
Subsichtenbildung - Beispiele
CREATE VIEW KinderreicheManager OF ManagerTyp
UNDER GutBezahlteMitarbeiter
AS (SELECT *
FROM ONLY(Manager)
WHERE CARDINALITY(Kinder) > 4);
Die Supersicht
GutBezahlteMitarbeiter
umfasst nun auch alle
"kinderreichen" Manager!
CREATE VIEW GutBezahlteManager OF ManagerTyp
UNDER GutBezahlteMitarbeiter
AS (SELECT *
FROM ONLY(Manager)
WHERE Gehalt > Franken(25000));
Die Supersicht
GutBezahlteMitarbeiter
umfasst nun auch alle
"gut bezahlten" Manager!
4-87
Tabellen- vs. Sichtenhierarchie
CREATE TABLE Personen
OF PersonTyp
CREATE VIEW MehrsprachigePersonen
OF PersonTyp
Supertabelle
CREATE TABLE Mitarbeiter
OF MitarbeiterTyp
UNDER PersonTyp
Supertabelle
CREATE TABLE Manager
OF ManagerTyp
UNDER MitarbeiterTyp
CREATE VIEW GutBezahlteMitarbeiter
OF MitarbeiterTyp
Supersicht
CREATE VIEW GutBezahlteManager
OF ManagerTyp
UNDER GutBezahlteMitarbeiter
4-88
Einfügungen und Löschungen in Sichtenhierarchien



Person
INSERTs und DELETEs an die
zugrundeliegenden Tabelle propagiert
Mit=GutBezahlteMitarbeiter
Mng=GutBezahlteManager
INSERT INTO Mit(Name)
VALUES('Billy');
INSERT INTO Mng(Name)
VALUES('Joe');
('Billy', ...)
('Joe', ...)
UNDER
Mit MitarbeiterTyp
Mitarbeiter MitarbeiterTyp
('Billy', ...)
('Joe', ...)
('Billy', ...)
('Joe', ...)
DELETE FROM Mit
WHERE Name='Joe';
UNDER
UNDER
Mng
PersonTyp
ManagerTyp
('Joe', ...)
Manager
ManagerTyp
('Joe', ...)
4-89
SQL-99 - Datenmodell
SET
MULTISET
OBJECT
ROW
ARRAY
REF
Einstiegspunkte in die Datenbank:
Typisierte Tabelle:
SET(OBJECT(...))
Untypisierte Tabelle:
MULTISET(ROW(...))
Basisdatentyp
Subtypbeziehung
Untermengenbeziehung
4-90
SFW-Block (1)

Grundgerüst einer SQL-Anfrage: SFW-Block
SELECT
FROM
[WHERE
[GROUP BY
[HAVING

Projektionsliste
Tabellenausdruck
Prädikat]
Attributliste]
Gruppenprädikat]
Was ist das Ergebnis einer Anfrage in SQL-99?
–
–
–
Tupeltabelle

Objekttabelle

Wert bzw. Kollektion — (In SQL:200n soll dies möglich sein)
4-91
SFW-Block (2)

SELECT: Was darf in der Projektionsliste stehen?
–
–
–

Attribute (auch abgeleitete, berechnete)
Methodenaufrufe
Unterabfragen


()
Nur skalare Unterabfragen,
die genau einen Wert liefern!
Beispiel:
SELECT m.Name, 12*m.Einkommen, (SELECT COUNT(*)
FROM Mitarbeiter
WHERE Vorgesetzter = REF(m))
FROM Manager m;
4-92
SFW-Block (3)

FROM: Welche Tabellenausdrücke sind erlaubt?
–
–
–
–
–

Tupeltabellen
Objekttabellen (auch flache Extensionen)
Kollektionsabgeleitete Tabellen
Methodenaufrufe (die Tabellen liefern)
Unterabfragen (abgeleitete Tabellen)



—

Beispiele: Kollektionsabgeleitete bzw. mittels Unterabfragen abgeleitete Tabellen
SELECT *
FROM Manager m, UNNEST(m.Leitet) p;
SELECT *
FROM (SELECT * FROM (Tabelle1 UNION Tabelle2) INTERSECT Tabelle3);
4-93
SFW-Block (4)

WHERE: Welche Prädikate sind erlaubt?
–
–
–

Prädikate über Attribute
Prädikate mit Methodenaufrufen
Prädikate mit Unterabfragen



Beispiel:
SELECT *
FROM Manager m
WHERE Name LIKE 'T%' AND Einkommen > 50000 AND
3 < (SELECT COUNT(*)
FROM Mitarbeiter
WHERE Vorgesetzter = REF(m));
4-94
Zusammenfassung

SQL-99 : Objektrelationale Erweiterung von SQL-92
–
–
–
–
–
Neue Basisdatentypen und Typkonstruktoren
Benutzerdefinierte Datentypen und Typhierarchien
Typisierte Tabellen und Tabellenhierarchien
Typisierte Sichten und Sichtenhierarchien
Neue Anfragenkonstrukte, z.B.
 Objektattributzugriff mittels Dot-Operator
 Dereferenzierung mittels DEREF und Pfeil-Operator
 Zugriff auf flache Extension einer Tabelle mittels ONLY
 Zugriff auf Typ eines Attributs bzw. Variablen mittels IS OF
 Zugriff auf Subtyp eines Attributs mittels TREAT
4-95