Algoritmos para Operação de Junção AULA 17 Profa. Sandra de Amo Programa de Pós-Graduação em CC - UFU Sistemas de Banco de Dados - 2012-2.

Apresentação em tema: "Algoritmos para Operação de Junção AULA 17 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 Algoritmos para Operação de Junção AULA 17 Profa. Sandra de Amo Programa de Pós-Graduação em CC - UFU Sistemas de Banco de Dados - 2012-2

2 Tabelas a serem juntadas R : tabela externa M páginas Pr tuplas por página S : tabela interna N páginas Ps tuplas por página Condição de Junção: Ri = Sj Custo de uma operação de I/O = 10ms

3 Nested Loops Join – tupla a tupla Para cada tupla r ε R faça Para cada tupla s ε S faça se ri = sj então insere em Result Retorne Result t Páginas de S Página de R

4 Custo do NLJ - t/t S é escaneada Pr. M vezes Cada scan em S equivale a N operações de I/O (N = número de páginas de S) R é escaneada uma vez Custo total = Pr. M. N + M Não se considera o custo de escrever o resultado, pois é igual para todos os métodos.

5 Exemplo M = 1000 páginas Pr = 100 registros por página N = 500 Custo = 1000 + 100.1000.500 = 50.000.100 I/Os ~ 140 horas de processamento !!

6 Nested Loops Join – página a página Para cada R-page de R faça Para cada S-page de S faça se ri = sj então insere em Result Retorne Result Páginas de S Página de R

7 Custo do NLJ- p/p S é escaneada M vezes Cada scan em S equivale a N operações de I/O (N = número de páginas de S) R é escaneada uma vez Custo total = M. N + M Não se considera o custo de escrever o resultado, pois é igual para todos os métodos.

8 Exemplo M = 1000 páginas N = 500 Custo = 1000 + 1000.500 = 501.000 I/Os ~ 1,4 horas de processamento

9 Block Nested Loops Join – uso do Buffer Caso 1: Tem-se espaço suficiente no buffer para a relação S inteira + 2 páginas extras Para cada R-page faça Para cada S-page in memory faça se ri = sj então insere em Result Retorna Result Relação S inteira Buffer Página de RPágina de output Custo = M + N I/Os No exemplo : 1500 I/Os = 15 segundos

10 Block Nested Loops Join – uso do Buffer Caso 2: Tem-se espaço suficiente no buffer para B - 2 páginas da relação R + 2 páginas extras Para cada bloco de (B-2) páginas in memory de R-page faça Para cada S-page faça se ri = sj então insere em Result Retorna Result Bloco de B-2 páginas de R Buffer tem capacidade para B páginas Página de SPágina de output

11 Esquema Geral do BNL Join Bloco de B-2 páginas de R Buffer tem capacidade para B páginas Página de SPágina de output Relações R e S Disco Relação R S

12 Custo do BNL Join K = Número de blocos de B-2 páginas de M K = [M/(B-2)] Cada página de S é escaneada K vezes Cada scan em S equivale a N operações de I/O (N = número de páginas de S) R é escaneada uma vez Custo total = K.N + M = [M/(B-2)]N + M Não se considera o custo de escrever o resultado, pois é igual para todos os métodos.

13 Exemplo M = 1000 páginas N = 500 B = 102 Custo = (1000/100).500 + 1000 = 6000 I/Os ~ 1 minuto

14 Exercício Calcular o custo do BNL Join, caso a relação S (menor) seja escolhida como a relação externa.

15 Otimizações do BNL Join 1. Diminuindo o custo de CPU para fazer as junções. Se houver espaço suficiente na memória, construir uma tabela hash para cada R-block carregado na memória, com chave = atributo da junção. Para cada tupla s ε S, para encontrar r ε R-block tal que ri = sj, utiliza-se a tabela Hash construída.

16 Otimizações do BNL Join 2. Ao invés de utilizar B-2 páginas em memória para alocar blocos da relação externa R, e uma só página para a relação S, utilizar (B-2)/2 páginas para alocar um bloco de R e (B-2)/2 páginas para alocar um bloco da relação interna S. Exercício: calcular o custo neste caso. Onde há melhora de performance em relação ao método anterior (onde 1 única página em memória é alocada para a relação S) ?

