BD I / 2013-02Processamento de

Consultas

Prof. Altigran Soares da SilvaIComp/UFAM

Processamento de Consultas

Q Plano de execução da consulta

Foco: Sistemas relacionais

Outros?

Exemplo

Select B,D From R,S Where R.A = “c” and S.E = 2 and R.C=S.C

R A B C S C D E

a 1 10 10 x 2

b 1 20 20 y 2

c 2 10 30 z 2

d 2 35 40 x 1

e 3 45 50 y 3

Resultado B D2 x

• Como executar a consulta?

- Fazer produto cartesiano- Selecionar as tuplas- Fazer projeção

Uma idea

RXS R.A R.B R.C S.C S.D S.E

a 1 10 10 x 2

a 1 10 20 y 2 . .

C 2 10 10 x 2 . .

Uma resposta ..

Álgebra Relacional – pode ser usada para descrever planos de execuçãoEx: Plano I

B,D

R.A=“c” S.E=2 R.C=S.C

XR S

OU: B,D [ R.A=“c” S.E=2 R.C = S.C (RXS)]

Outra ideia:

B,D

R.A = “c” S.E = 2

R S

Plano II

Junção natural

R SA B C (R) (S) C D Ea 1 10 A B C C D E 10 x 2b 1 20 c 2 10 10 x 2 20 y 2c 2 10 20 y 2 30 z 2d 2 35 30 z 2 40 x 1e 3 45 50 y 3

Plano III

Usar os índices sobre R.A e S.C

(1) Usar o indíce sobre R.A para selecionar as tuplas onde R.A = “c”

(2) Para cada valor de R.C, usar o índice sobre S.C para achar as tuplas de S

(3) Eliminar as tuplas de S onde S.E 2(4) Aplicar o Join sobre as tuplas de R e S

e projetar os atributos B e D

R SA B C C D Ea 1 10 10 x 2b 1 20 20 y 2c 2 10 30 z 2d 2 35 40 x 1e 3 45 50 y 3

A CI1 I2

=“c”

<c,2,10> <10,x,2>E=2?

saida: <2,x>

prox. tupla:<c,7,15>

Otimização de Consulta

Determinar qual o “melhor” entre os vários possíveis planos de execução de uma consulta

parse

convert

regras

Est. tamanho

Comp. planos físicos Custos estimados

melhor

execução

{P1,P2,…..}

{(P1,C1),(P2,C2)...}

Pi

resposta

Consulta SQL

parse tree

plano lógico p/ a consulta

Plano “melhorado”

Plano + tamanho

estatísticas

Exemplo: Consulta SQL

SELECT titleFROM StarsInWHERE starName IN (

SELECT nameFROM MovieStarWHERE birthdate LIKE ‘%1960’

);

Encontrar os filmes cujos atores nasceram em 1960

Examplo: Parse Tree<Query>

<SFW>

SELECT <SelList> FROM <FromList> WHERE <Condition>

<Attribute> <RelName> <Tuple> IN <Query>

title StarsIn <Attribute> ( <Query> )

starName <SFW>

SELECT <SelList> FROM <FromList> WHERE <Condition>

<Attribute> <RelName> <Attribute> LIKE <Pattern>

name MovieStar birthDate ‘%1960’

Examplo: Álgebra Relacional

title

StarsIn <condition>

<tuple> IN name

<attribute> birthdate LIKE ‘%1960’

starName MovieStar

Examplo: Plano lógico da consulta

title

starName=name

StarsIn name

birthdate LIKE ‘%1960’

MovieStarAplicando regra para condições “IN”

Examplo: Plano Melhorado

title

starName=name

StarsIn name

birthdate LIKE ‘%1960’

MovieStar

Examplo: Estimado tamanhos de resultados

tamanho estimado

StarsIn

MovieStar

Examplo: Possível plano físico

Parâmetros: ordem da junção,

tamanho da mem, atributos,...

Hash join

SEQ scan index scan Paramêtro:Condiçaõ deseleção,...

StarsIn MovieStar

Example: Custo estimado

L.Q.P

P1 P2 …. Pn

C1 C2 …. Cn

Escolha o melhor!

Estrutura desta Unidade

Capitulo 66.1 Álgebra para consultas [“bags” vs

sets]- Seleção, projeção, junção, … - Elminação de duplicatas, agrupamento, ordenação

6.2 Operadores físicos- Varredura (Scan), ordenação, …

