Método de Acesso Dinâmico - B-Tree AULA 14 Profa. Sandra de Amo Programa de Pós-Graduação em CC - UFU Sistemas de Banco de Dados - 2012-2.

Apresentação em tema: "Método de Acesso Dinâmico - B-Tree AULA 14 Profa. Sandra de Amo Programa de Pós-Graduação em CC - UFU Sistemas de Banco de Dados - 2012-2."— Transcrição da apresentação:

1 Método de Acesso Dinâmico - B-Tree AULA 14 Profa. Sandra de Amo Programa de Pós-Graduação em CC - UFU Sistemas de Banco de Dados - 2012-2

2 B-Trees : Método de Acesso Dinâmico Nós internos da árvore são alterados à medida que novos registros são inseridos nas folhas, ou quando registros são deletados. Quando tais nós são alterados ? Operações de inserção e deleção são balanceadas de modo a que cada nó interno tenha uma ocupação mínima e máxima. Uma ocupação mínima de 50% é garantida em cada nó (exceto a raiz) Arvore é Balanceada Todos os caminhos da raiz até a folha têm o mesmo comprimento. Cada nó (exceptuando a raiz) contém m entradas, onde d m 2d, d = ordem da B-tree A raiz contém m entradas onde 1 m 2d Páginas das folhas são ligadas em sequência através de ponteiros – podem ser percorridas em sequência nas duas direções. Altura da árvore : Devido ao grande espalhamento da árvore, sua altura é raramente maior do que 4

3 Formato de um nó interno P0 P1P2 PiPi+1PmK1... K2K3Ki+1Km Pi = ponteiros que apontam para um núm. de página no nível imediatamente inferior Ki = valor do atributo chave do índice. Exemplo: se o atributo chave é idade então Ki é um valor de idade. K < Ki+1 K Ki+1 Valores K da chave nesta página são < Ki+1 Valores K da chave nesta página são Ki+1

4 Busca (entradas sem duplicatas) 13172430 Ordem = 2 : cada nó interno contém K entradas, 2 K 4 Chave de busca contém chave candidata (não há duplicatas) 2*3*7* 5* 14* 16*19*20*22*24*27* 29* 33*34*39*38* 15 ? 5 ?

5 Inserção 13172430 2*3*7* 5* 14* 16*19*20*22*24*27* 29* 33*34*39*38* Se nó onde deve ocorrer a inserção não está cheio Exemplo inserindo 23 * 23*

6 Inserção: se nó onde deveria ocorrer a inserção já está cheio Variante 1 : Se nó está cheio divida e ajuste os nós ancestrais. Variante 2 : Testa primeiro se pode redistrisbuir num nó vizinho. Em caso negativo, divide. Redistribuição: aumenta o custo I/O (vizinho à direita e esquerda devem ser testados) Divisão: pode propagar modificações por diversos níveis Ideal (o que é mais vantajoso em termos de custos) Nós intermediários: sempre dividir, não redistribuir Nós Folha: procure redistribuir entre os vizinhos Se tiver espaço no vizinho direito, redistribua. Caso contrário, verifica se tem espaço no vizinho esquerdo, e redistribua Caso contrário: divida a folha cheia.

7 Inserção : Testando vizinho à direita 13172430 7* 5*5* 14 * 16* 19*20*22*24*27* 29* 33*34*39*38* Inserindo 6* 6* 14* 16* 2*3* CHEIA !!

8 Inserção : Testando vizinho à direita 13172430 7* 5*5* 14 * 16* 19*20*22*24*27* 29* 33*34*39*38* Inserindo 6* 14* 16* 2*3* 7* 5*5* 2* 3* 6*

9 Inserção : Testando vizinho à direita 13172430 5*5* 14 * 16* 19*20*22*24*27* 29* 33*34*39*38* Inserindo 6* 14* 16* 2*3* 7* 5*5* 2* 3* 6* 7* 6*

10 Resumo: Inserção da chave X na folha P P está cheia Vizinho à direita VD tem espaço e pai(VD) = pai(P) Insere X em P Obtém página P com 2d+1 elementos Transfere último elemento Y de P para primeira posição de VD Seja Pai = pai(VD) = pai(P) Pt i = ponteiro de Pai apontando para VD K i = chave em Pai antes de Pt i Substitui K i por Y

11 Exercicio Inserir a chave 30* 13172432 7* 5*5* 14 * 16* 19*20*22*24*27* 28* 33*34*38* 2*3* 29* 14* 16*

