Deduktivn í databáze a jejich implementace v relačním prostředí

1. Deduktivní databáze a jejich implementace v relačním prostředí Karel Ježek

2. Obsah přednášky • Motivace • Pojmy • Problémy • Experimentální systém • Rozšíření

3. Motivace • Logická pravidla dovolují přirozené vyjadřování rekurze • Logická pravidla umožňují integrovat znalosti do informačního systému

4. miluje(Piják, Pivo) • prodává(Bar, Pivo, Cena) • navštěvuje(Piják, Bar) • šťastný(X) :- navštěvuje(X, Bar), • miluje(X, Pivo), • prodává(Bar, Pivo, Cena). • Hlava pravidla = levá strana • Tělo pravidla = pravá strana = konjunkce podcílů • Hlava a podcíle jsou atomy • Atom = predikát a jeho argumenty • Predikát = jméno relace nebo aritmet. predikát (např. >) • Argumenty jsou proměnné nebo konstanty • Podcíle mohou být případně negovány

5. Sémantika pravidel • Hlava je pravdivá pro ty své argumenty, pro které jsou pravdivé podcíle těla. (neobsahuje-li tělo negace nebo aritmetická porovnání, získáme výsledek joinem podcílů a projekcí na proměnné hlavy) Např. šťastný = projekcepiják (navštěvuje join miluje join prodává)

6. Vyhodnocování pravidel • Přiřazováním proměnných: Uvažuj všechna možná přiřazení hodnot k proměnným. Jsou-li všechny podcíle pravdivé, přidej hlavu do výsledné relace. • Přiřazováním n-tic: Uvažuj všechna přiřazení takových n-tic podcílům, že podcíle jsou pro ně pravdivé. Jsou-li proměnným přiřazeny konzistentní hodnoty, přidej hlavu do výsledku.

7. Př.: s(X, Y) :- r(X, Z), r(Z, Y), not r(X,Y). A B r = 1 2 2 3 Ad1) Pro prvý podcíl je pravdivé (1) X = 1, Z = 2 (2) X = 2, Z = 3 V případě (1) je pro Y =3 pravdivý druhý podcíl. Jelikož (1, 3) není v r, je třetí podcíl také pravdivý. Proto (1, 3) patří do s. Ad2) Začneme s pozitivními relacemi r(X, Z) r(Z, Y) (1, 2) (1, 2) (1, 2) (2, 3) (2, 3) (1, 2) (2, 3) (2, 3) Pouze řádek druhý je kozistentní pro Z. Vyhovuje i třetímu podcíli, takže (1, 3) je jedinou n-ticí patřící do s.

8. Bezpečnost • s(X) :- r(Y). • s(X) :- not r(Y). • s(X) :- r(Y), X >Y. Ve všech případech je nekonečný výsledek i pro konečnou relaci r. Pro smysluplnost vyhodnocení musí být splněny podmínky bezpečnosti

9. Jesliže proměnná X se vyskytuje: • v hlavě pravidla, nebo • v negovaném podcíli, nebo • v aritmetickém porovnání, pak se musí současně vyskytovat i v pozitivním podcíli těla.

10. Datalog • Kolekce pravidel je programem datalogu • Predikáty / relace dělíme na dvě třídy: • EDB = extenzionální databáze = relace uložené v DB • IDB = intenzionální databáze = relace definované jedním nebo více pravidly • Predikát musí být z EDB nebo z IDB, ne z obou současně. IDB predikát může být v hlavě i v těle pravidla, EDB predikát může být jen v těle

11. Vyjadřovací síla základního Datalogu • Datalog bez rekurze = relační algebra • Datalog simuluje SQL select-from-where příkaz (bez agregace a grupování) • Rekurzivní Datalog je schopen vyjadřovat dotazy nevyjádřitelné v SQL • Stejně jako SQL však není úplný v Turingově smyslu

