Processamento de

transações
Banco de Dados II
Transação

Conjunto de operações que formam uma

unidade lógica de processamento de banco
de dados
As operações podem ser
inserção, exclusão, alterações ou consultas
Uma transação sempre é executada por
completo
Transação

begin transaction
<operações>
end transaction

Programa do usuário pode realizar vários

operação com os dados
SGBD se preocupa apenas com leituras e escritas
dos dados
Transação

O acesso ao BD é feito pelas operações:

Read (x) – ler o item de dado x e transfere para a
memória principal (MP)
Write (x) – grava o item x da memória para o BD
Transação

 Operação read (x):

 Encontrar o endereço do bloco que contém x
 Copiar o bloco para o buffer na MP
 Copiar x para a variável que o referenciou
 Operação write (x):
 Encontrar o endereço do bloco que contém x
 Copiar o bloco para o buffer na MP
 Atualizar o valor de x no buffer
 Armazenar o bloco atualizado de volta no disco
Exemplo de transação

 Seja T1 uma transação que transfere 50 reais da conta A

para a conta B.

T1: read (A);

A := A - 50;
write (A);
read (B);
B := B + 50;
write (B);
Transações

Uma transação deve acessar um BD consistente

Durante a execução da transação o BD pode ficar
temporariamente inconsistente
Quando a transação é efetivada, o BD deve estar
consistente
Deve ser considerado:
Controle de concorrência
Recuperação
Propriedades de transação (ACID)

Atomicidade
Consistência
Isolamento
Durabilidade
Propriedades de transação (ACID)

 Exemplo (transferência entre contas)

Ti : read (A);
A := A - 50;
write (A);
read (B);
B := B + 50;
write (B);
Propriedade – Atomicidade

Garante que todas as ações da transação

serão refletidas no banco de dados ou nada
será alterado no BD.
Se a transação não se completar, os valores
antigos são restabelecidos para fazer com que
pareça que ela nunca foi executada.
Propriedade – Atomicidade

 Exemplo:
 Se os valores de A e B forem 1.000 e 2.000,
respectivamente, antes da execução de Ti.
 A transação começou a ser executada e ocorreu uma
falha depois da execução da operação write (A), mas
antes da operação write (B)
 Os valores de A e B são 950 e 2.000, estando portanto,
inconsistentes.
 O sistema deve garantir que o estado de
consistência seja restabelecida.
Propriedade – Consistência

Se o banco de dados é consistente antes de

uma transação, permanecerá consistente
depois da execução da transação.
Ex.: A soma de A + B deve permanecer
inalterada após a execução da transação Ti.
Propriedade – Isolamento

 Quando são executadas diversas transações

concorrentes, suas operações podem ser
intercaladas de modo inconveniente, resultando
em um estado inconsistente.
 O isolamento garante que a execução simultânea
de transações resulte em uma situação equivalente
ao estado obtido caso as transações tivessem sido
executadas uma de cada vez, em qualquer ordem.
Propriedade – Isolamento

Exemplo:
Durante Ti, o BD fica temporariamente
inconsistente - após write (A) e antes de write (B).
Se uma segunda transação, em execução
concorrente, ler A e B obterá valores
inconsistentes (950 e 2000). Se executar
atualizações baseadas nesses valores, o banco
de dados permanecerá inconsistente mesmo
após a execução das transações.
Propriedade – Durabilidade

Garante que, uma vez completada a transição

com sucesso, todas as atualizações realizadas
no banco de dados persistirão, até mesmo se
houver uma falha de sistema após a transação
se completar.
Estados da transação
Estados da transação

 Ativa
Imediatamente após o início da execução
A transação permanece neste estado enquanto está
em execução
 Efetivação parcial
Após a execução da última instrução
 Efetivada
Após ser completada com sucesso
Estados da transação

 Falha
Após a descoberta que a execução normal não
pode ser realizada
 Abortada
