unioeste

U niversidade Esiaduall do Qc-sle da Paran

Processamento
Mdulo I:
de T ransaes
(Aulas 1 e 2)

Clodis Boscarioli

I n fmtrm t i c a
Agenda:
Introduo:
Apresentao da disciplina;

Leitura do Plano de Ensino;

Conceito de transao;

Estados de uma transao;

Teoria de Serializao:
Serializao de conflito;

Serializao de viso.
 Usurios Programadores Usurios Administra-
navegantes de aplicaes sofisticados dores de BD
Usurios

Viso Geral 1 1
I
i
I

Interface com Programas de Consultas Esquema de

de um SGBD aplicaes aplicaes (queries) Banco de Dad

Programas de Pr-compilador Compilador Interpretador

Processador aplicaes em < de comandos DM DDL
de consultas cdigo objeto DML

u Componentes de execuo
SGBD de consultas ^
t Gerenciador
Gerenciador
de buffer
Gerenciador de transaes
de memria
t
Gerenciador
de arquivos

Armazenamento
Dados
em disco Indices
estatsticos
Arquivos de Dicionrio
dados de dados
Justificativa
Um dos critrios de classificao para SGBDs em relao ao
nmero de usurios que podem us-los ao mesmo tempo:

Monousurio: apenas um usurio pode utilizar o sistema em um

momento;
Sistemas de BD que so projetados para uso em um micro-computador;
Multiusurio: vrios usurios podem utilizar o sistema em um momento.
Sistemas de reserva de passagens areas;
Sistemas bancrios/financeiros;
Sistemas de venda para WEB.

Neste contexto, insere-se o conceito de multiprogramao.

permitida a existncia de SGBDs multiusurios porque possibilita-se
a execuo de vrios programas ao mesmo tempo .

Na realidade, se existe apenas uma CPU, ento parte dos programas

so intercalados na execuo e, a cada unidade de tempo , um
programa apenas executado;
Comandos de um programa so executados e ento o programa
suspenso para que comandos de um outro programa sejam
executados.
 j A j ; A i Uma nica
*------ s------------ i CPU CPU2

B D
CPU1

tempo

Em SGBDs os dados do BD so os recursos primrios que podem ser lidos/

recuperados e modificados.

A execuo de um programa de acesso e/ou modificao ao contedo do BD

chamado de transao.
Transaes
Um conjunto de vrias operao em um BD pode ser visto pelo usurio
como uma nica unidade.

Exemplo:
A transferncia de fundos de uma conta corrente pra uma conta poupana
uma operao nica do ponto de vista do cliente, porm, dentro do sistemas de
banco de dados, ela envolve vrias operaes.

essencial que todo o conjunto de operaes seja concludo, ou que, no

caso de uma falha, nenhuma delas ocorra.

Essas operaes, que formam uma nica unidade lgica de trabalho so

chamadas de transaes.

Um SGBD precisa:
Garantir que a execuo da transao seja completa;
Administrar a execuo simultnea de vrias transaes evitando
inconsistncias;
Uma transao que calcula o total de dinheiro do cliente poderia trabalhar com o saldo
da conta corrente antes do dbito feito pela transao de transferncia e, tambm,
verificar o saldo da poupana depois do crdito. Com isso, obteria um resultado
incorreto.
Operaes de Leitura/Escrita
As operaes de acesso ao BD que uma transao
pode fazer so:

read(x): que transfere o item de dados x do BD para um buffer

local alocado transao que executou a operao de read. O
valor de x colocado dentro de uma varivel de programa.

write(x): que transfere o item de dados x do buffer local da

transao que executou o write de volta para o BD. O valor da
varivel de programa passado para o item de dado no BD.

OBS.: para fins de simplificao, o item de dados e a varivel de

programa correspondente sero representados da mesma
forma, x.
Execuo das Operaes
Executar read(x):

Encontrar o endereo do bloco de disco que contm x;

Copiar este bloco de disco para dentro do buffer/memria principal, se
ele j no estiver l;
Copiar o item x do buffer para a varivel de programa.

Executar write(x):

Encontrar o endereo do bloco de disco que contm x;

