You are on page 1of 25

PHP Data Objects

O PDO, ou PHP Data Objects, é uma camada de abstração
de acesso a dados, que significa que, independente do
banco de dados que você está utilizando, poderá usar as
mesmas funções para executar queries e consultar dados.

Além de tornar o código fácil de manter, o PDO não atrela a
aplicação a um SGBD específico – o que não impede de usá-
lo para implementar funcionalidades específicas de cada um
deles sempre que necessário.

2

PHP Data Object 3 .

O construtor da classe PDO espera 3 parâmetros <?php // MySQL $db = new PDO(“mysql:host=daileon.dbname=jaspion”. Conexão A conexão com o banco de dados é feita no construtor da classe PDO.dbname=jaspion”. Para desconectar. // PostgreSQL $db = new PDO(“pgsql:host=daileon. além das credenciais de acesso. Uma vez instanciado o objeto PDO. “root”. e as informações de conexão são passadas na forma de uma DSN (ou data source name). basta destruir o objeto: unset($db) 4 . “root”. “123456”). “123456”). estamos conectados ao banco de dados.

podemos usar métodos deste objeto para manipular comando no SGBD. Existe o método exec(). “123456”). Agora. teremos um objeto da classe PDO. 5 . $db->exec(“CREATE TABLE posts (id INT AUTO_INCREMENT.dbname=jaspion”. titulo VARCHAR(255) conteudo TEXT)”). que executa um comando SQL e retorna o número de linhas afetadas por este comando: <?php $db = new PDO(“mysql:host=daileon. o método retorna zero. “root”. Executar comandos Após conectar com o banco de dados. Caso nenhuma linhas seja afetada.

$dados = $db->query(“SELECT * FROM posts”). já que são uma coleção de dados retornados pela nossa consulta. 6 . “root”.dbname=jaspion”. precisamos usar outro método. Realizar consultas O método exec() pode executar qualquer comando SQL em nosso banco. quando precisamos fazer consultas e manipular valores de retorno do banco. <?php $db = new PDO(“mysql:host=daileon. Porém. Este método se chama query(). Estes objetos podem ser iterados. “123456”). e retorna um objeto da classe PDOStatement contendo os resultados da consulta feita.

sendo que: ● fetch() retorna apenas um resultado da consulta. 7 . <?php $db = new PDO(“mysql:host=daileon.dbname=jaspion”. dependendo dos parâmetros passados. print_r($todos). Realizar consultas Para acessar os dados contidos no objeto PDOStatement. Estes métodos podem retornar arrays ou objetos. ● fetchAll() retorna todos os resultados. $dados = $db->query(“SELECT * FROM posts”). $todos = $dados->fetchAll(). print_r($um). “123456”). fazemos uso dos métodos fetch() e fetchAll(). “root”. $um = $dados->fetch().

$associativo = $dados->fetchAll(PDO::FETCH_ASSOC). Podemos escolher se vamos recuperar apenas índices associativos. $numerico = $dados->fetchAll(PDO::FETCH_NUM). $dados = $db->query(“SELECT * FROM posts”). “123456”). Realizar consultas Por padrão. <?php $db = new PDO(“mysql:host=daileon. ou se apenas índices numéricos. “root”. fetch() e fetchAl() retornam tanto índices associativos (nomes das colunas) quanto índices numéricos (posição da coluna de acordo com a sua ordem na tabela). print_r($associativo). 8 .dbname=jaspion”. print_r($numerico).

retornarem um objeto anônimo onde as propriedades são as colunas: <?php $db = new PDO(“mysql:host=daileon. $obj = $dados->fetchAll(PDO::FETCH_OBJ). Realizar consultas Podemos configurar os métodos fetch() e fetchAll() para. 9 . ao invés de retornarem um array.dbname=jaspion”. $dados = $db->query(“SELECT * FROM posts”). “123456”). echo $obj->titulo. “root”.

● Transactions proporcionam uma forma de recuperar informações a partir de um desastre. isolamento e durabilidade. toda transaction deve ser ACID compliant. 10 . ter atomicidade. consistência. ● Por definição. ou seja. ● Seu objetivo é isolar programas que acessam o banco de forma concorrente. Transactions ● São uma sequência de operações feitas em um SGBD independente de outras transações. ● Garantem que sempre vamos manipular nosso banco de dados de maneira confiável.

dbname=banco". e ficarão contidos nela. Transactions Podemos definir transações em nossas aplicações com PDO através do comando beginTransaction: <?php $db = new PDO("mysql:host=localhost. $db->beginTransaction(). Eles farão parte da transação. $db->exec(“INSERT INTO logistica (compra) VALUES (5641)”). $db->exec(“UPDATE cliente SET compra = 5641”). Após a chamada deste método. "123456"). "root". todos os comandos feitos não serão automaticamente executados. 11 . $db->exec(“UPDATE pedidos SET compra = 5641”).

12 . Transactions O PDO vai aguardar por um dos métodos abaixo para finalizar a transação: ● commit. para efetivar todos os comandos no banco. // Caso alguma coisa tenha dado errado. <?php // Caso tenha dado tudo certo $db->commit(). podemos desfazer $db->rollback(). para descartar todos os comandos executados. ● rollback.