12. Rekurze StartIDB =  Aplikuj pravidlana IDB a EDB Došlo kezměněIDB? anone konec

13. Vyhodnocování pevného bodu Dány vzájemně rekurzivní predikáty p1, p2, …, pn Hledáme R1, R2, …, Rn všechny n-tice, pro které jsou p1 ,…, pn pravdivé. Získáme je řešením soustavy rovnic Ri = Ei (R1,R2, …,Rn) (i=1,2, …, n) (Ei reprezentuje všechna rekurzivní pravidla pro pi )

14. rodič(Rodič, Dítě) • předek(A, B) :- rodič(A, B). • předek(A, B) :- předek(A, Z), rodič(Z, B). • předek = předek join rodič U rodič • Iterační řešení • Naivní metoda • Seminaivní metoda (při lineární rekurzi)

15. Naivní metoda for i := 1 to n do Ri = ; repeat cond := true; for i := 1 to n do Si := Ri; for i := 1 to n do begin Ri := Ei(S1, S2, …, Sn); if Ri  Si then cond := false end until cond;

16. Seminaivní metoda for i := 1 to n do Ri = ; for i := 1 to n do Di = ; repeat cond := true; for i := 1 to n do begin Di := Ei(D1, D2, …, Dn) - Ri; Ri := Di  Ri; if Di  then cond := false end until cond;

17. Příklad – strom předků a b c f g j k

18. předek1 = rodič (a, b), (a, c), (b, f), (c, g), (f, j), (f, k), (g, k). předek2 = předek1 join rodič U rodič (a, b), (a, c), (b, f), (c, g), (f, j), (f, k), (g, k), (a, f), (a, g), (b, j), (b, k),(c, k), předek3 = předek2 join rodič U rodič (a, b), (a, c), (b, f), (c, g), (f, j), (f, k), (g, k), (a, f), (a, g), (b, j), (b, k), (c, k), (a, j), (a, k).

19. předek(P,D) :- rodič (P,D). • předek(P,D) :- rodič(P,X), předek(X,D). • ?-předek(bohouš,X). • Není nutné vyhodnocovat celou relaci předek • Metoda magických množin kombinuje vyhodnocování zdola nahoru a shora dolů -zdobení programu (předávání informace shora) -vytvoření magického faktu (seménka) -konstrukce magických pravidel -konstrukce modifikovaných pravidel

20. m_seed_predek_bf(bohous). m_predek_bf(A):-m_seed_predek_bf(A). m_predek_bf(X):-m_predek_bf(P), rodic(P, X). predek_bf(P, D):-m_predek_bf(P), rodic(P, D). predek_bf(P, D):-m_predek_bf(P), rodic(P, X), m_predek_bf(X), predek_bf(X, D). ?-predek_bf(bohous, X). b f b j b k

21. Problém s negací • Negace v rekurzi způsobuje nejednoznačné výsledky nebo nekonečný výpočet • Stratifikovaná negace Graf G závislosti predikátů • Vrcholy G jsou predikáty • Hrana vede z q do p, je-li v IDB pravidlo p :- …, q, … . • Je-li q negováno, hrana je ohodnocena „~“

22. Př. • EDB: q = {1, 2} • IDB: p(X) :- q(X), not p(X). • p = Ø • p = {1, 2} • p = Ø • … • G: q p • ~ U U

23. Stratum IDB predikátu A je maximální počet ~ hran na cestě do A z EDB predikátu v grafu závislosti predikátů. Datalogovský program je stratifikovaný, jestliže každý IDB predikát má konečné stratum Je-li datalogovský program stratifikovaný, můžeme vyhodnotit IDB relace v pořadí od nejnižšího strata

