5. Implementierung von PräferenzQuerysprachen

Transkript

1 . Implementierung von PräferenzQuerysprachen Es werden Implementierungsdetails zu folgenden Themen vorgestellt:. Integration mit SQL-Datenbanken. Algebraische Präferenz-Optimierung. Auswertung der Präferenz-Selektion -

2 . Integration mit SQL-Datenbanken Drei prinzipielle Vorgehensweisen für die Integration mit SQL-Datenbanken stehen zur Verfügung: Lose Kopplung Hybride Kopplung Enge Kopplung -

3 .. Lose Kopplung Applikationsintegration durch lose Kopplung, Präprozessor, on top of the db, rewriting Applikation Preference SQL-Anfrage Preference JDBC-Treiber Preference SQL Rewriter BMO-Ergebnisse Standard JDBC-Treiber SQL-Anfrage Standard SQL DB-System -

4 Beispiel: Preference SQL Rewriter Identifier Make Audi BMW Volkswagen SELECT FROM PREFERRING Model Price Mileage Airbag A yes series yes Beetle yes Diesel no yes no * cars Make = 'Audi' AND Diesel = 'yes'; -4

5 CREATE VIEW Auxiliary AS SELECT *, CASE WHEN Make = 'Audi' THEN 0 ELSE END AS Makelevel, CASE WHEN Diesel = 'yes' THEN 0 ELSE END AS Diesellevel FROM cars; Einfügen in eine temporär erstellte Relation bmo INSERT INTO bmo SELECT Identifier, Make, Model, Price, Mileage, Airbag, Diesel FROM Auxiliary A WHERE NOT EXISTS (SELECT FROM Auxiliary A WHERE A.Makelevel <= A.Makelevel AND A.Diesellevel <= A.Diesellevel AND (A.Makelevel < A.Makelevel OR A.Diesellevel < A.Diesellevel)); -

6 .. Enge Kopplung Ansatz: Erweiterung des existierenden SQL-Optimierers um Präferenzoptimierungstechniken Implementierung von σ[p] im DB-Kern Vorteil: Größtmögliche Effizienz Nachteil: Höchster Implementierungsaufwand Kooperation mit DB-Hersteller Beispiel: relationales Datenbanksystem EXASolution.0 von Exasol. -6

7 Enge Kopplung: Applikation Preference SQL-Anfrage Standard JDBC-Treiber Preference SQL Optimierer BMO-Ergebnisse Query Engine Standard SQL DB-System -7

8 .. Hybride Kopplung Ansatz: SQL-System für Standardteile (d.h. relationale Algebra, z.b. πx(σh(r))) der Preference Query nützen. Spezialmethoden in einer Middleware Algebraische Preference Query Optimierung Effiziente Algorithmen für die Präferenz-Selektion σ[p] und die gruppierende Präferenz-Selektion σ[p grouping G] Anfrage-Operatorbaum wird von Preference SQL (P-Optimierer, P-Engine) verwaltet. -8

9 Hybride Kopplung Applikation Client Preference SQL-JDBC-Treiber (Client) Preference SQL-Anfrage BMO-Ergebnisse Preference SQL-JDBC-Treiber (Server) Preference SQL (P-Optimierer, P-Engine) Server Standard JDBC-Treiber SQL-Anfrage SQL-Zwischenergebnisse Standard SQL DB-System -9

10 Vorteile: Die Preference SQL-Komponente liegt nur auf einem Server, womit eine leichte Wartbarkeit und eine einfache Erweiterung von Preference SQL gewährleistet sind, da kein Update auf Seite der Clients erforderlich ist. Die Standard-SQL-Komponente eines DB-Systems bleibt unverändert. Nachteile: Die Laufzeit einer Preference SQL-Anfragegenerierung erhöht sich, da Preference SQL als eigene Komponente zusätzlich zur StandardSQL-Komponente eines DB-Systems Rechenzeit verbraucht. Nachoptimierung innerhalb Standard-SQL-Komponente ist nötig. - 0

11 ..4 Literatur W. Kießling, G. Köstler: Preference SQL - Design, Implementation, Experiences 8th International Conference on Very Large Data Bases (VLDB 00). pp , Hong Kong, China, Aug. 00. W. Kießling, M. Endres, F.Wenzel: The Preference SQL System - An Overview In Bulletin of the Technical Committee on Data Engineering, Vol. 4 No., June 0, p. 8. -

12 . Algebraische Präferenz-Optimierung Preference Relational Algebra: Relationale Algebra Präferenz-Selektion: σ[p](r) := { t R v R: t[a] <P v[a]} Gruppierende Präferenz-Selektion: σ[p GROUPING G] (R) := { t R v R: t[g] G v[g] t[a] <P v[a]} Spezialfall (triviale SV-Semantik): σ[p GROUPING G] (R) := σ[p GROUPING idg] (R) -

13 .. Ablauf einer Preference SQL QueryAuswertung. Übersetzung in einen initialen Operatorbaum der Preference Relational Algebra (PRA). Operatorbaumtransformationen nach Heuristiken. Kostenbasierte Auswahl effizienter Algorithmen zur Auswertung des Operatorbaums aus () -

14 Beispiel: Relationales Datenbankschema: USED_CARS (id, Age, Color, Price ) // id ist Fremdschlüssel CAR_DETAIL (id, Brand, ) // auf id von CAR_DETAIL SELECT FROM WHERE PREFERRING u.price, d.brand, u.age used_cars u, car_detail d u.id = d.id and u.color = 'red' u.age AROUND 8 PRIOR TO d.brand IN ('BMW', 'Mercedes') ; - 4

15 Initialer Ausführungsplan der Anfrage: πu.price, d.brand, u.age σ[around(u.age, 8) & POS(d.brand, {BMW, Mercedes})] σu.id = d.id color = red X used_car u car_detail d -

16 .. Transformationsregeln Ziel ist die frühzeitige Anwendung von Präferenzen, um die Ergebnismenge zu reduzieren. Theorem L: Theorem L: Theorem L: Theorem L4: Theorem L: Theorem L6: Schiebe Projektion über eine Präferenz-Selektion. * Schiebe Präferenz-Selektion über kartesisches Produkt. Schiebe Präferenz-Selektion über Vereinigung. Teile Priorisierung in Gruppierung auf. * Schiebe Präferenz-Selektion über harte Selektion. * Schiebe Präferenz-Selektion über Join. * * Diese Theoreme werden noch detaillierter vorgestellt. - 6

