Revisão Prova 2 Métodos de Acesso: BTree e Hash AULA 20 Profa. Sandra de Amo GBC053 – BCC 2013-1.

Apresentação em tema: "Revisão Prova 2 Métodos de Acesso: BTree e Hash AULA 20 Profa. Sandra de Amo GBC053 – BCC 2013-1."— Transcrição da apresentação:

1 Revisão Prova 2 Métodos de Acesso: BTree e Hash AULA 20 Profa. Sandra de Amo GBC053 – BCC 2013-1

2 Discussão Implementação dos operadores de SQL Técnicas usando Ordenação (Externa !) Projeção – Junção - Conjuntos Técnicas usando Particionamento Projeção – Junção – Conjuntos Técnicas usando Indice Seleção Junção

3 REVISÃO – BTREE

4 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. Ideal 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.

5 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 !!

6 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*

7 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*

8 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*

9 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

10 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*

11 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*

12 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*

13 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ó).

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

15 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*

16 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*

17 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*

18 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

19 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

20 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

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

22 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

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

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

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

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

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

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

29 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 existe possibilidade de juntar nós intermediários

30 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

31 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*

32 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*

33 REVISÃO – BULK LOADING

34 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

35 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

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

37 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

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

39 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

40 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

41 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

42 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*

43 Exemplo: Entrada: Arquivo de indice de 9 páginas com 4 registros em cada uma. d = 2, k = 0, x = 1 Saída: (3, ) B0 = 18 páginas (folhas em amarelo) contendo 2 (= d + k) registros em cada uma B1 = Nível 1 da Btree = 5 páginas (azuis) de 3 (= d + x) registros cada (exceto a última) B2 = Nível 2 da Btree (raiz) = 1 página com 4 registros

44 Exemplo: Entrada: Arquivo de indice de 9 páginas com 4 registros em cada uma. d = 2, k = 0, x = 1 Saída: (3, ) B0 = 18 páginas (folhas em amarelo) contendo 2 (= d + k) registros em cada uma B1 = Nível 1 da Btree = 5 páginas (azuis) de 3 (= d + x) registros cada (exceto a última) B2 = Nível 2 da Btree (raiz) = 1 página com 4 registros

45 REVISÃO – HASH

46 Hash Estático Função Hash não se altera Caso um bucket fique cheio cria-se páginas de overflow para este bucket que ficou cheio. Alguns buckets podem concentrar muito mais páginas que outros buckets.

47 Inserção 0 1 2 5 h h(7) mod 6 = 1 7 … … Inserindo 4 3 Cheia

48 Supressão 0 1 2 5 h h(25) mod 6 = 1 25 … … Suprimindo 4 3

49 Função Hash Componente importante da técnica hash Deve distribuir valores das chaves de maneira uniforme nos buckets. Número de buckets = N = parâmetro h(x) = a*x + b, a, b : parâmetros de ajuste

50 Custos Páginas primárias do índice podem ser armazenadas em páginas de disco sucessivas. Caso não haja overflow Busca no índice requer 1 I/O Inserção e Supressão requerem 2 I/O Custo pode ser alto se existem muitas páginas de overflow. Estratégia : criar inicialmente os buckets deixando 20% de área livre em cada um.

51 Hash (dinâmico) Extensível Solução 1 : quando algum bucket ficar cheio Dobrar o número de buckets Distribuir as entradas nos novos buckets Defeito : o arquivo todo deve ser lido e reorganizado e o dobro de páginas devem ser escritas. Espaço em alguns buckets é alocado bem antes de sua utilização efetiva. Solução 2 : utilizar um diretório de ponteiros para os buckets. Dobrar o número de entradas no diretório Separar somente os buckets que ficaram cheios.

52 Exemplo 00 01 10 11 2 Diretório dos Ponteiros Profundidade Global 4*12*32*16* 2 1*5*21* 2 10* 2 15*7*19* 2 Bucket A Bucket B Bucket C Bucket D Páginas do Indice Profundidade Local