24. Př. • zdroj(1). nedosažitelný • hrana(1, 2). • hrana(3, 4). ~ • hrana(4, 3). • cil(2). dosažitelný • cil(3). • dosazitelny(X) :- zdroj(X). • dosazitelny(X) :- dosazitelny(Y), hrana(Y, X). • nedosazitelny(X) :- cil(X), not dosazitelny(X). • Počítá dosažitelný={1, 2} stratum 0 • Počítá nedosažitelný={3}

25. LDL, LDL++ (MCC Austin, UCLA) • Verze 5.1 (1998) • Otevřená architektura, integrace s SQL systémy, možnost propojení s externími SŘBD • Podpora nemonotonních, nedeterministických a v omezené míře nestratifikovaných programů

26. Aditi (Melbourne) • Verze Aditi2 (2001) • Integrovaný systém orientovaný na diskové zpracování • Víceuživatelský provoz (klient server architektura) • Fakta uložena pouze v databázových relacích

27. Florid /LoPiX (Freiburg) • Spojení logického a OO paradigma • Vyhodnocuje zdola nahoru naivní metodou • Jazyk - F-logic (objekty) - predikátový zápis • LoPiX (2001) – zpracování XML dat

28. XSB (Leuven, Lisabon, Uppsala) • Vyhodnocování shora dolů (základní) • Vyhodnocování zdola nahoru (tabled resolution) • Modulárně stratifikované programy • Rozhraní pro C, Java, Perl, Oracle • Generické predikáty (predikáty vyššího řádu) • Verze 2.5 (březen 2002)

29. ConceptBase (Aachen) • Multiuživatelský deduktivní manažer objektů (pro konceptuální modelování) • Verze 5.23 (květen 2002) • Vše je objektem • Jazyk O-Telos podporuje - logický formát, - sémantické sítě, - rámce. • Rozhraní pro klientské programy v C, Java, Prolog

30. Překlad Datalogu do SQL v systému EDD • Překlad faktů • Překlad pravidel • Rozšíření - negativní literály - agregáty - přiřazovací příkazy - neurčitost

31. Překlad faktů jméno_faktu(c1, c2, …, cN). CREATE TABLE jméno_faktu( ARG1 typ1, ARG2 typ2, ARGN typN ); INSERT INTO jméno_faktu VALUES(c1,c2, …, cN) ; Překlad faktů z databázových tabulek jméno_tabulky(atr1 typ1, atr2 typ2, …, atrN typN).

32. Překlad pravidel • Každé pravidlo je přeloženo na jeden příkaz SELECT • Při více pravidlech pro jeden predikát je výsledkem sjednocení příkazů SELECT Překlad na příkaz SELECT • Argumenty SELECT jsou jména korespondující argumentům hlavy pravidla • FROM část tvoří jména predikátů z těla pravidla. Alias je použito při násobném výskytu predikátu v těle • WHERE část je konstruována cyklem:

33. FOR p IN prvý .. poslední predikát pravé strany pravidla LOOP IF p není predikát porovnání THEN FOR a IN prvý .. poslední argument predikátu p LOOP IF a je proměnná THEN IF a se dříve vyskytnul jako argument q v pravé straně THEN generuj do WHERE části podmínku spojení "p.jméno_sloupce = q.jméno _sloupce"; END IF; ELSE generuj do WHERE podmínku "p.jméno_sloupce = a"; END IF; END LOOP; ELSE -- p je porovnávací predikát IF oba argumenty predikátu p jsou proměnnéTHEN generuj do WHERE "argument_1 porovnání argument_2”; ELSE --proměnná je porovnávána s konstantou generuj "argument porovnání konstanta"; END IF; END IF; END LOOP;

34. Překlad rekurze • Vyhodnocování predikátů respektuje pořadí v grafu závislosti G • Nerekurzivní predikát lze přeložit na pohled nebo na tabulku • Rekurzivní predikát je reprezentován tabulkou • Cyklický graf závislosti G je kondenzován na acyklický graf GT • Pro uzel vzniklý kondenzací je generována smyčka v procedurálním rozšíření SQL

