Roteiro
Noções de Processamento de Transações
Luiz Henrique de Campos Merschmann
Departamento de Computação
Universidade Federal de Ouro Preto
[email protected]
www.decom.ufop.br/luiz
Posicionamento
Introdução
Propriedades das Transações
Plano de Execução de Transações
Serialização dos Planos de Execução
BCC321 - Banco de Dados I
Introdução ao Processamento de Transações
Ementa
1. Conceitos básicos em sistemas de banco de dados.
Classificação de um SGBD
2. Conceitos e arquitetura de sistemas de banco de dados.
3. Modelagem conceitual de dados.
4. Modelo Relacional: conceitos básicos e restrições de
integridade.
5. Linguagens: álgebra e cálculo relacional.
I
Monousuário: se somente um usuário de cada vez puder
usar o sistema.
I
Multiusuário: se muitos usuários puderem usá-lo
concorrentemente.
6. A linguagem SQL e o uso de APIs.
Concorrência
7. Projeto de banco de dados.
Em um SGBD multiusuário os itens de dados armazenados são
recursos que devem ser acessados concorrentemente por usuários
ou programas de aplicação.
8. Normalização de banco de dados.
9. Noções de processamento de transações, concorrência e
recuperação de falhas.
10. Aspectos de implementação de banco de dados.
Introdução ao Processamento de Transações
Introdução ao Processamento de Transações
Transação
I
É um programa em execução que forma uma unidade lógica
de processamento no banco de dados.
I
Inclui uma ou mais operações de acesso ao banco de dados
(inserção, exclusão, alteração ou recuperação).
As operações de banco de dados que formam uma
transação podem:
Processamento intercalado versus processamento paralelo de transações concorrentes.
A maior parte da teoria relacionada a controle de concorrência
em bancos de dados foi desenvolvida em termos de concorrência
intercalada.
Propriedades das Transações
I
Estar embutidas em um programa de aplicação.
I
Ser especificadas interativamente (p.ex.: SQL).
Limites de uma transação
I
Declarações de início e fim de transação.
I
Um programa de aplicação pode conter várias transações
(separadas pelos limites).
Modelo de Banco de Dados Simplificado
Para assegurar a integridade dos dados, o sistema de banco de
dados deve manter as seguintes propriedades (ACID) das
transações:
I
Atomicidade: uma transação é uma unidade atômica de
processamento.
I
Consistência: uma transação será preservadora de
consistência se sua execução fizer o banco de dados passar
de um estado consistente para outro.
I
Isolamento: uma transação deve ser executada como se
estivesse isolada das demais.
I
Durabilidade: as mudanças aplicadas ao banco de dados por
uma transação efetivada devem persistir no banco de dados.
I
I
Banco de dados é representado por uma coleção de itens de
dados.
As operações básicas de acesso ao banco de dados que uma
transação pode conter são:
I
I
ler_item(X): transfere um item X do banco de dados para
uma variável de programa.
escrever_item(X): grava o valor de uma variável de
programa em um item de banco de dados chamado X.
Exemplos de Transações
Propriedades ACID (exemplo)
Considere que, inicialmente, os valores das contas X e Y são
1000 e 2000. Suponha que T1 seja uma transação que transfere
50 reais da conta X para a conta Y .
T1
T2
ler_item(X);
X := X - 50;
escrever_item(X);
ler_item(Y);
Y := Y + 50;
escrever_item(Y);
ler_item(X);
ler_item(Y);
Z := X + Y;
escrever_item(Z);
Propriedades ACID (exemplo)
Consistência
I
Requisito: que soma X + Y permaneça inalterada pela
execução da transação T1 .
I
Sem o requisito de consistência, o dinheiro poderia ser
criado ou destruído pela transação.
I
Garantir a consistência para uma transação individual é
responsabilidade do programador de aplicação que codifica
a transação.
Propriedades ACID (exemplo)
Atomicidade
I
Suponha que:
I
I
Durante a execução de T1 , ocorra uma falha que impeça T1
de completar sua execução.
A falha aconteceu depois da operação escrever_item(X),
mas antes da operação escrever_item(Y ).
Durabilidade
I
Essa propriedade garante que, quando uma transação é
executada com sucesso, todas as atualizações que ela
executou no banco de dados persistam, mesmo que haja
uma falha no sistema após a transação terminar.
I
Nesse caso, os valores das contas X e Y refletidos no banco
de dados são 950 e 2000, respectivamente ⇒ estado
inconsistente.
I
I
Se a propriedade de atomicidade estiver presente, todas as
ações da transação (ou nenhuma delas) são refletidas no
banco de dados.
No nosso exemplo, significa que após o término da
transação, os valores das contas X e Y no banco de dados
serão 950 e 2050.
I
Garantir a durabilidade é responsabilidade do sistema de
banco de dados.
I
Garantir a atomicidade é responsabilidade do sistema de
banco de dados.
Propriedades ACID (exemplo)
Estado da Transação
Isolamento
Para o propósito de recuperação, o sistema precisa manter o
controle de quando a transação inicia, termina e de suas
efetivações ou interrupções (commits ou abort (rollback)).
I
Se várias transações forem executadas simultaneamente,
suas operações podem intercalar de maneira a gerar
inconsistência.
I
Durante a execução de T1 , temporariamente, o banco de
dados fica num estado inconsistente.
I
Esse estado inconsistente ocorre quando a transação já
gravou o valor deduzido em X, mas ainda não gravou o
valor aumentado em Y .
I
Se a transação T2 estiver sendo executada simultaneamente
e, no ponto de inconsistência mencionado anteriormente, ler
X e Y , ela trabalhará dados inconsistentes.
I
Garantir o isolamento é responsabilidade do sistema de
banco de dados.
Estados de execução de uma transação:
Diagrama de transição de estado.
Planos de Execução de Transações
Caracterizando um Plano Baseado na Facilidade
de Recuperação
Quando transações são executadas concorrentemente, de
maneira intercalada, a ordem de execução das operações das
várias transações é conhecida como plano de execução.
T1
tempo
Duas operações em um plano são ditas em conflito se:
T2
ler_item(X);
X := X - N;
ler_item(X);
X := X + M;
escrever_item(X);
ler_item(Y);
escrever_item(X);
Y := Y + N;
escrever_item(Y);
O plano de execução (Sa ) da figura
ao lado pode ser escrito da seguinte
forma:
Sa :
r1 (X); r2 (X); w1 (X); r1 (Y ); w2 (X); w1 (Y )
tempo
T1
O plano de execução (Sb ) da figura
ao lado pode ser escrito da seguinte
forma:
Sb :
r1 (X); w1 (X); r2 (X); w2 (X); r1 (Y ); a1
T2
ler_item(X);
X := X - N;
escrever_item(X);
ler_item(X);
X := X + M;
escrever_item(X);
ler_item(Y);
FALHA
1. Pertencerem a diferentes transações.
2. Acessarem o mesmo item X.
3. Pelo menos uma das operações for um escrever_item(X).
Exemplo:
Plano de execução Sb : r1 (X); w1 (X); r2 (X); w2 (X); r1 (Y ); a1
Por exemplo, r1 (X) e w2 (X) conflitam, mas r1 (X) e w1 (X) não
conflitam.
Em alguns planos o processo de recuperação de transações é
fácil, enquanto em outros pode ser muito complicado. Portanto
é importante caracterizar os tipos de planos nos quais a
recuperação é possível.
Plano recuperável
I
Um plano S é recuperável se nenhuma transação T de S for
efetivada até que todas transações T 0 , que tiverem gravado
um item posteriormente lido por T , tenham sido efetivadas.
Quais dos planos a seguir são recuperáveis?
I
I
Sa : r1 (X); w1 (X); r2 (X); r1 (Y ); w2 (X); c2 ; a1 .
Sb : r1 (X); w1 (X); r2 (X); r1 (Y ); w2 (X); c1 ; c2
Caracterizando um Plano Baseado na Facilidade
de Recuperação
Caracterizando um Plano Baseado na Facilidade
de Recuperação
Fenômeno de reversão em cascata (cascading rollback )
T1
ler_item(A);
escrever_item(A);
Plano livre de reversão em cascata(avoid cascading rollback )
I
Se cada transação do plano ler somente os itens que foram
gravados por transações efetivadas.
I
Exemplo:Sb : r1 (X); w1 (X); r2 (X); r1 (Y ); w2 (X); c1 ; c2
Para satizfazer esse critério, operação r2 (X) desse plano
deve ser adiada até que T 1 seja efetivada (ou abortada).
Serialização dos Planos
O conceito de serialização de planos é usado para identificar
quais planos são corretos quando há intercalação das operações
das transações na execução dos planos.
I
I
Exemplo: Sc : w1 (X); w2 (X); a1
Esse plano é livre de reversão em cascata, mas não é um
plano estrito.
I
I
Plano serial: se para cada transação T participante, todas
as operações de T forem executadas consecutivamente no
plano (sem intercalação das operações de outra transação).
Exemplos:
T1
tempo
Nesse caso, as transações não poderão nem ler nem escrever
um item X até que a última transação que tenha escrito X
seja efetivada (ou abortada).
T3
ler_item(A);
escrever_item(A);
Plano estrito (strict schedule)
I
T2
ler_item(A);
escrever_item(A);
tempo
Caracterizando um Plano Baseado na Facilidade
de Recuperação
T2
ler_item(X);
X := X - N;
escrever_item(X);
ler_item(Y);
Y := Y + N;
escrever_item(Y);
ler_item(X);
X := X + M;
escrever_item(X);
Planos estritos simplificam o processo de recuperação.
Plano A
I
I
T1
T2
ler_item(X);
X := X + M;
escrever_item(X);
ler_item(X);
X := X - N;
escrever_item(X);
ler_item(Y);
Y := Y + N;
escrever_item(Y);
Plano B
Planos seriais fornecem resultados corretos.
Qual é o problema ao se utilizar planos seriais?
Serialização dos Planos
Serialização dos Planos
I
Plano não-serial: intercalação das operações das transações
no plano.
I
Exemplos:
I
T1
T2
tempo
ler_item(X);
X := X - N;
escrever_item(X);
ler_item(Y);
ler_item(X);
X := X + M;
escrever_item(X);
Y := Y + N;
escrever_item(Y);
Plano C
T1
T2
ler_item(X);
X := X - N;
escrever_item(X);
Discussão: Valores iniciais dos itens: X = 90, Y = 90, N =
3 e M = 2.
Valores esperados (de acordo com o significado das
transações): X = 89 e Y = 93.
Serialização dos Planos
Conceito de equivalência de planos
I
Quando dois planos são considerados equivalentes?
I
Dois planos podem ser considerados equivalentes se
produzirem o mesmo estado final no banco de dados?
Duas definições de equivalência de planos:
Equivalência de conflito.
Equivalência de visão.
I
Plano D
Qual desses planos não-seriais fornece resultados corretos?
I
I
ler_item(X);
X := X + M;
escrever_item(X);
I
I
Alguns planos não-seriais fornecem resultados corretos.
Como determinar quais dos planos não-seriais fornecem
resultados corretos?
ler_item(Y);
Y := Y + N;
escrever_item(Y);
I
I
I
I
Usar o conceito de serialização.
Um plano S com n transações é serializável se ele for
equivalente a algum plano serial com as mesmas n
transações.
Dizer que um plano S não-serial é serializável é o mesmo
que dizer que ele é correto.
Serialização dos Planos
Equivalência de conflito
I
Dois planos são conflito equivalentes se a ordem de
quaisquer duas operações conflitantes for a mesma em
ambos os planos.
I
Definiremos que um plano S é conflito serializável se ele
for (conflito) equivalente a algum plano serial S 0 .
Serialização dos Planos
Testando a Serialização por Conflito de um Plano
Equivalência de conflito
I
Idéia: reordenar as operações não-conflitantes em S até
formar um plano serial equivalente S 0 .
I
Exemplo: Planos D e A das figuras anteriores.
I
Como A é um plano serial e D é equivalente a A, então D é
um plano serializável.
Testando a Serialização por Conflito de um Plano
4. Para cada caso em S em que Tj executar um
escrever_item(Z) depois que uma Ti executar um
escrever_item(Z), criar um arco (Ti → Tj ) no grafo.
5. O plano S será serializável se, e apenas se, o grafo não
contiver ciclos.
O algoritmo verifica as operações ler_item e escrever_item
de um plano e constrói um grafo de precedência (grafo
de serialização).
I
O grafo de serialização é um grafo orientado G(N,E), onde
N é o conjunto de transações do plano.
I
1. Para cada transação Ti participante do plano S, criar um
nó Ti no grafo.
3. Para cada caso em S em que Tj executar um
escrever_item(Z) depois que uma Ti executar um
ler_item(Z), criar um arco (Ti → Tj ) no grafo.
Há um algoritmo para determinar se um plano é serializável
de conflito ou não.
I
Testando a Serialização por Conflito de um Plano
Algoritmo para testar a serialização de conflito de um plano
S
Exemplos:
T1
tempo
2. Para cada caso em S em que Tj executar um ler_item(Z)
depois que uma Ti executar um escrever_item(Z), criar um
arco (Ti → Tj ) no grafo.
I
T2
ler_item(X);
X := X - N;
escrever_item(X);
ler_item(Y);
Y := Y + N;
escrever_item(Y);
ler_item(X);
X := X + M;
escrever_item(X);
Plano A
T1
ler_item(X);
X := X - N;
escrever_item(X);
ler_item(Y);
Y := Y + N;
escrever_item(Y);
T2
ler_item(X);
X := X + M;
escrever_item(X);
Plano B
Testando a Serialização por Conflito de um Plano
I
T1
T2
tempo
ler_item(X);
X := X - N;
escrever_item(X);
ler_item(Y);
ler_item(X);
X := X + M;
escrever_item(X);
Y := Y + N;
escrever_item(Y);
Plano C
T1
T2
I
ler_item(X);
X := X - N;
escrever_item(X);
ler_item(X);
X := X + M;
escrever_item(X);
I
ler_item(Y);
Y := Y + N;
escrever_item(Y);
Equivalência de visão
As condições 1 e 2 asseguram que cada transação lê os
mesmos valores em ambos os planos.
I
A condição 3 (em conjunto com a 1 e 2) assegura que
ambos os planos de execução resultem no mesmo estado
final do banco de dados.
I
Definiremos que um plano S tem visão serializável se ele
tiver visão equivalente a um plano serial.
I
O plano Sa : r1 (X); w2 (X); w1 (X); w3 (X); c1 ; c2 ; c3 é visão
serializável?
I
Sim, pois é visão equivalente ao plano serial T1 , T2 , T3 .
A definição de equivalência de planos chamada de
equivalência de visão é menos restritiva do que a
equivalência de conflito.
Dois planos S e S 0 são visão equivalentes se as três
condições seguintes forem atendidas:
1. O conjunto de transações participantes em S e S 0 seja o
mesmo.
2. Para toda operação ri (X) de Ti em S, se o valor X lido
pela operação tiver sido produzido por uma operação wj (X)
de Tj (ou se for o valor original de X antes do plano
iniciar), a mesma condição deverá ser garantida para o valor
lido pela operação ri (X) de Ti em S 0 .
3. Se a operação wk (Y ) de Tk for a última operação a gravar o
item Y em S, então wk (Y ) de Tk deverá ser a última
operação a gravar Y em S 0 .
Plano D
Serialização dos Planos
I
Serialização dos Planos
Equivalência de visão
Exemplos:
Aplicação da Serialização
I
Um plano serializável fornece os benefícios da execução
concorrente, sem deixar de ser correto.
I
Na prática é muito difícil testar a serialização de um plano.
I
É difícil determinar como as operações de um plano serão
intercaladas antecipadamente de modo a garantir a
serialização.
I
Portanto, a abordagem utilizada na maioria dos SGBDs é
definir protocolos (conjuntos de regras) que, se seguidos por
todas as transações individualmente (ou impostos pelo
sistema de controle de concorrência do SGBD) garantirão a
serialização de todos os planos dos quais as transações
participem.
Perguntas
FIM