Copiar o bloco de disco para a memria principal se ele j no estiver
l;
Copiar o item x da varivel de programa x para a localizao correta no
buffer;
Copiar o bloco alterado do buffer de volta para o disco (imediatamente
ou mais tarde).
Exemplo de Transao

A)
read(x); read(x);
x := x - N; x := x + M;
write(x); write(x);
read(y);
y := y + N;
write(y);

Ti

Acesso concorrente ao dado x.

Outro Exemplo

Seja T, uma transao que transfere 50 reais da conta A

para a conta B. Essa transao pode ser definida como:

T1: read(A);
A := A - 50;
write(A);
read(B);
B := B + 50;
write(B);
Propriedades das Transaes (ACID)
A - Atomicidade: ou todas as operaes da transao so refletidas
corretamente no banco de dados ou nenhuma o ser.

Suponha que, durante a execuo da transao Th uma falha acontea

impedindo T, de se completar com sucesso (uma queda de energia).
Suponha ainda que a falha tenha ocorrido depois da execuo da
operao write(), mas antes da operao write(B). O que acontece?

O estado do sistema no reflete mais um estado real do mundo que se

supe representado no BD. E um estado inconsistente.

Estes estados no podem ser perceptveis. Ou seja, estados

inconsistente s so permitidos no momento de execuo da
transao, onde o usurio no ter qualquer tipo de acesso aos dados.

Assegurar a atomicidade de uma transao responsabilidade do

SGBD, mais especificamente, do Componente de Gerenciamento
de Transaes e Recuperador de Falhas.
Propriedades das transaes (ACID)
C - Consistncia: a execuo de uma transao
isolada (ou seja, sem a execuo concorrente
de outra transao) preserva a consistncia do
banco de dados.

A exigncia da consistncia aqui significa que a soma

de A com B deve permanecer nalterada aps a
execuo da transao.

Se o banco de dados est consistente antes de uma

execuo de transao, o banco de dados
permanece consistente aps a execuo da
transao.

Responsabilidade do programador.
Propriedades das transaes (ACID)
I - Isolamento: embora diversas transaes possam ser executadas
de forma concorrente, o sistema garante que, para todo par de
transaes T e T, T, tem a sensao de que T, terminou sua
execuo antes de T, comear, ou vice-versa. Cada transao no
toma conhecimento de outras transaes concorrentes a eia no
sistema.

A execuo concorrente de vrias transaes implica no intercalamento

de suas operaes. Se este intercalamento feito de forma
inconveniente, inconsistncias sero geradas.

No exemplo dado, se uma transao concorrente ler o valor de A antes

dele ser escrito mais depois do processamento A-50 ter sido feito, ela
estar lendo um valor inconsistente.

Execues em srie resolvem este problema mas a concorrncia

benfica por causa do tempo de execuo (melhora do desempenho).

Assegurar o isolamento de responsabilidade do Controlador de

Concorrncia.
Propriedades das transaes (ACID)

D - Durabilidade: depois da transao

completar-se com sucesso, as mudanas que
ela faz no banco de dados persistem, at
mesmo se houver falhas no sistema.

No exemplo dado, se a transao se completar com

sucesso e o usurio que a disparou for notificado da
transferncia de fundos, isso significa que no houve
nenhuma falha de sistema que Tenha resultado em
perda de dados relativa a essa transferncia.

Assegurar a durabilidade responsabilidade do

componente do SGBD chamado de Recuperador
de Falhas.
Operaes Adicionais
Uma transao uma unidade de trabalho atmica que
completada em sua totalidade ou nada dela deve ter efeito. Para
tornar isso possvel, as seguintes operaes so necessrias:

Begin-transactiorr. Denota o incio da execuo da transao;

End-transaction:Especifica que as operaes da transao terminaram

e marca o limite final da execuo da transao. Neste ponto
necessrio verificar se o COMMIT ou o ABORT so necessrios, caso
j no tenham sido explicitados;

Commt-transacton:Sinal de trmino com sucesso e que as alteraes

podem ser permanentemente gravadas no BD;

Rollback (abort-transaction): Assinala que a transao no terminou

com sucesso e que seus efeitos devem ser desfeitos;

Undo: Desfaz uma operao;

Redo: Refaz uma operao.

