Você está na página 1de 17

Como conectar MySQL com PHP via PDO

Veja neste artigo como conectar ao MySQL com PHP via PDO e como utilizar
os recursos desta conexo e forma eficaz.
Neste artigo veremos passo a passo de como realizar a conexo com
o banco de dados MySQL atravs do PHP e como utilizar os recursos
desta conexo. Utilizaremos para este artigo um recurso chamado
PDO, que ir nos auxiliar e facilitar a conexo com o MySQL, mas
antes de comear com a mo na massa importante e necessrio
entender o que o PDO e como ele ir nos auxiliar.

PDO
PDO ou PHP Data Objects define uma interface consistente para
acesso a banco de dados em PHP, ou seja, com o PDO podemos
conectar no s ao MySQL mas tambm a muitos outros bancos
como PostgreSQL, SQLServer, Oracle e assim por diante, basta
utilizarmos o driver adequado.
Voc pode questionar: "Se eu vou utilizar apenas MySQL, no
melhor instalar as bibliotecas dependentes dele e utilizar apenas as
funes relacionadas ao MySQL?" A resposta no. Voc nunca deve
ficar amarrado ao banco de dados em que est trabalhando (este
um princpio simples relacionados a boas prticas), e quando voc
opta por usar as funes nativas do MySQL, sem nenhuma camada
de abstrao (Como o PDO, por exemplo), voc est colocando todo
seu projeto em risco, totalmente dependente de uma tecnologia que
amanh ou depois pode no ser mais vivel.
Imagine se daqui a dois ou trs anos decidido que o banco de
dados da sua aplicao ser migrado de MySQL para Oracle por
questes de performance. Nesse caso voc ter um trabalho rduo
em converter todas as funes que antes eram apenas entendidas

pelo MySQL para o Oracle, um trabalho que seria poupado facilmente


se voc tivesse optado por usar PDO.
Com o PDO voc abstrai o banco de dados que est sendo utilizado
pela aplicao, ou seja, a aplicao no sabe qual banco de dados
est usando, podendo ser MySQL, PostgreSQL, Oracle e etc, no
importa. Se voc precisa mudar de banco e dados, apenas o Driver
ligado ao PDO ser alterado mas o seu cdigo principal continuar
intacto e ileso.

Iniciando configurao do PDO


Bom, antes de mais nada necessrio ter o driver do PDO para
MySQL instalado no seu PHP, e para isso basta executar o comando
da Listagem 1 (partindo do princpio que voc est trabalhando com
Linux/Ubuntu).
Listagem 1. Instalando PDO para MySQL no PHP
sudo pecl install pdo
sudo pecl install pdo_mysql

Depois de instalado o PDO e o PDO para o MySQL ento iremos ativlo no php.ini, que pode ser encontrado
em /etc/php5/apache2/php.ini. Voc deve incluir as linhas
da Listagem 2 no php.ini.
Listagem 2. Ativando PDO no php.ini
extension=pdo.so
extension=pdo_mysql.so

Obviamente que nosso exemplo est voltado apenas para o MySQL,


mas estivem diversos outros drivers para outros bancos, como por
exemplo: pdo_oci (oracle), pdo_pgsql (postgresql), pdo_sqlite e etc.