12 Inserção : Testando vizinho à esquerda 8172430 7* 5*5* 14 * 16* 19*20*22*24*27* 29* 33*34*39*38* Inserindo 35* 8*8* 14* 16* 2*3* 33* 34* 39* 38* 35*

13 Inserção : Testando vizinho à esquerda 81724 7* 5*5* 14 * 16* 19*20*22*24*27* 29* 33* 35*39*38* Inserindo 35* 8*8* 14* 16* 2*3* 34* 34

14 Resumo: Inserção da chave X na folha P P está cheia Vizinho à direita VD não tem espaço ou não existe ou pai(VD) pai(P) Vizinho à esquerda VE tem espaço e pai(VE) = pai(P) Insere X em P Obtém página P com 2d+1 elementos Transfere primeiro elemento Y de P para última posição de VE Seja Pai = pai(P) = pai(VE) Pt i = ponteiro de Pai apontando para P K i = chave em Pai antes de Pt i Substitui K i por Y

15 Exercicio Inserir a chave 25* 13172432 7* 5*5* 14 * 16* 19*20*22*24*27* 28* 33*34*38* 14* 16* 2*3* 29* 39*

16 Discussão Distribuição nas folhas vizinhas não acarreta mudança aumento de ocupação dos nós pais Portanto: Nós pais não ultrapassam ocupação máxima Não precisam ser divididos nem redistribuídos entre seus vizinhos Não há crescimento da altura da árvore Modificações não se propagam para nós acima do nó-pai

17 Inserção : Vizinhos estão cheios Divisão da Folha 13172430 2*3* 7* 5* 13 * 14* 19*20*22*24*27* 29* 33*34*39*38* Inserindo 8* Cheia ! 7*8* 5 5* Cheia ! 15*16* 2*3*7* 5* 8*

18 Divisão de nós intermediários 13172430 5 2*3* 7* 5* 13 * 14* 19*20*22*24*27* 29* 33*34*39*38* 7*8* 5 5* 15*16*

19 Divisão de nó intermediário 132430 5 17 2*3* 7* 5* 14 * 16* 19*20*22*24*27* 29* 33*34*39*38* 7*8* 5 5*

20 Resumo: Divisão de Folha Inserção da chave X na folha P P está cheia Vizinho à direita VD não tem espaço ou não existe ou pai(VD) pai(P) Vizinho à esquerda VE não tem espaço ou não existe ou pai(VE) pai(P) Insere X em P Obtém página P com 2d+1 elementos Divide página P em duas páginas P1 e P2 P1 tem d elementos P2 tem d+1 elementos Pai = pai(P) Elimina ponteiro de Pai que aponta para P Y = primeiro elemento de P2 Insere novo nó Y em Pai Insere dois novos ponteiros em Pai à esquerda de Y apontando para P1 à direita de Y apontando para P2 Se Pai ultrapassar tamanho máximo : Divide(Pai)

21 Resumo: Divisão de nó intermediário Divide(P), P = nó intermediário, P raiz Tamanho(P) = 2d+1 X = chave do meio de P Divide P em P1 e P2 P1 contém os d primeiros elementos de P P2 contém os d últimos elementos de P Seja Pai = pai(P) Insere X em Pai Elimina ponteiro de Pai que apontava para P Insere dois novos ponteiros em Pai à esquerda de X apontando para P1 à direita de X apontando para P2 Se Pai ultrapassar tamanho máximo : Divide(Pai)

22 Resumo: Divisão de Raiz Divide(P), P = nó intermediário, P = raiz Tamanho(P) = 2d+1 X = chave do meio de P Divide P em P1 e P2 P1 contém os d primeiros elementos de P P1 contém os d últimos elementos de P Cria novo nó raiz R com única chave X, em nível acima do nível dos nós P1 e P1 Insere dois ponteiros em R à esquerda de X apontando para P1 à direita de X apontando para P2

23 Exercicio: Insira (49,*) 25344555 17*19* 24* 23* 26* 28* 35*37*38*46*47* 54* 56*58*65*60* 40* 48* 8 11 12* 15* 14* 16 8* 10* 9* 2* 6* 5*

24 Deleção Se ocupação não fica abaixo do mínimo, deleta, não altera ponteiros, nem nós ancestrais Se ocupação fica abaixo do mínimo Tenta redistribuição com nó vizinho, se possível Caso contrário junta com vizinho à direita ou à esquerda (caso for o último nó).

25 Discussão Redistribuição é vantajosa no caso de deleção: pois deixa mais espaço nos nós para futuras inserções

