Chapter 12: Query Processing. José Alferes Sistemas de Bases de Dados - ISCTEM janeiro de 2017

Transcrição

1 Chapter 12: Query Processing José Alferes Sistemas de Bases de Dados - ISCTEM janeiro de

2 Chapter 12: Query Processing - Visão geral de processamento e otimização de perguntas - Medidas de custo de perguntas - Operações de seleção - Ordenação - Operações de junção - Outras operações - Avaliação de expressões - Paralelismo intra-query (no livro, está no capítulo 18) 108

3 Visão geral de processamento 1. Parsing e tradução 2. Otimização 3. Avaliação 109

4 Parsing e Avaliação - Parsing e tradução Traduzir a pergunta SQL para uma forma interna Traduzir depois para álgebra relacional A álgebra relacional é mais compacta, e diferencia melhor entrea as várias operações diferentes O parser verifica a sintaxe Isto é matéria para uma disciplina de Compiladores - Avaliação O query-execution engine pega num query-evaluation plan, executa o plano, e devolve o resultado O cerne da questão está em saber como fazer um bom plano de execução! A execução é simplesmente seguir esse plano (ou programa) 110

5 Otimização - Uma expressão de álgebra relacional pode ter várias equivalentes E.g., σ balance<2500 ( balance (account)) is equivalent to balance (σ balance<2500 (account)) - cada expressão pode ser avaliada usando vários algoritmos Assim, cada expressão pode ser avaliadas de muitas maneiras - Uma expressão anotada com algoritmos, especificando uma estratégia de avaliação, chama-se um evaluation-plan. E.g., usar um índice em balance para encontrar registos com saldo < 2500, Ou percorrer toda a tabela para descartar registo com saldo

6 Exemplo de plano de avaliação 112

7 Otimização - Query Optimisation: De todos os planos equivalentes, escolher aquele que tem menor custo (estimado) O custo é estimado com base em estatística e.g. nº de registos, tamanho médio de registos, etc - Vou começar por falar em Medidas de custo (para ter medidas sobre as quais avaliar os vários algoritmos e plano) Algoritmos para avaliação dos (principais) operadores da álgebra relacional Como combinar os algoritmos de operações individuais por forma a avaliar a expressão completa Como estes algoritmos e combinações podem ser paralelizados - Falarei depois em otimização de perguntas I.e., como encontrar o plano com menor custo estimado 113

8 Medidas de custo de perguntas - Tempo necessário para obter a resposta à pergunta Há vários fatores que contribuem para esse custo Acesso a disco, CPU, ou até à rede - Normalmente, o custo predominante é o de acesso a disco, e é relativamente fácil de estimar. As medidas entram com Nº de seeks Nº de blocos lidos Nº de blocos escritos * average-seek-cost * average-block-read-cost * average-block-write-cost O custo de escrita é maior que o de leitura porque - os dados são lidos depois de escritos para confirmar que tudo correu bem O custo de seek é normalmente muito maior (um ordem de grandeza) que o de transferência de blocos 114

9 Medidas de custo de perguntas (Cont.) - Por simplicidade, usamos o nº de blocos transferidos do disco e o nº de seeks como medidas de custo t T tempo de transferência de um bloco t S tempo de um seek seek Custo de transferir b blocos com S seeks b * t T + S * t S - Não se contabiliza o custo de escrita final no disco - Ignora-se custo de CPU porque tipicamente é muito menor Os sistemas reais por vezes entram em conta com o custo de CPU, mas tem pouca influência - A avaliação dos custos de um algoritmos é semelhante ao que se faz numa disciplina de Algoritmos e Estruturas de Dados mas as medias são muito diferentes Avaliação função de seeks e transferência de blocos, em vez de ser em função de nº de passos 115

10 Operação de seleção (recall) - Notação: σ p (r) - p é o predicado de seleção - Definido como: σ p (r) = {t t r and p(t)} onde p é uma fórmula de cálculo proposicional com termos ligados por: (and), (or), (not) Cada termo tem a forma: <attribute> onde op é um de: =,, >,. <. - Exemplo de seleção: σ branch-name= Perryridge (account) op <attribute> or <constant> - Para outros operadores, consultar documentação de uma cadeira introdutória de Bases de Dados 116