Exemplo com Operadores (1)
Procedure Transfer;
begin
start; (begin transaction)
input (FROMaccount, TOaccount, amount);
temp := read(Accounts[FROMaccount]);
if temp < amount then
begin
output(insufficient funds);
Abort;
end
else
begin
write(Accounts[FROMaccount],temp - amount);
temp = read(Accounts[TOaccount]);
write(Accounts[TOaccount], temp + amount);
commit;
output(transfer complete);
end;
return; (end transaction)
end.
 Exemplo com Operadores (2)
begin transaction
update TABELA1 set CAMP01 = 'NOVO VALOR
where CAM P02 = 35
if @@ERROR <> 0
rollback
else
commit
end transaction

Suponha uma tabela que possua 6000 tuplas que satisfaam a condio e que
na tupla 4666 houve uma falha no sistema. Neste caso, a varivel chamada
@@ERROR guardar o cdigo do erro, o comando ROLLBACK ser executado
e as 4666 tuplas j atualizadas sero automaticamente voltadas a seu estado
anterior.
Ao contrrio, se tudo correr bem, o comando COMMIT ser executado e todas
as 6000 tuplas sero atualizadas com xito.
 Estados de uma Transao
Read/Write

Diagrama de transio de estados Qom sucesso

para a execuo da transao. ou com fa|ha.
Consideraes
Uma transao entra no estado de falha quando o
sistema determina que ela j no pode prosseguir sua
execuo normal. Essa transao deve ser desfeita e
entra no estado de abortada. Nesse momento o sistema
tem duas opes:

Reiniciar a transao: somente se ela foi abortada como

resultado de algum erro de hardware ou de software no criado
pela lgica interna da transao. Uma transao reiniciada
considerada uma transao nova.

Matar a transao: normalmente, isto feito em decorrncia de

algum erro lgico interno e s pode ser corrigido refazendo o
programa de aplicao. Esse erro d-se ou porque a entrada de
dados no era adequada ou porque os dados desejados no
foram encontrados no banco de dados.
Consideraes

Escritas externas observveis (escrever em um

terminal ou em uma impressora):

Uma escrita desse tipo no pode ser apagada j que

vista externamente ao sistema de banco de dados.

Geralmente somente so permitidas aps a transao

ser efetivada.
Execuo Concorrente
Permitir que mltiplas transaes concorram na atualizao de dados traz
diversas complicaes em relao consistncia desses dados.

Razes para permitir a concorrncia:

Uma transao consiste em diversos passos. Alguns envolvem atividades

de l/O, outros atividades de CPU. A CPU e os discos podem operar em
paralelo. Logo, a atividade de 1/0 pode ser feita em paralelo com o
processamento na CPU, por meio das execues paralelas das transaes.
Enquanto uma leitura ou escrita solicitada por uma transao esta em
desenvolvimento em um disco, outra transao pode ser processada na
CPU, e outro disco pode estar executando uma leitura ou escrita solicitada
por uma terceira transao. Assim aumenta-se o rendimento do sistema, ou
seja, o nmero de transaes que podem ser executadas em um
determinado tempo.

Pode haver uma mistura de transaes em execuo simultnea no

sistema, algumas curtas e outras longas. Se a execuo das transaes for
sequencial, uma transao curta pode ser obrigada a esperar at que uma
transao longa precedente se complete. Com a concorrncia reduz-se o
tempo mdio de resposta, ou seja, o tempo mdio para uma transao ser
concluda aps sua submisso.
Execuo Concorrente

Sejam T1 e T2 duas transaes que transferem

fundos de uma conta para outra.

A transao T1 transfere 50 dlares da conta A

para a conta B.

A transao T2 transfere 10 por cento do saldo

da conta A para a conta B.
Execuo Concorrente

TV 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;
write(B);
Execuo Seqencial
Escalas de execuo em seqncia: Observe que o estado do BD sempre
consistente.

Ti t2 Ti t2

read(A); read(A);
A := A - 50; temp := A * 0,1;
write(A); A := A -te m p ;
read(B); write(A);
B := B + 50; read(B);
write(B); B := B + temp;
write(B);
read(A);
temp := A * 0,1; read(A);
A := A - temp; A := A - 5 0 ;
write(A); write(A);
read(B); read(B);
B := B + temp; B := B + 50;
write(B); write(B);
Execuo Concorrente
Correta Incorreta