Desenvolvendo
J temos todo o conceito do funcionamento do PDO em mente, temos
tambm ele instalado e configurado em nosso ambiente, agora s nos
resta comear a desenvolver nosso projeto.
Para comear, iremos criar uma classe chamada Conexao que ser
responsvel por gerenciar as conexes com o banco de dados.
atravs dessa classe que toda nossa aplicao conversar com o
banco e neste exato ponto que temos a ponte de abstrao do PDO.
Observe a Listagem 3.
Listagem 3. Classe Conexao.php
<?php
class Conexao {
public static $instance;
private function __construct() {
//
}
public static function getInstance() {
if (!isset(self::$instance)) {
self::$instance = new
PDO('mysql:host=localhost;dbname=basedetestes', 'root',
'123456', array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES
utf8"));
self::$instance>setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

self::$instance>setAttribute(PDO::ATTR_ORACLE_NULLS,
PDO::NULL_EMPTY_STRING);
}
return self::$instance;
}
}
?>

Acima temos a nossa Classe Conexao que implementa um padro de


projeto chamado Singleton, que nos garante que apenas uma
instncia de Conexao ser mantida durante toda a aplicao.
Ao solicitar um getInstance() na nossa classe Conexao, verificado
se a mesma j possui uma instncia criada em memria, caso
contrrio ele ir iniciar o processo de criao, que explicaremos
abaixo.
A classe PDO recebe como construtor quatro parmetros: So eles:
1. Local onde est armazenado nosso banco de dados
('mysql:host=localhost;dbname=basedetestes');
2. Usurio do banco de dados (root);
3. Senha do banco de dados (123456);
4. Um array com vrios parmetros aceitos pelo PDO. Em nosso
caso setamos apenas um parmetro que diz respeito ao charset
utilizado pelo MYSQL, que ser UTF8.
Logo depois setamos alguns atributos que voc pode conhecer melhor
lendo o manual do PDO no site oficial do PHP, isso porque eles so
muitos e voc pode realizar diversas operaes com eles, mas estes
fogem do escopo do nosso artigo.

Por fim, temos nossa conexo criada e configurada via PDO com
nossa base de dados MYSQL. Lembra que falamos que neste ponto
que ocorre a comunicao direta da nossa aplicao com a base de
dados? Ento exatamente aqui o nico local que precisaremos
mudar caso seja necessrio mudar nosso banco de dados de MYSQL
para qualquer outro.
Vamos prosseguir com nosso artigo mostrando como utilizar nossa
classe Conexao.php em nossa aplicao, mas para isso iremos
montar um cenrio de teste para melhor entendimento.
Nosso cenrio: Vamos criar uma estrutura para cadastro do usurio,
onde teremos POJO + DAO. No entraremos em detalhes para que
serve um POJO ou um DAO, pois so conceitos relacionados a padro
de projeto e como dissemos anteriormente, fogem do escopo deste
artigo. Mesmo que voc no os conhea (recomendamos que voc os
estude urgentemente), voc poder continuar com este artigo e
entender o uso do PDO.
Primeiro vamos a criao do nosso POJO Usuario.php, conforme
a Listagem 4.
Listagem 4. Usuario.php
<?php
class PojoUsuario {
private
private
private
private
private
private

$cod_usuario;
$nome;
$email;
$senha;
$ativo;
$perfil;

public function getCod_usuario() {


return $this->cod_usuario;
}

public function setCod_usuario($cod_usuario) {


$this->cod_usuario = $cod_usuario;
}
public function getNome() {
return $this->nome;
}
public function setNome($nome) {
$this->nome = $nome;
}
public function getEmail() {
return $this->email;
}
public function setEmail($email) {
$this->email = strtolower($email);
}
public function getSenha() {
return $this->senha;
}
public function setSenha($senha) {
$this->senha = $senha;
}
public function getAtivo() {
return $this->ativo;
}
public function setAtivo($ativo) {
$this->ativo = strtolower($ativo);
}
public function getPerfil() {
return $this->perfil;
}
public function setPerfil($perfil) {
$this->perfil = $perfil;
}

}
?>

Vamos partir direto para nosso DAO, chamado de DaoUsuario, onde


faremos todas as operaes com o banco de dados utilizando nosso
PDO. Para no tornar o artigo muito maante de cdigo fonte, iremos
comear por um simples mtodo que insere um usurio no banco de
dados, conforme a Listagem 5.
Listagem 5. Mtodo inserir da classe DaoUsuario
public function Inserir(PojoUsuario $usuario) {
try {
$sql = "INSERT INTO usuario (
nome,
email,
senha,
ativo,
cod_perfil)
VALUES (
:nome,
:email,
:senha,
:ativo,
:cod_perfil)";
$p_sql = Conexao::getInstance()>prepare($sql);
$p_sql->bindValue(":nome", $usuario>getNome());
$p_sql->bindValue(":email", $usuario>getEmail());
$p_sql->bindValue(":senha", $usuario>getSenha());
$p_sql->bindValue(":ativo", $usuario>getAtivo());
$p_sql->bindValue(":cod_perfil", $usuario>getPerfil()->getCod_perfil());

return $p_sql->execute();
} catch (Exception $e) {
print "Ocorreu um erro ao tentar executar
esta ao, foi gerado um LOG do mesmo, tente novamente mais
tarde.";
GeraLog::getInstance()->inserirLog("Erro:
Cdigo: " . $e->getCode() . " Mensagem: " . $e>getMessage());
}
}

Na primeira linha montamos todo nosso SQL e gravamos em um


varivel chamado $sql. Todo nosso SQL baseado em parmetros, ou
seja, nome relativo ao :nome e assim por diante.
Na seguinte linha:
$p_sql = Conexao::getInstance()->prepare($sql);
Estamos pedindo ao PDO que prepare a sentena SQL para que
possamos realizar os binds necessrios, e ao realizar o prepare()
o PDO retorna um objeto pronto para realizamos a operao
necessria.
Os binds so as operaes de atribuio de valores aos nossos
parmetros, ou seja, o parmetro :nome ter o valor armazenado
em $usuario->getNome() e assim por diante. Utilizando o mtodo
bindValue() do PDO garantimos uma srie de segurana extra para
nosso cdigo, tais como preveno a SQL Injection.
Por ltimo, chamamos o mtodo execute() que ir executar nosso
SQL no banco de dados, retornando TRUE Em caso de sucesso ou
FALSE em caso de falha.
Vamos agora ver nosso DAO completo como ficou e explicar alguns
pontos importantes. Observe a Listagem 6.

Listagem 6. DAO Completo com PDO


<?php
class DaoUsuario {
public static $instance;
private function __construct() {
//
}
public static function getInstance() {
if (!isset(self::$instance))
self::$instance = new DaoUsuario();
return self::$instance;
}
public function getNextID() {
try {
$sql = "SELECT Auto_increment FROM
information_schema.tables WHERE table_name='usuario'";
$result = Conexao::getInstance()>query($sql);
$final_result = $result>fetch(PDO::FETCH_ASSOC);
return $final_result['Auto_increment'];
} catch (Exception $e) {
print "Ocorreu um erro ao tentar executar
esta ao, foi gerado um LOG do mesmo, tente novamente mais
tarde.";
}
}
public function Inserir(PojoUsuario $usuario) {
try {
$sql = "INSERT INTO usuario (
nome,
email,
senha,
ativo,
cod_perfil)

VALUES (
:nome,
:email,
:senha,
:ativo,
:cod_perfil)";
$p_sql = Conexao::getInstance()>prepare($sql);
$p_sql->bindValue(":nome", $usuario>getNome());
$p_sql->bindValue(":email", $usuario>getEmail());
$p_sql->bindValue(":senha", $usuario>getSenha());
$p_sql->bindValue(":ativo", $usuario>getAtivo());
$p_sql->bindValue(":cod_perfil", $usuario>getPerfil()->getCod_perfil());

return $p_sql->execute();
} catch (Exception $e) {
print "Ocorreu um erro ao tentar executar
esta ao, foi gerado um LOG do mesmo, tente novamente mais
tarde.";
}
}
public function Editar(PojoUsuario $usuario) {
try {
$sql = "UPDATE usuario set
nome = :nome,
email = :email,
ativo = :ativo,
cod_perfil = :cod_perfil WHERE
cod_usuario = :cod_usuario";
$p_sql = Conexao::getInstance()>prepare($sql);

$p_sql->bindValue(":nome", $usuario>getNome());
$p_sql->bindValue(":email", $usuario>getEmail());
$p_sql->bindValue(":ativo", $usuario>getAtivo());
$p_sql->bindValue(":cod_perfil", $usuario>getPerfil()->getCod_perfil());
$p_sql->bindValue(":cod_usuario", $usuario>getCod_usuario());
return $p_sql->execute();
} catch (Exception $e) {
print "Ocorreu um erro ao tentar executar
esta ao, foi gerado um LOG do mesmo, tente novamente mais
tarde.";
}
}
public function EditarComSenha(PojoUsuario
$usuario) {
try {
$sql = "UPDATE usuario set
nome = :nome,
email = :email,
ativo = :ativo,
senha = :senha,
cod_perfil = :cod_perfil WHERE
cod_usuario = :cod_usuario";
$p_sql = Conexao::getInstance()>prepare($sql);
$p_sql->bindValue(":nome", $usuario>getNome());
$p_sql->bindValue(":email", $usuario>getEmail());
$p_sql->bindValue(":ativo", $usuario>getAtivo());
$p_sql->bindValue(":senha", $usuario>getSenha());
$p_sql->bindValue(":cod_perfil", $usuario>getPerfil()->getCod_perfil());

$p_sql->bindValue(":cod_usuario", $usuario>getCod_usuario());
return $p_sql->execute();
} catch (Exception $e) {
print "Ocorreu um erro ao tentar executar
esta ao, foi gerado um LOG do mesmo, tente novamente mais
tarde.";
}
}
public function
AlterarSenhaAlreadyCripted($cod_usuario, $senha_nova_md5) {
try {
$sql = "UPDATE usuario set
senha = :senha_nova
WHERE
cod_usuario = :cod_usuario";
$p_sql = Conexao::getInstance()>prepare($sql);
$p_sql->bindValue(":senha_nova",
$senha_nova_md5);
$p_sql->bindValue(":cod_usuario",
$cod_usuario);
return $p_sql->execute();
} catch (Exception $e) {
print "Ocorreu um erro ao tentar executar
esta ao, foi gerado um LOG do mesmo, tente novamente mais
tarde.";
GeraLog::getInstance()->inserirLog("Erro:
Cdigo: " . $e->getCode() . " Mensagem: " . $e>getMessage());
}
}
public function AlterarSenha($cod_usuario,
$senha_antiga, $senha_nova) {
try {

$pojoUsuario = $this>BuscarPorCOD($cod_usuario);
if ($pojoUsuario->getSenha() ==
md5(trim(strtolower($senha_antiga)))) {
$sql = "UPDATE usuario set
senha = :senha_nova
WHERE
cod_usuario = :cod_usuario
and senha = :senha_antiga";
$p_sql = Conexao::getInstance()>prepare($sql);
$p_sql->bindValue(":senha_nova",
md5(trim(strtolower($senha_nova))));
$p_sql->bindValue(":senha_antiga",
md5(trim(strtolower($senha_antiga))));
$p_sql->bindValue(":cod_usuario",
$cod_usuario);
return $p_sql->execute();
}
else
return false;
} catch (Exception $e) {
print "Ocorreu um erro ao tentar executar
esta ao, foi gerado um LOG do mesmo, tente novamente mais
tarde.";
}
}
public function Deletar($cod) {
try {
$sql = "DELETE FROM usuario WHERE cod_usuario
= :cod";
$p_sql = Conexao::getInstance()>prepare($sql);
$p_sql->bindValue(":cod", $cod);
return $p_sql->execute();
} catch (Exception $e) {

print "Ocorreu um erro ao tentar executar


esta ao, foi gerado um LOG do mesmo, tente novamente mais
tarde.";
}
}
public function BuscarPorEmailSenha($email, $senha) {
try {
$sql = "SELECT * FROM usuario WHERE email
= :email and senha = :senha";
$p_sql = Conexao::getInstance()>prepare($sql);
$p_sql->bindValue(":email", $email);
$p_sql->bindValue(":senha", $senha);
$p_sql->execute();
return $this->populaUsuario($p_sql>fetch(PDO::FETCH_ASSOC));
} catch (Exception $e) {
print "Ocorreu um erro ao tentar executar
esta ao, foi gerado um LOG do mesmo, tente novamente mais
tarde.";
}
}
public function BuscarPorCOD($cod) {
try {
$sql = "SELECT * FROM usuario WHERE
cod_usuario = :cod";
$p_sql = Conexao::getInstance()>prepare($sql);
$p_sql->bindValue(":cod", $cod);
$p_sql->execute();
return $this->populaUsuario($p_sql>fetch(PDO::FETCH_ASSOC));
} catch (Exception $e) {
print "Ocorreu um erro ao tentar executar
esta ao, foi gerado um LOG do mesmo, tente novamente mais
tarde.";
}
}
public function BuscarPorEmail($email) {
try {

$sql = "SELECT * FROM usuario WHERE email


= :email";
$p_sql = Conexao::getInstance()>prepare($sql);
$p_sql->bindValue(":email", $email);
$p_sql->execute();
return $this->populaUsuario($p_sql>fetch(PDO::FETCH_ASSOC));
} catch (Exception $e) {
print "Ocorreu um erro ao tentar executar
esta ao, foi gerado um LOG do mesmo, tente novamente mais
tarde.";
}
}
public function BuscarTodos() {
try {
$sql = "SELECT * FROM usuario order by nome";
$result = Conexao::getInstance()>query($sql);
$lista = $result->fetchAll(PDO::FETCH_ASSOC);
$f_lista = array();
foreach ($lista as $l)
$f_lista[] = $this->populaUsuario($l);
return $f_lista;
} catch (Exception $e) {
print "Ocorreu um erro ao tentar executar
esta ao, foi gerado um LOG do mesmo, tente novamente mais
tarde.";
}
}
public function BuscarTodos_Ativo() {
try {
$sql = "SELECT * FROM usuario WHERE ativo =
's' order by nome";
$result = Conexao::getInstance()>query($sql);
$lista = $result->fetchAll(PDO::FETCH_ASSOC);
$f_lista = array();

foreach ($lista as $l)


$f_lista[] = $this->populaUsuario($l);
return $f_lista;
} catch (Exception $e) {
print "Ocorreu um erro ao tentar executar
esta ao, foi gerado um LOG do mesmo, tente novamente mais
tarde.";
}
}
private function populaUsuario($row) {
$pojo = new PojoUsuario;
$pojo->setCod_usuario($row['cod_usuario']);
$pojo->setNome($row['nome']);
$pojo->setEmail($row['email']);
$pojo->setSenha($row['senha']);
$pojo->setAtivo($row['ativo']);
$pojo->setPerfil(ControllerPerfil::getInstance()>BuscarPorCOD($row['cod_perfil']));
return $pojo;
}
}
?>
Nossa classe DAO Singleton, o que nos garante apenas uma
instncia na aplicao. Perceba que utilizamos com muita frequncia
o Conexao::getInstance(), pois ele retorna a instncia atual do
PDO, ou seja, a conexo atual com o banco de dados e atravs dele
que faremos as operaes necessrias.
O restante dos mtodo utilizados pelo PDO podem ser todos vistos
com detalhes no manual oficial do PDO, mas com a listagem acima
voc consegue ter uma viso geral de todas as funcionalidades
bsicas necessrias para construir um CRUD com o PDO conectado ao
MYSQL.
Este artigo a base/core para qualquer CRUD que sua aplicao
necessite, voc apenas deve adaptar para sua necessidade mas o

princpio e lgica de como tudo funciona est incluso aqui. Detalhes


mais tcnicos de funes especficas do PDO podem ser encontrados
em seu site oficial.
O melhor de tudo que voc poder aplicar este artigo a qualquer
banco de dados, seja ele MySQL, PostgreSQL, Oracle ou SQLServer. A
nica coisa que voc ter que se preocupar e gastar um pouco a mais
de tempo na classe Conexao para criar os parmetros necessrios
para o seu banco de dados e instalar o PDO necessrio no seu
ambiente, fora isso, todo restante do processo no muda.

Ronaldo Lanhellas
Bacharel em Cincia da Computao. Atuando como Analista de Sistemas
Java.

Leia mais em: Como conectar MySQL com PHP via


PDO http://www.devmedia.com.br/como-conectar-mysql-com-php-viapdo/30317#ixzz30fvf3Ytk