17 Theorem L7: Theorem L8: Theorem L9: Theorem L0: Theorem L: Theorem L: Theorem L: Teile Pareto-Präferenz auf und schiebe sie über Join. Teile Priorisierung auf und schiebe sie über Join. Vereinfache gruppierte Präferenz-Selektionen. * Kaskadiere Präferenzen und harte Selektionen. Nutze Kommutativität, Assoziativität und Distributivität von Pareto-Präferenzen. Teile Priorisierung auf und schiebe die jeweiligen Präferenzen über kartesisches Produkt. Teile Pareto auf und schiebe die jeweiligen Präferenzen über kartesisches Produkt. - 7

18 Transformationsgesetze in Preference Relational Algebra (PRA): Wir betrachten ein Relationenschema R(A, An) mit einer Instanz R dom(a) dom(an). Ferner sei attr(r) = {A, An}. - 8

19 (L) Schiebe Projektion über Präferenz-Selektion: Für die Präferenz P = (A, <P, P) und A, X attr(r) gilt: a) Falls A X: πx(σ[p](r)) = σ[p](πx(r)) b) sonst: πx(σ[p](r)) = πx(σ[p](πx A(R))) Ebenso gilt auch für die Präferenz P = (A, <P, P) mit A, X attr(r): a) Falls A, B X: πx(σ[p grouping B](R)) = σ[p grouping B](πX(R)) b) sonst: analog zu oben - 9

20 (L) Schiebe Präferenz-Selektion über kartesisches Produkt: Für die Präferenz P = (A, <P, P) und A attr(r) gilt: σ[p](r x T) = σ[p](r) x T - 0

21 (L) Schiebe Präferenz-Selektion über Vereinigung: Für die Präferenz P = (A, <P, P) mit A attr(r), attr(r) = attr(t) gilt: σ[p](r T) = σ[p]( σ[p](r) σ[p](t) ) (L4) Teile Priorisierung in Gruppierung auf: Für die Präferenzen P = (A, <P, P ) und P = (A, <P, P ) mit A, A attr(r) gilt: a) σ[p & P](R) = σ[p grouping P ] (σ[p](r)) b) σ[p & P](R) = σ[p] (σ[p grouping P ](R)) -

22 (L) Schiebe Präferenz-Selektion über harte Selektion: Für die Präferenzen P = (A, <P, P) mit A attr(r) und eine harte Bedingung H gilt: σ[p](σh(r)) = σh( σ[p](r) ) gdw. w, v R: (H(w) w[a] <P v[a]) => H(v) Eine Vertauschung ist möglich, wenn für jedes Tupel w, das die harte Bedingung H erfüllt, auch das dominierende Tupel v die harte Bedingung erfüllt. -

23 Gegenbeispiel und Beispiel zu L: Gegeben sei die R(A, B) = {(, ), (, ), (, ), (, ), (, 00)} mit Q: σ[highest(b), =](σa = (R)) = σ[highest(b), =]({ (, ), (, )}) = {(, )}; Q: σa = (σ[highest(b), =](R)) = σa = ({(, 00)}) = ; Das Tupel v = (, 00) erfüllt nicht die Bedingung A =, dominiert aber aufgrund seines maximalen B-Wertes das gesamte Ergebnis. L ist nicht anwendbar! Falls v durch v = (, 00) ersetzt wird, ist (L) anwendbar. -

24 (L6) Schiebe Präferenz-Selektion über Join: Für die Präferenz P = (A, <P, P) mit A attr(r) und X attr(r) attr(t), gilt: Falls für jedes Tupel aus R mindestens ein Join-Partner in T existiert: σ[p](σr.x = T.X(R T)) = σr.x = T.X(σ[P](R) T) (L7) Teile Pareto-Präferenz auf und schiebe sie über Join: Für die Präferenzen P = (A, <P, P ) mit A attr(r), P = (A, <P, P ) mit A attr(t) und X attr(r) attr(t), gilt: Falls für jedes Tupel aus R mindestens ein Join-Partner in T existiert: σ[p P](σR.X = T.X(R T)) = σ[p P](σR.X = T.X( σ[p grouping X](R) T)) - 4

25 (L8) Teile Priorisierung auf und schiebe sie über Join: Gegeben seien P = (A, <P, P ) mit A attr(r) und P = (A, <P, P ) mit A attr(r) attr(s). Zudem sei X attr(r) attr(s). Falls jedes Tupel in R wenigstens einen Join-Partner in S hat: σ[p & P](σR.X = S.X(R S)) = σ[p grouping P ] (σr.x = S.X(σ[P](R) S)) Bemerkung zu L6 - L8: Falls R.X ein Fremdschlüssel auf S.X ist, hat jedes Tupel in R wenigstens einen Join-Partner in S. -

26 (L9) Vereinfache gruppierende Präferenz-Selektion: Für die Präferenzen P = (A, <P, P), P = (A, <P, P ) und P = (A, <P, P ) mit A, A, A attr(r) und mit,, als beliebige Äquivalenzrelationen gilt: a) σ[(p grouping ) grouping ](R) = σ[p grouping ( )](R), wobei gilt: x ( ) y gdw. x y x y b) σ[(p grouping ) & P](R) = σ[(p & P) grouping ](R) c) σ[(p (P grouping )](R) = σ[(p P) grouping ](R) d) σ[(p grouping ) (P grouping )](R) = σ[(p P) grouping ( )](R) e) σ[p grouping G](R) = R, falls G eindeutig (z.b. Primärschlüssel) ist. - 6

27 (L) Kommutativität, Assoziativität und Distributivität: Für die Präferenzen P = (A, <P, P ), P = (A, <P, P ) und P = (A, <P, P ) gilt: a) σ[p P ](R) = σ[p P ](R) b) σ[(p P ) P ](R) = σ[p (P P )](R) c) σ[(p & P) & P](R) = σ[p & (P & P)](R) d) σ[p & (P P )](R) = σ[(p & P) (P & P )](R) - 7

28 (L) Teile Priorisierung auf und schiebe die jeweiligen Präferenzen über kartesisches Produkt Gegeben seien: P = (A, <P, P ) mit A attr(r), P = (A, <P, P ) mit A attr(s). σ[p & P](R S) = σ[p](r) σ[p](s) - 8

29 (L) Teile Pareto auf und schiebe die jeweiligen Präferenzen über kartesisches Produkt Gegeben seien: P = (A, <P, P ) mit A attr(r), P = (A, <P, P ) mit A attr(s). σ[p P](R S) = σ[p](r) σ[p](s) - 9

