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
 Conexão
A conexão com o banco de dados é feita no construtor da classe
PDO, e as informações de conexão são passadas na forma de
uma DSN (ou data source name), além das credenciais de acesso.
O construtor da classe PDO espera 3 parâmetros
<?php
// MySQL
$db = new PDO(“mysql:host=daileon;dbname=jaspion”, “root”, “123456”);
// PostgreSQL
$db = new PDO(“pgsql:host=daileon;dbname=jaspion”, “root”, “123456”);

Uma vez instanciado o objeto PDO, estamos conectados ao banco

de dados. Para desconectar, basta destruir o objeto:

unset($db)

4
 Executar comandos
Após conectar com o banco de dados, teremos um objeto da
classe PDO. Agora, podemos usar métodos deste objeto para
manipular comando no SGBD.

Existe o método exec(), que executa um comando SQL e retorna o

número de linhas afetadas por este comando:
<?php
$db = new PDO(“mysql:host=daileon;dbname=jaspion”, “root”, “123456”);
$db->exec(“CREATE TABLE posts (id INT AUTO_INCREMENT, titulo VARCHAR(255)
conteudo TEXT)”);

Caso nenhuma linhas seja afetada, o método retorna zero.

5
 Realizar consultas
O método exec() pode executar qualquer comando SQL em nosso
banco.
Porém, quando precisamos fazer consultas e manipular valores de
retorno do banco, precisamos usar outro método.
Este método se chama query(), e retorna um objeto da classe
PDOStatement contendo os resultados da consulta feita.
Estes objetos podem ser iterados, já que são uma coleção de
dados retornados pela nossa consulta.

<?php
$db = new PDO(“mysql:host=daileon;dbname=jaspion”, “root”, “123456”);
$dados = $db->query(“SELECT * FROM posts”);

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

7
 Realizar consultas
Por padrão, 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).
Podemos escolher se vamos recuperar apenas índices
associativos, ou se apenas índices numéricos.

<?php
$db = new PDO(“mysql:host=daileon;dbname=jaspion”, “root”, “123456”);

$dados = $db->query(“SELECT * FROM posts”);

$associativo = $dados->fetchAll(PDO::FETCH_ASSOC);
$numerico = $dados->fetchAll(PDO::FETCH_NUM);

print_r($associativo);
print_r($numerico);

8
 Realizar consultas

Podemos configurar os métodos fetch() e fetchAll() para, ao

invés de retornarem um array, retornarem um objeto anônimo
onde as propriedades são as colunas:

<?php
$db = new PDO(“mysql:host=daileon;dbname=jaspion”, “root”, “123456”);

$dados = $db->query(“SELECT * FROM posts”);

$obj = $dados->fetchAll(PDO::FETCH_OBJ);
echo $obj->titulo;

9
 Transactions

● São uma sequência de operações feitas em um SGBD

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

10
 Transactions
Podemos definir transações em nossas aplicações com PDO
através do comando beginTransaction:

<?php
$db = new PDO("mysql:host=localhost;dbname=banco", "root", "123456");

$db->beginTransaction();
$db->exec(“UPDATE pedidos SET compra = 5641”);
$db->exec(“UPDATE cliente SET compra = 5641”);
$db->exec(“INSERT INTO logistica (compra) VALUES (5641)”);

Após a chamada deste método, todos os comandos feitos não

serão automaticamente executados. Eles farão parte da
transação, e ficarão contidos nela.

11
 Transactions

O PDO vai aguardar por um dos métodos abaixo para finalizar a

transação:
● commit, para efetivar todos os comandos no banco;
● rollback, para descartar todos os comandos executados.

<?php
// Caso tenha dado tudo certo
$db->commit();
// Caso alguma coisa tenha dado errado, podemos desfazer
$db->rollback();

12
 Prepared Statements

● Prepared Statements são comandos SQL pré-construídos, que

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

13
 Prepared Statements

Para preparar nossas queries, usamos um método chamado

prepare().
Ele é similar ao exec() e query, mas não vai executar as queries, e
sim prepará-las para posterior execução.

Quando criamos prepared statements, precisamos criar

placeholders (ou substitutos).
Placeholders (?) são como lacunas, que serão substituídos pelos
valores na hora da execução da query.

14
 Prepared Statements

Para executarmos um comando preparado, usamos o método

execute(), passando como parâmetro um array de valores que
substituirão os placeholders.

<?php
$db = new PDO(“mysql:host=localhost;dbname=banco”, “root”, “123456”);
$st = $db->prepare(“INSERT INTO posts (titulo, conteudo) VALUES (?, ?)”);

$st->execute(array(“Meu Post”, “Meu primeiro post!”));

$st->execute(array(“Outro Post”, “Meu segundo post!”));
$st->execute(array(“Mais Post”, “Meu terceiro post!”));

15
 Stored Procedures
Antes de conhecermos como usar Stored Procedures utilizando
PDO, vamos descobrir como utilizá-la direto no MySQL.
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;
mysql> end //

Para chamar a procedure, é preciso voltar ao delimitador antigo

(1):
mysql> delimiter ;
mysql> call teste(@1);

16
 Stored Procedures

Vamos, agora, executar nossa procedure em nossa aplicação com

o auxílio do PDO. Para executar procedures, usamos o comando
SQL CALL:

<?php
$db = new PDO("mysql:host=localhost;dbname=banco", "root", "123456");
$statement = $db->prepare("CALL teste(@1)");
$um = $statement->execute();

echo $um;

17
 Controle de Erros
Por padrão, 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.
● PDO::ERRMODE_EXCEPTION, lança exceções toda vez que
problemas são encontrados.

<?php
$db = new PDO("mysql:host=localhost;dbname=banco", "root", "123");
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

18
 Controle de Erros

Quando setamos o atributo PDO::ATTR_ERRMODE como

PDO::ERRMODE_EXCEPTION, podemos utilizar o PDO com
nosso já conhecido bloco try/catch:

<?php
try {
$db = new PDO("mysql:host=lochsot;dbname=banco", "root", "123456");
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch (PDOException $e) {
echo "Falha na conexão: " . $e->getMessage();
}

19
 Relembrando MVC
Agora que já conhecemos PDO como uma robusta opção de
acesso a banco de dados, vamos relembrar um pouco da
estrutura MVC, que estamos aos poucos usando para modelar
nosso projeto de e-commerce de livros:

index.php

app
Controller.php
Model.php
View.php
lib
Livro.php
Usuario.php
view
blog.php
post.php

20
 index.php
Caso existam classes, elas poderão ficar separadas:

<?php
function appLoad($classe) {
require_once("app/$classe.php");
}

function libLoad($classe) {
require_once("lib/$classe.php");
}
spl_autoload_register(“appLoad”);
spl_autoload_register(“libLoad”);
new Controller();

21
 Controller.php
<?php
class Controller {
public $template;
public $model;

public function __construct() {

$this->template = new Template();
$this->model = new Model();
switch($_GET['action']) {
case 'home':
$this->home();
break;
case 'post':
$this->verPost($_GET['id']);
break;
default:
$this->home();
break;
}
}

22
 Controller.php

public function home() {

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

23
 Model

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

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

posts.php
<!DOCTYPE html>
<html>
<head>
<title>Meu Blog</title>
</head>
<body>
<h1> <?php echo $data['titulo']; ?></h1>
<?php echo $data['conteudo']; ?>
</body>
</html>

25