SQL – OLAP 7. óra

1. SQL – OLAP7. óra

2. Hatékonysági kérdések Időigényes műveletek (ahol lehet javítani): f(v)(C) , f(D.a)(C), D.a(C), D, aggr(C) (és ahol nem…) C1  C2 Adott kulcsú cellák megkeresése A: szekvenciális keresés ? reménytelen !! k1 k2 k3 v1 v2 v3 B: index alapú keresés ? k1+k2+k3 : ha mindegyik kulcs adott költség : log (N3) ez OK !! de asszimnetrikus !

3. Hatékonysági kérdések k1 k2 k3 v1 v2 v3 Több-dimenziós keresőfa : minden szint egy-egy dimenzióhoz rendelt ciklikusan k1 k2 k3 k1 k2

4. Hatékonysági kérdések ha valamelyik kulcs tetszőleges (intervallum) akkor több ágon fut a keresés Ha keresési feltétel: k1 = %, k2=x, k3=% csomópontok száma: L,L2,L3 (L a B-fa fokszáma) költség: első k2 szinten: L, második k2 szinten: L*L2, i. k2 szinten: L2*i+1 ez is túl nagy még !!!

5. Hatékonysági kérdések Grid file Szimmetrikus az egyes dimenziókra Hash függvény jelöli ki a rekeszt h2(k2) h1(k1) Lemez blokk Ha túlcsordul, egyik dimenzió mentén felhasad Hátránya : reláció-őrző hash függvény kellene

6. Hatékonysági kérdések Legbiztosabb megoldás: többszörös indexelés, többszintű pointer láncolat k1 index k2 index k1-k2 index

7. Fizikai megvalósítás K többletköltség? G P A F L O Audi Opel Fiat Lada Baja 7,2 6,1 7,0 3,2 Miskolc 9,1 7,4 Dorog 7,2 4,2

8. Hatékonysági kérdések k1 index Keresés menete: - megfelelő szintű index kiválasztása - érték megkeresés (log (Nk)) - fő pointer-lánc bejárása - mellék pointer-láncok bejárása Csak a szükséges elemeket érinti

9. Indexelés: sparse - dense index ritka index: nem minden rekord indexelt (index szekvenciális) feltétel: rendezettség szélső elemre mutat lsd: cluster index sűrű index: minden rekord indexelt idő: logM(N/k) + [k] = logMN - logMk + [k] hely: N/k/M blokk

10. Indexelés: bitmap index táblázatos tárolás rekordok A 0 értékek 0 B 1 1 C szűk domain esetére támogatja a logikai operátorokat gyakran társítják a projekciós index-szel rekordok érték C B

11. Összetett feltételek, több kulcs esetére is alkalmas a bitmap index fetétel: K1 = 5 and K2 > 5 B-fa szerint: K1=5 megkeresése majd szekvencia a K2> 5 ellenőrzésre K1 0 5 0 1 1 K2 0 6 0 1 7 1 + metszetképzés / unió / komplementer

12. Bitindexek típusai normál mód: minden érték egy sor 1 0 1 0 0 0 2 1 0 1 0 3 előnyös egzakt érték keresésnél tartomány mód: minden érték több sor (a tőle nagyobb értékek) 1 0 1 0 0 1 2 1 1 1 1 3 előnyös tartomány érték keresésnél

13. Bitindexek típusai dekompozíciós mód: a tábla több résztáblára bontott <rn,…,r2,r1> szám n-es alapján képzi a bitmintát: C = b1 + b2*r1 + … + bn+1*rn Pl. n =1 , b1 = 3 –hez: 5 = 1*3 + 2 rn = D/szorzatn-1(ri) 0 1 0 0 1 0 0 1 0 2 1 0 0 0 1 0 1 1 0 1 0 2 0 0

14. Bitindexek típusai hierarchikus bitindex: a zéró helyek felsőbb szinten jelzi 1 1 1 0 0 1 1 0 1 0 1 0 0 0 0 0 0 0 0 1 0 0 1 0 0 1 0 2 1 0

15. Join index A kapcsolódó rekordpárok kijelölése kulcs szerint rendezve tény-kulcshoz dimenzió-kulcsot vagy dimenzió-kulcshoz tény-kulcsot rendel TELEPHELY cim nev OSSZDB SELEJTDB TERMEK cim nev TELEP OSSZDB TERMEK B-fa Nem kell explicit keresést végezni

16. Cella keresési költségek módszer teljes kulcs részkulcs intervallum 1 fa: N k-fa: K’ logMN + K’*N’ logMN+N/(2B) B-fa logMN (metszetek) Grid-file (H/2)K 1 HK-K’ V*N/B’ V’*N/B’ V*N/2/B’ bitmap N :elemszám, M fokszám V : értékek száma, K’ kiválasztott dim. db B: blokkméret, H: bucketek száma, K:dimenziók száma