6.3-6.10 Implementação de operadores + estimativa de curstos

Capítulo 77.1 Parsing7.2 Leis da Álgebra7.3 Parse tree -> Plano lógico de

consulta 7.4 Estimativa do tamanho de resultados7.5-7 Otimização baseada em custos

Estudo do Livro Texto - Capítulos 6,7

Opcionais: 6.8, 6.9, 6.10, 7.6, 7.7 Eliminação de duplicadas, agrupamento e

agregação

Otimização de consultas - Níveis

Nível de álgebra relacional Nível do plano de consulta detalhado

Estimativa de custos Sem índices Com índices

Gerar e comparar planos

Otimização em Álgebra Relacional Regras de transformação

Preservando equivalência

O que são boas transformações?

Leis Associativas e Comutativas Produtos

R x S = S x R (R x S) x T = R x (S x T)

Junções Naturais R S = S R⨝ ⨝ (R S) T = R (S T)⨝ ⨝ ⨝ ⨝

Uniões e Intersecções R U S = S U R R U (S U T) = (R U S) U T

Junções Teta Comutativa

R ⨝C S = S ⨝C R Não é associativa:

Seja R(a,b), S(b,c) e T(c,d) (R ⨝R.b>S.b S) ⨝a<d T ≠ R ⨝R.b>S.b (S ⨝a<d T)

Seleções Tendem a reduzir bastante o tamanho das

relações Portanto, em geral, devem ser processados

antes dos outros operadores, ou seja, nos níveis mais baixos da árvore

Regras da álgebra são usadas para “quebrar” condições complexas e aumentar as oportunidades de “descidas” na árvore

Seleções - Regras

p1p2(R) =

p1vp2(R) =

p1 [ p2 (R)] = p2 [ p1 (R)]

[ p1 (R)] U [ p2 (R)]

Bags vs. Conjuntos R = {a,a,b,b,b,c} S = {b,b,c,c,d} R U S = ?

Opção 1: R U S = {a,a,b,b,b,b,b,c,c,c,d} Opção 2: R U S = {a,a,b,b,b,c,c,d}

Efeito da opção 2

p1vp2 (R) = p1(R) U p2(R) Exemplo R={a,a,b,b,b,c} P1 satisfeita por a,b; P2 satisfeita por b,c

p1vp2 (R) = {a,a,b,b,b,c}

p1(R) = {a,a,b,b,b} e p2(R) = {b,b,b,c}

p1(R) U p2 (R) = {a,a,b,b,b,c}

Opção 1 – Mais interessante Senador (……) Deputado (……)

T1 = ano,estado Senador; T2 = ano,estado Deputado

T1 Ano Estado T2 Ano Estado 97 AM 99 AM 99 AM 99 AM 98 SP 98 AM

União?

Projeções Notação

Para X e Y sendo conjuntos de atributos XY = X U Y

xy (R) ≠ x [y (R)]

⨝

p (R ⨝ S) = [p (R)] ⨝ S p = predicado com atributos de R

q (R ⨝ S) = R ⨝ [q (S)] q = predicado com atributos de S

Objetivo é “adiantar” as seleções para antes da junção

⨝Derivações

pq (R ⨝ S) = [p (R)] ⨝ [q (S)]

pqm (R ⨝ S) = m [(p R) ⨝ (q S)]pvq (R ⨝ S) = [(p R) ⨝ S]U[R ⨝ (q S)]

Regras: combinados

Sejam x = subconjunto dos atributos de R z = atributos do predicado de P

(subconjunto dos atribs de R)

x[p (R) ] = {p [ x (R) ]} x xz

⨝Sejam x = subconjunto dos atributos de R y = subconjunto dos atributos de S

z = interseção dos atributos de R e S

xy (R S) = ⨝ xy {[xz (R) ] ⨝[yz (S) ]}

Projeções Notação

Para X e Y sendo conjuntos de atributos XY = X U Y

xy (R) ≠ x [y (R)]

Regras: combinados

Sejam x = subconjunto dos atributos de R z = atributos do predicado de P

(subconjunto dos atribs de R)

x [p (R)] = {p [ x (R) ]} x xz

p(R U S) = p(R) U p(S)

p(R - S) = p(R) - S = p(R) - p(S)

Regras U combinadas:

p1p2 (R) p1 [p2 (R)]

p (R ⨝ S) [p (R)] ⨝ S

R ⨝ S S ⨝ R

x [p (R)] x {p [xz (R)]}