Após a transação ter sido cancelada e o banco de
dados restaurado a seu estado anterior ao início da
transação.
Duas opções:
Reiniciar a transação – apenas se não ocorrer erro
lógico interno
Matar a transação
Exemplo de transação

Reserva de passagens aéreas

T1 – transfere N reservas de um vôo, que guarda o
total de poltronas reservadas em x, para outro vôo,
que armazena o total de assentos reservados em y
T2 – reserva M assentos no vôo que guarda o total de
poltronas reservadas em x
 Podem:
Ser executadas concorrentemente
acessar e atualizar o mesmo item de dados
Exemplo de transação

T1: ler(x); T2: ler (x);

x := x-N; x := x+M;
gravar (x); gravar (x);
ler(y);
y := y+N;
gravar (y);
Plano de execução

Serial
Plano de execução

Intercalado
Problemas na Concorrência

Problemas podem ocorrer quando transações

são executadas concorrentemente sem
controle:
Atualização perdida
Atualização temporária
Resumo incorreto
Problemas na concorrência

Atualização perdida
(sobrescrita)
 Problemas na concorrência

T1 falha e T2 lê o valor
´temporário”
incorreto de x

Falha
Problemas na concorrência

T3 lê x depois da
subtração de N e lê y
antes da adição de N
(resumo errado)
Execuções Concorrentes

 Transações Concorrentes:
Pode causar inconsistência do BD
Implementação complexa
O paralelismo entre CPU e I/O pode ser explorado
para executar diversas transações em paralelo
Aumento da utilização do disco e do processador –
enquanto uma transação está utilizando a CPU, outra
transação pode estar lendo ou escrevendo no disco
Execuções Concorrentes

Transações Concorrentes
Mistura de transações em execução simultânea
(longas e curtas)
Sequencial - transação deve esperar até que uma
transação longa se complete, gerando atrasos
imprevisíveis em sua execução.
Concorrentes - compartilham os ciclos de CPU e
os acessos a disco entre si, redução de atrasos e
do tempo médio de resposta.
Execuções Concorrentes
 T1 (transfere R$ 50,00 da conta A para a conta B)
 T2 (transfere 10% do saldo da conta A para a conta B)
Execuções Concorrentes

T1 T2
 Suponha A=1.000 e B=2.000
read (A);
 Escala 1 - uma escala A := A - 50;
(schedule) sequencial na qual write (A);
read (B);
T1 é seguido por T2
B := B + 50;
write (B);
read (A);
temp := A * 0,1;
A := A - temp;
write (A);
read (B);
B := B + temp;
write (B);
Execuções Concorrentes

T1 T2
 Escala 2 - uma escala de
read (A);
execução sequencial na qual temp := A * 0,1;
T2 é seguido por T1 A := A - temp;
 Em ambos os casos - write (A);
read (B);
preservação da soma A + B B := B + temp;
write (B);

read (A);
A := A - 50;
write (A);
read (B);
B := B + 50;
write (B);
Execuções Concorrentes

T1 T2
 Escala 3 - uma escala de read (A);
execução concorrente A := A - 50;
equivalente à Escala 1 write (A);
read (A);
 Preservação da soma A + B
temp := A * 0,1;
A := A - temp;
write (A);
read (B);
B := B + 50;
write (B);
read (B);
B := B + temp;
write (B);
Execuções Concorrentes

T1 T2
 Escala 4 - uma escala de
read (A);
execução concorrente A := A - 50;
 Estado inconsistente read (A);
temp := A * 0,1;
A := A - temp;
write (A);
read (B);
write (A);
read (B);
B := B + 50;
write (B);
B := B + temp;
write (B);
Serialização (Seriação)

 O controle da execução concorrente não pode

ser deixado sob a responsabilidade do sistema
operacional, pois pode gerar escalas inconsistentes
 É tarefa do componente de Controle de