30 .. Operatorbaumoptimierung Der aus der Vorlesung Datenbanksysteme I bekannte HillClimbing-Algorithmus wird um Transformationsregeln für Preference Relational Algebra (PRA) erweitert. Eingabe ist ein initialer Operatorbaum T: Algorithmus PassPreference(T): {update T: Schritt A- <Schiebe Präferenz-Selektion über Vereinigung: L> Schritt - Schritt - <Teile harte Selektionen auf> <Schiebe harte Selektionen so weit als möglich nach unten> - 0

31 .. Operatorbaumoptimierung Schritt B-: Schritt B-: Schritt B-: Schritt B-4: Schritt B-: Schritt -: Schritt -: <Teile Priorisierung in Gruppierung auf: L4> <Schiebe Präferenz-Selektion über Join: L6> <Teile Präferenz auf und schiebe sie über Join: L7; L9e; L8> <Schiebe Präferenz-Selektion über kartesisches Produkt: L> <Teile Präferenz auf und schiebe sie über kartesisches Produkt: L, L> <Schiebe Projektionen soweit wie möglich nach unten auch über Präferenzen (L)>; <Kombiniere harte Selektionen und kartesische Produkte zu Joins> return T} -

32 Beispiel für Operatorbaumoptimierung: Benutzte Schemata ohne Angabe von Domänen sind: USED_CARS (id, Age, Color, Price ) // id ist Fremdschlüssel CAR_DETAIL (id, Brand, ) // auf id von CAR_DETAIL SELECT FROM WHERE PREFERRING u.price, d.brand, u.age used_cars u, car_detail d u.id = d.id AND u.color = 'red' u.age AROUND 8 PRIOR TO d.brand IN ('BMW', 'Mercedes') -

33 Initialer Ausführungsplan: πu.price, d.brand, u.age πu.price, d.brand, u.age σ[around(u.age, 8, ~AROUND) & POS(d.brand, {BMW, Mercedes}, ~POS)] σ[around(u.age, 8, ~AROUND) & POS(d.brand, {BMW, Mercedes}, ~POS)] σu.id = d.id σu.id = d.id u.color = red X σu.color = red X used_car u car_detail d used_car u -: Harte Selektion aufteilen und -: verschieben. car_detail d -

34 πu.price, d.brand, u.age σ[around(u.age, 8, ~AROUND) & POS(d.brand, {BMW, Mercedes}, ~POS)] πu.price, d.brand, u.age σ[pos(d.brand, {BMW, Mercedes}, ~POS) grouping ~AROUND] L4a σ[around(u.age, 8, ~AROUND)] σu.id = d.id σu.id = d.id X X σu.color = red used_car u σu.color = red car_detail d used_car u B-: Teile Priorisierung in Gruppierung auf. car_detail d - 4

35 πu.price, d.brand, u.age πu.price, d.brand, u.age σ[pos(d.brand, {BMW, Mercedes}, ~POS) grouping ~AROUND] σ[pos(d.brand, {BMW, Mercedes}, ~POS) grouping ~AROUND] σ[around(u.age, 8, ~AROUND)] σu.id = d.id L6 X σu.id = d.id σ[around(u.age, 8, ~AROUND)] X σu.color = red used_car u σu.color = red car_detail d used_car u B-: Schiebe Präferenz-Selektion über Join. car_detail d -

36 πu.price, d.brand, u.age La σ[pos(d.brand, {BMW, Mercedes}, ~POS) σ[pos(d.brand, {BMW, Mercedes}, ~POS) grouping ~AROUND] grouping ~AROUND] σu.id = d.id σu.id = d.id X X πu.price, d.brand, u.age σ[around(u.age, 8, ~AROUND)] σ[around(u.age, 8, ~AROUND)] σu.color = red σu.color = red used_car u car_detail d used_car u -: Schiebe Projektion über gruppierte Präferenz-Selektion. car_detail d - 6

37 σ[pos(d.brand, {BMW, Mercedes}, ~POS) σ[pos(d.brand, {BMW, Mercedes}, ~POS) grouping ~AROUND] grouping ~AROUND] πu.price, d.brand, u.age σu.id = d.id b(db) 0(DB) La πu.price, d.brand, u.age σu.id = d.id X X σ[around(u.age, 8, ~AROUND)] σ[around(u.age, 8, ~AROUND)] σu.color = red used_car u πu.id, u.price, u.age πd.id, d.brand σu.color = red car_detail d used_car u -: Schiebe Projektion über Präferenz-Selektion. car_detail d - 7

38 σ[pos(d.brand, {BMW, Mercedes}, ~POS) σ[pos(d.brand, {BMW, Mercedes}, ~POS) grouping ~AROUND] grouping ~AROUND] πu.price, d.brand, u.age πu.price, d.brand, u.age σu.id = d.id u.id = d.id X σ[around(u.age, 8, ~AROUND)] πu.id, u.price, u.age σ[around(u.age, 8, ~AROUND)] πd.id, d.brand πd.id, d.brand σu.color = red σu.color = red used_car u πu.id, u.price, u.age car_detail d used_car u -: Selektion + kartesisches Produkt zu Joins. car_detail d - 8

39 Weiteres Beispiel: Zwischenstand eines PRA-Operatorbaums πu.price, s.name σ[(lowest(u.age, ~LOWEST) BETWEEN(u.price, [000, 6000], ~BETWEEN)) & POS(c.brand, {BMW}, ~POS) & AROUND(s.zipcode, 86609, ~AROUND) ] u.sid = s.sid u.ref = c.ref seller s σu.color = gray u.color = red used_car u category c - 9

40 Endstand des PRA-Operatorbaums πu.price, s.name σ[around(s.zipcode, 86609) grouping {~BETWEEN, ~LOWEST, ~POS} ] πu.price, u.age, s.name, s.zipcode, c.brand u.sid = s.sid σ[pos(c.brand, {BMW}, ~POS) grouping {~BETWEEN, ~LOWEST}] πs.name, s.zipcode, s.sid seller s πu.price, u.age, u.sid, c.brand u.ref = c.ref πc.ref, c.brand category c σ[lowest(u.age, ~LOWEST) BETWEEN(u.price, [000, 6000], ~BETWEEN)] πu.price, u.age, u.sid, u.ref Anwendung der Regeln: L8; L8; Lb, La; σu.color = gray u.color = red used_car u - 40

41 SQL-Client: EXPLAIN-Anweisung - 4

42 ..4 Weiterführende Literatur J. Chomicki: Preference formulas in relational queries ACM Transactions on Database Systems (TODS). Volume 8, Issue 4 (December 00), pp B. Hafenrichter, W. Kießling: Optimization of Relational Preference Queries 6th Australasian Database Conference (ADC 00). pp. 7-84, Newcastle, Australia, Jan. 00. M. Endres, P. Roocks, M. Huber, W. Kießling: Grouping Queries with SV-Semantics in Preference SQL 8th Multidisciplinary Workshop on Advances in Preference Handling, in conkunction with AAAI-4, Quebec City, Canada. - 4