Quais são as boas transformações?

Convenção: Projeções ocorrem antes

Exemplo: R(A,B,C,D,E) x={E} P: (A=3) (B=“gato”)

x {p (R)} vs. E {p{ABE(R)}}

E se houverem indíces em A, B?

B = “gato” A=3

fazer a interseção de apontadores para encontrar os apontadores que levam as tuplas desejadas

Limites para aplicação de regras:

Nenhuma transformação por aplicação da regra é sempre boa

No entanto, executar seleções mais cedo é geralmente melhor

Mais transformações no livro texto

Eliminação de sub-expressões comuns Outras operações:

eliminação de duplicatas

Onde estamos Processamento de Consultas

Nível da Álgebra Relacional transformações boas transformações

Nível de plano de consulta detalhado estimativa de custos gerar e comparar planos

Estimativa de Custos

(1) Estimativa do tamanho dos resultados(2) Estimativa do nr. de operações de E/S

Tamanho do resultado Para obter estimativas do tamanho do

resultado, manter estatísticas para cada relação R

T(R) : # tuplas em R S(R) : # bytes em cada tupla de R B(R): # blocos p/ armazenar todas as tuplas de R V(R, A) : # valores distintos em R p/ o atrib. A

Exemplo R A: 20 bytes string

B: 4 bytes inteiroC: 8 bytes dataD: 5 bytes string

A B C Dcat 1 10 acat 1 20 bdog 1 30 adog 1 40 cbat 1 50 d

T(R) = 5 S(R) = 37V(R,A) = 3 V(R,C) = 5V(R,B) = 1 V(R,D) = 4

Estimativa de tamanho para W = R1 x R2

T(W) =

S(W) =

T(R1) T(R2)

S(R1) + S(R2)

S(W) = S(R)

T(W) = ?

Estimativa de tamanho p/ W = A=a(R)

Exemplo R V(R,A)=3

V(R,B)=1V(R,C)=5V(R,D)=4

W = z=val(R) T(W) =

A B C Dcat 1 10 acat 1 20 bdog 1 30 adog 1 40 cbat 1 50 d

T(R)V(R,Z)

Hipótese:

Valores na expressão de seleção Z = valsão uniformemente distribuídas sobre ospossíveis valores de V(R,Z)

O que acontece com W = z val (R) ?

T(W) = ?

Solução 1: Há 50% de chance da tupla satisfazer a

condição T(W) = T(R)/2

Solução 2: Intuitivamente, menos que a metade satisfaz T(W) = T(R)/3

Solução # 3: Estimar faixas de valores

Examplo R ZMin=1 V(R,Z)=10

W= z 15 (R)Max=20

f = 20-15+1 = 6 (fração dentro da faixa) 20-1+1 20

T(W) = f T(R)

Ou, alternativamente: fV(R,Z) = fração de valores distintos

T(W) = [f V(Z,R)] T(R) = f T(R) V(Z,R)

Estimativa de Tamanho para W = R1 R2Seja x = atributos de R1 y = atributos of R2

x y =

Mesmo que R1 x R2

Caso 1

W = R1 R2 x y = AR1 A B C R2 A D

Caso 2

Hipóteses:

V(R1,A) V(R2,A) Cada valor de A em R1 está em R2V(R2,A) V(R1,A) Cada valor de A em R2 está em R1

Lembrete: V(R,A) = nr. de valores distintos de A em R

R1 A B C R2 A D

Cálculo de T(W) se V(R1,A) V(R2,A)

Tome 1 tupla compara

1 tupla casa com T(R2) tuplas... V(R2,A)

Logo, T(W) = T(R2) T(R1) V(R2, A)

V(R1,A) V(R2,A) T(W) = T(R2) T(R1) V(R2,A)

V(R2,A) V(R1,A) T(W) = T(R2) T(R1) V(R1,A)

[A é o atributo comum]

T(W) = T(R2) T(R1)max{ V(R1,A), V(R2,A) }

Em geral W = R1 R2

Hipótese AlternativaValores uniformemente distribuídos sobre o

domínio

R1 A B C R2 A D

Uma tupla casa com T(R2)/DOM(R2,A) tupla, então

T(W) = T(R2) T(R1) = T(R2) T(R1) DOM(R2, A) DOM(R1, A)

Caso 2

Assume-se que é o mesmo domínio

Em todos os casos:

S(W) = S(R1) + S(R2) - S(A)

Lembrete = S é o tamanho da tupla