Concorrência garantir que qualquer escala
executada deixe o BD em estado consistente
 O controle de concorrência deve garantir que
qualquer escala concorrente seja equivalente a
uma escala sequencial
Serialização (Seriação)

 Quais escalas de execução podem garantir a

consistência do BD e quais não podem?
Duas formas de verificar a equivalência entre
escalas:
Por conflito
Por visão
Serialização

 Para uma escala de execução, as únicas

operações importantes são: leitura (read) e escrita
(write)
T1 T2
read (A);
write (A);
read (A);
write (A);
read (B);
write (B);
read (B);
write (B);
Serialização de conflito

Considere
Uma escala de execução S
Duas instruções sucessivas Ii e Ij, das transações Ti e Tj
(i <> j)
Se Ii e Ij referem-se a itens de dados diferentes, então
Ii e Ij podem ser alternados sem afetar os resultados
de qualquer instrução de S
Serialização de conflito

 Se Ii e Ij referem-se ao mesmo item de dados Q:

Ii = read(Q), Ij = read(Q). A sequência de execução
não importa.
Ii = read(Q), Ij = write(Q). A ordem de Ii e Ij importa.
Ii = write(Q), Ij = read(Q). A ordem de Ii e Ij importa.
Ii = write(Q), Ij = write(Q). O valor obtido pela próxima
instrução read(Q) de S é afetado
Serialização de conflito

 Diz-se que duas instruções entram em conflito se elas

são operações pertencentes a transações diferentes,
agindo no mesmo item de dado, e pelo menos uma
dessas instruções é uma operação de escrita.
T1 T2
read (A); • A instrução write(A) de T1 entra em
write (A); conflito com a instrução read(A)
read (A); de T 2 .
write (A); • A instrução write(A) de T 2 não está
read (B); em conflito com a instrução read(B)
de T1 .
write (B);
read (B);
write (B);
 Serialização de conflito
 A instrução write(A) de T 2 não entra em conflito com a
instrução read(B) de T1. Então, é permitido mudar a
ordem dessas instruções para gerar uma escala de
execução equivalente.

T1 T2 T1 T2

read(A) read(A)
write(A) write(A)
read(A) read(A)
write(A) read(B)
read(B) write(A)
write(B) write(B)
read(B) read(B)
write(B) write(B)
 Serialização de Conflito

T1 T2 T1 T2

read(A) read(A)
write(A) write(A)
read(B) read(B)
read(A) read(A)
write(A) write(B)
write(B) write(A)
read(B) read(B)
write(B) write(B)
Serialização de Conflito

 Se uma escala de execução S puder ser

transformada em outra S´, por uma série de trocas
de instruções não conflitantes, então S e S´ são
equivalentes no conflito.
 O conceito de equivalência por conflito leva ao
conceito de serialização por conflito.
 Uma escala de execução S é serializável por
conflito se ela é equivalente por conflito a uma
escala de execução sequencial.
Serialização de Conflito

A escala abaixo é serializável por conflito?

Não, pois não é

equivalente em
conflito nem à escala
sequencial <T3, T4>
nem <T4, T3>
Teste de Serialização de Conflito

 Para testar se uma escala é conflito serializável, é

possível usar um algoritmo que constrói um grafo de
precedência (o grafo de serialização)
 G = (N, E), Onde N é o conjunto de vértices e E é o
conjunto de arestas dirigidas
O conjunto de vértices é composto por todas as
transações que participam da escala.
O conjunto de arestas consiste em todas as arestas Ti
→ Tj
Teste de Serialização de Conflito

 Algoritmo:
 Para cada transação Ti da escala S, criar um nó Ti no grafo
 Para cada caso em S que Tj executar um read(x) depois que
Ti executar um write(x), criar uma seta (Ti → Tj) no grafo
 Para cada caso em S que Tj executar um write(x) depois que
Ti executar um read(x), criar uma seta (Ti → Tj) no grafo
 Para cada caso em S que Tj executar um write(x) depois que