11 Algoritmos para seleção - File scan Para localizar registos de uma tabela que obedecem a uma condição - Algoritmos A1 (linear search). Percorrer todos os registos e verificar um a um se obedecem à condição Custo estimado = b r block transfers + 1 seek b r é o nº de blocos da relação r Se a condição for de igualdade sobre uma chave candidata, pode-se parar quando se encontra Custo médio = (b r /2) block transfers + 1 seek Este algoritmo pode sempre ser usado, independentemente de: condição de seleção, ou ordenação dos registos, ou disponibilidade de índices 117

12 Algoritmos para seleção (Cont.) - A2 (binary search). Só é aplicável quando se trata de uma condição de igualdade sobre o atributo de ordenação do ficheiro Assume que os blocos estão contíguos Custo estimado (nº de blocos a ler): Custo para localizar o 1º registo com busca binária - log 2 (b r ) * (t T + t S ) Se houver vários registo que satisfaçam a condição Adicionar custo de transferência do nº de blocos que contêm registo com o mesmo valor - veremos à frente como estimar este custo Se b r não for muito grande, então o mais certo é não valer a pena Note que t S é várias vezes maior t T São necessárias estimativas do tamanho (nº de blocos) da relação, para ver se vale ou não a pena 118

13 Seleção usando índices - Index scan A condição de seleção tem que ser sobre o(s) atributo(s) do índice - A3 (primary index on candidate key, equality). vai buscar um único registo que satisfaz uma condição de igualdade Custo = (h i + 1) * (t T + t S ) onde h i é a altura do índice - Relembre-se que numa B+-tree a altura é log n/2 (K), onde n é o nº de entradas por nó e K é o nº de valores diferentes. E.g. para relação r com valores diferente, e com 100 entradas por nó, h i = 4 A não ser que a tabela seja mesmo muito pequena, este algoritmo, quando aplicável, vale sempre a pena 119

14 Seleção usando índices (cont) - A4 (primary index on non-key, equality) Vai buscar vários Os registos estão em blocos seguidos Seja b = nº de blocos com registo que obedecem à condição Custo = h i * (t T + t S ) + t S + t T * b - A5 (equality on search-key of secondary index). Se a search-key for chave Custo = (h i + 1) * (t T + t S ) Se não for os n registos podem estar em blocos diferentes Custo = (h i + n) * (t T + t S ) - Se n for grande, este custo pode ser muito grande! Note que multiplica pelo nº de seeks 120

15 Seleções com comparações - Podem-se implementar seleções da forma σ A V (r) ou σ A V (r) usando um scan linear ou binário, como visto antes ou usando índices da seguinte forma: - A6 (primary index, comparison). Para σ A V (r) usar o índice para encontrar o 1º registo v e percorra a tabela a partir daí Para σ A V (r) simplesmente percorra a tabela até que > v; - neste caso, o índice é irrelevante - A7 (secondary index, comparison). Para σ A V (r) usar o índice para encontrar o 1º registo v e percorrer o índice sequencialmente a partir daí. Para σ A V (r) percorra as folhas do índice e siga os apontadores para os registos, até que o registo seja > v Em ambos os casos - tem que se ir buscar registo a registo (com um seek por registo) - Um linear file scan é provavelmente muito melhor!!!! 121

16 Seleções mais complexas - Conjunção: σ θ1 θ2... θn (r) - A8 (conjunctive selection using one index). Selecionar uma condição θ i e usar o algoritmo A1 a A7 que tiver menor custo para σ θi (r). Testar as outras condições em memória (o custo é o apenas a condição escolhida) Neste caso a escolha da condição é crucial! Há que estimar qual a melhor - A9 (conjunctive selection using multiple-key index). Usar uma combinação apropriada de índices sobre múltiplos atributos, se disponível - A10 (conjunctive selection by intersection of identifiers). Usar o índice para cada condição, e interceptar os vários apontadores Ir buscar apenas os registo do resultado da interceção 122

17 Seleções mais complexas - Disjunção:σ θ1 θ2... θn (r). - A11 (disjunctive selection by union of identifiers). Só é aplicável se os atributos de todas as condições tiverem índice. Caso contrário, usar linear scan. Ir buscar apontadores de cada um, e fazer a união. No fim, ir buscar registos - Negação: σ θ (r) Use linear scan Pode usar índice, se forem poucos os registos que satisfazem θ, e há um índice aplicável a θ 123

