Kap. 5 Erweiterung der Relationenalgebra für Deduktive Datenbanken

Kap. 5 Erweiterung der Relationenalgebra für
Deduktive Datenbanken
Ziel dieses kurzen Kapitels:
– Verbindung herstellen zwischen Logiksprachen und
Relationenalgebra.
– Umgehen mit (rekursiven) Regeln zusätzlich zu Fakten.
– Zulassen von rekursiven Gleichungen in Relationenalgebra
– Auflösen solcher Gleichungen = Berechnung von Fixpunkten
Wir wissen aus IS-G über die Grenzen von Algebra und SQL: z.B. sind
Erreichbarkeitsprobleme in Graphen nicht ausdrückbar. Wie immer ist die
explizite Programmierung in SQL eine Abhilfe.
Deduktive DB-1
IS-K2001
5.1 Einführung und Problemstellung
•
In einem nicht deduktiven DBMS werden Informationen ausschließlich extensional in Form von Daten (Fakten) - gespeichert.
In einem deduktiven DBMS können Informationen zusätzlich auch intensional - in
Form von Regeln - repräsentiert werden. Die Auswertung von Anfragen (eine Form
von Inferenz) basiert auf der logischen Deduktion.
Im Vergleich zu Prolog bietet ein deduktives DBMS die Dienstleistungen einer
Datenbank an (Persistenz, Transaktionen, SQL, …); damit ist die Wissensbasis nicht
auf die Grösse des Hauptspeichers begrenzt.
•
•
•
Beispiel mit extensionaler Repräsentation
Flug
FlugNr
SR58
AA371
DA77
AA70
AA351
UA111
IS-K2001
Flugverbindung
Abflugort
Zürich
Chicago
Phoenix
Zürich
Dallas
Chicago
Zielort
Chicago
Phoenix
Flagstaff
Dallas
Phoenix
Dallas
...
Abflugort
Zürich
Zürich
Zürich
Zürich
...
Zielort
Chicago
Dallas
Phoenix
Flagstaff
...
Deduktive DB-2
• Beispiel mit intensionaler Repräsentation der Flugverbindungen:
in SQL99 (rekursive Anfrage):
WITH RECURSIVE FlugVerbindung AS
(SELECT Abflugort, Zielort FROM Flug
UNION
SELECT a.Abflugort, b.Zielort
FROM FlugVerbindung a, Flug b
WHERE a.Zielort = b.Abflugort)
SELECT * FROM FlugVerbindung;
als Menge von (Prolog-artigen) Regeln:
flugverbindung (a,z) :- flug (a,z).
flugverbindung (a,z) :- flug (o,z) , flugverbindung (a,o).
als relationen-algebraische Gleichung: F=Flug, V=Flugverbindung
V = π[Von, Nach] ( F [Nr, Von, Nach] ) ∪
π[Von, Nach] ( F [Nr, Von, Ueber] |×| V [Ueber,Nach] )
Deduktive DB-3
IS-K2001
5.2 Datalog - Hintergrundinformation
•
Eine deduktive Datenbank enthält Fakten und Regeln:
– Fakt: variablenfreie atomare Formel, z.B. flug (sr58,zürich,chicago).
– Regel: Formel der From A ⇐ W, wobei A ein Atom ist (=Kopf der Regel) und W
eine beliebige Formel (=Körper der Regel).
– Typischerweise verwendet man nur normalisierte Regeln, sogenannte
Hornklauseln:
∀ X1, ..., Xn:
p0 (Z01, ..., Z0k0) ⇐ p1 (Z11, ..., Z1k1)∧ ... ∧ pm (Zm1, ..., Zmkm)
mit ki-stelligen Prädikaten pi, Variablen X1, ..., Xn und Argumenten Zij, so dass Zij
entweder eine Konstante ist oder eine der Variablen X1, ..., Xn. Eine Hornklausel ist
äquivalent zu:
∀ X1, ..., Xn:
p0 (Z01, ..., Z0k0) ∨¬ p1 (Z11, ..., Z1k1)∨ ... ∨¬ pm (Zm1, ..., Zmkm)
Eine Hornklausel ist also eine Disjunktion von Atomen, wobei höchstens ein nichtnegiertes Atom vorkommen darf.
– Ein Fakt kann ebenfalls als Hornklausel geschrieben werden:
flug (sr58,zürich,chicago) ⇐ True
IS-K2001
(m=0)
Deduktive DB-4
•
•
In Datalog werden Fakten und Regeln analog zu Prolog formuliert:
– Fakten:
flug(sr58, zürich, chicago).
flug(aa371, chicago, phoenix).
flug(da371, phoenix, flagstaff).
– einfache
Regeln:
flugVonZuerich(Nr) :- flug(Nr, zürich, _).
– rekursive
Regeln:
flugverb(Von, Nach) :- flug(_, Von, Nach).
flugverb(Von, Nach) :- flug(_, Von, Ueber), flugverb(Ueber, Nach).
Zur Erinnerung: Schreibweise in Prolog/Datalog
– Prädikate werden klein geschrieben, ebenso String-Konstanten
– Variablen beginnen mit einem Grossbuchstaben. _ steht für anonyme Variablen,
deren Wert nicht weiter benötigt wird (man kann _ mehrfach in einer Regel
verwenden, ohne dass implizit der selbe Wert assoziert wird, d.h. vater(_,_) wird
auch durch vater(hans,rolf) erfüllt).
– Operatoren: , (Komma) steht für UND-Verknüpfung, ; (Semikolon) für ODER;
\+ für Negation (z.B. \+vater(rolf)); X\==Y für X ungleich Y
– Lesen: vater(rolf)
„Rolf ist Vater“
vater(hans,rolf)
„Hans ist Vater von Rolf“
Deduktive DB-5
IS-K2001
•
Anfragen werden mit einem Widerspruchsbeweis beantwortet:
– Anfrage in Prolog:
?- flugVonZuerich(sr58).
– Prädikatenlogische
False ⇐ flugVonZuerich(sr58)
Bedeutung:
– In Prolog wird die sogenannte SLD-Resolution verwendet, um einen
Widerspruchsbeweis zu führen. D.h. für alle Prädikate der Anfrage werden Regeln
oder Fakten gesucht, welche unifiziert werden können. Dabei werden z.T. auch
Variablen gebunden. Ausserdem verwendet Prolog Backtracking, um alle
möglichen Antworten zu erzeugen. Ziel des Beweises ist es, zu zeigen, dass durch
Induktion der Widerspruch False ⇐ True entsteht. Damit wäre die Anfrage erfüllt.
Falls dies nicht gelingt, ist das Anfrageprädikat nicht beweisbar.
?- flugVonZuerich(sr58)
False ⇐ flugVonZuerich(sr58)
False ⇐ flug(sr58,zürich,_)
False ⇐ True
{ flugVonZuerich(Nr) :- flug(Nr, zürich, _). }
{ flug(sr58, zürich, chicago).
}
Damit ist der Widerspruchsbeweis gelungen, d.h. das Anfrageprädikat ist erfüllt. In
Prolog (sicstus) kann man die Auswertungsstrategie gut verfolgen, wenn man die
Trace-Ausgabe (trace. eingeben) aktiviert.
IS-K2001
Deduktive DB-6
•
Unterschied Datalog <-> Prolog
– Keine strukturierten Argumente (z.B. Listen)
– Keine oder nur beschränkte Anzahl vordefinierter Funktionssymbole (+,-,*);
dadurch kann die Termination der Auswertung garantiert werden. Z.B. terminiert
das folgende Prolog-Programm nicht für ?-path(X,Y,L).
path(X,Y,1) :- edge(X,Y).
path(X,Y,L) :- edge(X,Z), path(Z,Y,L0), L == L0+1.
In Datalog möchte man dies verhindern.
– Eine deduktive Datenbank sollte typischerweise stratifiziert sein, d.h. ein rekursiv
definiertes Prädikat nimmt keinen Bezug auf seine Negation. Also: die Definition
von Prädikat p darf \+p nicht enthalten.
– Fakten und Regeln müssen bereichsbeschränkt sein. Fakten sind per Definition
bereichsbeschränkt; bei Regeln muss jede verwendete Variable bereichsbeschränkt sein, d.h. sie muss in mindestens einem nicht-negierten Prädikat im
Körper der Regel vorkommen. In den folgenden Bsp. ist Y jeweils nicht
bereichsbeschränkt und somit sind die Regeln nicht zulässig
p(X,Y) :- q(X).
p(X,Y) :- q(X), X<Y.
p(X,Y) :- q(X), \+r(X,Y).
Deduktive DB-7
IS-K2001
Beispiel:
Adam ♥ Abigail
Jonny ♥ Bonnie
Bill ♥ Jill
Bob
Clyde Claire
Cerise Charly
Cecilia
Fakten:
mann(adam).
mann(jonny). mann(bob). mann(bill).
frau(abigail). frau(bonnie).
frau(jill).
mann(clyde). mann(charly).
frau(claire). frau(cerise).
frau(cecilia).
ehepaar(adam, abigail).
ehepaar(jonny, bonnie).
ehepaar(bill, jill).
elternteil(adam, bonnie).
elternteil(abigail, bonnie).
elternteil(jonny, clyde).
elternteil(bonnie, clyde).
elternteil(bill, cerise).
elternteil(jill, cerise).
elternteil(adam, bob).
elternteil(abigail, bob).
elternteil(jonny, claire).
elternteil(bonnie, claire).
elternteil(bill, charly).
elternteil(jill, charly).
elternteil(adam, bill).
elternteil(abigail, bill).
IS-K2001
elternteil(bill, cecilia).
elternteil(jill, cecilia).
Deduktive DB-8
Regeln
vater(X,Y) :- mann(X), elternteil(X,Y).
mutter(X,Y) :- frau(X), elternteil(X,Y).
vorfahr(X,Y) :- elternteil(X,Y).
vorfahr(X,Z) :- elternteil(X,Y), vorfahr(Y,Z).
geschwister(Y,Z) :- elternteil(X,Y), elternteil(X,Z), Y \== Z.
cousine(W,Y) :- geschwister(X,U), elternteil(X,Y), elternteil(U,W), frau(W).
selbeGeneration(X,Y) :- ehepaar(X,Y).
selbeGeneration(X,Y) :- elternteil(U,X), elternteil(V,Y), selbeGeneration(U,V).
Datalog mit Negation:
ledig(X) :- mann(X), \+ ehepaar(X,_).
ledig(Y) :- frau(Y), \+ ehepaar(_,Y).
Beispiele für Anfragen
?- ledig (X).
?- cousine (X, clyde).
?- selbeGeneration (clyde, X).
Deduktive DB-9
IS-K2001
5.3 Gleichungen in Relationenalgebra und Berechnung von Fixpunkten
•
Kleine Zusammenfassung der Relationenalgebra:
– Sei {D1, ..., Dm} eine Menge von Wertebereichen. Eine Relation R besteht aus
• einem Schema, das eine Menge {A1, ..., An} von Attributen ist, kurz
sch(R) = { A1, ..., An}.
•
jedem Attribut Ai wird ein Wertebereich dom(Ai) aus {D1, ..., Dm} zugeordnet.
einer Ausprägung (auch Extension genannt)
val(R) ⊆ dom(A1) x … x dom(An).
t ∈ val(R) heisst Tupel der Relation R. t.A mit A⊆{ A1, ..., An} bezeichnet ein
Tupel, welches nur die Attribute A von t enthält.
–
Mengenoperationen: Für zwei Relationen R, S mit sch(R) = sch(S)
Vereinigung R ∪ S:
Durchschnitt R ∩ S:
Differenz
R - S:
–
val(R ∪ S) = {t | t ∈ val(R) ∨ t ∈ val(S)}
val(R ∩ S) = {t | t ∈ val(R) ∧ t ∈ val(S)}
val(R - S) = {t | t ∈ val(R) ∧ t ∉ val(S)}
Selektion σ (Filterung, Auswahl von Tupeln): Sei F eine Boolesche Formel über
den Attributen einer Relation R und beliebigen Konstanten. Dann selektiert
σ[F](R) genau jene Tupel von R, welche F erfüllen:
sch(σ[F](R)) = sch(R)
val(σ[F](R)) = {t | t ∈ R ∧ F(t)}
IS-K2001
wobei F(t) bedeutet, dass t
die Bedingung F erfüllt.
Deduktive DB-10
–
Projektion π (Auswahl von Spalten): Sei A ⊆ sch(R) eine Teilmenge der Attribute
einer Relation R. Das Resultat einer Projektion π[A](R) auf der Relation R ist wie
folgt definiert:
sch(π[A](R)) = A
val(π[A](R)) = {t | ∃ r ∈ val(R): t.A = r.A}
Achtung: Die Projektion beinhaltet eine Duplikateliminierung.
–
Natural Join |×| (Natürlicher Verbund, Verbindung zweier Relationen über gleiche
Attributnamen und gleiche Attributwerte der Tupel): Seien R, S Relationen mit
Schemata A=sch(R) und B=sch(S). Das Resultat des Joins R |×| S ist wie folgt
definiert:
sch(R|×|S) = sch(R) ∪ sch(S)
val(R|×|S) = {t | ∃ r ∈ val(R) ∃ s ∈ val(S): t.A = r.A ∧ t.B = s.B}
–
Umbennung von Attributen: Sei die Relation Ehepaar(MN,FN) gegeben.
• Ehepaar steht für die Relation mit den Attributen MN und FN.
• Ehepaar[Mann,Frau] steht für die gleiche Relation, aber die Attribute heissen
nun Mann und Frau.
• Mit solchen Umbennungen kann man einen Natural Join zwischen zwei
Relationen erzwingen, auch wenn die Attribute der Relationen ursprünglich
unterschiedlich benannt waren.
Deduktive DB-11
IS-K2001
Datalog -> Relationenalgebra
•
Fakten und Regeln in Datalog lassen sich sehr leicht auch mit Hilfe der
Relationenalgebra ausdrücken. Die Fakten werden in Extensionen gespeichert, wobei
für jedes Prädikat mit Faktenbestandteil eine eigene Relation definiert wird.
Mann
Ehepaar
•
IS-K2001
MN
Adam
Jonny
Bob
MN
Adam
Jonny
Bob
...
FN
Abigail
Bonnie
Jill
Frau
Elternteil
FN
Abigail
Bonnie
Jill
...
E
Adam
Adam
Abigail
...
K
Bonnie
Bob
Bonnie
Datalog Regeln lassen sich mit relationen-algebraischen Ausdrücken formulieren.
Dabei muss allerdings zwischen rekursiven und nicht-rekursiven Prädikaten
unterschieden werden.
Deduktive DB-12
•
Darstellung von nicht-rekursiven Prädikaten:
–
vater(X,Y) :- mann(X), elternteil(X,Y).
Vater(X,Y) := Mann[X] |×| Elternteil[X,Y]
–
mutter(X,Y) :- frau(X), elternteil(X,Y).
Mutter(X,Y) := Frau[X] |×| Elternteil[X,Y]
–
geschwister(Y,Z) :- elternteil(X,Y), elternteil(X,Z), Y \== Z.
Geschwister(Y,Z) := π[X,Y] ( σ[Y<>Z] ( Elternteil[X,Y] |×| Elternteil[X,Z] ) )
–
cousine(W,Y) :- geschwister(X,U), elternteil(X,Y), elternteil(U,W), frau(W).
Cousine(W,Y) := π[W,Y] ( Geschwister(X,U) |×| Elternteil[X,Y]
|×| Elternteil[U,W] |×| Frau(W) )
Deduktive DB-13
IS-K2001
•
Wie aber können rekursive Prädikate umgesetzt werden?
– Versuch: wie nicht-rekursive Prädikate:
vorfahr(X,Y) :- elternteil(X,Y).
vorfahr(X,Z) :- elternteil(X,Y), vorfahr(Y,Z).
Vorfahr(X,Y) =
Elternteil(X,Y) ∪
π[X,Y] ( Elternteil(X,Y) |×| Vorfahr(Y,Z) )
IS-K2001
–
Offensichtliches Problem: Vorfahr(X,Y) ist rekursiv definiert; aber wie bestimmt
man nun die Extension der Relation Vorfahr?
• Dazu muss man den sogenannten Fixpunkt von Vorfahr(X,Y) berechnen, so
dass die linke Seite identisch mit der rechten Seite der Gleichung wird. Allg.
interessiert uns der kleinste Fixpunkt von Vorfahr.
–
Allgemeine Notation:
• Ein rekursives Prädikat kann allg. in einen nicht-rekursiven Teil und einen
rekursiven Teil zerlegt werden. In unseren Datalog Beispielen bildet häufig
eine Faktentabelle den nicht-rekursiven Teil (z.B. Elternteil); der rekursive
Teil entsteht meist durch Komposition der Faktentabelle mit dem zu
definierenden Prädikat (z.B. Elternteil |×| Vorfahr)
Deduktive DB-14
•
Allgemeine Vorgehensweise bei rekursiven Prädikaten:
– Identifikation des nicht-rekursiven Teils. Sei G(F) ein relationen-algebraischer
Ausdruck über der Faktenrelation F, der diesen Teil erzeugt.
– Bestimmung des rekursiven Teils. Dieser setzt sich meist aus einer Komposition
(join) der zu definierenden Relation H und der Faktenrelation F zusammen.
– Damit lautet die Fixpunktgleichung für die Relation H:
H = G(F) ∪ H ⊗ F
–
•
Die Erweiterung auf mehrere Faktenrelationen ist einfach.
Bestimmung des Fixpunktes resp. Berechnung der Extension von H:
– Wie in der numerischen Mathematik lösen wir diese Gleichung iterativ:
– Naive Iteration
H0 := {}; i := 0;
repeat
i := i+1;
Hi := G(F) ∪ Hi-1 ⊗ F;
until Hi = Hi-1;
Deduktive DB-15
IS-K2001
Naive Iteration am Einstiegsbeispiel:
Datalog:
flug(sr58,zuerich,chicago).
flug(da77,phoenix,flagstaff).
flug(aa351,dallas,phoenix).
flug(aa371,chicago,phoenix).
flug(aa70,zuerich,dallas).
flug(ua111,chicago,dallas).
flugverb(Von, Nach) :- flug(_, Von, Nach).
flugverb(Von, Nach) :- flug(_, Von, Ueber), flugverb(Ueber, Nach).
Relationenalgebra:
Flug(Nr,Abflug,Ziel) = { <SR58, z,c>, <AA371, c,p>, <DA77, p,f>, <AA70, z,d>,
<AA351, d,p>, <UA111, c,d> }
FlugVerb:
F
:= Flug
H
:= FlugVerb
G(F)
:= π[Von, Nach] ( F [Nr, Von, Nach] )
H⊗F
:= π[Von, Nach] ( F [Nr, Von, Ueber] |×| H [Ueber,Nach] )
Naive Auswertung: H = G(F) ∪ H ⊗ F
IS-K2001
i
Hi
0
1
2
3
4
{ }
{ <z,c>,
{ <z,c>,
{ <z,c>,
{ <z,c>,
<c,p>,
<c,p>,
<c,p>,
<c,p>,
<p,f>,
<p,f>,
<p,f>,
<p,f>,
<z,d>,
<z,d>,
<z,d>,
<z,d>,
<d,p>,
<d,p>,
<d,p>,
<d,p>,
<c,d> }
<c,d>, <z,p>, <c,f>, <d,f> }
<c,d>, <z,p>, <c,f>, <d,f>, <z,f> }
<c,d>, <z,p>, <c,f>, <d,f>, <z,f> }
Deduktive DB-16
•
Der naive Algorithmus berechnet im i-ten Durchgang nochmals das Resultat des
(i-1)-ten Durchgangs. Diese unötigen Operationen können mittels des semi-naiven
Algorithmuses verhindert werden.
– Das Ziel ist, nur jene Tupel zu berechnen, welche beim Schritt von i zu i+1 neu
entstehen können.
– Setze für i=1,2,... :
Hi = Hi-1 ∪ Di
– Ferner muss gelten: (A ∪ B) ⊗ F = A ⊗ F ∪ B ⊗ F
Hi+1 = G(F) ∪ Hi ⊗ F
= G(F) ∪ ((Hi-1 ∪ ∆i) ⊗ F)
= G(F) ∪ (Hi-1 ⊗ F) ∪ (∆i ⊗ F)
∪ (∆i ⊗ F)
=
Hi
∪ (∆i ⊗ F - Hi)
=
Hi
∆i+1 = ∆i ⊗ F - Hi
–
Delta-Iteration (semi-naive Auswertung)
H0 := {}; ∆1 := G(F); i := 0;
repeat
i := i+1;
Hi := Hi-1 ∪ ∆i;
∆i+1 := ∆i ⊗ F - Hi;
until |∆i+1| = 0;
Deduktive DB-17
IS-K2001
Semi-naive Iteration am Einstiegsbeispiel:
i=0
IS-K2001
H0 = { }
1
H1 = { <z,c>, <c,p>, <p,f>, <z,d>, <d,p>, <c,d> }
∆1 = { <z,c>, <c,p>, <p,f>, <z,d>, <d,p>, <c,d> }
2
H2 = { <z,c>, <c,p>, <p,f>, <z,d>, <d,p>, <c,d>, <z,p>, <c,f>, <d,f> }
∆2 = { <c,f>, <d,f>, <z,p> }
3
H3 = { <z,c>, <c,p>, <p,f>, <z,d>, <d,p>, <c,d>, <z,p>, <c,f>, <d,f>, <z,f> }
∆3 = { <z,f> }
4
∆4 = { }
Deduktive DB-18
Vergleich Datalog mit Relationenalgebra
Sätze:
1) Die Menge der Anfragen, die
sich mit (rekursivem) Datalog
mit Negation ausdrücken
lassen, ist eine echte
Obermenge der Menge von
Anfragen, die sich mit der
Relationenalgebra ausdrücken
lassen.
Datalog mit Negation
Relationenalgebra
= Nicht-rekursives
Datalog mit Negation
2) Nichtrekursives (sicheres)
Datalog mit Negation ist
äquivalent zur
Relationenalgebra
3) Nichtrekursives Datalog ohne
Negation ist äquivalent zur
Relationenalgebra ohne
Differenz.
Datalog ohne Negation
(ohne Beweise, siehe dazu z.B. Ullman)
RA ohne Differenz
= Nicht-rekursives Datalog
ohne Negation
Deduktive DB-19
IS-K2001
5.3 Implementierung einer deduktiven Datenbank mit SQL
•
Prolog eignet sich nur bedingt für deduktive Datenbanken
– Wissensbasis beschränkt durch Hauptspeicher
– Keine Unterstützung für Performance, Persistenz, Concurrency Control,
Recovery, Integritätskontrolle, Datenunabhängigkeit...
– Häufig liegen die Daten in einer relationalen Datenbank und können nur
umständlich nach Prolog exportiert werden.
•
Idee: Abbildung von Datalog auf SQL-Schnittstelle analog zur Abbildung von Datalog
auf die Relationenalgebra
– Für jedes Prädikat mit Faktenbestandteil wird ein Tabelle angelegt. Z.B.:
CREATE TABLE Flug (
flugNr VARCHAR2(6) PRIMARY KEY,
abflug VARCHAR2(20),
ziel
VARCHAR2(20)
);
INSERT
INSERT
INSERT
INSERT
INSERT
INSERT
IS-K2001
INTO
INTO
INTO
INTO
INTO
INTO
Flug
Flug
Flug
Flug
Flug
Flug
VALUES
VALUES
VALUES
VALUES
VALUES
VALUES
('SR58','Zürich','Chicago');
('AA371','Chicago','Phoenix');
('DA77','Phoenix','Flagstaff');
('AA70','Zürich','Dallas');
('AA351','Dallas','Phoenix');
('UA111','Chicago','Dallas');
Deduktive DB-20
–
Für Prädikate, welche über nicht-rekursive Regeln definiert sind, definiert man
eine View. Bsp:
• jusiva(X,N) :- father(X), age(X,N), \+married(X), N<25.
CREATE VIEW
SELECT
FROM
WHERE
AND
jusiva(Name, Age) AS
f.Name,a.Age
father f,age a
f.Name=a.Name
NOT EXISTS (SELECT *
FROM married m
WHERE m.Name=f.Name)
AND a.Age<25;
–
Prädikate, die über rekursive Regeln definiert sind, müssen mittels
Fixpunktiteration berechnet werden. Hierzu gibt es zwei Ansätze:
• Materialisierte Prädikate: Zur Gewährleistung der Korrektheit können
Triggers auf den Basisrelationen verwendet werden. Nach Änderungen in
den Basisrelationen kann entweder ein neuer Fixpunkt berechnet werden
(teuer, dafür einfach zu implementieren) oder der Fixpunkt wird inkrementell
angepasst (billig, aber kompliziert [z.B. Löschen])
• Materialisierung der Anfrage: Die vollständige Materialisierung eines
Prädikats kann unter Umständen unerwünscht sein (zu grosse Datenmenge). Stattdessen wird der Fixpunkt für jede Anfrage (mit genügend
starken Einschränkungen, z.B. Flüge von Zürich) einzeln berechnet. Die
Methoden sind dann dieselben wie bei der Materialisierung.
Deduktive DB-21
IS-K2001
–
Naive Iteration in SQL (Flugbeispiel)
• Ausgangslage: Faktentabelle Flug (siehe 2 Folien vorher). Zusätzlich
benötigen wir für die Materialisierung ein Tabelle für die Flugverbindungen:
CREATE TABLE FlugVerbindung(
von
VARCHAR2(20),
nach VARCHAR2(20)
);
•
Für die rekursive Regel
flugverb(Von, Nach) :- flug(_, Von, Nach).
flugverb(Von, Nach) :- flug(_, Von, Ueber), flugverb(Ueber, Nach).
wird jeweils eine View für den nicht-rekursiven und den rekursiven Teil der
Regel definiert.
CREATE VIEW FV_nrec(von,nach) AS
SELECT abflug,ziel FROM Flug;
CREATE VIEW
SELECT
FROM
WHERE
IS-K2001
FV_rec(von,nach) AS
a.von,b.ziel
FlugVerbindung a, Flug b
a.nach=b.abflug;
Deduktive DB-22
•
Letztlich wird der Fixpunkt mit einem SQL Skript gemäss naiver Iteration
berechnet (hier: Oracle PL/SQL Syntax):
DECLARE
last INTEGER;
n
INTEGER;
BEGIN
last:=-1;
DELETE FROM FlugVerbindung;
INSERT INTO FlugVerbindung SELECT * FROM FV_nrec;
LOOP
SELECT COUNT(*) INTO n FROM FlugVerbindung;
EXIT WHEN last=n;
last:=n;
INSERT INTO FlugVerbindung
SELECT * FROM FV_rec MINUS SELECT * FROM FlugVerbindung;
END LOOP;
END;
/
–
Semi-naive Iteration in SQL (Flugbeispiel)
• Die semi-naive Iteration benötigt zwei zusätzliche, temporäre Tabellen zur
Berechnung und Speicherung der ∆i Mengen.
CREATE TABLE FV_delta(
von
VARCHAR2(20),
nach VARCHAR2(20)
);
CREATE TABLE FV_new(
von
VARCHAR2(20),
nach VARCHAR2(20)
);
Deduktive DB-23
IS-K2001
•
Die View für den rekursiven Teil der Regel muss angepasst werden:
CREATE FV_sn_rec(von,nach) AS
SELECT a.von,b.ziel
FROM FV_delta a, Flug b
WHERE a.nach=b.abflug;
•
Der Fixpunkt kann mit folgendem SQL Skript gemäss semi-naiver Iteration
bestimmt werden (hier: Oracle PL/SQL Syntax):
DECLARE
n INTEGER;
BEGIN
DELETE FROM FlugVerbindung;
DELETE FROM FV_delta;
INSERT INTO FV_delta SELECT * FROM FV_nrec;
LOOP
INSERT INTO FlugVerbindung SELECT * FROM FV_delta;
DELETE FROM FV_new;
INSERT INTO FV_new
SELECT * FROM FV_sn_rec MINUS SELECT * FROM FlugVerbindung;
SELECT COUNT(*) INTO n FROM FV_new;
EXIT WHEN n=0;
DELETE FROM FV_delta;
INSERT INTO FV_delta SELECT * FROM FV_new;
END LOOP;
END;
/
IS-K2001
Deduktive DB-24
–
Anfragen können schliesslich als SELECT Anweisung über Faktentabellen, Views
für nicht-rekursive Prädikate und/oder materialisierte Fixpunkte formuliert werden.
• ?- parent(X, laura).
SELECT
FROM
WHERE
•
?- flugVonZuerich(sr58).
SELECT
FROM
WHERE
–
p.Parent
parent p
p.Child=‘Laura’;
COUNT(*)
flugVonZürich f
f.Nr=‘SR58’;
SQL99 lässt zudem ein Mischform von Definition und Anfrage von rekursiven
Prädkaten zu.
WITH RECURSIVE FlugVerbindung AS
(SELECT Abflugort, Zielort FROM Flug
UNION
SELECT a.Abflugort, b.Zielort
FROM FlugVerbindung a, Flug b
WHERE a.Zielort = b.Abflugort)
SELECT * FROM FlugVerbindung;
IS-K2001
Deduktive DB-25
Literatur
•
•
•
•
J.D. Ullman. Principles of Database and Knowledge-Base Systems, Volume II: The
New Technologies. Computer Science Press, 1989.
A.B. Cremers, U. Griefahn, R. Hinze. Deduktive Datenbanken, Vieweg, 1994.
S. Ceri, G. Gottlob, L. Tanca. Logic Programmin and Databases, Springer, 1990.
J.W. Lloyd. Foundations of Logic Programming. Springer, 1987.
Links
•
•
SBB, Fahrplanauskunft, http://www.sbb.ch/.
Airlines of the Web, Quick Reservations Check, http://www.flyaow.com/.
IS-K2001
Deduktive DB-26