Ti executar um write(x), criar uma seta (Ti → Tj) no grafo
 S será conflito serializável se, e somente se, o grafo não
contiver ciclo.
Teste de Serialização de Conflito
Teste de Serialização de Conflito
Teste de Serialização de Conflito

Não é serializável em conflito

Teste de Serialização de Conflito
Serialização de Conflito

Exercício: verificar se a escala abaixo é conflito

serializável.
Serialização de Conflito

Os valores finais das contas A e B depois da

execução da escala apresentada ou da escala
sequencial <T1, T5> são os mesmos.
Para o sistema determinar se as escalas
produzem o mesmo resultado, ele tem de
analisar toda a computação executada por T1
e T5, o que é oneroso e difícil de implementar
em termos computacionais.
Visão Serializada
 Menos restritiva que a serialização de conflito.
 Duas escalas S e S’ devem atender as seguintes
condições:
 Para cada item de dados Q, se a transação Ti fizer uma leitura
no valor inicial de Q na escala S, então a transação Ti também
deve ler o valor inicial de Q na escala S´.
 Para cada item de dados Q, se a transação Ti executar uma
read(Q) na escala S, e aquele valor foi produzido por meio da
transação Tj, então a transação Ti também deverá, na escala S´,
ler o valor de Q que foi produzido por meio da transação Tj.
 Para cada item de dados Q, a transação que executa a
operação final write(Q) na escala S tem de executar a
operação write(Q) final na escala S´.
 Visão Serializada - exercício
 Verificar se as escalas abaixo são equivalentes em visão
T1 T2 T1 T2

read (A) read (A)

A := A - 50 temp := A * 0,1
write (A) A := A - temp
read (B) write (A)
B := B + 50 read (B)
write (B) B := B + temp
read (A) write (B)
temp := A * 0,1 read (A)
A := A - temp A := A - 50
write (A)
write (A)
read (B)
read (B)
B := B + 50
B := B + temp
write (B)
write (B)
 Visão Serializada - exercício

 Verificar se as escalas abaixo são equivalentes em visão

T1 T2 T1 T2

read (A) read (A)

A := A - 50 A := A - 50
write (A) write (A)
read (B) read (A)
B := B + 50 temp := A * 0,1
write (B) A := A - temp
read (A) write (A)
temp := A * 0,1 read (B)
A := A - temp B := B + 50
write (A) write (B)
read (B) read (B)
B := B + temp B := B + temp
write (B) write (B)
Visão Serializada
 Uma escala de execução S tem visão serializada se for
equivalente, em visão, a uma escala de execução
sequencial.
 Toda escala conflito serializável é visão serializável, mas
há escalas visão serializável que não são conflito
serializável.

T3 T4 T6
read (Q)
write (Q)
write (Q)
write (Q)
Recuperação

 Se uma transação Ti falhar, é preciso desfazer seus

efeitos para garantir a propriedade de atomicidade da
transação.
 Em um sistema que permite a execução concorrente,
também é necessário assegurar que qualquer
transação Tj que seja dependente de Ti também seja
abortada.
Recuperação

 Na escala abaixo, o que acontece se T8 falhar?

T8 T9

read(A)
write(A)
read(A)
read(B)
Recuperação

 São escalas onde para cada par Ti,Tj, se Tj lê dados

previamente escrito por Ti, então a efetivação de Ti
deverá ser antes de Tj.

T8 T9

read(A)
write(A)
read(A)
read(B)
Recuperação em cascata

 Caso T10 falhe, acontece um retorno em cascata

(cascading rollback)

T10 T11 T12

read(A)
read(A)
write(A)
read(A)
write(A)
read(A)
Referências

Sistemas de Banco de Dado – Elmasri, Navathe

Capítulo 17
Sistemas de Banco de Dados – Silberschatz,
Korth
Capítulo 13