26 Exemplo: Deleção 2*3* 14 * 16* 19* 20*22* 24* 27*29* 33*34*39*38* Removendo 19* 7*8*5* 5132430 17

27 Deleção: Redistribuição nas folhas Com nó direito Removendo 20* 5132430 17 2*3* 14 * 16* 20*22* 24* 27*29* 33*34*39*38* 7*8*5*

28 Deleção: Redistribuição nas folhas Com nó direito Removendo 20* 5132730 17 2*3* 14 * 16* 24* 27*29* 33*34*39*38* 7*8*5* 24 22*

29 Resumo: Deleção da chave X na folha P P tem d elementos (ocupação mínima) Vizinho à direita VD tem d+1 elementos e pai(VD) = pai(P) Remove X de P Obtém página P com d-1 elementos Transfere primeiro elemento Y de VD para última posição de P Seja Pai = pai(VD) = pai(P) Pt i = ponteiro de Pai apontando para VD K i = chave em Pai antes de Pt i Substitui K i por Y

30 Deleção: Redistribuição nas folhas Com nó esquerdo Removendo 33* 51330 17 2*3* 14 * 16* 22* 24* 27*29* 33* 7*8*5* 24 35*

31 Deleção: Redistribuição nas folhas Com nó esquerdo Removendo 33* 51330 17 2*3* 14 * 16* 22* 24* 27* 7*8*5* 24 35* 29* 29

32 Resumo: Deleção da chave X na folha P P tem d elementos (ocupação mínima) Vizinho à direita VD tem d elementos ou pai(VD) pai(P) ou VD não existe Vizinho à esquerda VE tem d+1 elementos e pai(VE) = pai(P) Remove X de P Obtém página P com d-1 elementos Transfere último elemento Y de VE para primeira posição de P Seja Pai = pai(VE) = pai(P) Pt i = ponteiro de Pai apontando para P K i = chave em Pai antes de Pt i Substitui K i por Y

33 Discussão Distribuição nas folhas vizinhas não acarreta mudança - redução de ocupação dos nós pais Portanto: Nós pais não ficam abaixo da ocupação mínima Não precisam ser juntados nem redistribuídos entre seus vizinhos Não há redução da altura da árvore Modificações não se propagam para nós acima do nó- pai

34 Deleção: Juntando Folhas Com nó à direita 2*3* 14 * 15* 22* 33*34*39*38* Removendo 24* 7*8*5* 51330 17 24 * 27 27*29*22*27*29* Não dá para redistribuir os vizinhos Tamanho do vizinho direito = d Vizinho à esquerda tem pai diferente JUNTA COM O VIZINHO DA DIREITA 16* 40

35 Deleção: Juntando Folhas Com nó à direita 33*34*39*38* Removendo 24* 51330 17 24 * 27 27*22*27*29* 27 Quase vazia ! 30 2*3* 14 * 15* 7*8*5* 16* 17 40

36 Junção de nós intermediários 2*3* 14 * 16* 33*34*39*38* 7*8*5* 30 24 * 27 27*22*27*29* 3051330 273051330 Removendo 24* 17 40

37 Deleção: Juntando Folhas Com nó à esquerda 2*3* 14 * 16* 49*50* Removendo 16* 7*5* 51360 45 45*46* 47 63* 65*

38 Deleção: Juntando Folhas Com nó à esquerda 2*3* 14 * 16* 49*50* Removendo 16* 7*8*5* 51360 45 41*43* 47 63* 65* Só pode ser a última chave deste nó

39 Deleção: Juntando Folhas Com nó à esquerda 2*3* 14 * 16* 49*50* Removendo 16* 7*5* 51360 45 45*46* 47 63* 65*

40 Deleção: Juntando Folhas Com nó à esquerda 2*3* 14 * 49*50* Removendo 16* 7*5* 51360 45 45*46* 47 63* 65*

41 Deleção: Juntando Folhas Com nó à esquerda Removendo 16* 560 45 47 2*3* 49*50* 7*5* 45*46* 63* 65* 14*

42 Deleção: Juntando Folhas Com nó à esquerda Removendo 16* 560 45 47 Devem ser juntadas 2*3* 49*50* 7*5* 45*46* 63* 65* 14*

43 Deleção: Juntando Folhas Com nó à esquerda 2*3* 49*50* Removendo 16* 7*5* 5 45 45*46* 63* 65* 14* 4760