Usando ideias similares é possível estimar os tamanhos de:

AB (R) ….. Seção 7.4.2

A=aB=b (R) …. Seção 7.4.3 R S com vários atributos comuns …. Seção 7.4.5União, Intersecção, Diferença, …. Seção 7.4.7

Nota: Para expressões complexas, estimar tamanhos de valores intermediários

Ex.: W = [A=a (R1) ] R2

Tratar como uma relação U

T(U) = T(R1)/V(R1,A) S(U) = S(R1)V (U, *) = ???? …

Estimando os V (U,*)

Ex., U = A=a (R1) Suponha que R1 tem atributos A,B,C,D

V(U, A) = V(U, B) =V(U, C) = V(U, D) =

Exemplo R1 V(R1,A)=3

V(R1,B)=1V(R1,C)=5V(R1,D)=3

U = A=a (R1)

A B C Dcat 1 10 10cat 1 20 20dog 1 30 10dog 1 40 30bat 1 50 10

V(U,A) =1 V(U,B) =1 V(U,C) = T(R1) V(R1,A)

V(U,D) ... algo entre os dois

Possíveis escolhas U = A=a (R)

V(U,A) = 1V(U,X) = V(R,X), X ≠ A

Para junções U = R1(A,B) R2(A,C)

V(U,A) = min { V(R1, A), V(R2, A) }V(U,B) = V(R1, B)V(U,C) = V(R2, C)

[Preservação de conjuntos de valores 7.4.4]

Exemplo:Z = R1(A,B) R2(B,C) R3(C,D)

T(R1) = 1000 V(R1,A)=50 V(R1,B)=100T(R2) = 2000 V(R2,B)=200 V(R2,C)=300T(R3) = 3000 V(R3,C)=90 V(R3,D)=500

R1R2R3

T(U) = 10002000 V(U,A) = 50 200 V(U,B) = 100

V(U,C) = 300

Resultado Parcial: U = R1 R2

Z = U R3

T(Z) = 100020003000 V(Z,A) = 50200300 V(Z,B) = 100

V(Z,C) = 90 V(Z,D) = 500

Sumário

Estimar o tamanho dos resultados é uma “arte”

Não esquecer: Estatísticas devem ser mantidas (custo?)

Visão Geral

Estimando o custo dos plano de consulta Estimando o tamanho dos resultados [feito!][feito!] Estimando o número de op. de ES [próximo!][próximo!]

Gerando e comparando planos

--> Geração e compraração de planos Consulta

Geração Planos

Poda x x

Estimativa

de CustoCustos

Seleção

Otimização de Consultas

Escolher mínimo

Para gerar planos deve-se considerar:

Transformações nas expressão da Algebra(e.x. ordem das junções)

Uso dos índices existentes Construções de índices ou ordenação das

consultas em tempo de processamento

Detalhes de implementação:ex. – Algoritmo de junção

- Gerenciamento de Memória - Processamento paralelo

Estimando custos de E/S:

Contagem do nr. blocos de disco que devem ser lidos ou escritos para executar o plano de consulta

Para estimar estes custos, parâmetros adicionais são necessários:

B(R) = nr. de blocos que contêm as tuplas de Rf(R) = nr. max de tuplas de R por blocoM = nr. de blocos de memória disponíveis

HT(i) = nr. de níveis no índice iLB(i) = nr. de blocos folha no índice i

Índices de Clustering

Indíces que permitem que as tuplas sejam lidas na ordem em que ocorrem fisicamente

A

ÍndiceA

101517193537

Noçoes de clustering Clustered file organization

….. Clustered relation

….. Clustering index

R1 R2 S1 S2 R3 R4 S3 S4

R1 R2 R3 R4 R5 R5 R7 R8

Exemplo R1 R2 sobre um atributo comum CT(R1) = 10.000T(R2) = 5.000S(R1) = S(R2) = 1/10 blocosMémoria disponível = 101 blocos

Metrica: nr. de ESs (ignorando a escrita do

resultado)

Cuidado! Essa pode não ser a melhor maneira de comparar Ignora custos de CPU Ignora temporização Ignora requisitos de “double buffering”

Opções

Transformações: R1 R2, R2 R1 Algoritmos de junção:

Iteração (loops aninhados) Merge Join Join com Indices Hash join

Iteração (conceitualmente)para cada r R1 faça para cada s R2 faça

se r.C = s.C então retorne <r,s>