17 Conclusão Até o momento: NLJ - t/t = 140 horas NLJ - p/p = 1 hora e 24 min BNL Join com B = 102 páginas no buffer = 1 min

18 Index Nested Loops Join Se uma das relações (S) possui um índice nos atributos da junção (chave = atributos da junção) Usa S como a relação interna Para cada tupla r ε R faça Para cada tupla s ε S tal que ri = sj insere em Result Retorna Result Usa o índice em S para encontrar todas as tuplas de S com sj = ri

19 Custo do INL Join Para cada r = Custo para encontrar todas as tuplas de S com s j = r i Se o índice é B-Tree: custo para encontrar a folha apropriada é 2 a 4 I/Os = profundidade da árvore Se o índice é Hash : custo para encontrar o bucket apropriado é 1 a 2 I/Os (2 I/Os caso for extensível com diretório de ponteiros em disco). Se o índice é agrupado: custo de encontrar as tuplas correspondendo ao ponteiro indicado pelo índice é 1 I/O. Se o índice não é agrupado: custo de encontrar as tuplas correspondendo ao ponteiro indicado pelo índice pode ser N I/O, onde N = número de tuplas de S com s i = r j.

20 Custo do INL Join Custo Total em caso de índice hash agrupado: M + (2 + 1).Pr.M Custo Total em caso de índice B-tree agrupado M + (4 + 1).Pr.M

21 Exemplo 1 Tamanho de R = M = 1000 páginas Tamanho de S = N = 500 Pr = 100 tuplas por página S tem indice hash no atributo de junção Atributo de junção é chave da relação S Custo = 1000 + 100.000 (1 + 1,2 ) = 221.000 I/0s = 37 min

22 Exemplo 2 Tamanho de S = M = 1000 páginas Tamanho de R = N = 500 Pr = 80 tuplas por página S tem indice hash no atributo de junção não é chave da relação Atributo de junção não é chave da relação S Custo p/ encontrar a pág. do índice correspondendo a si = rj 500 + 80. 500 (1,2) = 500 + 40000(1,2) = 48500 I/Os Custo p/ encontrar as tuplas em S indicadas pelo ponteiro da entrada Total de tuplas de S = 100.000 Total de tuplas de R = 40.000 Se há distribuição uniforme, cada tupla de R casa com 2,5 tuplas de S. Se o indice de S é agrupado: as tuplas de S que casam com rj estão em uma página: Custo total = 48.500 + 40000 = 88.500 I/Os = 15 min Se o indice de R não é agrupado: Custo total = 48.500 + 2,5. 40000 = 148.500 I/Os = 25 min

23 Conclusão INL Join vale mais a pena quando o índice está na relação maior e é agrupado. Até o momento: NLJ - t/t = 140 horas NLJ - p/p = 1 hora e 24 min BNL Join com B = 102 páginas no buffer = 1 min INL Join com índice agrupado na rel. maior = 15 min INL Join com índice ñ agrupado na rel. maior = 25 min

24 Sort Merge Join Ordena relação R pelo atributo de junção Ordena relação S pelo atributo de junção Carrega página de R e página de S na memória. Varre ambas as páginas simultaneamente para encontrar as tuplas que casam. À medida que se encontram as tuplas que casam vai- se construindo páginas da relação de output.

25 Sort Merge Join: Esquema Geral Página de S Página de output Relações R e S Disco Relação R S Página de R 4, 5, 2 4, 5, 2, 1, 3 4, 7, 2 6, 7, 3 6, 1, 9 2, 5, 2 3, 5, 2 4, 1, 3 4, 7, 1 5, 8, 0 6, 8, 4 6, 7, 5 4, 5, 2, 7, 1 6, 7, 3, 8, 4 4, 7, 2, 1, 3 Relação R S

26 Algoritmo Sort Merge Join Se R não está ordenada pelo atributo i, ordena R pelo atributo i Se S não está ordenada pelo atributo j, ordena S pelo atributo j Tr = 1 a tupla de R Ts = 1 a tupla de S Gs = 1 a tupla de S While Tr eof e Gs eof do While Tr i < Gs j do Tr = next tuple em R depois de Tr; endwhile While Tr i > Gs j do Gs = next tuple em S depois de Gs; endwhile While Tr i = Gs j do Ts = Gs While Ts j = Tr i do insere em Result Ts = next tuple em S depois de Ts; endwhile Tr = next tuple em R depois de Tr; endwhile Gs = Ts; endwhile