35. Př. rodic(a, b). rodic(a, c). rodic(b, f). rodic(c, g). rodic(f, j). rodic(f, k). rodic(g, k). predek(A, B) :- rodic(A, B). predek(A, B) :- predek(A, Z), rodic(Z, B).

36. CREATE TABLE rodic(ATTR_0 VARCHAR2(30),ATTR_1 VARCHAR2(30)); INSERT INTO rodic VALUES('a','b'); INSERT INTO rodic VALUES('a','c'); INSERT INTO rodic VALUES('b','f'); INSERT INTO rodic VALUES('c','g'); INSERT INTO rodic VALUES('f','j'); INSERT INTO rodic VALUES('f','k'); INSERT INTO rodic VALUES('g','k'); CREATE TABLE predek(ATTR_0 VARCHAR2(30),ATTR_1 VARCHAR2(30)); INSERT INTO predek SELECT DISTINCT rodic0.ATTR_0,rodic0.ATTR_1 FROM rodic rodic0;

37. DECLARE c NUMBER; BEGIN LOOP c := 0; INSERT INTO predek SELECT DISTINCT predek0.ATTR_0,rodic0.ATTR_1 FROM predek predek0,rodic rodic0 WHERE predek0.ATTR_1=rodic0.ATTR_0 AND (predek0.ATTR_0,rodic0.ATTR_1) NOT IN (SELECT ATTR_0,ATTR_1 FROM predek); c := c + SQL%ROWCOUNT; COMMIT; IF c = 0 THEN EXIT; END IF; END LOOP; END; /

38. ATTR_0 ATTR_1 ------------------------------ ------ a b a c b f c g f j f k g k a f a g b j b k c k a j a k

39. Překlad negativních literálů Ovlivňuje konstrukci části WHERE • Porovnávací predikát přeložený bez negace na tvar τ, je při negaci nahražen NOT τ • Negace predikátu, který je definován v programu se přeloží na konstrukci NOT EXISTS (SELECT …)

40. Př. v(1,2). v(1,3). v(1,4). v(3,5). v(4,6). v(5,7). ucpany(3). hrana(A,B) :- v(A,B). hrana(A,B) :- v(B,A). cesta(A,B) :- hrana(A,B). cesta(A,B) :- hrana(A,C), cesta(C,B), not ucpany(C). ?-cesta(1,X).

41. INSERT INTO cesta SELECT DISTINCT hrana0.ATTR_0,hrana0.ATTR_1 FROM hrana hrana0; DECLARE c NUMBER; BEGIN LOOP c := 0; INSERT INTO cesta SELECT DISTINCT hrana0.ATTR_0,cesta0.ATTR_1 FROM hrana hrana0,cesta cesta0 WHERE hrana0.ATTR_1=cesta0.ATTR_0 AND NOT EXISTS (SELECT * FROM ucpany WHERE ATTR_0=hrana0.ATTR_1) AND (hrana0.ATTR_0,cesta0.ATTR_1) NOT IN (SELECT ATTR_0,ATTR_1 FROM cesta); c := c + SQL%ROWCOUNT; COMMIT; IF c = 0 THEN EXIT; END IF; END LOOP; END; /

42. 1 ATTR_1 --------------- 1 1 1 2 1 3 1 4 1 6 1 2 3 5 7 4 6

43. Překlad agregátů • Využití agregačních funkcí SQL • Agregáty se mohou vyskytovat jen vhlavách pravidel p(, agreg(Y)) :- …, q(…, Y, …), … . SELECT …, agreg(q0.attr_k) FROM …, q q0 … WHERE … GROUP BY atributy reprezentované .

44. Př. owns(a, b, 0.6). owns(a, c, 0.4). owns(b, c, 0.6). owns(b, d, 0.3). owns(c, d, 0.4). controlsvia(X, X, Y, N) :- owns(X, Y, N). controlsvia(X, Y, Z, N) :- controls(X, Y), owns(Y, Z, N). controlsum(X, Y, sum(N) ) :- controlsvia(X, _, Y, N). controls(X, Y) :- controlsum(X, Y, N), N > 0.5.