53 Exemplo – inserção 00 01 10 11 2 Diretório 4*12*32*16* 2 1*5*21* 2 10* 2 15*7*19* 2 Páginas do Indice Inserindo 13* 13*

54 Exemplo – inserção 00 01 10 11 2 Diretório 4*12*32*16* 2 1*5*21* 2 10* 2 15*7*19* 2 Inserindo 20* 13* 4*12*20* 2 32*16* 2

55 Exemplo – Inserção 00 01 10 11 2 Diretório 1*5*21* 2 10* 2 15*7*19* 2 Inserindo 20* 13* 4*12*20* 3 32*16* 3 000 001 010 011 100 101 110 111 3 Global Local Bucket A1 Bucket A2 Bucket D Bucket C

56 Exercicio: Busca 22*, 21*, 8* Diretório 1*5*21* 2 10* 2 15*7*19* 2 13* 4*12*20* 3 32*16* 3 000 001 010 011 100 101 110 111 3 Global Bucket A1 Bucket A2 Bucket D Bucket C Local

57 Hash (Dinâmico) Linear Assim como o Hash Extensível, o Hash Linear é ideal para inserções e supressões; Vantagem sobre extensível Lida muito bem com colisões Oferece muita flexibilidade Cadeias de overflow podem tornar o hash linear inferior em performance ao hash extensivel

58 Parâmetros e Contadores Nivel = indica a rodada atual Inicializado com 0 Next = bucket que deve ser dividido, se necessário Inicializado com 0 N m = número de buckets na rodada m N 0 = N N m = N*2 m Somente o bucket com número Next é dividido. Usa-se páginas de overflow para os outros buckets, se ficarem cheios. Após divisão, Next é incrementado.

59 Esquema Geral : rodada k Bucket Next a ser dividido Imagens dos buckets divididos Bucket b Bucket b + m Buckets existentes no inicio da rodada k m = número de buckets da rodada k

60 32*44*36* 9*25*5* 14* 31*35*7* 18*10*30* 11* Páginas Primárias Nivel = 0, N = 4 = 2 2 Next = 0 h0h0 h1h1 00 01 10 11 000 001 010 011 Esta informação não é armazenada ! Inserção de 43* h 0 (43) = 3 (11) 43* Next = 1 44*36* 00

61 32* 9*25*5* 14* 31*35*7* 18*10*30* 11* Nivel = 0, N = 4 = 2 2 h0h0 h1h1 00 01 10 11 000 001 010 011 Busca de 18* h 0 (18) = 2 (10) 43* Next = 1 44*36* 00 2 > Next Bucket 2 não foi dividido ainda 100

62 32* 9*25*5* 14* 31*35*7* 18*10*30* 11* Nivel = 0, N = 4 = 2 2 h0h0 h1h1 00 01 10 11 000 001 010 011 Busca de 32* e 44* h 0 (32) = 00 43* Next = 1 44*36* 00 0 < Next Bucket 0 já foi dividido ainda h 0 (44) = 00 h 1 (32) = 000 h 1 (44) = 100 Bucket 0 + 4 100

63 Inserção de 37* 32* 9*25*5* 14* 31*35*7* 18*10*30* 11* 00 01 10 11 000 001 010 011 43* Next = 1 44*36* 00 100 h 0 (37) = 01 37*

64 Inserção de 29* 32* 9*25*5* 14* 31*35*7* 18*10*30* 11* 00 01 10 11 000 001 010 011 43* Next =1 44*36* 00 100 h 0 (29) = 01 37* 5*37*29* 01101 Next =2

65 Incremento de Nível 32* 9*25* 66* 31*35* 7* 18*10*34* 11* 00 01 10 11 000 001 010 01143* 44*36* 00100 h 0 (50) = 10 5*37*29* 01101 14*30*22* 10 110 h 1 (50) = 010 50* Next =3 Next =0 Nivel = 1 31* 11111 7* 43* 11*