enquanto são executadas múltiplas vezes com parâmetros diferentes. prepared statements garantem que nenhuma query que foi preparada pode sofrer um ataque de SQL injection. Prepared Statements ● Prepared Statements são comandos SQL pré-construídos. agindo como um cache dinâmico. que podem ser manipulados utilizando parâmetros variáveis. 13 . ● Suas queries só precisam ser lidas uma única vez. ● Isso torna a execução da query muito mais rápida. ● Além do benefício de performance.

Placeholders (?) são como lacunas. usamos um método chamado prepare(). e sim prepará-las para posterior execução. precisamos criar placeholders (ou substitutos). que serão substituídos pelos valores na hora da execução da query. mas não vai executar as queries. 14 . Ele é similar ao exec() e query. Quando criamos prepared statements. Prepared Statements Para preparar nossas queries.

dbname=banco”. “Meu primeiro post!”)). $st = $db->prepare(“INSERT INTO posts (titulo. “root”. passando como parâmetro um array de valores que substituirão os placeholders. Prepared Statements Para executarmos um comando preparado. ?)”). “Meu terceiro post!”)). conteudo) VALUES (?. “123456”). $st->execute(array(“Outro Post”. 15 . usamos o método execute(). “Meu segundo post!”)). <?php $db = new PDO(“mysql:host=localhost. $st->execute(array(“Mais Post”. $st->execute(array(“Meu Post”.

mysql> end // Para chamar a procedure. Veja como criar uma procedure “teste”: # mysql -u root -p mysql> delimiter // mysql> create procedure teste (out parametro INT) mysql> begin mysql> select id from posts where id=1. vamos descobrir como utilizá-la direto no MySQL. 16 . é preciso voltar ao delimitador antigo (1): mysql> delimiter . mysql> call teste(@1). Stored Procedures Antes de conhecermos como usar Stored Procedures utilizando PDO.

agora. executar nossa procedure em nossa aplicação com o auxílio do PDO. 17 . $statement = $db->prepare("CALL teste(@1)"). $um = $statement->execute().dbname=banco". "root". echo $um. Stored Procedures Vamos. "123456"). Para executar procedures. usamos o comando SQL CALL: <?php $db = new PDO("mysql:host=localhost.

$db->setAttribute(PDO::ATTR_ERRMODE. ● PDO::ERRMODE_EXCEPTION. o PDO oferece três modos de controle de erros: ● PDO::ERRMODE_SILENT: para obter erros através dos métodos errorCode e errorInfo (junto com comandos SQL) ● PDO::ERRMODE_WARNING. lança warnings toda vez que problemas são encontrados. "123"). lança exceções toda vez que problemas são encontrados. 18 . <?php $db = new PDO("mysql:host=localhost. Controle de Erros Por padrão. "root". PDO::ERRMODE_EXCEPTION).dbname=banco".

dbname=banco". podemos utilizar o PDO com nosso já conhecido bloco try/catch: <?php try { $db = new PDO("mysql:host=lochsot. $e->getMessage(). "123456"). PDO::ERRMODE_EXCEPTION). "root". $db->setAttribute(PDO::ATTR_ERRMODE. Controle de Erros Quando setamos o atributo PDO::ATTR_ERRMODE como PDO::ERRMODE_EXCEPTION. } 19 . } catch (PDOException $e) { echo "Falha na conexão: " .

php view blog.php app Controller.php lib Livro. Relembrando MVC Agora que já conhecemos PDO como uma robusta opção de acesso a banco de dados.php 20 . vamos relembrar um pouco da estrutura MVC. que estamos aos poucos usando para modelar nosso projeto de e-commerce de livros: index.php post.php View.php Model.php Usuario.

php Caso existam classes.php"). 21 . spl_autoload_register(“libLoad”).php"). new Controller(). index. elas poderão ficar separadas: <?php function appLoad($classe) { require_once("app/$classe. } spl_autoload_register(“appLoad”). } function libLoad($classe) { require_once("lib/$classe.

case 'post': $this->verPost($_GET['id']). Controller. default: $this->home(). break. break. break. switch($_GET['action']) { case 'home': $this->home(). public function __construct() { $this->template = new Template(). } } 22 . public $model. $this->model = new Model().php <?php class Controller { public $template.

} } 23 .php'. $data).php public function home() { $data = $this->model->getContent().php'. $data). $this->template->load('blog. Controller. } public function verPost($id) { $data = $this->model->getPost($id). $this->template->load('post.

'conteudo' => 'duazxczczcxuads' ). } } 24 . } public function getPost($id) { return array( 'titulo' => "Post $id". Model <?php class Model { public function getContent() { return array( 'conteudo' => 'duadsuadsioiuads' ).

php <!DOCTYPE html> <html> <head> <title>Meu Blog</title> </head> <body> <h1> <?php echo $data['titulo']. ?> </body> </html> 25 . ?></h1> <?php echo $data['conteudo'].php <!DOCTYPE html> <html> <head> <title>Meu Blog</title> </head> <body> <h1>Bem vindo ao blog!</h1> <?php echo $data['conteudo']. View blog. ?> </body> </html> posts.