A apresentação está carregando. Por favor, espere

A apresentação está carregando. Por favor, espere

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

Apresentações semelhantes


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

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

15 Deleção: Redistribuição nas folhas Com nó direito Removendo 20* *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* *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* *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* *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* * 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* * 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* * 27 27*22*27*29* Removendo 24* 17 40

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

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

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

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

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

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

29 Redistribuição em nós intermediários *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 *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 *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 *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 h h(7) mod 6 = 1 7 … … Inserindo 4 3 Cheia

48 Supressão 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 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 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 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 Diretório 1*5*21* 2 10* 2 15*7*19* 2 Inserindo 20* 13* 4*12*20* 3 32*16* 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* 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 h1h 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 h1h 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 h1h 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

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

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

65 Incremento de Nível 32* 9*25* 66* 31*35* 7* 18*10*34* 11* * 44*36* h 0 (50) = 10 5*37*29* *30*22* h 1 (50) = * Next =3 Next =0 Nivel = 1 31* * 43* 11*


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

Apresentações semelhantes


Anúncios Google