17. Aggregációs számítások SELECT sum(fiz) FROM dolgozok WHERE beosztas = ‘irnok’ a feltételt teljesítő rekordok pozíciót ismertnek tekintjük (Bf) - alap módszer: a kijelölt rekordok közvetlen beolvasása N: rekord db., B: blokk méret, R: eredmény rekord db. érintendő blokkok száma: O(N/B * (1 – e-RN/B)) nem egyszerű feladat a = szummaB(B* P(B)) P(B) = ((N:B))szorzati((S:i)) : 1<= i <= S N/B R

18. Aggregációs számítások • projekciós index módszer: a kijelölt mező értékeket a • a projekciós indexből vesszük be. • előny: kevesebb blokk olvasás (B’ >> B) O(N/B’ * (1 – e-RN/B’)) • mező indexen keresztül (B’’ >> B’): • sum = 0 • foreach v in DOM(fiz) { • Bv = foundset az index alapján • sum = sum + v*|Bf metszet Bv | • } • O(V*N/B’’ + N/B’)

19. Aggregációs számítások A költség függ az aggregáció jellegétől SELECT max(fiz) FROM dolgozok WHERE beosztas = ‘irnok’ • közvetlen elérés: • O(N/B * (1 – e-RN/B)) • bitmap index az elemre (metszet a Bf-fel): • O(V*N/B’’ ) • projekciós index: • O(N/B’ * (1 – e-RN/B’)) • mező index • O(V/2*N/B’’ + N/B’)

20. Hatékonysági kérdések Az aggregáció gyorsítása: elő-aggregációk tárolása elemi érték (k1,k2) k2 szerinti aggregáció k1 szerinti aggregáció k1.k2 szerinti aggregáció

21. Cube-tree struktúra az alapadatok és az aggregált adatok hatékony elérésére szolgál az adatok R-tree struktúrában tároltak alapadat v(x,y,z) v(0,0,0) v(x,y,0) aggregált adatok

22. Előaggregáció előnye: gyorsabb válaszadás Hátránya: több helyfoglalás lassabb módosítás (load) Cél az egyéb költségek minimalizálása Csak a szükséges előszámításokat végezzük el Tapasztalat: egyes aggregációk kiszámíthatók más aggregációs értékekből A,B, Sum(C) A,B,C, Sum(C) A, Sum(C) Származtatási háló ez egyes aggregációs szintek között

23. A B C A,B A,C B,C A,B,C Minden view-hoz helyköltség, minden élhez időköltség rendelhető   hely-költség +   idő-költség => minimális

24. Greedy algoritmus addig növeli a bevont elemek halmazát, amíg egy szigorú korlátba nem ütközik S = {alap-view} loop { vi = argmaxi {B(vi,S) : vi S} S = S  {vi} } B(v,S) =  w < v Bw Bw = CostS(w) - Costv(w), ha CostS(w) > Costv(w) 0 , különben

25. 0.2 2 2 1 0.2 0.4 0.4 3 2 1 3 4 5 0.5 0.2 0.4 1 3 2 0.7 Az eredő nyereség kiszámítsánál a v hivatkozási valószínűségét is figyelembe lehet venni.

26. Lekérdezések kapcsolati viszonya Milyen feltételek mellett lehet egy Q lekérdezést más V view-kból leszármaztatni? relációk: view-k egyenértékűsége és view-k egymásbafoglalása Általános esetre nem ismert még a megoldás speciális eset: pontos illeszkedés V1 < V2: - V1 mezői, hivatkozásai V2-ben is benne vannak - azonos aggregáció - V2 szelekciói V1-ben is benne vannak - V1 szelekciói szűkebbek V2: SELECT a,sum(b), avg(c), d FROM t1 WHERE t1.c > 5 GROUP BY a V1: SELECT a,sum(b) FROM t1 WHERE t1.c > 5 AND t1.d = 5 GROUP BY a

27. Hatékonyabb művelet optimalizálás a hagyományos QGM optimalizálás is módosulhat eddig csak SPJ műveleteket vettünk : szelekcio(proj) - join – szelekcio – csoportképzés? –aggregáció? SELECT B.b, sum(A.a) FROM A,B,C WHERE A.m=B.n AND A.h = C.f AND C.l = x GROUP BY B.b De! Az A és B tábla join-ja közben lehet aggregálni és csoportosítani, nem kell utána újra átfutni a táblát

28. Hatékonyabb művelet optimalizálás szabály : a csoportosítás lesüllyesztése minél lentebbre SELECT B.b, sum(A.a) FROM A,B,C WHERE A.m=B.n AND A.h = C.f AND C.l = x GROUP BY B.b aggregáció ekvijoin transzformáció scan left-deep join alap

29. Lesüllyesztés feltételei • a csomópont felett csak kulcs- idegenkulcs alapú • join műveletek vannak • - a csomópontban minden aggregációs mező szerepel • - minden felettes join mező egyben csoportképzési mező is sum(A.c) C.a ez szűk esetben teljesül sum(A.c) kapcsolt lesüllyesztések: - több csomópontra szétbontott B.y C select C.n,sum(A.c) from A,B,C where A.x = B.x and B.y=C.y group by C.n sum(A.c) B A.x A B C A