Prezentace se nahrává, počkejte prosím

Prezentace se nahrává, počkejte prosím

1 Univerzální B-stromy (UB-Stromy) Michal Krátký, Rudolf Bayer Vícerozměrná přístupová metoda.

Podobné prezentace


Prezentace na téma: "1 Univerzální B-stromy (UB-Stromy) Michal Krátký, Rudolf Bayer Vícerozměrná přístupová metoda."— Transkript prezentace:

1 1 Univerzální B-stromy (UB-Stromy) Michal Krátký, Rudolf Bayer Vícerozměrná přístupová metoda

2 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 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 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 5 Z(x) počítá pro každou n-tici Z-adres u (tj. jeho pozici na Z-křivc e) Z-hodnoty jsou efektivně počítány tzv. b itovým prokládáním (bit-interleaving) Pro x   a binární reprezentaci každého atributu x i = x i,s-1 x i,s-2... x i,0 definujeme Z-hodnotu Z(x): Z-uspořádání

6 (a)(b) Z-uspořádání pro univerzum 8x8

7 7 Z-region [4 : 20] 4 20 UB-Stromové dělení: [0 : 3],[4 : 20], [21 : 35], [36 : 47], [48 : 63] Z-region [  ] je prostor pokrytý intervalem na Z-křivc e. Z-regiony/UB-stromy

8 8 V listech B-stromu jsou uloženy n-tice náležící k danému Z-regionu UB-index UB-soubor V uzlu B-stromu jsou uloženy adresy Z-regionů UB-strom

9 9 Algoritmus vkládání bodu Vstup: x: bod, který má být vložen do UB-Stromu Výstup: žádný  = Z(x) find [  :  ] in the UB-Tree, such that  retrieve page(  :  ) insert x into page(  :  ) if count(  :  ) > C choose  [  :  ], so that ½C -  count(  :  )  ½C +  split page(  :  ) into page(  :  ) and page(  1 :  ) end if

10 10 Ukázka vkládání bodů

11 11 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 */ } B-Strom Z-adresa UB-Strom

12 12 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 13 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 14 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 15 Po vložení dalších dvou bodů...

16 16 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 */ } B-Strom Z-adresa UB-Strom

17 17 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 */ } B-Strom Z-adresa UB-Strom

18 18 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 19 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-adresaB-Strom

20 20 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-adresaB-Strom

21 21UB-Strom 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 */ } Z-adresaB-Strom

22 22 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-adresaB-Strom

23 23 Z-adresaB-Strom UB-Strom 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 */ }

24 24UB-Strom Z-adresaB-Strom 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 */ }

25 25 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-adresaB-Strom

26 26 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-adresaB-Strom

27 27UB-Strom Z-adresa B-StromUB-Strom B-Strom

28 28UB-Strom Z-adresa B-StromUB-Strom B-Strom

29 29 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-adresaB-Strom

30 30 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-adresaB-Strom

31 31 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-adresaB-Strom

32 32 Po vložení dalších bodů obsahuje UB-strom 5 Z-regionů..

33 33 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-adresaB-Strom

34 34 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-adresaB-Strom

35 35 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-adresaB-Strom

36 36 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-adresaB-Strom

37 37 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-adresaB-Strom

38 38 A po vložení dalších bodů...

39 39 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-adresaB-Strom

40 40 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-adresaB-Strom

41 41 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-adresaB-Strom

42 42 Výpočet Z-adresy

43 43 _ _ _ _ _ (25,18) Z- adresa _ _ _ _ _ Atribut 2Atribut 1 Bitové řetězce Atribut 1 Atribut 2 Z- adresa UB-strom 1 Zdrojový kód 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; }

44 44 _ _ _ _ _ (25,18) Z- adresa _ _ _ _ _ Atribut 2Atribut 1 Bitové řetězce Atribut 1 Atribut 2 Z- adresa UB-strom 1 Zdrojový kód 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; }

45 45 _ _ _ _ _ (25,18) Z- adresa _ _ _ _ _ Atribut 2Atribut 1 Bitové řetězce Atribut 1 Atribut 2 Z- adresa UB-strom Zdrojový kód 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; }

46 46 _ _ _ _ _ (25,18) Z- adresa _ _ _ _ _ Atribut 2Atribut 1 Bitové řetězce Atribut 1 Atribut 2 Z- adresa UB-strom Zdrojový kód 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; }