27 Exercício

28 Custo do Sort-Merge Join Número de páginas no buffer = B Custo de ordenar a relação R 2M(log B-1 M1 + 1) onde M1 = M/B Custo de ordenar a relação S 2N(log B-1 N1 + 1) onde N1 = N/B Custo de juntar as duas relações = M + N (supondo que cada partição de R e cada partição de S cabe numa página) Observação : uma partição corresponde ao conjunto de tuplas com o mesmo valor do atributo de junção

29 Exemplo 1 M = 1000, N = 500, B = 102 Custo de ordenar a relação R 2M(log B-1 M/B + 1) = 2. 1000 (log 101 1000/102 + 1) = = 2. 1000 (0,5 + 1) = 3000 I/Os Custo de ordenar a relação S = 2. 500 (0,3+1) = 1300 I/Os Custo de juntar as duas relações = 1500 I/Os Custo total = 5800 I/Os Custo do BNL Join = 6000 I/Os Custos não muito diferentes

30 Exemplo 2 M = 1000, N = 500, B = 35 Custo de ordenar a relação R 2M(log B-1 M/35 + 1) = 2. 1000 (log 34 1000/35 + 1) = = 2. 1000 (1 + 1) = 4000 I/Os (34) 1 = 34 1000/35 = 28,57 Custo de ordenar a relação S = 2. 500 (1 + 1) = 2000 I/Os Custo de juntar as duas relações = 1500 I/Os Custo total = 7500 I/Os = 3 min e 7 seg Custo do BNL Join = [M/(B-2)]N + M = 31. 500 + 1000 = 16500 I/Os = 7 min Sort Merge bem mais rápido

31 Exemplo 3 M = 1000, N = 500, B = 300 Custo de ordenar a relação R 2M(log B-1 M/300 + 1) = 2. 1000 (log 299 3,33 + 1) = = 2. 1000 (0,2 + 1) = 2400 I/Os (299) 0.2 = 3,12 Custo de ordenar a relação S = 2. 500 (0,2 + 1) = 1200 I/O Custo de juntar as duas relações = 1500 I/Os Custo total = 5100 I/Os = 2min e 7 segundos Custo do BNL Join = 4. 500 + 1000 = 3000 I/Os = 75 seg BNL mais rápido

32 Discussão: Sort Merge Join Piores casos: Se o número de tuplas numa partição da segunda relação (S) é muito grande e não cabe no buffer pool Partição de S deverá ser varrida tantas vezes quanto for o número de tuplas na correspondente partição de R. Pior caso: todas as tuplas de R e S contém o mesmo valor no atributo de junção: Custo = Pr. N

33 Otimização do Sort Merge Join Realizar a junção durante a ordenação das relações Tamanho do buffer = B páginas Primeira iteração da ordenação: ordena-se cada página de R e cada página de S e obtém-se M/B subarquivos ordenados de R e N/B subarquivos ordenados de S Custo: 2M + 2N Segunda iteração da ordenação: finaliza a ordenação dos arquivos e ao mesmo tempo constrói a junção das 2 tabelas Para finalizar a ordenação na 2a iteração: Número de etapas = log B-1 (M/B) + 1 2 log B-1 (M/B) 1 B M/B + 1 B 2 – B M B(B-1) M M > B

34 Esquema Geral 2 a iteração da ordenação Buffer Subarquivos da Relação R em disco Cada página está ordenada Subarquivos da Relação S em disco RS Página de em disco Página ordenada de R Página ordenada de S

35 Custo do Sort Merge Join Otimizado Otimização Primeira iteração da ordenação: ordena-se cada página de R e cada página de S e obtém-se M/B subarquivos ordenados de R e N/B subarquivos ordenados de S Custo: 2M + 2N Suponha que: Temos no buffer 2X + 1 páginas, onde X > M 1/2 M = tamanho da relação maior número de subarquivos de R = M/X < M 1/2 número de subarquivos de S = N/X < M/X < M 1/2 Idéia: Se tivermos B > 2 M 1/2 + 1, teremos espaço suficiente para fazer o merge dos subarquivos de R e dos subarquivos de S na segunda iteração, além de construir a resposta da junção simultaneamente. Custo = M + N (Não levo em consideração o tempo para gravar a resposta) Custo Total = 3(M+N)

