Algoritmos de Junção – Sort-Merge Join Hash Join

Apresentação em tema: "Algoritmos de Junção – Sort-Merge Join Hash Join"— Transcrição da apresentação:

1 Algoritmos de Junção – Sort-Merge Join Hash Join
AULA 17 Profa. Sandra de Amo GBC053 – BCC 2013-1

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

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

4 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 = 1a tupla de R Ts = 1a tupla de S Gs = 1a tupla de S While Tr ≠ eof e Gs ≠ eof do While Tri < Gsj do Tr = next tuple em R depois de Tr; endwhile While Tri > Gsj do Gs = next tuple em S depois de Gs; While Tri = Gsj do Ts = Gs While Tsj = Tri do insere <Tr, Ts> em Result Ts = next tuple em S depois de Ts; endwhile Tr = next tuple em R depois de Tr; Gs = Ts; 4

5 Exercício Execute o algoritmo SortMerge em R e S especificando os valores assumidos pelas Variáveis Tr, Gs e Ts. 5

6 Custo do Sort-Merge Join
Número de páginas no buffer = B Custo de ordenar a relação R 2M(logB-1M1 + 1) onde M1 = M/B Custo de ordenar a relação S 2N(logB-1N1 + 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 6

7 Exemplo 1 M = 1000, N = 500, B = 102 Custo de ordenar a relação R
2M(logB-1M/B + 1) = (log / ) = = (0,5 + 1) = 3000 I/Os Custo de ordenar a relação S = (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 7

8 Exemplo 2 M = 1000, N = 500, B = 35 Custo de ordenar a relação R
2M(logB-1M/35 + 1) = (log /35 + 1) = = (1 + 1) = 4000 I/Os (34)1 = /35 = 28,57 Custo de ordenar a relação S = (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 = = I/Os = 7 min Sort Merge bem mais rápido 8

9 Exemplo 3 M = 1000, N = 500, B = 300 Custo de ordenar a relação R
2M(logB-1M/ ) = (log299 3,33 + 1) = = (0,2 + 1) = 2400 I/Os (299)0.2 = 3,12 Custo de ordenar a relação S = (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 = = 3000 I/Os = 75 seg BNL mais rápido 9

10 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 = M + Pr . M 10

11 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 = logB-1 (M/B) + 1 ≤ 2  logB-1 (M/B) ≤ 1 B ≥ M/B + 1  B2 – B ≥ M  B(B-1) ≥ M  B > M 11

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

13 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 > M1/2 M = tamanho da relação maior número de subarquivos de R = M/X < M1/2 número de subarquivos de S = N/X < M/X < M1/2 Idéia: Se tivermos B > 2 M1/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) 13

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

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

16 Hash Join Fase do particionamento Fase de junção
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. 16

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

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

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

20 Algoritmo Hash Join Rotina Junta(P1,…Pk,P’1,…,P’k)
% (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 <r,s> em Result                 end           end      end 20

21 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) 21

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

23 Exemplo 1000 M = 500 N = 1000 B > 500 ~ 25 páginas
Custo Hash = 3(1500) = 4500 Custo de Sort-Merge = 3(1500) caso B > ~ 65 páginas 25 ≤ B ≤ 65: Hash Join é melhor B ≥ 65 : 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 23

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