Transcript Kein Folientitel

Objektrelationale
Datenbanken
© 2000
Marco Graupner 96I
[email protected]
1
1. Die DBMS - Matrix
Abfrage
2
4
Keine Abfrage
1
3
• 1: Texteditoren
• 2: relationale SQL-DBMS
–
–
–
–
–
Einfache Komplexe
Daten
Daten
Querysprache: SQL 89, SQL 92
Client-Werkzeuge: 4GL, Berichtsgenerator, DB-Entwurfswerkzeuge
Transaktionsverwaltung (atomar, serialisierbar, dauerhaft)
Datensicherung
Schutz sensibler Daten
• 3: CAD-Anwendungen, OO-DBMS
• 4: Objektrelationale DB
– Querysprache mit benutzerdefinierten Funktionen und Operatoren
(SQL 3, OQL) sowie leistungsfähiger Optimierung
© 2000
Marco
Graupner 96I
[email protected]
2
2. Basisdatentyperweiterung
• Fähigkeit, neue Datentypen mit ihren entsprechenden
Operatoren und Funktionen in einem SQL-Kontext zu
erzeugen
• beseitigt ungünstige Typsimulationen:
SELECT r.name
FROM emp j, emp r
WHERE j.name = 'Joe'
AND (j.long - r.long) ** 2 + (j.lat - r.lat) ** 2 < 1 ;
------------------------------------------------------ALTER TABLE emp
ADD COLUMN location point ;
-------------------------------------------------------
SELECT r.name
FROM emp j, emp r
WHERE j.name = 'Joe'
AND distance(j.location,r.location) < 1 ;
© 2000
Marco
Graupner 96I
[email protected]
3
2. Basisdatentyperweiterung
• Erzeugung von Basistypen:
CREATE TYPE mytype_t (
INTERNALLENGTH = 8,
INPUT = mytypeInput,
OUTPUT = mytypeOutput ) ;
Speicherplatz einer Instanz in Bytes
OUTPUT:
zur Wandlung der Instanzen von und
nach ASCII bei interner Speicherung
•
INTERNALLENGTH:
•
INPUT,
• Umwandlungsroutinen ermöglichen hohe Flexibilität bei
der Verwaltung der Werte
© 2000
Marco
Graupner 96I
[email protected]
4
2. Basisdatentyperweiterung
• Benutzerdefinierte Funktionen:
CREATE FUNCTION fname (typname_1, ... , typname_k)
RETURNS typname AS (filename OR SQL-Ausdruck) ;
• z.B.:
CREATE FUNCTION stundenlohn(int)
RETURNS float AS SELECT ($1 / 2000) ;
• Nutzung in einer Abfrage:
SELECT name FROM emp
WHERE stundenlohn(jahresgehalt) > 15 ;
• Substitution durch objektrelationalen Server:
SELECT name FROM emp
WHERE jahresgehalt / 2000 > 15 ;
• keine Substitution bei Nicht-SQL-Funktionen (C, Java,...),
Ausführung erfolgt während der Query-Verarbeitung
© 2000
Marco
Graupner 96I
[email protected]
5
2. Basisdatentyperweiterung
• Benutzerdefinierte Operatoren:
CREATE OPERATOR
BINDING operatorname
TO funktionsname;
• z.B.:
CREATE OPERATOR
BINDING >>
TO enthalten_in ;
• Nutzung in einer Abfrage:
SELECT r.name FROM emp, emp r
WHERE emp.name = 'Joe'
AND r.location >> kreis(emp.location,1) ;
• Substitution durch:
SELECT r.name FROM emp, emp r
WHERE emp.name = 'Joe'
AND enthalten_in(r.location, kreis(emp.location,1)) ;
© 2000
Marco
Graupner 96I
[email protected]
6
2. Basisdatentyperweiterung - Erforderliche Eigenschaften
• Dynamische Bindung
• Client- oder Serveraktivierung
• Sicherheit
• Callbacks
• Benutzerdefinierte Zugriffsverfahren
• Typen beliebiger Länge
© 2000
Marco
Graupner 96I
[email protected]
7
3. Komplexe Objekte
• Grundbausteine: Verbunde (Sätze), Mengen, Referenzen
• Verbunde als Typkonstruktor:
CREATE TYPE angest_t (
name
gehalt
adresse
varchar(30),
int,
varchar(50)) ;
• Verbundtyp für Spalte einer Tabelle:
CREATE TABLE jobs (
job_desc
angestellter
varchar(30),
angest_t) ;
• Mengen:
SETOF(Typ)
• Referenzen:
REF(Typ)
© 2000
Marco
Graupner 96I
[email protected]
8
3. Komplexe Objekte - Manipulieren von Verbunden
• Benutzerdefinierte Funktionen:
– Argumente u./o. Ergebnis sind zusammengesetzter Typ
• Funktionen in der FROM - Klausel:
– benutzt von der Funktion zurückgegebene Information
SELECT ...
FROM funktion(...)
WHERE ... ;
FROM (SELECT ...)
• Kaskaden - Punkt - Notation:
SELECT instanz1.attribut1
FROM ...
WHERE instanz2.attribut2 = ... ;
© 2000
Marco
Graupner 96I
[email protected]
9
3. Komplexe Objekte - Manipulieren von Mengen von Verbunden
• Benutzerdefinierte Funktionen:
– Argumente u./o. Ergebnis sind Menge von Verbunden
CREATE FUNCTION transport_autos
RETURN SETOF(auto_t) AS
SELECT autos FROM abt
WHERE abtname = 'Transport' ;
• Funktionen in der FROM - Klausel:
SELECT name FROM transport_autos() WHERE jahr = 1985 ;
• Kaskaden - Punkt - Notation:
SELECT dname FROM dept
WHERE 1985 IN autos.jahr
AND 'Ford' IN autos.name ;
-------------------------------------------------------------SELECT dname FROM dept
SELECT dname
WHERE EXISTS (
FROM dept
SELECT 1 FROM dept.autos
WHERE autos.(jahr = 1985
WHERE jahr = 1985
AND name = 'Ford') ;
AND name = 'Ford') ;
© 2000
Marco
Graupner 96I
[email protected]
10
3. Komplexe Objekte - Verwendung von Referenzen
• Ersatz für Primärschlüssel-Fremdschlüssel-Beziehung
• Zeiger auf einen Satz eines bestimmten Typs
• Referenzierung mittels OID (object identifier)
SELECT referenz
...
SELECT deref(referenz)
...
SELECT ref(instanz)
...
liefert OID
liefert einen Satz des
Typs auf den gezeigt wird
liefert Referenz (OID) auf
eine Instanz von typ
• Beispiel:
UPDATE dept
SET manager_ref = (
SELECT ref(emp) FROM emp WHERE name = 'Joe')
WHERE dname = 'shoe' ;
• Kaskaden - Punkt - Notation
SELECT deref(manager_ref).birthdate
...
© 2000
Marco
Graupner 96I
[email protected]
11
3. Komplexe Objekte - Erforderliche Eigenschaften
• Ein reichhaltiger Satz komplexer Typen muß unterstützt werden.
– mind. die 3 Typkonstruktoren: Verbund, Menge und Referenz
• Funktionen müssen für alle komplexen Typen zur Verfügung stehen
und die erwähnten Eigenschaften von Funktionen besitzen.
• Es kann keine Grenze für die Größe von komplexen Typen geben.
• SQL - Unterstützung für komplexe Typen ist erforderlich.
– Kaskaden - Punkt - Notation für Verbunde
– Funktionen, die Mengen zurückliefern, müssen überall auftreten
können, wo eine Tabelle in einer SQL-Abfrage auftreten kann
© 2000
Marco
Graupner 96I
[email protected]
12
4. Andere Typkonstruktoren
• Liste (list)
• Kellerspeicher (stack)
• Schlange (queue)
• Feld (array)
CREATE TYPE ... ( ...
feldname typ[anzahl] ...) ;
SELECT feldname[index]
FROM ... ;
• einfügbares Feld (insertable array)
– Feld, in dem man irgendwo ein Element einfügen kann
© 2000
Marco
Graupner 96I
[email protected]
13
5. Vererbung - Datenvererbung
• Nur auf zusammengesetzte Typen anwendbar
CREATE TYPE supertyp_t (
attribut_1, ..., attribut_x ) ;
CREATE TYPE subtyp_t (
attribut_x+1, ... attribut_y)
UNDER supertyp_t, ... ;
-->
subtyp_t erbt attribut_1 bis attribut_x von supertyp_t
• mehrere Ebenen tiefe Vererbungshierarchie
• auch Mehrfachvererbung möglich
• Auflösen von Mehrdeutigkeit bei Mehrfachvererbung
durch Neudefinition der Attribute in einem der Supertypen
© 2000
Marco
Graupner 96I
[email protected]
14
5. Vererbung - Datenvererbung
• Tabelle erstellen um Instanzen von subtyp_t zu erhalten:
CREATE TABLE supertyp OF TYPE supertyp_t ;
CREATE TABLE subtyp OF TYPE subtyp_t
UNDER supertyp_t, ... ;
• um nur eine Tabelle und nicht alle in der
Tabellenhierarchie nachgeordneten zu durchsuchen:
SELECT ...
FROM ONLY (tabelle)
WHERE ... ;
© 2000
Marco
Graupner 96I
[email protected]
15
5. Vererbung - Vererbung von Funktionen
• Vererbungsverhalten benutzerdefinierter Funktionen wird
von ihren Argumenten bestimmt
• subtyp erbt automatisch im supertyp definierte Funktionen,
wenn diese nicht explizit im subtyp neu definiert wurden
• Funktionen gleichen Namens können durch Überladung
verschiedene Bedeutungen für verschiedene Datentypen
haben ( Polymorphismus )
• bei Mehrdeutigkeit in der Mehrfachvererbung:
neuer Name für eine der beiden konkurrierenden
Funktionen der Supertypen oder Neudefinition im Subtyp
© 2000
Marco
Graupner 96I
[email protected]
16
5. Vererbung - Erforderliche Eigenschaften
• Sowohl Daten- als auch Funktionsvererbung muß
unterstützt werden.
• Überladen muß unterstützt werden.
• Typen und Tabellen müssen getrennte Konzepte besitzen.
– Falls nicht wird ein hohes Maß an Flexibilität eingebüßt
– z.B.: mehrfache Tabellen eines bestimmten Typs
• Mehrfache Vererbung muß unterstützt werden.
– Oft muß ein bestimmter Typ von verschiedenen Supertypen erben
© 2000
Marco
Graupner 96I
[email protected]
17
6. Regeln
• Allgemeine Syntax:
CREATE RULE regelname AS
ON ereignis
DO aktion ;
• 4 Variationen:
–
–
–
–
Aktualisierung - Aktualisierung - Regeln ( update - update - rules )
Abfrage - Aktualisierung - Regeln ( query - update - rules )
Aktualisierung - Abfrage - Regeln ( update - query - rules )
Abfrage - Abfrage - Regeln ( query - query - rules )
© 2000
Marco
Graupner 96I
[email protected]
18
6. Regeln
• Aktualisierung - Aktualisierung - Regeln:
CREATE RULE regelname AS
ON UPDATE TO instanz1.attribut1 WHERE current.attribut2 = wert1
DO UPDATE instanz1
SET attribut1 = new.attribut1
WHERE attribut2 = wert2 ;
• Abfrage - Aktualisierung - Regeln:
CREATE RULE regelname AS
ON SELECT TO instanz1.attribut1 WHERE current.attribut2 = wert
DO INSERT INTO instanz2 VALUES
(current.attribut1, attribut3, ... ) ;
© 2000
Marco
Graupner 96I
[email protected]
19
6. Regeln
• Aktualisierung - Abfrage - Regeln:
CREATE ALERTER alarmname
( MECHANISM = 'callback' );
CREATE RULE regelname AS
ON UPDATE TO instanz1.attribut1 WHERE current.attribut2 = ...
DO ALERT alarmname;
– Server signalisiert dem Client asynchron, daß das Ereignis eingetreten ist
– Client kann dann entsprechende Abfrage durchführen
• Abfrage - Abfrage - Regeln:
CREATE RULE regelname AS
ON SELECT TO instanz1.attribut1 WHERE current.attribut2 = ...
DO INSTEAD < BEGIN >
SELECT attribut1
FROM instanz1
WHERE attribut2 = ...
< END > ;
© 2000
Marco
Graupner 96I
[email protected]
20
6. Regeln - Komplikationen bei ihrer Nutzung
• Mehrfache Regeln vom selben Ereignis ausgelöst,
erzeugen manchmal unvorhersehbare Ergebnisse.
• Kettenregeln können Endlosschleifen verursachen.
• Das Beenden einer Transaktion bricht auch den Aktionsteil
einer Regel ab.
• Die Wahl des Zeitpunkts der Regelaktivierung kann einen
Unterschied im Endzustand der Datenbank ausmachen.
© 2000
Marco
Graupner 96I
[email protected]
21
6. Regeln - Erforderliche Eigenschaften
• Das Regelsystem muß Ereignisse und Aktionen
unterstützen, die sowohl Abfragen als auch
Aktualisierungen sind.
• Das Regelsystem muß mit anderen objektrelationalen
Möglichkeiten integriert sein.
• Das Regelsystem unterstützt {sofortige, aufgeschobene}
und {dieselbe, unterschiedliche} Transaktions ausführungssemantik.
• Das Regelsystem darf keine Schleifen bilden.
© 2000
Marco
Graupner 96I
[email protected]
22
7. Objektrelationale Syntaxanalyse
Benutzt dynamische Systemkatalogtabellen für:
• Tabellen
– Name der Tabelle, Anzahl der Spalten, ...
• Spalten
– Name, Datentyp, ...
• Typen
– Name, Import- und Exportfunktionen, ...
• Funktionen
– Name, Anzahl und Typen ihrer Argumente, Rückgabetyp, ...
• Operatoren
– Name, Identität der Funktion, die diesen Operator implementiert, ...
• Regeln, Vererbung, Zugriffsmethoden
© 2000
Marco
Graupner 96I
[email protected]
23
8. Objektrelationale Optimierer
1. Operator- und Funktionsnotation
2. generische B-Bäume
3. Benutzerdefinierte Vergleichsoperatoren
CREATE INDEX indexname
ON tabelle USING B-tree (attribut, operatorklasse);
4. Benutzerdefinierte Selekivitätsfunktionen
CREATE FUNCTION ...
WITH SELFUNC = selfunktion
EXTERNAL NAME '...' LANGUAGE ...;
5. Benutzerdefinierte Negatoren
CREATE FUNCTION ...
WITH NEGATOR = negfunktion
EXTERNAL NAME '...' LANGUAGE ...;
© 2000
Marco
Graupner 96I
[email protected]
24
8. Objektrelationale Optimierer
6. Benutzerdefinierte Kommutatoren
CREATE FUNCTION ...
WITH COMMUTATOR = commfunktion
EXTERNAL NAME '...' LANGUAGE ...;
7. Zugriffsmethoden auf eine Funktion der Daten
CREATE INDEX indexname
ON tabelle USING B-tree (funktionsname(...));
8. Intelligentes Sortieren der Klauseln in einem Prädikat
9. Optimieren teurer Funktionen
10. Benutzerdefinierte Zugriffsmethoden
© 2000
Marco
Graupner 96I
[email protected]
25
8. Objektrelationale Optimierer
11. "Glätten" komplexer Abfragen
12. "In-line" - Mengen
13. Indizes für Attribute von Mengen
14. Optimieren des Durchsuchens von Vererbungshierarchien
15. Optimieren von Verbunden über Vererbungshierarchien
© 2000
Marco
Graupner 96I
[email protected]
26
9. Strategien kommerzieller Hersteller
• Inkrementelle Entwicklung von rel.
objektrel. DBMS
– IBM, Microsoft
• Erzeugen einer Umhüllung
– Hewlett - Packard
• Herstellen eines Gateway von objektrelational zu relational
– Computer Associates
• Anheften einer objektrelationalen Maschine an relationale
Speicherverwaltung
– Tandem
• Anheften einer objektrelationalen Maschine an ein
persistentes Sprachsystem ( C++, Smalltalk, ... )
– Versant
• Erweiterung eines objektorientierten Systems
– die meisten Hersteller von OO-DBMS
© 2000
Marco
Graupner 96I
[email protected]
27