43 . Auswertung der Präferenz-Selektion Klassifizierung: Algorithmen ohne vordefinierte Indexstruktur mit vordefinierter Indexstruktur: effizient, jedoch nicht geeignet im Allgemeinen Algorithmen für allgemeine, strikt partielle Ordnungen: Block-Nested-Loop (BNL) ist allgemein gültig. Für Spezialfälle gibt es schnellere Algorithmen. spezielle Algorithmen für Pareto Priorisierung & Numerisches Ranking rank F - 4

44 .. Der BNL-Algorithmus Eigenschaften: Keine vordefinierte Indexstruktur Allgemeine, strikt partielle Ordnungen Komplexität: Worst Case: Average Case: Θ (n) Θ (n) Basisalgorithmus ist ein Nested-Loop (NL), der vollständig im Hauptspeicher abläuft. Dieser wird anschließend um eine Blockverwaltung ergänzt (block nested loop, BNL). - 44

45 Initialisierung des Standard-NL ohne Blockverwaltung: Kandidatenliste cand = ; Berechnung:. Lese das nächste Tupel t, vergleiche es mit allen c cand: Verwerfe t, falls es von irgend einem c dominiert wird, und fahre mit Schritt fort. Entferne c von cand, falls es von t dominiert wird.. Füge t zu cand hinzu.. Falls es noch ein Tupel gibt, fahre mit Schritt fort. 4. Gebe cand als Ergebnismenge zurück. - 4

46 Nested-Loop mit Blockverwaltung (BNL): Datenstrukturen: Eingabe t t t t000 Window Ext. Speicher tp tp tp tp für BMOKandidaten i+ i+... tp i+k für nicht im Window enthaltene BMOKandidaten - 46

47 Nested-Loop mit Blockverwaltung (BNL): Ausgangssituation: Eingabe Window Ext. Speicher t t leer t t t7... t000-47

48 Berechnung: In der ersten Iteration wird der NL-Algorithmus auf die Eingabetupel angewandt. Eingabe Window Ext. Speicher t t leer t t t7... t000 Seien t4 ~P t7 und t <P t7. Test auf Dominanz Window t7 t4-48

49 Falls das BMO-Window voll ist, werden die BMO-Kandidaten im externen Speicher gespeichert. Seien t4 ~P t980 und t7 ~P t980 Eingabe Window Ext. Speicher t t7 t980 t4 leer t t000-49

50 In der n-ten Iteration werden die Tupel des Windows ausgegeben, bei denen zum Zeitpunkt der Einfügung der externe Speicher leer war. Alle anderen Tupel des Windows bleiben erhalten und müssen mit den Tupeln aus dem externen Speicher in der nächsten Iteration verglichen werden. Die Tupel des externen Speichers werden die neue Eingabe. Eingabe Window Ext. Speicher t980 leer leer leer leer

51 .. Analyse von Better-Than-Graphen (BTG) Wir betrachten eine Pareto-Präferenz P = P Pm = ({A,, Am}, <P), Standardauswertung von σ[p](r) kann über den BNLAlgorithmus erfolgen. Komplexität von BNL: worst case: O(n) average case: O(n) Frage: Geht es schneller? Antwort: Ja! Unter speziellen Voraussetzungen... -

52 ... BTG für schwache Ordnungen Zur Erinnerung: Pi = (Ai, <P ) ist eine schwache Ordnung, weak order preference i (WOP), gdw. Pi eine strikte partielle Ordnung ist und zudem negative Transitivität gilt: (x <p y) (y <p z) (x <p z) Alle Basis-Konstruktoren außer EXPLICIT sind WOPs! Zudem wird reguläre SV-Semantik angenommen, d.h.: xi ist genau dann durch yi substituierbar, falls xi und yi indifferent sind. Eine schwache Ordnung mit regulärer SV-Semantik zerfällt in Äquivalenzklassen unvergleichbarer Elemente. Diese Klassen können linear geordnet werden. -

53 Visualisierung von Better-Than-Graphen (BTG) per Hasse-Diagramm: Ein Knoten für jede Äquivalenzklasse. Substituierbare Elemente bilden eine Äquivalenzklasse. Der Level eines Knoten entspricht den Level-Funktionen für Basis-Präferenzen. Beispiel : P = POS/POS(color, {rot, blau}; {schwarz}, ~P ) {rot, blau} Level 0 {schwarz} Level others Level -

54 Beispiel : P = AROUND0000(tarifgehalt, 60000, ~P ), wobei gelten soll: inftarifgehalt = 0 und suptarifgehalt = {60000} Level 0 {[40000, 60000), (60000, 80000]} Level {[0000, 40000), (80000, 90000]} Level {[0, 0000)} Level - 4

55 Wichtige Eigenschaft: Für jede Präferenz Pi mit schwacher Ordnung, die definiert ist auf einer kategoriellen Domäne, bzw. auf einer numerischen Domäne, wobei die Domäne durch die Benutzung des d-parameters und durch die reguläre SV-Semantik partitioniert wird, kann der Test auf Dominanz wie folgt im BTG ersetzt werden: levelp : dom(a) N0 i x <P y levelp (x) > levelp (y) i i i Zudem gilt: x ~P y levelp (x) = levelp (y) i i i -

56 ... BTG für Pareto-Präferenz Damit ergibt sich für eine Pareto-Präferenz P über schwachen Ordnungen P,, Pm mit regulärer SV-Semantik: P = P... Pm = ({A,..., Am}, <p) (x,, xm) <P (y,, ym) gdw. i: levelp (xi) > levelp (yi) i i j {,..., m} mit j i: levelp (xj) >= levelp (yj) j j sowie (x,..., xm) P (y,..., ym) gdw. j {,..., m}: levelp (xj) = levelp (yj) j j - 6

57 Beispiel: P = POS/POS(color, {rot, blau}; {schwarz}, ~P ) (0,0) Level 0 P = AROUND0000(tarifgehalt, 60000, ~P ) P = P P (0,) (0,) (,) (,0) Level (0,) (,) (,) Level Beachte: P ist keine schwache Ordnung! Knoten entsprechen Äquivalenzklassen. (,) (,) (,) Level (,0) Level 4 Level - 7

58 .. Der BNL++-Algorithmus Zur Erinnerung: Der BNL-Algorithmus ist ohne zusätzliche Voraussetzungen für die Berechnung der Pareto-Präferenz einsetzbar und deshalb von grundsätzlicher Bedeutung. - 8