18 Ordenação - Os algoritmos de ordenação são importantes em processamento de perguntas, pelo menos porque: A própria pergunta pode requerer ordenação (order by clause) Alguns algoritmos (de projeção, junção, agregações, operações de conjuntos) precisam de ordenação prévia das relações - Para ordenar uma relação: Pode-se fazer um índice sobre o atributo pelo qual se quer ordenar, e usar para ler a relação de forma ordenada Isto não ordena a relação fisicamente Pode requerer um seek por registo Para relações que cabem em memória, carregar a relação toda e depois usar um bom algoritmos de ordenação dos que conhece (e.g. quicksort). Se não couber em memória, usar algoritmos específicos que tenham em conta as medidas de custo de acesso em bases de dados (seeks e transferências de blocos) 124

19 External Sort-Merge - Algoritmo de ordenação a ser usado apenas se a relação não couber em memória Seja M a dimensão da memória (em blocos). 1. Criar runs ordenados. Inicialmente i = 0 Repetir até ao fim da relação: (a) Ler M blocos para a memória (b) Ordenar cada um desses blocos (com o seu algoritmo favorito de ordenação) (c) Escrever o run ordenado R i ; incrementar i. Seja N o valor final de i 2. Merge the runs (próximo slide).. 125

20 External Sort-Merge (Cont.) 2. Merge the runs (N-way merge). Por enquanto, assuma-se N < M (onde N é o nº de runs, e M o nº de blocos que cabe em memória). 1. Ler o 1º bloco de cada run para a memória, e usar um bloco para buffer de output 2. repeat 1. Selecionar o menor registo em memória 2. Escrever esse registo no buffer de output. Se este estiver cheio, escrever o buffer em disco 3. Apagar o registo da memória. If esse bloco de memória fica vazio then ler o bloco seguinte desse run (se existir). 3. until todos os runs foram consumidos 126

21 External Sort-Merge (Cont.) - Se N M, são necessários várias passagens de merge. Em cada uma, são juntos M - 1 runs contíguos. Uma passagem reduz o nº de runs por um fator de M -1, cria runs maiores no mesmo fator E.g. Se M=11, e há 90 runs, uma passagem reduz o nº de runs para 9, cada um deles 10 vezes maior que os iniciais Repetir até que todos os runs se fundam num só. - Note que, na prática, isto só é necessário para tabelas mesmo muito grandes: Considere uma memória de 4GB e blocos de 4KB blocks (i.e. cabem 1M blocos em memória) Para ser necessário um 2º passo, teriam que haver mais do que 1M runs, i.e. 4000TB (porque cada run tem 4GB)! 127

22 Exemplo: External Sorting Using Sort-Merge 128

23 Custo de transferência Merge Sort - Análise de custo: Nº total de passos: log M 1 (b r /M). Transferências de blocos para criação de runs em cada passo 2b r Não se conta com o custo de escrita para o passo final - Isto é assim em todas as operações, pois o resultado pode nunca precisar de ser escrito em disco (vai para outra operação, ou aparece no ecrã, etc) Logo, o nº de transferências de blocos é: b r ( 2 log M 1 (b r / M) + 1) 129

24 Custo de Seeks External Merge Sort - Custo em seeks Durante a geração de runs: 1 seek para ler cada run e mais um para escrever 2 b r / M Na fase de merge Buffer size: b b (lê/escreve b b blocos de cada vez) Precisa de 2 b r / b b seeks por cada passagem - Exceto na passagem final, que só precisa de um Nº total de seek: 2 b r / M + b r / b b (2 log M 1 (b r / M) -1) 130

25 Operação de junção - Há vários algoritmos para implementar junções. Sem contar com os paralelos:: Nested-loop join Block nested-loop join Indexed nested-loop join Merge-join Hash-join - Tal como para a seleção, a escolha do melhor algoritmo em cada caso depende de estimativas - Os exemplo nos slides a seguir assume: Nº de registo em customer: 10,000 depositor: 5000 Nº de blocos em customer: 400 depositor:

