Você está na página 1de 21

Transações e Concorrência em

Banco de Dados

Prof. Roberto Ribeiro Rocha


Transações

● Definição de Transação:
– Conjunto de operações que forma uma unidade lógica
de processamento no BD
– Deve ocorrer de maneira completa e integral
● Uma transação inclui uma ou mais operações de acesso
ao Banco de Dados – inserção, exclusão, alterações ou
consultas
Recursos e Granularidade

● Recursos (ou item de dados)


– campo, registro (tupla), bloco do disco, arquivo, ou o
Bando de Dados inteiro
● Granularidade: tamanho de um recurso ou item de dados
– Granularidade Fina: recursos pequenos
– Granularidade Grossa: recursos grandes
Transações

● Hoje os sistemas são multi-usuários.


● Há necessidade de Controle de Concorrência

Operações seriais Operações intercaladas


Estrutura da Transação

T1: Transação T1
Início
      //lê um item de dado X do BD e guarda em A
     A = ler_item(X)
     processa(A)
      //escreve o valor de A em um item do BD X
     escrever_item (X,A)
Fim
Finalização de uma Transação
● Commit Transaction → sucesso na execução
– Encerramento da transação com sucesso;
– Torna as atualizações permanentes no Banco de Dados;
– Todas as operações da transação são gravadas
permanentemente
● Rollback Transaction → problema na execução
– Término da transação com erro;
– Retorna o Banco de Dados à posição anterior à transação;
– A transação NÃO terá nenhum efeito sobre o Banco de Dados
ou outras transações
Tipos de Falhas

● Falhas de hardware, software ou rede


● Erro durante a execução de alguma operação na
transação: estouro de variáveis, operação inválida, etc.
● Condições de exceção detectadas pela transação
(necessitam o cancelamento da mesma): saldo
insuficiente em conta
● Causas externas: falta de energia, temperatura, ar-
condicionado, etc.
Propriedades da Transação

● Propriedades ACID
– Atomicidade
– Consistência
– Isolamento
– Durabilidade
Propriedades da Transação

● Atomicidade
– A transação é considerada como uma unidade
atômica
1) Ela é executada em sua totalidade
2) Não pode executar somente partes
– Caso não for possível executar em sua totalidade → as
operações são desfeitas
Propriedades da Transação

● Consistência
– O programador define as regras de consistência
– O estado de um Banco de Dados sempre deve ficar
consistente após uma transação;
– BD consistente → transação → BD consistente
Propriedades da Transação

● Isolamento
– A execução de uma transação não pode ser afetada
por outras transações
– Mesmo quando elas executam concorrentemente
– O estado do BD deve ser equivalente como se
transações fossem executadas uma de cada vez.
– Tudo deve se passar como se todos os recursos
estivessem disponíveis
Propriedades da Transação

● Durabilidade
– Os efeitos de uma transação confirmada (commit) não
podem ser perdidos
Planos de Execução das Transações
● Define a ordem de execução das operações das
transações
● Mais utilizado quando se tem 2 ou mais transações

T1: Transação T 1
A=ler_item (X); T2: Transação T 2
A = A - N; C=ler_item (X);
escrever_item (X,A); C = C + M;
B=ler_item (Y); escrever_item (X,C);
B = B + N;
escrever_item (Y,B);
Planos de Execução das Transações

● Planos Seriais:
– todas as operações das transações são executadas
consecutivamente
● Planos Não-Seriais:
– as operações das transações executadas
concorrentemente
● Escalonamento de plano de execução
– analisa o plano e define a melhor forma de executá-lo
● Usa técnicas de bloqueio de recursos
– impede que múltiplas transações acessem os itens
concorrentemente
Exemplo: Plano de Execução Serial

A=ler_item (X);
A = A - N;
escrever_item (X,A);
B=ler_item (Y);
B = B + N;
escrever_item (Y,B);

C=ler_item (X);
C = C + M;
escrever_item (X,C);
Exemplo: Plano de Execução Não-Serial

A=ler_item (X);
A = A – N;
escrever_item (X,A);
C=ler_item (X);
C = C + M;
escrever_item (X,C);
B=ler_item (Y);
B = B + N;
escrever_item (Y,B);
Exemplo: Plano Não-Serial Inválido

A=ler_item (X);
A = A – N; //vai ler o X desatualizado
C=ler_item (X);
//atualiza o X
escrever_item (X,A);
B=ler_item (Y);
B = B + N;
escrever_item (Y,B);
C = C + M;
escrever_item (X,C);
Exercício
● Escreva 3 (três) possíveis combinações (não-seriais) de
execução das transações T1 e T2 abaixo de forma que o
resultado final da execução de ambas transações seja
consistente.
T1: Transação T 1
A=ler_item (X); T2: Transação T 2
A = A - N; C=ler_item (X);
escrever_item (X,A); C = C + M;
B=ler_item (Y); escrever_item (X,C);
B = B + N;
escrever_item (Y,B);
Exercícios

● Dê exemplos de recursos de baixa granularidade e de alta


granularidade.
● Considerando as duas transações abaixo, escreva duas
possíveis combinações (não-seriais) de execução dos
comandos.
– T1 → a=read(x), write(y,a)
– T2 → a=read(x), a++; write(x,a), b=read(y), write(x,b)
● Comente sobre a relação entre o controle de concorrência
e a granularidade dos itens de dados?
Exercício
● Escreva os comandos que foram efetivados no Banco de
Dados após a execução de cada conjunto de instruções:
● Execução 1: ● Execução 2:
– Comando 1 – Comando 1
– Rollback – Comando 2
– Comando 2 – Commit
– Commit – Comando 3
– Comando 3 – Rollback
– Comando 4 – Comando 4
– Rollback – Commit
– Comando 5 – Comando 5
– Comando 6 – Comando 6
– Commit – Rollback
– Comando 7 – Comando 7
– Rollback – Commit
Fim

● Obrigado!