59 Eigenschaften des BTG einer Pareto-Präferenz P = P... Pm: Ein Knoten im BTG für jede Kombination der Level aller Präferenzen Pi. Jeder BTG einer Pareto-Präferenz, deren Konstituenten jeweils schwache Ordnungen sind, ist ein vollständiger distributiver Verband. Es existiert ein bester Knoten (top) und ein schlechtester Knoten (bottom). - 9

60 Definition: Verband (V,, ) Sei V eine nichtleere Menge mit zwei zweistelligen Verknüpfungen (Vereinigung) und (Durchschnitt) mit folgenden Eigenschaften: x, y, z V gelte:... Kommutativität x y=y x bzw. x y=y x Assoziativität x (y z) = (x y) z bzw. x (y z) = (x y) z Verschmelzung x (x y) = x bzw. x (x y) = x - 60

61 Ein distributiver Verband hat zudem die Eigenschaft der Distributivität: x, y, z V: x (y z) = (x y) (x z) bzw. x (y z) = (x y) (x z) Auf V kann eine Halbordnung definiert werden durch: x z x z=z Bezüglich dieser Halbordnung hat jede zweielementige Teilmenge {v, w} ein Supremum s = v w und ein Infimum i = v w. Dabei ist ein Element s ein Supremum von {v, w}, wenn gilt: v s w s (d. h. s ist obere Schranke) Aus v t und w t folgt s t (d. h. s ist die kleinste obere Schranke). Analoges gilt ebenso für das Infimum i. - 6

62 Theorem: BTG ist vollständiger distributiver Verband Für einen BTG einer Pareto-Präferenz über der Menge V = { (i, i,, ik) ij N0 } gelten folgende Definitionen für x, y V: Infimum x y := max(x, y) = ( max(xi, yi ), max(xi, yi ),, max(xi, yi ) ) k k Supremum x y := min(x, y) = ( min(xi, yi ), min(xi, yi ),, min(xi, yi ) ) k k Im BTG sind die beiden Verknüpfungen zwischen allen Elementen wohldefiniert, woraus die Vollständigkeit folgt. Distributivität folgt aus der Distributivität von min( ) und max( ). - 6

63 Beispiele: (0,0) min((,0), (,)) = (min(,), min(0,)) = (,0) min((,0), (,), (0,)) = (0,0) min((,), (,)) = (,) max((,0), (,)) = (max(,), max(0,)) = (,) max((,0), (,), (,)) = (max(,,), max(0,,)) = (,) max((0,), (,)) = (,) max((,), (,)) = (,) (0,) (,0) (0,) (,) (,0) (0,) (,) (,) (,) (,) (,) - 6

64 Theoreme: a) Level eines BTG-Elements: level P ( a,..., a m ) = m i = level P ( a i ) b) Maximales Level des BTG: m max( P ) = c) i = max ( P i ) Größe des BTG (Knotenanzahl): BTG = m ( max( Pi )+) i= d) Höhe des BTG: h = max(p)

65 Beispielhaft sind folgende BTG-Kennzahlen angegeben: Präferenz Knoten- Kanten- Höhe anzahl anzahl Breite P,, 8 6 P,, P0, 0,

66 Mit Hilfe des Tools: BTG-Viewer* können BTGs visualisiert und bezüglich der Dominanz analysiert werden: P,, P,,00 P0, 0, 0 * Bachelor-Arbeit von Florian Schleuter - 66

67 ... Pruning-Analyse Abschneiden (Pruning): Finde alle Tupel t, wobei t <P (,) (0,) Level (,0) (0,) (,) (,0) Level (0,) (,) (,) Level (,) (,) (,) Level 0 (0,0) Level 4 Level - 67

68 Abschneiden (Pruning): Finde alle Tupel t, wobei t <P (,) (0,) Level (,0) (0,) (,) (,0) Level (0,) (,) (,) Level (,) (,) (,) Level 0 (0,0) Level 4 Level - 68

69 Abschneiden (Pruning): Finde alle Tupel t, wobei t <P (,) (0,) Level (,0) (0,) (,) (,0) Level (0,) (,) (,) Level (,) (,) (,) Level 0 (0,0) Level 4 Level - 69

70 Abschneiden (Pruning): Finde alle Tupel t, wobei t <P (,) (0,) Level (,0) (0,) (,) (,0) Level (0,) (,) (,) Level (,) (,) (,) Level 0 (0,0) Level 4 Level - 70

71 Theorem (Pruning-Level): Gegeben seinen Präferenzen Pi, die schwache Ordnungen sind, wobei für mindestens zwei Präferenzen max(pi) > 0 gelte. Dann hat ein Knoten x = (x,, xm) das folgende Pruning-Level pl(x): Falls x der beste Knoten ist: pl(0, 0,, 0) = Falls x sich auf dem Level max(p) befindet (schlechtester Knoten): pl(x) = max(p) + Ansonsten: pl(x,, xm) = max(p) min( { max(pi) xi xi > 0 } ) - 7

72 Beispiel: pl(,) = min({, }) = =4 (0,) Level (,0) (0,) (,) (,0) Level (0,) (,) (,) Level (,) (,) (,) Level 0 (0,0) Level 4 Level - 7

73 Beispiel: Level 0 (0,0) pl(,) = min({, }) = =4 (0,) Level (,0) (0,) (,) (,0) Level (0,) (,) (,) Level Level 4 Level - 7

74 ... BNL++-Algorithmus Im Folgenden wird die Basisvariante vorgestellt. Die Erweiterung um eine Blockverwaltung kann analog zum BNL-Algorithmus erfolgen. Initialisierung: Kandidatenliste cand = ; pruning_level = max(p) + ; Test auf Dominanz:. Lese ein Tupel, berechne seine Äquivalenzklasse ect und a) prüfe, ob levelp(ect) pruning_level. Falls ja, gehe zu Schritt. b) Für alle c cand mit level(ect) > level(c): Falls ect <P c, gehe zu Schritt. - 74

75 Test auf Dominanz (Fortsetzung). Lese ein Tupel, berechne seine Äquivalenzklasse ect und... c) Füge ect zu cand hinzu. d) Setze pruning_level auf min(pruning_level, pl(ect)). e) Für alle c cand mit level(c) > level(ect): Falls c <P ect, entferne c.. Falls ein weiteres Tupel als Input existiert, gehe zu Schritt.. Ansonsten gib cand als BMO-Ergebnismenge zurück. - 7