Iteração motivação Otimizador usa iteração quando nós temos

tabelas usando junção que possuem poucas tuplas.

Hash join (conceitualmente) Função de hashing h, valores entre 0 k Buckets para R1: G0, G1, ... Gk Buckets para R2: H0, H1, ... Hk

Algoritmo(1) Tuplas de R1 nos buckets G(2) Tuplas de R2 nos buckets H(3) Para i = 0 até k faça

comparar as as tuplas dos buckets

Gi e Hi

Exemplo simples hash: para/impar

R1 R2 Buckets2 5 Par: 4 4 R1 R23 12 Impar: 5 38 139 8

1114

2 4 8 4 12 8 14

3 5 9 5 3 13 11

Hash Join Motivação Hash joins são usados quando existe

junções de grandes tabelas. O otimizador usa a tabela menor das duas tabelas para construir uma tabela hash em memória, e faz a varredura na tabela maior e compara com o valor de hash com esta tabela hash para encontrar as linhas que pertencem a junção.

Merge join (conceitualmente)(1) se R1 e R2 não ordenados, ordene-os(2) i 1; j 1;

enquanto (i T(R1)) (j T(R2)) faça se R1{ i }.C = R2{ j }.C then RetorneTuplas i,j senão se R1{ i }.C > R2{ j }.C então j j+1 senão se R1{ i }.C < R2{ j }.C então i i+1

Procedimento RetorneTuplasEnquanto (R1{ i }.C = R2{ j }.C) (i T(R1)) faça

jj j;

enquanto (R1{ i }.C = R2{ jj }.C) (jj T(R2)) faça retorne <R1{ i }, R2{ jj }>;

jj jj+1;

i i+1;

Sort Merge Join Motivação Sort merge join funciona melhor que iteração

quando o volume de dados é maior nas tabelas, mas não tão bom quanto um hash join em geral.

Ele pode ser melhor que o hash join quando a junção tem as colunas já ordenadas ou a ordenação não é requerida.

Junção com Ìndice (Conceitualmente)

Para cada r R1 faça

[ X index (R2, C, r.C)

para cada s X façaretorne <r,s>]

Assuma índices sobre R2.C

Nota: X index(rel, atr, valor)

X = conjunto de tuplas de rel onde atr = valor

Fatores que afetam a performance

(1) Tuplas da relação são armazenadas fisicamente juntas?

(2) Relações são ordenadas pelo atributo de da junção?

(3) Existem índices ?

Custo: para cada tupla de R1: [Leitura da tupla + Leitura de R2]

Total =10.000 [1+5.000]=50.010.000 op. de ES

Examplo 1(a): Junção por iteração R1 R2 Relações não contíguas T(R1) = 10.000; T(R2) = 5.000 S(R1) = S(R2) =1/10 blocos MEM=101 blocos

• Pode-se fazer melhor?Usar a memória(1) Ler 100 blocos de R1(2) Ler todos de R2 (usando 1 bloco) + join(3) Repetir até terminar

Custo: para ler cada porção de R1:Ler Porção de R1: 1000 Ler R2 : 5000

6000

Total = 10.000 x 6000 = 60,000 1.000

Reverter a ordem do join: R2 R1Total = 5000 x (1000 + 10.000) = 1000

5 x 11.000 = 55.000

• Pode-se fazer melhor?

Relações Contíguas

Exemplo 1(b) Iteração R2 R1

CustoPara cada porção de R2:

Ler porções: 100 ESsLer R1: 1000 ESs

1.100

Total= 5 porções x 1.100 = 5.500 ESs

Exemplo 1(c) Merge Join R1 e R2 ordenados por C; relações contíguas

Memória

R1R2

…..

…..

R1

R2

Custo total: Custo de Ler R1 + Custo de Ler R2= 1000 + 500 = 1.500 ESs

Example 1(d) Merge Join R1, R2 não ordenados, mas contiguos

Necessário ordenar R1e R2 primeiro….

Uma maneira de ordenar: Merge Sort(i) Para cada 100 blocos de R:

- Ler os 100 blocos- Ordenar na memória- Escrever no disco

partes ordenadas

Memória

R1

R2 ...

(ii) Ler as partes + merge + escrever

Ordenado Memória Partes

Ordenadas

......

Custo: Ordenação Cada tupla é lida,escrita,

lida,escritaPortanto...Custo para ordenar R1: 4 x 1.000 = 4.000Custo para ordenar R2: 4 x 500 = 2.000