T, t2 Ti t2

read(A); read(A);
A := A - 50; A := A - 50;
write(A);
read(A); read(A);
temp := A * 0,1; temp := A * 0,1;
A : = A -te m p ; A := A -te m p ;
write(A); write(A);

read(B); write (A);

B := B + 50; read(B);
write(B); B := B + 50;
write(B);
read(B); read(B);
B := B + temp; B := B + temp;
write(B); write(B);
Problemas na Concorrncia

Problema de alteraes perdidas;

Problema de alterao temporria;

Problema do resumo incorreto.

Problema de Alteraes Perdidas
Ocorre quando duas transaes que acessam o
mesmo item de BD possuem suas operaes
intercaladas de uma maneira que o valor de
algum item de dado fique incorreto.

ro1
T,

read(x);
x := x - N;
read(x)
x := x + M;
write(x);
read(y);
write(x)

y := y + N;
write(y)
Problema de Alterao Temporria
Ocorre quando uma transao altera um item de
dados e depois ela falha por alguma razo. O
item de dado acessado por outra transao
antes que o valor original seja estabelecido.
Ti

read(x);
x := x - N;
write(x);
read(x)
x := x + M;
write(x)

read(y);
falha
Problema de Resumo Incorreto
Se uma transao est calculando uma funo agregada com um
conjunto de tuplas e outras transaes esto alterando algumas
destas tuplas, a funo agregada pode calcular alguns valores
antes deles serem alterados e outros depois de serem alterados.

Ti t3

sum := 0;
read(a);
sum : sum + a;
read(x);
x := x - N;
write(x);
read(x)
sum := sum + x;
read(y);
sum := sum + y;
read(y);
y := y + N;
write(y)
 Serializao (Seriao)
O sistema de banco de dados deve controlar a execuo
concorrente de transaes para assegurar que o estado do BD
permanea consistente.

A consistncia do banco de dados, sob execuo concorrente, pode

ser assegurada por meio da garantia de que qualquer escala
executada tenha o mesmo efeito de outra que tivesse sido
executada sem qualquer concorrncia.

Isto , uma escala de execuo deve, de alguma forma, ser

equivalente a uma escala seqencial.

Formas de equivalncia entre escalas de execuo podem ser

verificadas sob dois prismas:
Por conflito;
Por viso.
Serializao de Conflito

Considere uma escala de execuo S com duas

intrues sucessivas, l| e L das transaes T, e
Tj (i <> j), respectivamente.

Se lj e li referem-se a itens de dados diferentes,

ento permitido alternar lj e \, sem afetar os
resultados de qualquer instruo da escala.

Se lj e li referem-se ao mesmo item de dado Q,

ento a ordem dos dois passos pode importar.
Serializao de Conflito

1. li = read(Q) e lj = read(Q)

A seqncia de execuo de lj e \.no importa, j

lido por Ti e Tj, mdependentemente da ordem destas operaes.

2. I, = read(Q) e lj = write(Q)

Se I; vier antes de L ento T: no l o valor de Q que escrito por T, na

instruo lr J J

Se lj vier antes de I,, ento T, l o valor de Q que escrito por Tj.

Assim, a ordem de I; e lj importa.

Serializao de Conflito
3. I, = write(Q) e Ij = read(Q)

A ordem de I, e I, importa por razes semelhantes s do caso

anterior.

4. I, = write(Q) e Ij = write(Q)

Como ambas as instrues so operaes de escrita, a ordem

dessas instrues no afeta T, ou T.

Entretanto, o valor obtido pela prxima instruo read(Q) em S

afetado, j que somente o resultado da ltima das duas
instrues write(Q) preservado no banco de dados.

Se no houver nenhuma outra instruo de write(Q) depois de I,

e Ij em S, ento a ordem de I, e afeta diretamente o valor final de
\.

Q no que se refere ao estado do banco de dados aps a

execuo da escala S.
Serializao de Conflito

Diz-se que duas instrues entram em conflito se elas