26 Nested-Loop Join - É o algoritmo mais simples, mas que pode ser sempre usado 8como o linear scan para a seleção) - Para calcular a junção r θ s for each tuple t r in r do begin for each tuple t s in s do begin test pair (t r,t s ) to see if they satisfy the join condition θ if they do, add t r t s to the result. end end - r é chamada a outer relation e s a inner relation da junção - Muito caro em geral, pois exige que se examinem todos os pares de registos das duas relações 132

27 Nested-Loop Join (Cont.) - No pior caso, e se a memória só comportar um bloco de cada relação custo estimado é de n r b s + b r transferências, mais n r + b r seeks - Em geral, é muito melhor que a menor relação seja a outer O nº de transferências é multiplicado pelo nº de blocos da relação inner O nº de seeks só depende da outer - No entanto, se a menor relações couber toda em memória, essa deve ser a inner! Nesse caso o custo é reduzido para b r + b s transferências e 2 seeks - A escolha da relação inner e da outer depende em muito do tamanho de cada relação 133

28 Exemplo de Custo de Nested-Loop Join - No pior caso com depositor como outer: = 2,000,100 transferências, = 5100 seeks com customer como outer = 1,000,400 transferências e 10,400 seeks - Se a relação menor (depositor) couber em memória, o custo será de 500 transferências e 2 seeks - Em vez de iterar sobre os registos, deve-se iterar sobre os blocos Desta forma, em vez n r b s + b r transferências, teríamos b r b s + b r - Esta é a base para o algoritmo block nested-loops (próximo slide). 134

29 Block Nested-Loop Join - Variante do nested-loop join em que cada bloco da relação inner é junto com um bloco da outer for each block B r of r do begin for each block B s of s do begin end end end end for each tuple t r in B r do begin for each tuple t s in B s do begin Check if (t r,t s ) satisfy the join condition if they do, add t r t s to the result. 135

30 Custo de Block Nested-Loop Join - Pior caso: b r b s + b r transferências e 2 * b r seeks Cada bloco da relação inner s é lido uma vez por cada bloco da outer (em vez de uma vez por cada registo da outer) - Melhor caso (quando a menor relação cabe em memória): b r + b s transferências e 2 seeks. - Podem-se fazer alguns melhoramentos pontuais: Fazer o inner loop alternadamente do princípio para o fim e do fim para o princípio (se a política de buffer replacement for LRU) Usar índice na relação inner para aceder mais rapidamente aos registos que se juntam com o registo em questão da relação outer 136

31 Indexed Nested-Loop Join - Podem usar-se índices se A junção é com condições de igualdade Há um índice no(s) atributo(s) de junção da relação inner Em alguns casos, compensa construir o índice de propósito só para fazer uma junção - Para cada registo t r da relação outer r, usar o índice de s para procurar os registos de s que satisfazem a condição de junção com t r. - Pior caso: o buffer só tem espaço para um bloco de r, e, para cada registo de r, faz-se um pesquisa no índice de s. - Custo da junção: b r (t T + t S ) + n r c onde c é o custo no índice (altura da árvore se for B+-Tree) c pode ser estimado como o custo de uma seleção de igualdade sobre o atributo de junção do s - Se houver índices para os atributos de junção quer em r quer em s, usa-se a relação com menos registos como outer 137

32 Exemplos de custos - Calcular depositor customer, com depositor como outer. - Se customer tiver um índice primário de B + -tree no atributo customername, com 20 entradas por nó. - Como customer tem tuples, a altura da árvore é 4, e são precisos 5 acesso para chegar a um registo - depositor tem registos - Para o nested loop, transferências e seeks - Com o block-nested-loop 400* = transferências e 2 * 100 = 200 seeks - Custo do index nested loop join * 5 = 25,100 transferências e seeks. Neste caso, não deve valer a pena usar o índice, pois um seek é 50 a 100 vezes superior à transferências (isto é assim porque as relações são relativamente pequenas) 138

33 Merge-Join 1. Ordenar ambas as relações pelo(s) atributo(s) de junção (se não estiverem já ordenadas, claro) 2. Juntar as relações ordenadas da seguinte forma 1. Um passo é semelhante à fase de junção do algoritmo sort-merge 2. A diferença principal está no tratamento de duplicados no atributo de junção todo o par com o mesmo valor no atributo de junção tem que ser junto 3. Algoritmo detalhado está no livro 139

