Bases de Dados - w3.ualg.ptw3.ualg.pt/~pserende/DATABASES/DATABASES/TEORICAS/PDF/8-SQL... · Uma...

Bases de Dados

PostgreSQL, MySQL e PhpTransações

P. Serendero, 2011-13

PostgreSQL e Php: transações

Os comandos SQL utilizados nalgumas aulas práticas e mostrados aqui foram feitos num interpretador de comandos: >psql.

O prompt do Mysql: >mysql. Exemplos tirados da Web

Para desenvolver aplicações é preciso inserir os comandos de SQL na linguagem de programação escolhida.

Operandos SQL "Embebidos" na linguagem de app.

Neste módulo mostramos como fazer chamados sql desde a linguagem Php


O Php é uma linguagem interpretada. “scripting language”

PHP, é a sigla de Hypertext Preprocessor“, Lerdorf 1995

Uma linguagem open-source para utilização geral, especialmente adaptada para desenvolvimento Web

Pode ser embebida em HTML.

Uma linguagem que funciona no lado do servidorInterpretada no web server com um processador

A sintaxe vem de C, Java, e Perl

O principal objetivo desta linguagem é permitir escrever páginas web dinamicamente geradas

Manual. http://www.php.net/manual/en/index.php


scripting language: uma linguagem de programação que permite o controlo de uma ou mais aplicações

Os chamados a SQL são interpretados previamente por um pre-processador

Consultar o Manual do PostreSQL: Programer’s Guide Client Interfaces

Em php existem extensões do PostgreSQL . Incluem sql embebido

Ver http://php.net/manual/en/book.pgsql.php /


No MySQL consultar:

Ler OBRIGATORIAMENTE

1) introdução:

2) Principais características:

http://dev.mysql.com/doc/refman/5.7/en/features.html


ANTES de utilizar a BD é preciso abrir. No fim devemos fecharAbrir o servidor de base de dados

<?php //php embebido em html

include '/dir1/dir11/bibliotecas/biblio-1.php'; $db = dbconnect(); //ligar a bd de dcbm if (!$db) { printf("<p>Erro ao abrir a Base de Dados. Contactar o Administrador da BD :).</p> \n"); exit(); }

pg_close($db); // fechar a bd no fim?>

PostgreSQL e Php: transações<?phpfunction dbconnect()//--------------------------{ $hostname= "localhost"; $db_name= “nome-bd"; $db_user = “postgres"; $user_psw= “lasdflakjasdfj";

$connection_string ="host=$hostname dbname = $db_name user =$db_user password = $user_psw";

$db = pg_connect($connection_string); // abrir a BD PostgreSQL desde php

if (!$db) { printf("<p> Não há ligação com a base de dados. Ensaiar mais tarde. </p>\n"); exit(); } return $db;}?>

MySQL e Php: open DB

Criando uma nova conexão com a Base de Dados:

mysqli_connect(host, username, password, dbname)

//criar a conexão$conexao=mysqli_connect("localhost","paula","ZyX123","minha_db");

// verificar a conexãoif (mysqli_connect_errno($conexao)) { echo "Erro na conexão com a BD: " . mysqli_connect_error(); }?>

BD: SEMPRE VERIFICAR SUCESSO DAS INSTRUÇÕES

MySQL e Php: close DB

Fechando uma conexão existente:

//criar a conexão$conexao=mysqli_connect("localhost","paula","ZyX123","db1");

// verificar a conexãoif (mysqli_connect_errno($conexao)) { echo "Erro na conexão com a BD: " . mysqli_connect_error(); }

mysqli_close($conexao); //fechamos a BD?>

mysqli = instruções melhoradas para o php 5.0

Várias BD

Este PC

PostgreSQL e Php: interrogar

$OK = pg_query ($db, $instruçao-sql);

Executa o query indicado na string $instruçao-sql na base de dados indicada na ligação prévia a base de dados representada aqui pela variável $db

Em caso de erro, devolve NULL (pode-se verificar sempre var $OK)

Pormenores do erro se podem encontrar na função pg_last_error() se a ligação a bd era válida

O primeiro parâmetro é opcional, mas se recomenda incluirAtenção: não utilizar acentos ou outros nos nomes das variáveis