so operaes pertencentes a transaes diferentes,
agindo no mesmo item de dado, e pelo menos uma
dessas instrues uma operao de escrita.

Ti t2

read(A) A instruo write(A) de T1 entra em conflito

write(A) com a instruo read(A) de T2.
read(A)
Porm, a instruo write(A) e T2 no est em
write(A)
conflito com a instruo read(B) de Tv
read(B)
write(B)
read(B)
write(B)
Serializao de Conflito
Seja lj e Ij instrues consecutivas de uma
escala de execuo S.

Se lj e lj so instrues de transaes diferentes

e no entram em conflito, ento podemos trocar
a ordem de lj e lj para produzir uma nova escala
de execuo S'.

Diz-se que S e S ' so equivalentes j que todas

as instrues aparecem na mesma ordem em
ambas as esca as de execuo com exceo de
lj e lj, cuja ordem no importa.
Serializao de Conflito

Ainda segundo a escala S, a instruo write(A) de T2

no entra em conflito com a instruo read(B) de T,.
Ento, permitido mudar a ordem dessas instrues
para gerar uma escala de execuo equivalente.

T, t2

read(A)
Em relao a um mesmo estado inicial do
write(A)
sistema, ambas as escalas (S e esta)
read(A) produzem o mesmo estado final no sistema.
read(B)
write(A)
write(B)
read(B)
write(B)
Serializao de Conflito
Se as seguintes trocas de instrues no-conflitantes
forem feitas:

read(B) de T1 por read(A) de T2;

write(B) de T1 por write(A) de T2;
write(B) de T1 por read(A) de T2.

... uma escala com execues seriais ser obtida.

Assim mostrou-se que a escala S equivalente, por

conflito, a uma escala seqencial.

Essa equivalncia garante que para um mesmo estado

inicial do sistema, a escala S produzir o mesmo estado
final produzido por essa escala seqencial.
Serializao de Conflito

Se uma escala de execuo S puder ser transformada

em outra, S , por uma srie de trocas de instrues no-
conflitantes, dizemos que S e S so equivalentes por
conflito

O conceito de equivalncia por conflito leva ao conceito

de serializao por conflito.

Uma escala de execuo S serializvel por conflito se

ela equivalente por conflito a uma escala de execuo
seqencial.
Serializao de Conflito

A escala abaixo no serializvel por conflito

pois no equivalente em conflito nem escala
seqencial <T3,T4> nem <T4,T3>.

T3 t4

read(A)

write(A)
write(A)
Serializao de Conflito
A escala abaixo no serializvel por conflito, mas produz o
mesmo resultado que uma escala seqencial. Confira.

Ti t2

read(A);
A := A - 50;
write(A);
read(B);
B := B - 10;
write(B);

read(B);
B := B + 50;
write(B);

read(A);
A := A + 10;
write(A);
Teste de Serializao de Conflito
Seja S uma escala. Para saber se ela serializvel em
relao s operaes conflitantes necessrio criar um
grafo de precedencia para S.

G = (V,E) em que V um conjunto de vrtices e E um

conjunto de arestas.

O conjunto de vrtices composto por todas as transaes que

participam da escala.

O conjunto de arestas consiste em todas as arestas Tj -> T para

as quais uma das seguintes condies verdadeira:

T| executa write(Q) antes de T executar read(Q);

T| executa read(Q) antes de Tj executar write(Q);
T| executa write(Q) antes de T executar write(Q);
Teste de Serializao de Conflito
Se existir uma aresta T, -> T. no grafo de precedncia,
ento, em qualquer escala seqencial S' equivalente a
S, Tj deve aparecer antes de
Exemplo: I

Ti
KJ

read (A);
A := A - 50;
write (A);
read(B);
B := B + 50;
write (B);
read (A);
temp := A * 0,1;
A := A - tem p;
write(A);
read(B);
B := B + tem p;
write(B);
 Teste de Serializao de Conflito
Exemplo:
T1 T 2

read(A) v y - -----------------
A := A - 50
read(A)
temp := A * 0,1 Ciclo no grafo: Se o grafo de precedncia
A := A - temp possui ciclo, ento a escala S no
write(A) serializvel por conflito.
read(B)
A ordem de serializao pode ser obtida por
meio da classificao topolgica, que
write(A)
estabelece uma ordem linear para a escala
read(B)
consistente com a ordem parcial do grafo
B := B + 50
write(B) de precedncia.