36 Exemplo M = 1000, N = 500, B = 102 102 > 2.1000 ½ + 3 = 64 + 3 = 67 Custo da 1 a iteração da ordenação = 2M + 2N = 2000 + 1000 = 3000 I/Os Custo da 2 a iteração (junção) = M + N = 1500 I/Os Custo total = 4500 I/Os = 45 segundos

37 Conclusão Até o momento: NLJ - t/t = 140 horas NLJ - p/p = 1 hora e 24 min BNL Join com B = 102 páginas no buffer = 1 min INL Join com índice agrupado na relação maior = 15 min INL Join com índice ñ agrupado na rel. maior = 25 min Sort Merge Join, B = 102 páginas no buffer = 1 min 30 s Sort Merge Join otimizado, B = 102 páginas no buffer Custo = 45 segundos

38 Hash Join Fase do particionamento Utiliza função hash para particionar R e S em k partições Fase de junção Supondo que cada partição i da relação menor S cabe na memória Carrega-se cada partição i de S na memória Reserva-se uma página para a partição i da relação R Para cada tupla t da partição i de R varre-se toda a partição correspondente de S. Sabe-se que as tuplas que casam com t só podem estar nesta partição i de S.

39 Fase do Particionamento de R e S Buffer tem capacidade para B páginas, onde B – 1 = número k de partições Página de R Relações R e S Disco Relação R particionada Pt 1Pt 2Pt 3Pt 6 Pt 5 Pt 4 Distribui Usando hash h

40 Fase da Junção de R e S Buffer tem capacidade para B páginas, onde B – 2 = tamanho da partição da relação menor Página da partição n de R Relações R e S particionadas Disco S Relação R Partição n de S (inteira) S Página de R

41 Algoritmo Hash Join Rotina Particiona(R,k) % R = tabela, k = número de partições Para cada página P da tabela R faça begin Leia P; Para cada tupla r em P faça begin i : = h(r(A)); insere r na página Ki do buffer pool; Se página Ki está cheia então grava Ki em disco e libera espaço no buffer correspondente a Ki; end end Para cada i=1,2,...,k faça begin Partição Pi = conjunto das páginas (em sequência) gravadas em disco correspondentes ao espaço Ki do buffer pool end

42 Algoritmo Hash Join Rotina Junta(P1,…Pk,P1,…,Pk) % (P1,...,Pk = partições de R; P 1,..., P k = partições de S) Para cada i = 1,...,k faça begin carrega partição Pi de R no buffer pool (supomos que cada partição da relação menor (R) caiba no buffer pool); Para cada página P da partição P'i de S faça begin Para cada tupla s de P faça begin Para cada r na partição Pi de R tal que r(A) = s(A) faça insere em Result end end end

43 Custo do Hash Join R = M S = N Fase do Particionamento = 2(M + N) Fase da Junção = M + N Custo Total = 3(M+N)

44 Requisitos de memória K = número de partições M = tamanho da relação menor N = tamanho da relação maior B = número de páginas no buffer Fase de particionamento: K = B - 1 Tamanho de cada partição da relação menor = M/K = M/(B-1) Fase da Junção : B = M/(B-1) + 2 B > M

45 Exemplo M = 500 N = 1000 B > 500 ~ 25 páginas Custo Hash = 3(1500) = 4500 Custo de Sort-Merge = 3(1500) caso B > 2 + 3 ~ 67 páginas 25 B 67: Hash Join é melhor B 67 : Hash e Sort-Merge têm os mesmos custos Quanto maior for a diferença entre o tamanho das relações, maior a vantagem do Hash Join sobre o Sort- Merge, pois necessita de menos espaço no buffer para ter o custo mínimo de 3(M+N). 1000

46 Conclusão NLJ - t/t = 140 horas NLJ - p/p = 1 hora e 24 min BNL Join com B = 102 páginas no buffer = 1 min INL Join com índice agrupado na relação maior = 15 min INL Join com índice ñ agrupado na rel. maior = 25 min Sort Merge Join, B = 102 páginas no buffer = 1 min 30 s Sort Merge Join otimizado, B = 102 páginas no buffer = 45 segundos Hash Join, B = 102 páginas no buffer = 45 segundos