Exemplo 1(d) Merge Join (continuação)R1,R2 contíguos, mais não ordenados

Custo Total = custo de ordenação + custo de junção

= 6.000 + 1.500 = 7.500 ESs

Mas: Custo Iteração = 5.500 Portanto, merge join não compensa!

Suponha R1 = 10.000 blocos contíguosR2 = 5.000 blocos não ordenados

Iteração: 5000 x (100+10.000) = 50 x 10.100 100

= 505.000 ESs Merge join: 5(10.000+5.000) = 75.000 ESs

Merge Join (com sort) VENCE!

Quanto de memória é necessária para o Merge Sort?

Ex.: Suponha que temos 10 blocos 10

...

100 partes O merge requer 100 blocos!R1

Em geral: k blocos na memória x blocos para ordenar a relação nr. de partes = (x/k) tamanho da parte = k

nr. de partes < buffers disponíveis para merge

portanto... (x/k) kou k2 x ou k x

Em nosso exemploR1 tem 1000 blocos, k 31.62R2 tem 500 blocos, k 22.36

São necessários pelo menos 32 buffers

Exemplo 1(e) Index Join

Assuma que há um índice sobre R1.C 2 níveis Cabe na memória

Assuma que R2 é contíguo, não ordenado

Custo: Leituras: 500 op de E/S Para cada tupla de R2:

Se R2.C=R1.C – Verifica no índice → 0 op de E/S Ler tupla de R1 → 1 op de E/S

Qual o número esperado de tuplas para R2.C=R1.C?

(a) Se R1.C é chave e R2.C é chave estrangeiranr. de tuplas esperadas é = 1

(b) Suponha que V(R1,C) = 5000, T(R1) = 10,000com distribuição uniforme: nr. de tuplas esperadas é = 2

(c) Suponha que DOM(R1, C) = 1,000,000 T(R1) = 10,000Com a hipótese alternativanr. esperado de tuplas = 10,000 = 1

1,000,000 100

Qual o número esperado para R2.C=R1.C?

Custo total com index join

(a) Custo total = 500+5000(1)1 = 5.500

(b) Custo total= 500+5000(2)1 = 10.500

(c) Custo total = 500+5000(1/100)1=550

E se o índice não cabe na memória?

Exemplo: Suponha que o índice sobre R1.C ocupa 201 blocos

Manter a raiz e 99 folhas na memória Os custo esperado de cada verificação é

E = (0) 99 + (1)101 0.5 200 200

Custo total (incluindo verificações)

Caso (b) : 2 tuplas esperadas = 500+5000 [verific. + carga de registros]= 500+5000 [0.5+2]= 500+12.500 = 13.000 op de E/S

Caso (c) : 1/100 tuplas esperadas= 500+5000 [0.5 + (1/100) ]= 500+2500+50 = 3050 op de E/S

Até agora …

Iteração 55.000Merge Join _______Sort+ Merge Join _______R1.C Index _______R2.C Index _______

Iteração 5500Merge join 1500Sort+Merge Join 7500 R1.C Index 5500 3050 550R2.C Index ________co

ntíg

uos

não

cont

íguo

s

R1 R2

R1, R2 contiguous (não ordenados) Usar 100 buckets Ler R1, hash, + escrever buckets

R1

Exemplo 1(f) Hash Join

... ...

10 blocos

100

→ O mesmo para R2→ Ler um bucket de R1; construi tabela hash na

memória→Ler o correpondente de Re + verifica na tabela hash

R1R2

...R1memória...

→ Repetir para todos os buckets

Custo:Buckets Ler R1 + escrever

Ler R2 + escreverJoin: Ler R1, R2

Custo total = 3 x [1000+500] = 4500Nota: isto é uma aproximação, uma vez que os buckets podem variar de tamanho e os blocos tem de estar completos

Requisitos mínimos de memória:

Tamanho dos buckets de R1 = (x/k)k = nr. de buffers de memóriax = número de blocos de R1

Assim: (x/k) < k

k > x São necessários k+1 buffers

Sumário

Iteração funciona bem para “pequenas” relações (relativo ao tamanho da memória)

Para equi-junções onde as relações não estão ordenadas e não há índices, hash join é usualmente melhor

Ordenação + merge join: bons para não equi-junções (ex. R1.C > R2.C)

Se as relações já estão ordenadas, usar merge join Se existem índices, eles podem ser úteis,

dependendo do tamanho esperado para os resultados