47 47 _ _ _ _ _ (25,18) Z- adresa _ _ _ _ _ Atribut 2Atribut 1 Bitové řetězce Atribut 1 Atribut 2 Z- adresa UB-strom Zdrojový kód 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; }

48 48 _ _ _ _ _ (25,18) Z- adresa _ _ _ _ _ Atribut 2Atribut 1 Bitové řetězce Atribut 1 Atribut 2 Z- adresa UB-strom Zdrojový kód 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; }

49 49 _ _ _ _ _ (25,18) Z- adresa _ _ _ _ _ Atribut 2Atribut 1 Bitové řetězce Atribut 1 Atribut 2 Z- adresa UB-strom Zdrojový kód 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; }

50 50 _ _ _ _ _ (25,18) Z- adresa _ _ _ _ _ Atribut 2Atribut 1 Bitové řetězce Atribut 1 Atribut 2 Z- adresa UB-strom Zdrojový kód 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; }

51 51 _ _ _ _ _ (25,18) Z- adresa _ _ _ _ _ Atribut 2Atribut 1 Bitové řetězce Atribut 1 Atribut 2 Z- adresa UB-strom Zdrojový kód 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; }

52 52 _ _ _ _ _ (25,18) Z- adresa _ _ _ _ _ Atribut 2Atribut 1 Bitové řetězce Atribut 1 Atribut 2 Z- adresa UB-strom Zdrojový kód 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; }

53 53 Algoritmus vymazání bodu 1/2 Vstup: x: bod, který má být vymazán z UB-stromu Výstup: žádný  = Z(x) search [  :  ] in the UB-Tree, such that      retrieve page(  :  ) delete x from page(  :  ) if count(  :  ) < ½ C -  merge page(  :  ) with the neighboring page(  + 1 :  ) into page(  :  )

54 54 if count(  :  ) > C choose  [  :  ] with count(  :  )  ½ C -  and count(  + 1 :  )  ½ C -  split page(  :  ) into page(  :  ) and page(  + 1:  ) end if Algoritmus vymazání bodu 2/2

55 55 Algoritmus bodového dotazu Vstup: x: bod zadaný zaindexovanými atributy Výstup: x: bod se všemi atributy  = Z(x) find [  :  ] in the UB-Tree, such that      retrieve page(  :  ) into main memory search content of page(  :  ) to find x

56 56 SELECT * FROM table WHERE (A 1 BETWEEN a 1 AND b 1 ) AND (A 2 BETWEEN a 2 AND b 2 ) AND..... (A n BETWEEN a n AND b n ) Vícerozměrný rozsahový dotaz

57 57 Algoritmus rozsahového dotazu Vstup: y,z: body definující dotazovací okno Z(y) < Z(z) Výstup: X: výsledná množina  = Z(y);  = Z(z); X =  repeat find [  :  ] in the UB-Tree, such that      X = X  {(x 1,...,x d’ )  [  :  ] | (x 1,...,x d )  [[ y, z]]}  = Z-address of the first point intersecting the query box with  >  until  > 

58 58 Ukázka rozsahového dotazu

59 59UB-strom B * -strom lineární Z-prostor 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

60 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 77 Práce s obecnými objekty 1/3

78 78 Práce s obecnými objekty 2/3

79 79 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) Práce s obecnými objekty 3/3

80 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 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.

82 82 Složitosti algoritmů bodový dotaz: O(lo g k N), kde N je počet n-tic, k = 1/2M, M je kapacita stránky rozsahový dotaz: r*O(lo g k N), kde r je počet regionů protínajících dotazovací okno vložení bodu (n-tice): O(lo g k N) vložení objektu: r*O(lo g k N), kde r je počet regionů protínajících bb(o) vymazání bodu: O(lo g k N) vymazání objektu: r*O(lo g k N)

83 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

84 84 Odkazy R. Bayer. The Universal B-Tree for multidimensional indexing, TUMI9637.pdf V. Markl. MISTRAL: Processing Relational Queries using a Multidimensional Access Technique,


Stáhnout ppt "1 Univerzální B-stromy (UB-Stromy) Michal Krátký, Rudolf Bayer Vícerozměrná přístupová metoda."

Podobné prezentace


Reklamy Google