76 Beispiel: BNL++ P = P P, reguläre SV-Semantik! P = POS/POS(color, {black, silver}; {red}, ~P ) P = BETWEEN0(hp, [0, 0], ~P ) Level 0 ID color hp levelp levelp levelp plp t green 0 t white 60 t yellow 40 0 t4 blue 60 t red 00 4 t6 black 70 0 Level 4 t7 silver 00 0 Level t8 red 80 4 Level Level Level - 76

77 P = P P P = POS/POS(color, {black, silver}; {red}, ~P ) P = BETWEEN0(hp, [0, 0], ~P ) Initialisierung: ID color hp levelp levelp plp max(p) = levelp t green 0 max(p) = t white 60 t yellow 40 0 t4 blue 60 t red 00 4 t6 black 70 0 t7 silver 00 0 t8 red 80 4 max(p) = pruning_level = + = 6 Cand = { } - 77

78 Ergebnis von Schritt : pruning_level = ID color Cand = {(,)} t green 0 t white 60 t yellow 40 0 t4 blue 60 t red 00 4 t6 black 70 0 t7 silver 00 0 t8 red 80 4 (,) hp levelp levelp levelp plp - 78

79 Ergebnis von Schritt : pruning_level = ID color Cand = {(,), (,)} t green 0 t white 60 t yellow 40 0 t4 blue 60 t red 00 4 t6 black 70 0 t7 silver 00 0 t8 red 80 4 (,) hp levelp levelp levelp plp - 79

80 Ergebnis von Schritt : pruning_level = ID color Cand = {(,0)} t green 0 t white 60 t yellow 40 0 t4 blue 60 t red 00 4 t6 black 70 0 t7 silver 00 0 t8 red 80 4 (,0) (,) hp levelp levelp levelp plp - 80

81 Ergebnis von Schritt : pruning_level = ID color Cand = {(,0)} t green 0 t white 60 t yellow 40 0 t4 blue 60 t red 00 4 t6 black 70 0 t7 silver 00 0 t8 red 80 4 (,0) (,) hp levelp levelp levelp plp - 8

82 Ergebnis von Schritt : pruning_level = ID color Cand = {(,), (,0)} t green 0 t white 60 t yellow 40 0 t4 blue 60 t red 00 4 t6 black 70 0 t7 silver 00 0 t8 red 80 4 (,0) (,) hp levelp levelp levelp plp - 8

83 Ergebnis von Schritt : pruning_level = ID color Cand = {(0,), (,0)} t green 0 t white 60 t yellow 40 0 t4 blue 60 t red 00 4 t6 black 70 0 t7 silver 00 0 t8 red 80 4 (,0) (0,) (,) hp levelp levelp levelp plp - 8

84 Ergebnis von Schritt : pruning_level = ID color Cand = {(0,), (,0)} t green 0 t white 60 t yellow 40 0 t4 blue 60 t red 00 4 t6 black 70 0 t7 silver 00 0 t8 red 80 4 (0,) (,0) (0,) hp levelp levelp levelp plp - 84

85 ID color (0,) hp levelp levelp levelp plp t green 0 t white 60 t yellow 40 0 t4 blue 60 t red 00 4 t6 black 70 0 Ergebnis von Schritt : t7 silver 00 0 pruning_level = t8 red 80 4 (,0) (,) Cand = {(0,), (,0)} Ergebnismenge ist {(,0), (0,)}. - 8

86 ..4 Hexagon-Algorithmus Der Hexagon-Algorithmus nutzt die Verbandseigenschaften des BTG für eine Optimierung aus. Verwendet dazu den explizit erstellten BTG in Form eines Feldes. Der Algorithmus besteht aus Phasen:. Konstruktion des BTG. Zuweisung von Eingabe-Tupeln an die Äquivalenzklasse (Knoten im BTG). Entfernen von dominierten Tupeln - 86

87 ..4. Knotenidentifizierung per Kantengewichte Eine Kante von einem Knoten zu einen anderen zeigt Dominanz: (0,0) (0,): ist dominiert von (0,0) bezüglich P (0,) (,0) (,0): ist dominiert von (0,0) bezüglich P Kanten können also nach den ihnen zugeordneten Präferenzen unterschieden werden. Für P = (P,, Pm) gibt es als m verschiedene Kantentypen. Gewicht einer Kante, die bezüglich Pi dominiert wird: weight ( P i ) = m j= i + ( max( P j )+) falls definiert, ansonsten. - 87

88 Beispiel: (0,0) weight(p) = (0,) weight(p) = max(p) + = 4 Ziel: Ordne den Knoten mit Hilfe von Kantengewichten eine eindeutige Knoten-ID zu. level 0 level (,0) (0,) (,) (,0) level (0,) (,) (,) level (,) (,) (,) level 4 level - 88

89 Eindeutige Knoten-ID: Eindeutige natürliche Zahl für jeden Knoten: NID(a,..., a m ) = m ( weight ( P i ) i= Eigenschaften: Die Summe der Kantengewichte auf jedem beliebigem Pfad vom eindeutigem Top-Element zu irgendeinem Knoten ist identisch und gibt die Knoten-ID an. Alle Zahlen aus dem Intervall [0, BTG -] sind zulässige Knoten-IDs. weight(p) = 0:(0,0) weight(p) = 4 ai ) :(0,) 4:(,0) :(0,) :(,) 8:(,0) :(0,) 6:(,) 9:(,) 7:(,) 0:(,) :(,) - 89

90 ..4. Konstruktion des BTG Berechne die BTG-Größe BTG ) ) Initialisiere die richtig dimensionierten Felder - next[ BTG ] für eine Breitensuche - nodes[ BTG ] als Speicher für Eingabe-Tupeln In einer Laufschleife von [0, BTG -] über alle Knoten tue: - Berechne das Level des jeweiligen Knotens. - Setze next[knoten-id] des jeweiligen Knotens. 0:(0,0) :(0,) 4:(,0) :(0,) :(,) 8:(,0) :(0,) 6:(,) 9:(,) 7:(,) 0:(,) :(,) - 90

91 ..4. Zuweisung der Eingabe-Tupeln zu BTG-Knoten ) In einer Laufschleife über alle Eingabe-Tupeln tue: - Berechne die Knoten-ID - Trage das aktuelle Tupel im Speicher von nodes[knoten-id] ein. 0:(0,0) :(0,) 4:(,0) :(0,) :(,) 8:(,0) :(0,) 6:(,) 9:(,) 7:(,) 0:(,) :(,) - 9