B := B + temp;
write(B)
Serializao de Viso

Trata-se de uma forma de equivalncia menos restritiva que a

equivalncia de conflito.

Considere duas escalas de execuo S e S, com o mesmo

conjunto de transaes participando de ambas. As escalas S e S
so ditas equivalentes por viso se as trs condies seguintes
forem satisfeitas:

Para cada item de dado Q, se a transao T fizer uma leitura no valor

inicial de Q na escala S, ento a transao T, tambm deve, na escala
S, ler o valor inicial de Q;
Para cada item de dado Q, se a transao T, executar um read(Q) na
escala S, e aquele valor foi produzido por meio da transao T (se
houver), ento a transao T, tambm dever, na escala S , ler o valor
de Q que foi produzido por meio da transao Tj;
Para cada item de dado Q, a transao (se houver) que executa a
operao final de write(Q) na escala S tem de executar a operao de
write(Q) final na escala S';
 Serializao de Viso

T1 t 2 T1 t 2 Ti t 2

read (A); read(A); read (A);

A ;= A - 50; temp := A * 0,1; A := A - 50;
write (A); A := A - temp; write (A);
read(B); write (A);
B ;= B + 50; read(B); read (A);
write (B); B := B + temp; temp := A * 0,1 ;
write(B); A := A - temp;
read (A); write(A);
temp := A * 0,1; read (A);
A := A - temp; A := A - 50; read(B);
write (A); write(A); B := B + 50;
read(B); read(B); write(B);
B := B + temp; B := B + 50;
write(B); write (B); read(B);
B := B + temp;
write(B);

No so equivalentes por viso
So equivalentes por viso
 Serializao de Viso
O conceito de equivalncia por viso leva ao
conceito de serializao por viso.
Uma escala serializvel por viso se ela for
equivalente em viso a uma escala de execuo
seqencial.

Ti t2 t3
equivalente em viso escala
read(Q) seqencial <J^,J2,J3>que
uma instruo read(Q) l o valor
write(Q) inicial de Q em ambas as escalas
write(Q) e T3 executa a escrita final de Q
em ambas as escalas.
write(Q)
Serializao de Viso
Modifica-se o grafo de precedncia para
serializao por conflito para testar se o
escalonamento serializvel por viso.

Verificando se o escalonamento abaixo

serializvel por conflito:
Serializao de Viso
Vejamos a seguinte situao:

Seja S uma escala.

Suponha que a transao T. leia o valor do item de dado
Q escrito por T,. Se S serializvel por viso, ento
qualquer em escala seqencial S, qual S
equivalente, Tj deve preceder Ty
Suponha agora que, na escala S, a transao Tk
executou um write(Q). Ento, na escala S', Tk deve
preceder T, ou deve seguir Tj. Ela no poder aparecer
entre Tj e Tj, porque dessa forma Tj no leria o valor de
Qescrito por T, e, S e S'no seriam equivalentes por
viso.
Serializao por Viso
Se o grafo no contiver ciclos ento o escalonamento serializvel
por viso.

Se o grafo contiver ciclos no significa, necessariamente, que o

escalonamento no serializvel.

Haver ento 2n grafos diferentes, sendo que cada um contm

apenas uma aresta de cada par.

Se alguns desses grafos for acclico, sabe-se que a escala

correspondente serializvel por viso.

O escalonamento serial equivalente obtido seguindo a ordenao

topolgica do grafo acclico.
Exemplo de Ordenao Topolgica
Fontes Bibliogrficas:
Sistemas de Banco de Dados (Cap. 15). Abraham
Silberchatz, Henry F. Korth, S Sudarshan. 5a Ed.
Elsevier, 2006.

Sistemas de Banco de Dados (Cap. 17). Ramez

Elmasri e Sham Navathe. 4a Ed. Pearson, 2005.

Controle de Concorrncia e Distribuio de Dados:

A teoria clssica, suas limitaes e extenses
modernas. Joo Eduardo Ferreira e Marcelo Finger.
So Paulo: Escola Brasileira de Computao, 2001.