34 Merge-Join (Cont.) - Só pode ser usado quando as condições de junção são igualdades - Cada bloco só é lido uma vez (assumindo que todos os registos para um qualquer valor do atributo de junção cabem em memória) - Assim, o custo da junção é (onde b b é o nº de blocos que cabem em memória): b r + b s transferências e b r / b b + b s / b b seeks mais o custo de ordenar as relações que não estiverem ordenadas - hybrid merge-join: Se uma relação estiver ordenada e a outra tiver um índice secundário de B + -tree no atributo de junção Juntar a relação ordenada com as folhas da B + -tree Ordenar o resultado nos endereços dos registos da relação não ordenada Percorrer a relação que não está ordenada para substituir os endereços pelos registos O scan sequencial é mais rápido que o acesso aleatório 140

35 Hash-Join - Também só é aplicável para junções com igualdade - Usa-se uma função de h is para particionar os registos de ambas as relações - h mapeia valores de JoinAttrs para {0, 1,..., n}, where JoinAttrs são os atributos de junção em r e s r 0, r 1,..., r n denota as partições na relação r Cada registo t r r vai para r i onde i = h(t r [JoinAttrs]). s 0, s 1..., s n denota as partições de s Cada registo t s s is vai para s i, onde i = h(t s [JoinAttrs]). - Ideia de base: partir as relações desta forma Fazer a junção de cada r i só com s i Não é necessário considerar diferentes partições pois um par de registo de r e de s só satisfazem a condição de junção se estiverem na mesma partição (a função de hash é a mesma nos dois) 141

36 Hash-Join (Cont.) 142

37 Hash-Join Algorithm O hash-join de r e s é calculado da seguinte forma: 1. Particionar s usando uma função de hash h. Nesta fase, reserva-se um bloco de memória como buffer de output para cada partição 2. Particionar r da mesma forma, e com a mesma função h 3. Para cada i: (a)carregar s i em memória e fazer um hash no atributo de junção, usando uma função de hash diferente de h (b)ler do disco os registos de r i um a um. Para cada registo t r procurar o registo t s de s i que se junta, com este novo hash s chama-se o build input e r chama-se o probe input. 143

38 Hash-Join algorithm (Cont.) - O nº de partições n da função h é escolhido por forma a que s i caiba sempre em memória. Tipicamente n é b s /M * f onde f é um fudge factor, tipicamente à volta de 1.2, para evitar overflows As partições da probe r i não precisam de caber em memória - Recursive partitioning é necessário se o nº de partições n for maior que o nº de blocos M da memória Em vez de particionar s em n buckets, usar M 1 partições Particionar as M 1 partições com uma outra função de hash Raramente é necessário: e.g., o recursive partitioning não é necessário para relações até 1TB desde que a memória tenha no mínimo of 2GB, com blocos de 4KB. Por isso não detalharei mais (se quiserem, está no livro) 144

39 Custo do Hash-Join - O custo do hash join é (onde n h é o nº de partições) 3(b r + b s ) +4 n h transferências e 2( b r / b b + b s / b b ) +2 n h seeks - Se o build couber em memória, não é necessário partir o s e Custo estimado vai para b r + b s. - Para o exemplo que temos vistos, assumindo que a memória tem 20 blocos - b depositor = 100 and b customer = depositor é usado como build. particiona-se em 5 partições, com 20 blocos cada - Igualmente, particiona-se customer em 5 partições, cada uma com 80 blocos. - Logo, o custo estimado é: 3( ) +4*5= 1520 transferências e 2( 100/ /3 ) +2*5= 346 seeks - O melhor que tínhamos até agora era transferências e 200 seeks (para block nested loop) ou 25,100 transferências e seeks (para index nested loop) 145

40 Complex Joins - Junção com conjunção de condições: r θ1 θ 2... θ n s Ou se usa nested-loop ou Começa por se calcular o resultado de uma condição r O resultado final tem os registo que além disso verificam as outras condições θi s - Junção com disjunção θ 1... θ i 1 θ i θ n r θ1 θ2... θn s Ou se usa nested-loop ou Calcula-se a união dos registo do resultado da computação de cada condição individual r θ i s: (r θ1 s) (r θ2 s)... (r θn s) 146