92 ..4.4 Entfernen von dominierten Tupeln ) In einer Laufschleife über alle Knoten eines Levels mit aufsteigendem Level (folge next[ ]: Breitensuche) tue: a) Entferne alle Knoten aus next[ ], die von keinem Eingabe-Tupel belegt sind bzw. b) Entferne alle Knoten die von dominanten Knoten beherrscht werden (Tiefensuche): Folge dazu allen Kanten des aktuellen Knotens, wobei das Gewicht der rekursiv besuchten ausgehenden Kanten immer kleiner gleich dem Gewicht der eingehenden Kante sein muss. Die Reihenfolge der Startkanten ist aufsteigend gemäß Gewicht. 0:(0,0) :(0,) 4:(,0) :(0,) :(,) 8:(,0) :(0,) 6:(,) 9:(,) 7:(,) 0:(,) :(,) - 9

93 Zwischenergebnis: 0:(0,0) :(0,) :(0,) 4:(,0) :(,) :(0,) 8:(,0) 6:(,) 7:(,) 9:(,) 0:(,) :(,) - 9

94 ) In einer Laufschleife tue: a) Entferne alle Knoten aus next[ ], die von keinem Eingabe-Tupel belegt sind bzw. :(,) 8:(,0) b) Entferne alle Knoten aus next[ ], die von dominanten Knoten beherrscht werden (Tiefensuche): :(0,) 6:(,) 9:(,) Folge dazu allen Kanten des aktuellen Knotens, wobei das Gewicht der rekursiv besuchten ausgehenden Kanten immer kleiner gleich dem Gewicht der eingehenden Kante sein muss. 7:(,) 0:(,) Die Reihenfolge der Startkanten ist aufsteigend gemäß Gewicht.. Startkante: weight(p) = :(,) - 94

95 ) In einer Laufschleife tue: a) Entferne alle Knoten aus next[ ], die von keinem Eingabe-Tupel belegt sind bzw. b) Entferne alle Knoten aus next[ ], die von dominanten Knoten beherrscht werden (Tiefensuche): Folge dazu allen Kanten des aktuellen Knotens, wobei das :(0,) Gewicht der rekursiv besuchten ausgehenden Kanten immer kleiner gleich dem Gewicht der eingehenden Kante sein muss. Die Reihenfolge der Startkanten ist aufsteigend gemäß Gewicht.. Startkante: weight(p) = 4 :(,) 8:(,0) 9:(,) 0:(,) :(,) - 9

96 Zwischenergebnis: :(,) :(0,) 8:(,0) 9:(,) :(,) 8:(,0) 0:(,) :(0,) :(,) Über link[] und link[8] endet der Algorithmus, ohne dass a) oder b) angewendet werden können. - 96

97 Beispiel zu Hexagon: ID color hp levelp levelp P = POS/POS(color,{black, silver}; {red}, ~P )) P = BETWEEN0(hp, [0, 0], ~P)) P = P P t green 0 t white 60 t yellow 40 0 t4 blue 60 t red 00 t6 black 70 0 t7 silver 00 0 weight(p) = t8 red 80 weight(p) = 4 max(p) = max(p) = BTG = (+) * (+) = next[], nodes[] - 97

98 I. Konstruktion des BTG: max(p) = 0:(0,0) :(0,) 4:(,0) max(p) = BTG = (+) * (+) = :(0,) :(,) 8:(,0) :(0,) 6:(,) 9:(,) weight(p) = weight(p) = 4 Felder für Verwaltung: next[], nodes[] 7:(,) 0:(,) :(,) - 98

99 II. Einfügen: ID color 0:(0,0) hp levelp levelp nid t green 0 9 t white 60 9 t yellow t4 blue 60 t red 00 7 t6 black 70 0 t7 silver 00 0 t8 red 80 6 :(0,) 4:(,0) :(0,) :(,) 8:(,0) :(0,) 6:(,) 9:(,) 7:(,) 0:(,) :(,) - 99

100 Hexagon Beispiel: Löschen III. Löschen: 0:(0,0) a) Kein Eintrag in nodes[0] :(0,) 4:(,0) :(0,) :(,) 8:(,0) :(0,) 6:(,) 9:(,) 7:(,) 0:(,) :(,) - 00

101 weight(p) = weight(p) = 4 b) Eintrag t7 (0,) in nodes[] a) kein Eintrag in nodes[], gelöscht b) Eintrag t (0,) in nodes[] wird dominiert, daher gelöscht. b) terminiert. 0:(0,0) :(0,) 4:(,0) :(0,) :(,) 8:(,0) :(0,) 6:(,) 9:(,) 7:(,) 0:(,) :(,) - 0

102 weight(p) = 0:(0,0) weight(p) = 4 b) Eintrag t7 (0,) in nodes[] :(0,) a) kein Eintrag in nodes[], :(0,) gelöscht weight(p) = b) Eintrag t8 (,) in nodes[6] :(0,) wird dominiert, daher gelöscht. b) Eintrag t (,) in nodes[7] wird dominiert, daher gelöscht. Terminiert. 4:(,0) :(,) 8:(,0) 6:(,) 9:(,) 7:(,) 0:(,) :(,) - 0

103 b) Eintrag t7 (0,) in nodes[] b) Einträge t (,) und t (,) in nodes[9] werden dominiert, daher gelöscht. a) kein Eintrag in nodes[0], gelöscht b) Eintrag t4 (,) in nodes[] wird dominiert, daher gelöscht. weight(p) = 0:(0,0) weight(p) = 4 :(0,) 4:(,0) :(,) 8:(,0) 6:(,) 9:(,) weight(p) = 4 7:(,) 0:(,) :(,) b) Terminiert. - 0

104 0:(0,0) a) Kein Eintrag in nodes[4], daher gelöscht. 4:(,0) :(0,) 4:(,0) 8:(,0) 9:(,) 0:(,) :(,) - 04

105 0:(0,0) 4:(,0) :(0,) 4:(,0) III terminiert: 8:(,0) 4:(,0) :(0,) 8:(,0) Die BMO-Menge gesteht aus {t, t7}. ID color hp levelp levelp nid t green 0 9 t white 60 9 t yellow t4 blue 60 t red 00 7 t6 black 70 0 t7 silver 00 0 t8 red

106 .. Leistungsfähigkeit von Hexagon Die Beurteilung der Leistungsfähigkeit eines Algorithmus lässt sich einerseits durch sein Komplexitätsmaß oder andrerseits durch einen Benchmark über Daten mit unterschiedlichen Verteilungen im Wettbewerb mit vergleichbaren Algorithmen bestimmen. - 06