PostgreSQL e Php: SELECT

…if ($nif-tripulante) { $query_tripulante = "SELECT * FROM tripulante WHERE nif = ‘$nif-tripulante‘ "; $res = pg_query($conexao, $query_tripulante); if ($res) { $c = pg_fetch_array($res); echo $c[0] . " <- Nome\n"; echo $c[1] . " <- Morada\n"; } else error …

pg_fetch_array — Carrega um tuplo como um array. para referenciar os elementos do array, podem-se utilizar índices ou os nomes dos atributos da tabela


function valida_chave($db, $tabela, $campo, $chave){ //------------------------------------------------------------------ $instr = "SELECT * FROM $tabela WHERE $campo = '$chave' "; $id = pg_query($db, $instr); $row = pg_fetch_row($id); if ($row[0] != $chave) return 0; else return 1; } //----------------------------------------------------------------------

pg_fetch_row: semelhante a pg_fetch_array só que apenas refere os elementos utilizando índicesIsto é, devolve um arranjo numerado com índices


//----------------------------------------------------------------function get_nome_disciplina($db, $id_disciplina){ $query = "SELECT * FROM grupo_curricular WHERE id = '$id_disciplina' "; $resultado = pg_query($db, $query); if ($resultado) { $r = pg_fetch_array($resultado); return $r['nome']; }else return NULL:} //-------------------------------------------------------------------------

MySQL e Php: SELECT<?php$nome = 'laura'; $apelido = 'gomes';

$consulta = sprintf("SELECT nome, apelido, morada, idade FROM aluno WHERE nome='%s' AND apelido='%s'", mysql_real_escape_string($nome), mysql_real_escape_string($apelido));

// Executar a pesquisa$resultado = mysql_query($consulta);<?php

mysql_real_escape_string() função da biblioteca de MySQL, que antepõe barras invertidas aos seguintes caracteres: \x00, \n, \r, \, ', " e \x1a.Se os dados a inserir são binários, sempre deve ser utilizada.Mais segura para os dados enviados ao servidor para consultas

MySQL e Php: SELECT// continuando

...

$resultado = mysql_query($consulta); X (mysql_query obsoleta desde o Php 5.5.0. Utilizar mysqli_query)

// Comprobar o resultado, utilizado para depurações

if (!$resultado) { $mensajem = 'Consulta não válida: ' . mysql_error() . "\n"; die($mensagem); }else $mensajem = 'Consulta feita: ' . $consulta;...

Função die(): imprime uma mensagem e termina o script

MySQL_fetch_array()// Utilizando os dados extraidos da BD://Utilizar alguma das funções de resultados do mysql// Consultar: mysql_result(), mysql_fetch_array(), mysql_fetch_row(), etc.

while ($fila = mysql_fetch_array($resultado, MYSQL-ASSOC)) { echo $fila['nome']; echo $fila['apelido']; echo $fila['morada']; echo $fila['idade']; }// no fim liberamos os recursos utilizados,mysql_free_result($resultado);?>

mysql_fetch_array : um arranjo com os dados do query devolvidos em $ resultado. Tipo resultado devolvido: MYSQL_ASSOC, MYSQL_NUM, MYSQL_BOTH.

MySQL_fetch_array()

<?phpmysql_connect("localhost", "user1l", "meu-passw") or //ligar ao server die("Não foi possível conectar: " . mysql_error());

mysqli_select_db("minha-bd"); //ligar a bd que precisamos

$resultado = mysqli_query("SELECT id, nombre FROM mitabla");

while ($fila = mysql_fetch_array($resultado, MYSQL_NUM)) { printf("ID: %s Nombre: %s", $fila[0], $fila[1]); }

mysqli_free_result($resultado); //libera toda a memória de $resultado?>

INSERIR tuplos dinamicamente: HTML

<html> Iniciar um bloco de html<head> <title>DEEI-UALG</title> <link rel="shortcut icon" href=“/deei/icon.ico" /> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /></head> <form name =“utilizador" action=“validar-user.php" method="POST" enctype="application/x-www-form-urlencoded"> Nome Utilizador: <INPUT TYPE = "text" value="" name ="usuario” /> Password: <INPUT TYPE = PASSWORD value ="" name="passwd” /><p> <input type="submit" value ="Validar" name = "go"></p></form></html>

Após submit, HTML carrega todos os dados de <input> no array $_POSTMuito importante: POST e action: o nome da função php a executar

INSERIR tuplos dinamicamente

***** este é o programa validar-user.php <?php …$usuario = $_POST['usuario']; $passw = $_POST['passw'];

$nivel = $_POST['nivel']; $data = $_POST['data']; date_default_timezone_set("Europe/Lisbon"); $data = date();if (verifica_utilizador($db, $usuario)) //verifica se utilizador existe

show_error ("Já existe um usuario com este nome. Favor trocar por um outro.",1);

$sqlcmd = "INSERT INTO utilizador ( usuario, passw, data) VALUES ('$usuario', '$passw', '$data')";

$OK = mysqli_query($db, $sqlcmd); //inserir registo na bd. pg_close($db); //após inserção, fechar a BD if (!$OK) show_error(1); else mandar_aviso("Novo Utilizador(a): $usuario - criado(a)", 4);?>

PostgreSQL e Php: UPDATE

SQL: UPDATE utilizadorSET passw = ‘D67N9#%BB’, data = ‘11/1172011’,WHERE usuario = “patricio”;---------------------------Php -----------------------------------------$usuario = $_POST['usuario']; $passw1 = $_POST['passw1'];

$passw2 = $_POST['passw2'];if ($passw1 != passw2)

show_error(“password incorrecto. Repetir sff",1);

$cmd = "UPDATE utilizador SET passw ='$passw1', WHERE usuario = '$usuario' ";If ( pg_query($db, $cmd)) echo ‘user alterado com sucesso’;

PostgreSQL e Php: APAGAR

SQLDELETE FROM climatologia WHERE city = ’London’;

--------------------------Php -----------------------------------------------

function apagar_registo($db, $bi){ $apagar = "DELETE FROM socio WHERE bi = '$bi'"; $OK = pg_query($db, $apagar); if ($OK) return("Registo sócio nº BI: $bi apagado. \n"); else return(“erro: Registo socio nº BI: $bi NÃO apagado\n");

Gestão de transações nas BD


Uma Base de Dados tem sempre acessos concorrentes: muitos utilizadores fazendo insert, update, delete simultaneamente

Para cada utilizador, o SGBD abre um novo processo. Uma nova sessão até este sair da BD. (fechar)

Cada operação que modifica a BD é uma transação

Como assegurar a integridade e coerência da BD?

Como assegurar a recuperação da BD quando há um crash?

Exemplos críticos: reservas bilhetes online, bancos, bolsa


Recuperação (recovery)Fundamentalmente significa poder recuperar a BD a um estado correcto após algum falhanço que deixa a BD num estado não correcto

A chave da recuperação: a redundancia. Recuperamos a partir de informações armazenadas previamente fazendo redundancia da BD

A gestão das transações de qualquer BD, relacional ou não, exige a capacidade de recuperação.

Gestão de transações na BD

Uma transação é uma sequência de operações SQL: uma unidade lógica de trabalho

Esta sequência é tratada como um todo

Por defeito, uma instrução de SQL é uma transação

As transações obedecem as propriedades “ACID":

• Atomicity (Ver na introdução)• Consistency• Isolation• Durability


Transações (comandos no MySQL)

START TRANSACTION [WITH CONSISTENT SNAPSHOT]BEGIN [WORK] Inicia uma transação

COMMIT [WORK] [AND [NO] CHAIN] [[NO] RELEASE]Termina uma transação. BD actualizada. Mudança é permanente

ROLLBACK [WORK] [AND [NO] CHAIN] [[NO] RELEASE]Termina uma transação. BD NÃO actualizada. (“undo”)

SET autocommit = {0 | 1} Coloca o commit em “piloto automático”Por defeito MySQL utiliza o modo 1: commit automatico


O que se passa quando o acesso é concorrente e a um mesmo registo da BD?

Por exemplo, a sua conta bancária: Você anda a tirar 30€ da sua conta, mas o seu pai ainda não fez depósito também na sua conta

Como deveríam acontecer as coisas? Qual transação primeiro?A conta do seu pai é actualizada depois de lhe depositar os 30€

Que se passa se a sua irmã sabe a sua conta e está intentar retirar 20€ no mesmo momento que você pretende levantar os 30€ que precisa?

Que se passa se a BD do banco “crasha” no meio disto tudo?

Gestão de transações na BDUma transação pode envolver uma sequência de operações na BD

Por exemplo, você quer transferir 100€ da conta 120 para a conta 350

O propósito final do transaction manager da BD e transformar o estado correcto da BD antes da transação, num outro estado correcto da BD após a operação

Em pseudo código queremos algo assim: –->

Gestão de transações na BDBEGIN TRANSACTION

1) UPDATE conta 120. saldo-final = saldo-final – 100; Se operação não funcionar ir para UNDO;

2) UPDATE conta 350. saldo-final = saldo-final + 100; Se operação não funcionar ir para UNDO;

COMMIT Ir para TERMINAR;

UNDO: ROLLBACK;

TERMINAR: RETURN;


O objectivo como se pode ver, é claramente não permitir efectuar só um update. Ou os dois são feitos, ou nada é feito. Caso contrário a BD ficava num estado incorrecto

Esta é a propriedade de atomicidade das transações

BEGIN TRANSACTION

1) UPDATE conta 120. saldo-final = saldo-final – 100; Se operação não funcionar ir para UNDO;

2) UPDATE conta 350. saldo-final = saldo-final + 100; Se operação não funcionar ir para UNDO;

COMMIT Ir para TERMINAR;

UNDO: ROLLBACK;

TERMINAR: RETURN;


A operação COMMIT representa uma transação feita com sucesso. A BD está agora novamente num estado correcto.

A operação ROLLBACK representa o contrário. Algo correu mal e a BD poderia estar num estado incerto

Como é possível fazer desfazer um update, ou refazer a operação iniciada se no meio o sistema falhou?

LOG RECORD: o sistema leva conta sequencialmente de todas as transações dum periodo de tempo.(before-after images)

Quando o sistema recuperar, pode desfazer ou refazer as operações que ficaram pendentes


Atomicidade:

Sistema deve garantizar execução de atomicidade de instruções individuais. Especialmente no modelo relacional onde as operações são feitas a nível de vários tuplos de uma vez

A operação não pode falhar no meio e deixar incorrecta a BD: uns tuplos actualizadas e outros não

Ou tudo feito ou nada feito


Recovery (Recuperação)Uma transação não só representa uma unidade de trabalho: representa igualmente uma unidade de recuperação

O SGBD deve garantizar poder recuperar a BD no seu estado correcto original após um falhanço no meio duma transação

Update primeiro feito nos buffers da RAM. O sistema garantiza que após COMMIT vai actualizar fisicamente as tabelas envolvidasPortanto se houver crash, não é necessário fzer UNDO

Caso houver um crash após COMMIT e antes de actualizar fisicamente a BD, como recuperar

LOG FILE e write-ahead log rule: Primeiro as transações são escritas no ficheiro log. Logo começa a transação.

Este log file permete refazer operações pendentes após o crash

Gestão de transações na BDDois tipos de categorias de falhanço do sistema:

Falhas do sistema afectando todas as transações em progresso (falta energia por exemplo): soft crash

Falhas dos recursos (falha do disco duro). Hard crashDestroi parcial ou totalmente a BD

Em ambos os casos os conteúdos da RAM perdem-se: os buffers utilizados pelo SGBD

Neste contexto, quais transações UNDO?Quais voltar a fazer?

O SGBD utiliza checkpoint records: a cada intervalo após algumas transações feitas, o sistema faz uma marca no tempo para indicar que até alí, tudo bem

Gestão de transações na BDTempo checkpoint falha sistema tr

ansaçoes

1

2

3

4

5

Tomada do livro do J.C. Date

Como resolve o sistema o problema destas transações após restart?Está claro que transações 3 e 5 tem que ser UNDOTransações 2 e 4 devem ser refeitas novamente (buffers da RAM)


O sistema funciona com 2 listas: UNDO e REDO

Lista UNDO igual a todas as transações do ultimo checkpoint

Lista REDO vazia

Começar verificar o sistema após o checkpoint

Se o registo de log encontra BEGIN TRANSACTION coloque esta

transação na lista de UNDO

Se o registo de log encontra uma transação COMMIT, mover a

transação da lista de UNDO para a lista de REDO

Quando terminar verificar o registo de log, as listas identificam

transações 3 e 5 na lista de UNDO e 2 e 4 na lista de REDO


Numa operação de inserção fazer LOCK na tabela:

BEGIN WORK;

LOCK TABLE tripulante IN SHARE MODE;SELECT id_tripulante FROM tripulanteWHERE nome = ’Alberto Martins Lopes’;

INSERT INTO tripulante VALUES ( _id_ , ’914563312’);COMMIT WORK;

Isolar a tabela com a chave primária no modo SHARE, quando se pretende actualizar uma tabela onde ela é chave estrangeira

Atenção: no standard SQl não há lock table set transaction


Numa operação de apagar fazer LOCK na tabela com a chave primária:

BEGIN WORK;

LOCK TABLE casa IN SHARE ROW EXCLUSIVE MODE;DELETE FROM descricao_casa

WHERE id IN (SELECT id FROM casa WHERE nivel < 5);

DELETE FROM casa WHERE nivel < 5;

COMMIT WORK;


Exemplo:Na conta do seu pai num depósito de 30€ para sim, o banco terá as instruções:

BEGIN WORK;UPDATE conta SET saldo = saldo - 30WHERE numero = 3334712; //a conta do seu pai

UPDATE contaSET saldo = saldo + 30WHERE numero = 8885990; // a sua contaCOMMIT WORK;Se algo correr mal, o dinheiro não será posto na sua conta, mas também não será levantado da conta do seu pai

Gestão de transações na BDOs utilizadores (programas) só vem resultados de transações que fizeram COMMIT

•E que acontece se no meio da transação do seu pai, a sua mãe que também tem acesso a conta do seu pai fazer uma transação e o programa de aplicação no processo dela utiliza igualmente o COMMIT?• SQL tem 4 níveis de isolamento das transações:

1. SERIALIZABLE2. REPEATABLE READ3. READ COMMITTED4. READ UNCOMMITTED

Compete ao programador especificar o nível de isolamento pretendido


Nível:1.SERIALIZABLE2. REPEATABLE READ3. READ COMMITTED4. READ UNCOMMITTED

Escrevemos:

SET TRANSACTION ISOLATION LEVEL <nível>


SERIALIZABLE

Se o programa da sessão do seu pai está a correr com o nível de isolamento SERIALIZABLE, só vai ver o seu saldo final depois a sessão da sua mãe que entrou pelo meio terminar pela sua vez.

No meio delas não vai ver nada diferente do estado anterior da sua conta antes do inicio destas duas transações feitas por dois processos concorrentes


READ COMMITTED

Neste caso, é possível ver o estado ‘parcial’ da conta após a primeira destas transações serem tratadas

REPETEABLE READ

semelhante ao anterior a diferencia é que se um tuplo é lido uma vez, então terá de ser forçosamente devolvido se a leitura for repetida


READ UNCOMMITTED

Se a transação utilizar esta opção então pode ler os dados transitórios que possam ter sido escritos por outras transações

Por exemplo, poderá ler um saldo inferior na conta, mesmo se a transação concorrente que levantava dinheiro “crashar” no meio e a aplicação fazer um ROLLBACK


No caso do PostgreSQL só existem as opções

SERIALIZABLE e READ COMMITTED

SERIALIZABLE Oferece um maior nível de isolamento.Faz como se as transações tivessem sido feitas sequencialmente e não concorrentemente.

READ COMMITTED dá menos isolamento, mas é mais eficiente de implementar pelo SGBD. Pretende manter a consistência dos dados

Ler sobre concurrency control no manual do PostreSQL

Gestão de transações

fim do módulo

Bases de Dados - w3.ualg.ptw3.ualg.pt/~pserende/DATABASES/DATABASES/TEORICAS/PDF/8-SQL... · Uma...

Documents

Transcript of Bases de Dados - w3.ualg.ptw3.ualg.pt/~pserende/DATABASES/DATABASES/TEORICAS/PDF/8-SQL... · Uma...