45. CREATE TABLE owns(ATTR_0 VARCHAR2(30), ATTR_1 VARCHAR2(30),ATTR_2 NUMBER); INSERT INTO owns VALUES('a','b',0.6); INSERT INTO owns VALUES('a','c',0.4); INSERT INTO owns VALUES('b','c',0.6); INSERT INTO owns VALUES('b','d',0.3); INSERT INTO owns VALUES('c','d',0.4); CREATE TABLE controlsvia(ATTR_0 VARCHAR2(30),ATTR_1 VARCHAR2(30),ATTR_2 VARCHAR2(30),ATTR_3 NUMBER); INSERT INTO controlsvia SELECT DISTINCT owns0.ATTR_0,owns0.ATTR_0,owns0.ATTR_1, owns0.ATTR_2 FROM owns owns0; CREATE TABLE controls(ATTR_0 VARCHAR2(30),ATTR_1 VARCHAR2(30)); CREATE TABLE controlsum(ATTR_0 VARCHAR2(30),ATTR_1 VARCHAR2(30),ATTR_2 NUMBER);

46. DECLARE c NUMBER; BEGIN LOOP c := 0; INSERT INTO controlsvia SELECT DISTINCT controls0.ATTR_0,controls0.ATTR_1, owns0.ATTR_1,owns0.ATTR_2 FROM controls controls0,owns owns0 WHERE controls0.ATTR_1=owns0.ATTR_0 AND (controls0.ATTR_0,controls0.ATTR_1,owns0.ATTR_1, owns0.ATTR_2) NOT IN (SELECT ATTR_0,ATTR_1,ATTR_2,ATTR_3 FROM controlsvia); c := c + SQL%ROWCOUNT; INSERT INTO controls SELECT DISTINCT controlsum0.ATTR_0,controlsum0.ATTR_1 FROM controlsum controlsum0 WHERE controlsum0.ATTR_2>0.5 AND (controlsum0.ATTR_0,controlsum0.ATTR_1) NOT IN (SELECT ATTR_0,ATTR_1 FROM controls); c := c + SQL%ROWCOUNT;

47. UPDATE controlsum SET(ATTR_2)=(SELECT DISTINCT SUM(controlsvia0.ATTR_3) FROM controlsvia controlsvia0 WHERE controlsvia0.ATTR_0=controlsum.ATTR_0 AND controlsvia0.ATTR_2=controlsum.ATTR_1) WHERE (ATTR_2) NOT IN (SELECT DISTINCT SUM(controlsvia0.ATTR_3) FROM controlsvia controlsvia0 WHERE controlsvia0.ATTR_0=controlsum.ATTR_0 AND controlsvia0.ATTR_2=controlsum.ATTR_1); c := c + SQL%ROWCOUNT;

48. INSERT INTO controlsum SELECT DISTINCT controlsvia0.ATTR_0,controlsvia0.ATTR_2, SUM(controlsvia0.ATTR_3) FROM controlsvia controlsvia0 WHERE (controlsvia0.ATTR_0,controlsvia0.ATTR_2) NOT IN (SELECT ATTR_0,ATTR_1 FROM controlsum) GROUP BY controlsvia0.ATTR_0,controlsvia0.ATTR_2; c := c + SQL%ROWCOUNT; COMMIT; IF c = 0 THEN EXIT; END IF; END LOOP; END; /

49. Tabulka controls ATTR_0 ATTR_1 ----------------------------------- a b b c a c b d a d

50. Přiřazovací příkaz • Užitečnost imperativní konstrukce • Nemožnost vyhodnocování predikátů zdola nahoru • Nemožnost vyjadřování pomocí SELECT