107 ... Komplexität Zur Bestimmung der Komplexität von σ[p](r) mittels Hexagon sei bekannt: Pareto-Präferenz P = P P, wobei alle P reguläre m i WOPs sind. Die Anzahl der Tupel der Relation R sei gegeben als R = n. - 07

108 Dann ist die Komplexität (worst-case = best-case) gegeben durch: Speicherbedarf in DB-Cache (unabhängig von n): Beachte: Hexagon ist nur anwendbar, falls der DB-Cache groß genug ist für den BTG! Zeit-Bedarf: Lesen und Einfügen der Tupel in den BTG: O(n) // IO-Kosten Löschen durch Tiefensuche: O( BTG ) // CPU-Kosten - 08

109 ... Benchmark Mit Hilfe verschiedener Testmengen als Input für einen Benchmark kann die Leistungsfähigkeit von Algorithmen für die Berechnung der Ergebnismenge des ParetoKonstruktors miteinander verglichen werden. LESS: LESS ++: Hexagon: basiert auf einen BNL-Algorithmus. basiert auf LESS-Algorithmus, erweitert um Pruning-Methoden, wie sie auch von BNL++ benutzt werden. BTG-basierter Algorithmus - 09

110 Unter der Voraussetzung, dass die Algorithmen und ihre Daten nur im Hauptspeicher gehalten werden, ergibt sich in Abhängigkeit von der Anzahl der mit Pareto verknüpften Präferenzen folgendes Laufzeitverhalten: - 0

111 Eine weiterer Benchmark vergleicht die Abhängigkeit von der Tupelanzahl von Testmengen mit folgenden statistischen Eigenschaften: Korrelierte Daten: Daten, die in einer Dimension als gut betrachtet werden, sind auch in einer anderen Dimension gut. Beispiel: Studierende: kurze Studiendauer gute Abschlussnote Antikorrelierte Daten: Daten, die in einer Dimension als gut betrachtet werden, sind in einer oder in allen anderen Dimensionen schlecht. Beispiel: Hotels: hohe Qualität niedriger Preis Statistisch unabhängige Daten Hinweis: Es wird ein logarithmischer Maßstab in den nachfolgenden Abbildungen verwendet. -

112 Laufzeit in Abhängigkeit von der Anzahl der Eingabetupel bei korrelierten Daten: -

113 Laufzeit in Abhängigkeit von der Anzahl der Eingabetupel bei antikorrelierten Daten: -

114 Laufzeit in Abhängigkeit von der Anzahl der Eingabetupel bei statistisch unabhängigen Daten: - 4

115 ..6 Scalagon Algorithmus Scalagon: Kombination von Hexagon und BNL (M. Endres, P.Roocks and W. Kießling - Scalagon: An Effizient Skyline Algorithm for All Seasons. Database Systems for Advanced Application (DASFAA) 0) Kap. -

116 Diskretisiere Wertebereich auf [,...,S] x [,...,S] Beispiel: Domäne D = [,...,0] x [,...,40] Beispiel für Skalierungsfaktor s = 0: D / s = [,...,] x [,...,4] (0, 0) (S, 0) (0, S) Verbandsstruktur bleibt erhalten (S, S) Kap. - 6

117 Phase : Entferne dominierte Kacheln (0, 0) - Pareto-Ordnung auf Tupeln induziert Produktordnung auf Kacheln: (0, ) (x, x) <P (y, y) <=> x <P y x <P y - ähnlich wie Standard-Hexagon (, 0) (0, ) - Beispiel: alle Tupel aus (0, ) dominieren alle Tupel aus (, ) (, ) Kap. - 7

118 Phase : Hexagon auf jeweiligen Kacheln Kap. - 8

119 Phase : Standard-BNL über alle übrigen Tupel - finde alle Tupel aus nicht-dominierten Kacheln, die in ihrer Kachel nicht dominiert sind Kap. - 9

120 Kritischer Punkt: Wahl der Skalierungsfaktor (s,, sn) = /s * (S,, Sn) s = : ähnlich Hexagon (α 0) s : alle Tupel auf einer Kachel, ähnlich BNL (α ) In der Praxis: Faktor α, der auch die Anzahl der Tupel berücksichtigt α-werte zwischen 0 und 0 sind meist zutreffend Kap. - 0

121 - Vergleich BNL / Hexagon / Scalagon mit α = => bringt keinen Vorteil Kap. -

122 - Vergleich BNL / Hexagon / Scalagon mit α = 0 => deutlicher Geschwindigkeitsvorteil vor Hexagon. BNL und Scalagon sind fast gleich gut (0.000 Tupel sind für BNL kein Problem) Kap. -

123 - Vergleich BNL / Hexagon / Scalagon mit α = 0 => deutliche Geschwindigkeitsvorteil vor BNL und Hexagon! Kap. -

124 ..7 Zusammenfassung Datenbank-Technologie bietet eine exzellente Unterstützung für Präferenzen und Personalisierung mit Hinblick auf: Leichte Modellierung (Präferenzen durch Konstruktoren für strikte partielle Ordnungen) Hohe Effizienz (Transformationen in Preference Relational Algebra, Optimierung der Join-Reihenfolge mit Präferenzen, BNL ++, Hexagon) Hinweis: Transitivität ist essentiell! Ansonsten wird die Berechnung der Präferenz-Selektion ineffizient. Weitere Optimierungsmöglichkeiten: Speicheroptimierung bei dünn besetzten BTGs Durch d-parameter kann bereits in der Modellierung Einfluss auf die Größe des BTGs genommen werden. - 4

125 ..8 Weiterführende Literatur S. Borzsonyi, D. Kossmann and K. Stocker: The Skyline Operator IEEE Conf. on Data Engineering pp. 4-40, Heidelberg, Germany, 00. BNL P. Godfrey, R. Shipley and J. Gryz: Algorithms and Analyses for Maximal Vector Computation VLDB Journal, 6(): 8, 007. LESS M. Endres, P. Roocks, W. Kießling: Scalagon: An Efficient Skyline Algorithm for All Seasons Database Systems for Advanced Application (DASFAA) 0 -

126 T. Preisinger: Graph-based Algorithms for Pareto Preference Query Evaluation Dissertation, Universität Augsburg, Juli 009. T. Preisinger, W. Kießling and M. Endres: The BNL++ Algorithm for Evaluating Pareto Preference Queries Proceedings of the ECAI 006 Multidisciplinary Workshop on Advances in Preference Handling Riva del Garda, Italy, August 006. T. Preisinger, W. Kießling: The Hexagon Algorithm for Pareto Preference Queries Proceedings of the rd Multidisciplinary Workshop on Advances in Preference Handling in conjunction with VLDB 007, Vienna, Austria, September