Stáhnout prezentaci
Prezentace se nahrává, počkejte prosím
1
Univerzální B-stromy (UB-Stromy)
Vícerozměrná přístupová metoda Rudolf Bayer Michal Krátký,
2
Obsah Úvod Vícerozměrná data Principy UB-stromů
Algoritmus vkládání bodu Algoritmus výpočtu Z-adresy Algoritmus rozsahového dotazu Práce s nebodovými objekty Složitosti algoritmů, výhody
3
Úvod UB-strom je vícerozměrná přístupová metoda
autorem je Rudolf Bayer, další výzkum Volker Markl Využívá Z-uspořádání a B-stromů
4
Vícerozměrná data Kartézským součinem domén atributů vznikne vícerozměrný prostor n-tice (řádek, tuple, entita, objekt) je bodem v n-dimenzionálním prostoru a je takto indexován Prostorová blízkost umožňuje shlukování těchto bodů pro uložení na diskové stránky => snížení počtu přístupů na disk => rychlejší operace Využití v data warehousingu, GIS, ...
5
Z-uspořádání Pro x Î W a binární reprezentaci každého atributu
xi = x i,s-1 x i,s x i,0 definujeme Z-hodnotu Z(x): Z(x) počítá pro každou n-tici Z-adresu (tj. jeho pozici na Z-křivce) Z-hodnoty jsou efektivně počítány tzv. bitovým prokládáním (bit-interleaving) Z(x) je bijektivní funkce, která počítá pro každý bod jeho Z-adresu (tj. pozici na Z-křivce).
6
Z-uspořádání pro univerzum 8x8
1 5 4 17 16 21 20 3 2 7 6 19 18 23 22 9 8 13 12 25 24 29 28 11 10 15 14 27 26 31 30 33 32 37 36 49 48 53 52 35 34 39 38 51 50 55 54 41 40 45 44 57 56 61 60 43 42 47 46 59 58 63 62 (a) (b)
7
Z-region [a :b ] je prostor pokrytý intervalem na Z-křivce.
Z-regiony/UB-stromy Z-region [a :b ] je prostor pokrytý intervalem na Z-křivce. UB-Stromové dělení: [0 : 3],[4 : 20], [21 : 35], [36 : 47], [48 : 63] Z-region [4 : 20] 4 20
8
UB-strom V uzlu B-stromu jsou uloženy adresy Z-regionů
UB-index UB-soubor K Z-regionu koresponduje jedna disková stránka. V listech B-stromu jsou uloženy n-tice náležící k danému Z-regionu
9
Algoritmus vkládání bodu
Vstup: x: bod, který má být vložen do UB-Stromu Výstup: žádný x = Z(x) find [a : g] in the UB-Tree, such that a Ł x Ł g retrieve page(a : g) insert x into page(a : g) if count(a : g) > C choose bÎ[a : g], so that ½C - e Ł count(a : b) Ł ½C + e split page(a : g) into page(a : b) and page(b + 1 : g) end if C je maximální počet bodů, které mohou být uloženy v jedné stránce. x je vložen do listu-stránky příslušející k Z-regionu, který je nalezen bodovým dotazem.
10
Ukázka vkládání bodů
11
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom B-Strom Z-adresa
12
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom B-Strom Z-adresa
13
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom B-Strom Z-adresa
14
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom B-Strom Z-adresa
15
Po vložení dalších dvou bodů ...
16
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom B-Strom Z-adresa
17
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom B-Strom Z-adresa
18
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom B-Strom Z-adresa
19
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom Z-adresa B-Strom
20
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom Z-adresa B-Strom
21
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom Z-adresa B-Strom
22
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom Z-adresa B-Strom
23
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom Z-adresa B-Strom
24
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom Z-adresa B-Strom
25
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom Z-adresa B-Strom
26
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom Z-adresa B-Strom
27
UB-Strom Z-adresa B-Strom UB-Strom Z-adresa B-Strom
28
UB-Strom Z-adresa B-Strom UB-Strom Z-adresa B-Strom
29
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom Z-adresa B-Strom
30
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom Z-adresa B-Strom
31
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom Z-adresa B-Strom
32
Po vložení dalších bodů obsahuje UB-strom 5 Z-regionů ..
33
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom Z-adresa B-Strom
34
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom Z-adresa B-Strom
35
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom Z-adresa B-Strom
36
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom Z-adresa B-Strom
37
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom Z-adresa B-Strom
38
A po vložení dalších bodů ...
39
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom Z-adresa B-Strom
40
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom Z-adresa B-Strom
41
Zaddress za = Z(tuple); BtreeInsert(za, tuple); }
Zdrojový kód Insert(Tuple tuple) { Zaddress za = Z(tuple); BtreeInsert(za, tuple); } Ubvalue findSplitPoint(Tuple t1, Tuple t2) /* nalezení optimální Z-adresy mezi t1 a t2 */ UB-Strom Z-adresa B-Strom
42
Výpočet Z-adresy
43
1 0 0 1 0 _ _ _ _ _ _ _ _ _ _ 1 1 0 0 1 1 _ _ _ _ _ _ _ _ _ _
Zdrojový kód UB-strom Zaddress Z(Tuple tuple) { Zaddress za = 0; int pos = 0, bit ; for (bit = 0; bit < maxbits(tuple); bit++) foreach attribute of tuple do if (attribute[bit] exists) { if (attribute[bit] is set) ZaddressSetBit(&za, pos); pos++; } return za; Atribut 1 Atribut 2 (25,18) Z-adresa Atribut 2 Atribut 1 _ _ _ _ _ _ _ _ _ _ Bitové řetězce 1 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ Z-adresa
44
1 0 0 1 0 _ _ _ _ _ _ _ _ _ _ 1 1 0 0 1 1 1 _ _ _ _ _ _ _ _ _ _
Zdrojový kód UB-strom Zaddress Z(Tuple tuple) { Zaddress za = 0; int pos = 0, bit ; for (bit = 0; bit < maxbits(tuple); bit++) foreach attribute of tuple do if (attribute[bit] exists) { if (attribute[bit] is set) ZaddressSetBit(&za, pos); pos++; } return za; Atribut 1 Atribut 2 (25,18) Z-adresa Atribut 2 Atribut 1 _ _ _ _ _ _ _ _ _ _ Bitové řetězce 1 1 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ Z-adresa
45
1 0 0 1 0 _ _ _ _ _ _ _ _ _ _ 1 1 0 0 1 1 1 0 _ _ _ _ _ _ _ _ _ _
Zdrojový kód UB-strom Zaddress Z(Tuple tuple) { Zaddress za = 0; int pos = 0, bit ; for (bit = 0; bit < maxbits(tuple); bit++) foreach attribute of tuple do if (attribute[bit] exists) { if (attribute[bit] is set) ZaddressSetBit(&za, pos); pos++; } return za; Atribut 1 Atribut 2 (25,18) Z-adresa Atribut 2 Atribut 1 _ _ _ _ _ _ _ _ _ _ Bitové řetězce 1 1 0 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ Z-adresa
46
1 0 0 1 0 _ _ _ _ _ _ _ _ _ _ 1 1 0 0 1 1 1 0 1 _ _ _ _ _ _ _ _ _ _
Zdrojový kód UB-strom Zaddress Z(Tuple tuple) { Zaddress za = 0; int pos = 0, bit ; for (bit = 0; bit < maxbits(tuple); bit++) foreach attribute of tuple do if (attribute[bit] exists) { if (attribute[bit] is set) ZaddressSetBit(&za, pos); pos++; } return za; Atribut 1 Atribut 2 (25,18) Z-adresa Atribut 2 Atribut 1 _ _ _ _ _ _ _ _ _ _ Bitové řetězce _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ Z-adresa
47
1 0 0 1 0 _ _ _ _ _ _ _ _ _ _ 1 1 0 0 1 1 1 0 1 0 _ _ _ _ _ _ _ _ _ _
Zdrojový kód UB-strom Zaddress Z(Tuple tuple) { Zaddress za = 0; int pos = 0, bit ; for (bit = 0; bit < maxbits(tuple); bit++) foreach attribute of tuple do if (attribute[bit] exists) { if (attribute[bit] is set) ZaddressSetBit(&za, pos); pos++; } return za; Atribut 1 Atribut 2 (25,18) Z-adresa Atribut 2 Atribut 1 _ _ _ _ _ _ _ _ _ _ Bitové řetězce _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ Z-adresa
48
Zdrojový kód UB-strom Zaddress Z(Tuple tuple) { Zaddress za = 0; int pos = 0, bit ; for (bit = 0; bit < maxbits(tuple); bit++) foreach attribute of tuple do if (attribute[bit] exists) { if (attribute[bit] is set) ZaddressSetBit(&za, pos); pos++; } return za; Atribut 1 Atribut 2 (25,18) Z-adresa Atribut 2 Atribut 1 _ _ _ _ _ _ _ _ _ _ Bitové řetězce _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ Z-adresa
49
Zdrojový kód UB-strom Zaddress Z(Tuple tuple) { Zaddress za = 0; int pos = 0, bit ; for (bit = 0; bit < maxbits(tuple); bit++) foreach attribute of tuple do if (attribute[bit] exists) { if (attribute[bit] is set) ZaddressSetBit(&za, pos); pos++; } return za; Atribut 1 Atribut 2 (25,18) Z-adresa Atribut 2 Atribut 1 _ _ _ _ _ _ _ _ _ _ Bitové řetězce _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ Z-adresa
50
Zdrojový kód UB-strom Zaddress Z(Tuple tuple) { Zaddress za = 0; int pos = 0, bit ; for (bit = 0; bit < maxbits(tuple); bit++) foreach attribute of tuple do if (attribute[bit] exists) { if (attribute[bit] is set) ZaddressSetBit(&za, pos); pos++; } return za; Atribut 1 Atribut 2 (25,18) Z-adresa Atribut 2 Atribut 1 _ _ _ _ _ _ _ _ _ _ Bitové řetězce _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ Z-adresa
51
Zdrojový kód UB-strom Zaddress Z(Tuple tuple) { Zaddress za = 0; int pos = 0, bit ; for (bit = 0; bit < maxbits(tuple); bit++) foreach attribute of tuple do if (attribute[bit] exists) { if (attribute[bit] is set) ZaddressSetBit(&za, pos); pos++; } return za; Atribut 1 Atribut 2 (25,18) Z-adresa Atribut 2 Atribut 1 _ _ _ _ _ _ _ _ _ _ Bitové řetězce _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ Z-adresa
52
Zdrojový kód UB-strom Zaddress Z(Tuple tuple) { Zaddress za = 0; int pos = 0, bit ; for (bit = 0; bit < maxbits(tuple); bit++) foreach attribute of tuple do if (attribute[bit] exists) { if (attribute[bit] is set) ZaddressSetBit(&za, pos); pos++; } return za; Atribut 1 Atribut 2 (25,18) Z-adresa Atribut 2 Atribut 1 _ _ _ _ _ _ _ _ _ _ Bitové řetězce _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ Z-adresa
53
Algoritmus vymazání bodu 1/2
Vstup: x: bod, který má být vymazán z UB-stromu Výstup: žádný x = Z(x) search [a : b] in the UB-Tree, such that a Ł x Ł b retrieve page(a : b) delete x from page(a : b) if count(a : b) < ½ C - e merge page(a : b) with the neighboring page(b + 1 : g) into page(a : g)
54
Algoritmus vymazání bodu 2/2
if count(a : g) > C choose d Î[a : g] with count(a : d) Ł ½ C - e and count(d + 1 : g) Ł ½ C - e split page(a : g) into page(a : d) and page(d + 1: g) end if
55
Algoritmus bodového dotazu
Vstup: x: bod zadaný zaindexovanými atributy Výstup: x: bod se všemi atributy x = Z(x) find [a : b] in the UB-Tree, such that a Ł x Ł b retrieve page(a : b) into main memory search content of page(a : b) to find x
56
Vícerozměrný rozsahový dotaz
SELECT * FROM table WHERE (A1 BETWEEN a1 AND b1) AND (A2 BETWEEN a2 AND b2) AND ..... (An BETWEEN an AND bn) N-rozměrný intervalový dotaz.
57
Algoritmus rozsahového dotazu
Vstup: y,z: body definující dotazovací okno Z(y) < Z(z) Výstup: X: výsledná množina x = Z(y); w = Z(z); X = Ć repeat find [a: b] in the UB-Tree, such that a Ł x Ł b X = X Č {(x1, ... ,xd’) Î [a : b] | (x1, ... ,xd) Î [[ y, z]]} x = Z-address of the first point intersecting the query box with x > b until x > w
58
Ukázka rozsahového dotazu
59
rangeQuery(Tuple ql, Tuple qh)
{ Zaddress start = Z(ql); Zaddress cur = start; Zaddress end = Z(qh); Page page = {}; while (1) cur = getRegionSeparator(cur); page = getPage(cur); outputMatchingTuples(page, ql, qh); if ( cur >= end ) break; cur = getNextZAddress(cur, start, end); } Zdrojový kód UB-strom B*-strom lineární Z-prostor
60
rangeQuery(Tuple ql, Tuple qh)
{ Zaddress start = Z(ql); Zaddress cur = start; Zaddress end = Z(qh); Page page = {}; while (1) cur = getRegionSeparator(cur); page = getPage(cur); outputMatchingTuples(page, ql, qh); if ( cur >= end ) break; cur = getNextZAddress(cur, start, end); } Zdrojový kód UB-strom B*-strom lineární Z-prostor
61
rangeQuery(Tuple ql, Tuple qh)
{ Zaddress start = Z(ql); Zaddress cur = start; Zaddress end = Z(qh); Page page = {}; while (1) cur = getRegionSeparator(cur); page = getPage(cur); outputMatchingTuples(page, ql, qh); if ( cur >= end ) break; cur = getNextZAddress(cur, start, end); } Zdrojový kód UB-strom B*-strom lineární Z-prostor
62
rangeQuery(Tuple ql, Tuple qh)
{ Zaddress start = Z(ql); Zaddress cur = start; Zaddress end = Z(qh); Page page = {}; while (1) cur = getRegionSeparator(cur); page = getPage(cur); outputMatchingTuples(page, ql, qh); if ( cur >= end ) break; cur = getNextZAddress(cur, start, end); } Zdrojový kód UB-strom B*-strom lineární Z-prostor
63
rangeQuery(Tuple ql, Tuple qh)
{ Zaddress start = Z(ql); Zaddress cur = start; Zaddress end = Z(qh); Page page = {}; while (1) cur = getRegionSeparator(cur); page = getPage(cur); outputMatchingTuples(page, ql, qh); if ( cur >= end ) break; cur = getNextZAddress(cur, start, end); } Zdrojový kód UB-strom B*-strom lineární Z-prostor
64
rangeQuery(Tuple ql, Tuple qh)
{ Zaddress start = Z(ql); Zaddress cur = start; Zaddress end = Z(qh); Page page = {}; while (1) cur = getRegionSeparator(cur); page = getPage(cur); outputMatchingTuples(page, ql, qh); if ( cur >= end ) break; cur = getNextZAddress(cur, start, end); } Zdrojový kód UB-strom B*-strom lineární Z-prostor
65
rangeQuery(Tuple ql, Tuple qh)
{ Zaddress start = Z(ql); Zaddress cur = start; Zaddress end = Z(qh); Page page = {}; while (1) cur = getRegionSeparator(cur); page = getPage(cur); outputMatchingTuples(page, ql, qh); if ( cur >= end ) break; cur = getNextZAddress(cur, start, end); } Zdrojový kód UB-strom B*-strom lineární Z-prostor
66
rangeQuery(Tuple ql, Tuple qh)
{ Zaddress start = Z(ql); Zaddress cur = start; Zaddress end = Z(qh); Page page = {}; while (1) cur = getRegionSeparator(cur); page = getPage(cur); outputMatchingTuples(page, ql, qh); if ( cur >= end ) break; cur = getNextZAddress(cur, start, end); } Zdrojový kód UB-strom B*-strom lineární Z-prostor
67
rangeQuery(Tuple ql, Tuple qh)
{ Zaddress start = Z(ql); Zaddress cur = start; Zaddress end = Z(qh); Page page = {}; while (1) cur = getRegionSeparator(cur); page = getPage(cur); outputMatchingTuples(page, ql, qh); if ( cur >= end ) break; cur = getNextZAddress(cur, start, end); } Zdrojový kód UB-strom B*-strom lineární Z-prostor
68
rangeQuery(Tuple ql, Tuple qh)
{ Zaddress start = Z(ql); Zaddress cur = start; Zaddress end = Z(qh); Page page = {}; while (1) cur = getRegionSeparator(cur); page = getPage(cur); outputMatchingTuples(page, ql, qh); if ( cur >= end ) break; cur = getNextZAddress(cur, start, end); } Zdrojový kód UB-strom B*-strom lineární Z-prostor
69
rangeQuery(Tuple ql, Tuple qh)
{ Zaddress start = Z(ql); Zaddress cur = start; Zaddress end = Z(qh); Page page = {}; while (1) cur = getRegionSeparator(cur); page = getPage(cur); outputMatchingTuples(page, ql, qh); if ( cur >= end ) break; cur = getNextZAddress(cur, start, end); } Zdrojový kód UB-strom B*-strom lineární Z-prostor
70
rangeQuery(Tuple ql, Tuple qh)
{ Zaddress start = Z(ql); Zaddress cur = start; Zaddress end = Z(qh); Page page = {}; while (1) cur = getRegionSeparator(cur); page = getPage(cur); outputMatchingTuples(page, ql, qh); if ( cur >= end ) break; cur = getNextZAddress(cur, start, end); } Zdrojový kód UB-strom B*-strom lineární Z-prostor
71
rangeQuery(Tuple ql, Tuple qh)
{ Zaddress start = Z(ql); Zaddress cur = start; Zaddress end = Z(qh); Page page = {}; while (1) cur = getRegionSeparator(cur); page = getPage(cur); outputMatchingTuples(page, ql, qh); if ( cur >= end ) break; cur = getNextZAddress(cur, start, end); } Zdrojový kód UB-strom B*-strom lineární Z-prostor
72
rangeQuery(Tuple ql, Tuple qh)
{ Zaddress start = Z(ql); Zaddress cur = start; Zaddress end = Z(qh); Page page = {}; while (1) cur = getRegionSeparator(cur); page = getPage(cur); outputMatchingTuples(page, ql, qh); if ( cur >= end ) break; cur = getNextZAddress(cur, start, end); } Zdrojový kód UB-strom B*-strom lineární Z-prostor
73
rangeQuery(Tuple ql, Tuple qh)
{ Zaddress start = Z(ql); Zaddress cur = start; Zaddress end = Z(qh); Page page = {}; while (1) cur = getRegionSeparator(cur); page = getPage(cur); outputMatchingTuples(page, ql, qh); if ( cur >= end ) break; cur = getNextZAddress(cur, start, end); } Zdrojový kód UB-strom B*-strom lineární Z-prostor
74
rangeQuery(Tuple ql, Tuple qh)
{ Zaddress start = Z(ql); Zaddress cur = start; Zaddress end = Z(qh); Page page = {}; while (1) cur = getRegionSeparator(cur); page = getPage(cur); outputMatchingTuples(page, ql, qh); if ( cur >= end ) break; cur = getNextZAddress(cur, start, end); } Zdrojový kód UB-strom B*-strom lineární Z-prostor
75
rangeQuery(Tuple ql, Tuple qh)
{ Zaddress start = Z(ql); Zaddress cur = start; Zaddress end = Z(qh); Page page = {}; while (1) cur = getRegionSeparator(cur); page = getPage(cur); outputMatchingTuples(page, ql, qh); if ( cur >= end ) break; cur = getNextZAddress(cur, start, end); } Zdrojový kód UB-strom B*-strom lineární Z-prostor
76
rangeQuery(Tuple ql, Tuple qh)
{ Zaddress start = Z(ql); Zaddress cur = start; Zaddress end = Z(qh); Page page = {}; while (1) cur = getRegionSeparator(cur); page = getPage(cur); outputMatchingTuples(page, ql, qh); if ( cur >= end ) break; cur = getNextZAddress(cur, start, end); } Zdrojový kód UB-strom B*-strom lineární Z-prostor
77
Práce s obecnými objekty 1/3
78
Práce s obecnými objekty 2/3
79
Práce s obecnými objekty 3/3
pro objekt o je vytvořen ohraničující obdélník bb(o) pro objekt o jsou uloženy identifikátory Id(o) pro každý region, který o protíná objekt sám je uložen mimo UB-strom o může protínat pouze regiony, které jsou protínány bb(o)
80
Vložení obecného objektu
1. Výpočet bb(o) 2. for all regions R which intersect bb(o) do if R intersects o then insert Id(o) into R // může dojít k rozštěpení R ...
81
Vyhledání objektů v zadaném okně
1. Nalezneme všechny regiony a získáme korespondující stránky dotazovacího okna q (stránky obsahují identifikátory Id(o) pro všechny objekty o, které protínají tyto regiony). 2. Pro všechny Id(o) zjišťujeme, zda o protíná q. Další algoritmy: * dotazy na body v okolí bodu * efektivnější algoritmus výběru stránek a jejich kešování při vykonávání rozsahového dotazu, tzv. Tetris algoritmus
82
Složitosti algoritmů bodový dotaz: O(logk N), kde N je počet n-tic, k = 1/2M, M je kapacita stránky rozsahový dotaz: r*O(logk N), kde r je počet regionů protínajících dotazovací okno vložení bodu (n-tice): O(logk N) vložení objektu: r*O(logk N), kde r je počet regionů protínajících bb(o) vymazání bodu: O(logk N) vymazání objektu: r*O(logk N) Vložení n-tice požaduje vyhledání bodu ke zjištění regionu a stránky. Jestliže je rozdělení spuštěno vložením, je nutné vyhledat cestu v UB-stromu, ale nedojde ke zvýšení řádu ceny. Pro mazání platí to samé.
83
Výhody UB-stromů Garance logaritmické časové složitosti v nejhorším případě pro vkládání, mazání a bodové dotazy Shlukování n-tic na diskové stránky při jejich prostorové blízkosti Dobré průměrné využití paměti Efektivní rozsahové dotazy Porovnání: R-strom - negarantuje logaritmickou složitost, neposkytuje dobré průměrné využití paměti 4-strom - strom může být nevyvažený Je důležité poznamenat, že pokud má být rozštěpena stránka, je rozdělen pouze jediný Z-region, výsledkem je pouze jeden update a jeden zápis do stránky listu B-stromu (plus další možné rozdělení na vyšších úrovních B-stromu). Toto je hlavní rozdíl od ostatních vícerozměrných přístupových metod jako R-stromy nebo Grid-Files. Existuje prototypová implementace (knihovna pro TransBase, Oracle, DB2) - Volker Markl.
84
Odkazy http://mistral.in.tum.de
R. Bayer. The Universal B-Tree for multidimensional indexing, TUMI9637.pdf V. Markl. MISTRAL: Processing Relational Queries using a Multidimensional Access Technique,
Podobné prezentace
© 2024 SlidePlayer.cz Inc.
All rights reserved.