44 Redistribuição em nós intermediários 13 17 55132730 22 1720 2*3*5*7*8*14*16*17*18*20*21*22*24*29*27* 33*34*38*39* Removendo 24* : Não dá para juntar os nós intermediários

45 Redistribuição em nós intermediários 13 17 551330 22 1720 2*3*5*7*8*14*16*17*18*20*21*22*29*27*33*34*38 * 39* Quase vazia

46 Redistribuição em nós intermediários 13 17 551330 22 1720 2*3*5*7*8*14*16*17*18*20*21*22*29*27*33*34*38 * 39* Ponteiros a reajustar !!

47 Redistribuição em nós intermediários 13 17 551330 22 17 2*3*5*7*8*14*16*17*18*20*21*22*29*27*33*34*38 * 39* 20

48 Redistribuição em nós intermediários 13 17 5513 17 52030 17 22 3*5*7*8*14*16*17*18*20*21*22*29*27*33*34*38 * 39*

49 Exercicios Construir algoritmos para: Juntar nó com nó-irmão da direita Juntar nó com nó-irmão da esquerda Distribuir nó intermediário com nó-irmão da direita Distribuir nó intermediário com nó-irmão da esquerda

50 Gerenciando Duplicatas Quando a chave do índice não é chave candidata da relação Em sistemas comerciais: Sybase: dados são ordenados pela chave – páginas são ordenadas sequencialmente – acrescenta-se páginas de overflow DB2, Oracle, MS SQL Server: considera-se um identificador de tuplas, eliminando-se as duplicatas. Exemplo: (k,*) (k,*)... (k,id1,*) (k,id2,*),...

51 Método Geral para Gerenciamento de Duplicatas 7*8*9*10*13*17*23* 41*37*43*47* 13 17 57913 17 5-37 2*3* 43 5*23* 17 Primeiro Filho Segundo Filho não contém nenhuma nova chave Primeira nova Chave é 37* 23*

52 Método Geral para Gerenciamento de Duplicatas 7*8*9*10*11*12*14* 41*37*43*47* 13 17 57913 17 51337 2*3* 43 5* 12 15* A primeira chave diferente é a 37

53 Duplicatas : chave não contém chave candidata 7*8*9*10*13*17*23* 41*37*43*47* 13 17 57913 17 5-37 2* 3* 43 5*23* 17 Busca 17*

54 Duplicatas : chave não contém chave candidata 7*8*9*13* 17*23* 41*37*43*47* 13 17 57913 17 5-37 2* 3* 43 5* 23* 17 Busca 24* ? Não precisa ir mais adiante !

55 Duplicatas : chave não contém chave candidata 7*8*9* 13* 17*23* 41*37*43*47* 13 17 57913 17 5-37 2* 3* 43 5* 23* 17 Busca 13*

56 Construção de uma B-Tree – Bulk Loading Ordena-se as entradas do índice pela chave de busca Aloca-se uma página vazia para a raiz Insere nesta página um ponteiro para a primeira página do arquivo contendo as entradas.

57 Exemplo 3*4*6*9*10*11*12*13*20*22*23*31*35*36*38*41*44* Páginas restantes a alocar Ordem da b-tree = 1

58 Exemplo 3*4*6*9*10*11*12*13*20*22*23*31*35*36*38*41*44* Ordem da b-tree = 1 6*10* Páginas restantes a alocar

59 Exemplo 3*4*6*9*10*11*12*13*20*22*23*31*35*36*38*41*44* 6*10*12* Precisa dividir 20*

60 Exemplo 3*4*6*9*10*11*12*13*20*22*23*31*35*36*38*41*44* 6*12*10*20* Páginas restantes a alocar

61 Exemplo 3*4*6*9*10*11*12*13*22*31*35*36*38*41*44* 6*12* 10* 20* 23* Precisa dividir 35*

62 Exemplo 3*4*6*9*10*11*12*13*22*31*35*36*38*41*44* 6*12* 10* 20* 23* 20* 35* Páginas restantes a alocar

63 Exemplo 3*4*6*9*10*11*12*13*22*31*35*36*38*41*44* 6*12* 10* 20* 23* 20* 35* 38* 44* Precisa dividir

64 Exemplo 3*4*6*9*10*11*12*13*22*31*35*36*38*41*44* 6*12* 10* 20* 23* 20* 38* 44* 35* Precisa dividir

65 Exemplo 3*4*6*9*10*11*12*13*22*31*35*36*38*41*44* 6*12* 10* 20* 23* 38* 44* 35* 20*