Proposição da Lista 1 - INF-Unioeste

BANCO DE DADOS II
Lista 1
(Transações e Controle de Concorrência)
Professor Responsável: Clodis Boscarioli
Série: 5ª Ano Letivo: 2008 Data de Proposição: 11/03/2008
1-) Quais dos seguintes planos é serializável (por conflito)? Para cada plano serializável,
determine os planos seriais equivalentes.
(a) r1 (X); r3 (X); w1(X); r2(X); w3(X)
(b) r1 (X); r3 (X); w3(X); w1(X); r2(X)
(c) r3 (X); r2 (X); w3(X); r1(X); w1(X)
(d) r3 (X); r2 (X); r1(X); w3(X); w1(X)
2-) Considere as três transações, T1, T2 e T3, e os planos S1 e S2 abaixo. Trace os grafos
de precedência de serialidade para S1 e S2 e diga se são serializáveis ou não. Se um plano
for serializável, escreva o(s) plano(s) serial(is) equivalente(s).
T1: r1(X); r1(Z); w1(X);
T2: r2(Z); r2(Y); w2(Z); w2(Y);
T3: r3(X); r3(Y); w3(Y);
S1: r1(X); r2(Z); r1(Z); r3(X); r3(Y); w1(X); w3(Y); r2(Y); w2(Z); w2(Y);
S2: r1(X); r2(Z); r3(X); r1(Z); r2(Y); r3(Y); w1(X); w2(Z); w3(Y); w2(Y);
3) Quantos planos seriais existem para as três transações abaixo? Quais são? Qual o
número total de planos possíveis?
T1 T2 T3
ler_item (X); ler_item (Z); ler_item (Y);
escrever_item (X); ler_item (Y); ler_item (Z);
ler_item(Y); escrever_item (Y); escrever_item (Y);
escrever_item (Y); ler_item (X); escrever_item (Z);
escrever_item (X);
4-) Liste todos os planos possíveis para as transações T1 e T2 abaixo e determine quais são
conflito serializáveis (correto) e quais não são.
T 1 T 2
ler_item (X);
ler_item (X);
X := X – N; X := X + M;
escrever_item (X); escrever_item (X);
ler_item (Y);
Y := Y + N;
escrever_item (Y);

5-) Defina transação no contexto de um banco de dados. Qual a importância do
gerenciamento de transações?
6-) Uma transação quando executada em um banco de dados deve prover ao usuário
transparência de concorrência e transparência de falha. Explique o que isto significa.
7-) Toda transação deve possuir quatro propriedades desejáveis, não independentes entre
si, que são ACID (Atomicidade, Consistência, Isolamento e Durabilidade). Explique cada
uma delas.
8-) Reescreva as transações abaixo utilizando as operações lock_item e unlock_item.
Transação 1 Transação 2
read_item (x)
read_item (x)
x = x – n
x = x + m
write_item (x)
write_item (x)
read_item (y)
y = y + n
write_item (y)
9-) Explique sucintamente o protocolo two phase locking. Como ele garante serialização dos
escalonamentos?
10-) Considere as seguintes transações:
T31: read (A);
read (B);
if A = 0 then B := B + 1;
write (B);
T32: read (B);
read (A);
if B = 0 then A := A + 1;
write (A);
Adicione instruções de bloqueio e desbloqueios às transações T31 e T32 de modo que
observem o protocolo de bloqueio em duas fases. A execução dessas transações pode
resultar em deadlock?
11-) Quais os benefícios proporcionados pelo bloqueio em duas fases severo? Quais as
desvantagens resultantes?
12-) Quando uma transação é revertida sob a ordenação de timestamp, ela recebe outro
timestamp. Por que não simplesmente manter seu timestamp antigo?
13-) Em bloqueio de granularidade múltipla, qual a diferença entre bloqueios implícito e
explícito?
14-) Considere as seguintes transações definidas em SQL. Ambas as transações alteram a
tabela Banco (Conta, Saldo).

BEGIN TRANSACTION T1
UPDATE Banco
SET Saldo = ((SELECT Saldo FROM Banco WHERE Conta = 10) – 100)
WHERE Conta = 10
UPDATE Banco
SET Saldo = ((SELECT Saldo FROM Banco WHERE Conta = 20) + 100)
WHERE Conta = 20
COMMIT TRANSACTION T1
BEGIN TRANSACTION T2
UPDATE Banco
SET Saldo = ((SELECT Saldo FROM Banco WHERE Conta = 20) – 200)
WHERE Conta = 20
UPDATE Banco
SET Saldo = ((SELECT Saldo FROM Banco WHERE Conta = 30) + 200)
WHERE Conta = 30
COMMIT TRANSACTION T2
(a) As instruções de leitura e escrita de T1 são as seguintes:
read(saldo_10)
saldo_10 := saldo_10 – 100
write(saldo_10)
read(saldo_20)
saldo_20 := saldo_20 + 100
write(saldo_20)
Seguindo o exemplo acima, obtenha as instruções de leitura e escrita dos dados da
transação T2.
(b) Defina uma escala de execução serializável de T1 e T2;
(c) Proponha escalas de execução concorrente serializáveis usando os protocolos:
(i) bloqueio em duas fases;
(ii) timestamps;
(d) Verifique se existe a possibilidade de deadlock ao executar T1 e T2 de modo
concorrente.
(e) Suponha uma nova transação T3 concorrente com T1 e T2 e mostre, através de uma
escala de execução, que existe a possibilidade de deadlock ao usar o bloqueio em duas
fases:
BEGIN TRANSACTION T3
UPDATE Banco
SET Saldo = ((SELECT Saldo FROM Banco WHERE Conta = 30) – 200)
WHERE Conta = 30
UPDATE Banco
SET Saldo = ((SELECT Saldo FROM Banco WHERE Conta = 10) + 200)
WHERE Conta = 10
COMMIT TRANSACTION T3

(f) Simule a execução da escala que você definiu no item (e) utilizando os seguintes
esquemas de prevenção de deadlock:
(i) esquema esperar-morrer; TS(T1) = 5, TS(T2) = 3 e TS(T3) = 8
(ii) esquema ferir-esperar; TS(T1) = 3, TS(T2) = 2 e TS(T3) = 1
15-) Mostre que há escalas de execução possíveis sob o protocolo de bloqueio em duas
fases, mas não são possíveis sob o protocolo de timestamp e vice-versa.
16-) Aplique o algoritmo de ordenação por timestamp para os planos de execução abaixo e
determine se o algoritmo permitirá a execução desses planos.
a-)
Transação T1 Transação T2 Transação T3
ler_item (Z)
ler_item (Y)
escrever_item (Y)
ler_item (Y)
Tempo
ler_item (Z)
ler_item (X)
escrever_item (X)
escrever_item (Y)
escrever_item (Z)
ler_item (X)
ler_item (Y)
escrever_item (Y)
escrever_item (X)
b-)
Tempo
Transação T1 Transação T2 Transação T3
ler_item (Y)
ler_item (Z)
ler_item (X)
escrever_item (X)
escrever_item (Y)
escrever_item (Z)
ler_item (Z)
ler_item (Y)
escrever_item (Y)
ler_item (Y)
escrever_item (Y)
ler_item (X)
escrever_item (X)
17-) Prove que o protocolo de bloqueio básico em duas fases garante a serialização de
conflito do plano de execuções.
(Indicação: mostre que, se um grafo de serialização para o plano de execução possui um
ciclo, então pelo menos uma das transações participantes no plano de execução não
obedece ao protocolo de bloqueio em duas fases).