Categories
Programação

Executando Queries com PDO

Para executar uma query SQL vamos usar o método query() da classe PDO, que irá nos rertornar um objeto da classe PDOStatement.

Então vamos lá, executar a query e guardar o resultado em $statement:

$statement = $pdo->query("SELECT city.Name, city.CountryCode, city.District, city.Population FROM world.city");

var_dump($statement);

E aqui está a saída do var_dump() com um objeto da classe PDOStatement:

object(PDOStatement)#2 (1) { ["queryString"]=> string(82) "SELECT city.Name, city.CountryCode, city.District, city.Population FROM world.city" }

Continuando… Já temos um objeto do tipo PDOStatement, e o que fazermos como ele?

Vamos conhecer agora alguns métodos pertencentes a sua classe PDOStatement, começando pelo fetch() que busca a primeira linha retornarda da nossa query:

$one_row = $statement->fetch();
var_dump($one_row);

Como saída na tela, temos um array:

array(4) { ["Name"]=> string(5) "Kabul" ["CountryCode"]=> string(3) "AFG" ["District"]=> string(5) "Kabol" ["Population"]=> int(1780000) }

Vamos agora converter esse array para um objeto JSON, e deixar essa saída pronta para ser recuperada por qualquer outra parte do sistema, como o front-end. Para isso basta substituir nosso var_dump() por um json_encode():

$one_row = $statement->fetch();
echo json_encode($one_row);

E aqui está a informação pronta para se consumida:

{
    Name: "Kabul", 
    CountryCode: "AFG",
    District: "Kabol", 
    Population: 1780000
}

Aqui já temos algo útil para uso, mas… Calma aí. Até agora viemos trabalhando com POO, usando classes, métodos e objetos… E então recebemos esses dados em um array antes de passá-los adiante. Por que?

O que ocorre é que o retorno padrão do metódo fetch() é um array. Isso não chega a ser um problema se você quiser logo depois imprimir as informações em formato JSON, uma vez que a função json_encode() recebe justamente um array.

Mas e se quisermos receber do fetch() um objeto ao invés de um array? É fácil:

$one_row = $statement->fetch(true);
var_dump($one_row);

Dessa vez passamos no método fetch() um parâmetro booleano com “true”. Isso vai nos garantir que o retorno seja um objeto. Vamos de novo a saída…

object(PDORow)#3 (5) { 
    ["queryString"]=> string(82) "SELECT city.Name, city.CountryCode, city.District, city.Population FROM world.city" 
    ["Name"]=> string(5) "Kabul" 
    ["CountryCode"]=> string(3) "AFG" 
    ["District"]=> string(5) "Kabol" 
    ["Population"]=> int(1780000) 
}

Legal, agora temos um objeto PDORow, com cinco atributos, sendo o primeiro “queryString” a query SQL que foi executada, e os demais cada uma das colunas que vieram da query. Vamos imprimir cada coluna, e ver código completo até aqui, incluindo o que foi feito nos posts anteriores:

$dsn = "mysql:host=localhost;dbname=world;port=3306;charset=utf8mb4";
    
$username = 'my_username';
$password = 'my_password';
        
$options = [
    PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
    PDO::ATTR_EMULATE_PREPARES   => false,
];
        
try {
     $pdo = new PDO($dsn, $username, $password, $options);
} catch (\PDOException $e) {
     throw new \PDOException($e->getMessage(), (int)$e->getCode());
}

$statement = $pdo->query("SELECT city.Name, city.CountryCode, city.District, city.Population FROM world.city");

$one_row = $statement->fetch(true);

echo $one_row->Name;
echo $one_row->CountryCode;
echo $one_row->District;
echo $one_row->Population;

Como saída temos agora:

Kabul AFG Kabol 1780000

Poderíamos até concatenar no final de cada echo ali em cima uma tag <br> para quebrar linhas e organizar melhor a informação impressa, mas isso começaria a sujar nosso código de backend, que deve somente buscar a informação no banco de dados.

Vamos então devolver a informação em formato JSON:

$one_row = $statement->fetch(true);
$one_object_json = array(
    $one_row->Name, 
    $one_row->CountryCode, 
    $one_row->District, 
    $one_row->Population
);
echo json_encode($one_object_json);

Se você leu o código com atenção, percebeu que eu coloquei cada um dos atributos: Name, CountryCode, District e Population dentro de um novo array, através da função array(), isso é devido ao fato da função json_encode() realmente precisar de um array como parâmetro de entrada.

Aqui está a saída:

[
    "Kabul",
    "AFG",
    "Kabol",
    1780000
]

Como visto, quando se trata de passar os dados obtidos para frente como JSON, não há vantagem em retornar um objeto no método fetch(). Mas então, como trabalhar com um objeto ao invés de um array e conseguir um retorno em JSON de forma fácil em PDO?

Vamos resolver isso no próximo post, com a criação de uma pequena mas poderosa classe! “A classe esquecida do PDO”.

Categories
Programação

O Poder do PDO

Não saber o poder do PHP Data Objects pode estar te levando a reinventar a roda todo dia!

Neste artigo vamos ver exemplos práticos de como utilizar PDO para facilitar sua vida, além de falar de boas e más praticas ao utilizá-lo.

Por que PDO?

Mas então, por que PDO afinal?

Resposta rápida:

Os reais benefícios do PDO são:

  • Segurança – Proteção contra SQL injections.
  • Usabilidade – Há muitos métodos prontos para automatizar operações totineiras.
  • Reutilização – O mesmo código PHP serve para acessar diferentes bancos de dados, de SQLite a Oracle, passando pelos populares SQLServer, PostgreSQL e claro MySQL.

Tudo sobre os benefícios do PDO:

PDO é uma camada de abstração de acesso ao banco de dados, que oferece uma interface unificada para acessar 12 bancos de dados diferentes, são eles:

  • PostgreSQL
  • SQLite
  • MySQL
  • Oracle
  • ODBC
  • MS SQLServer & Azure
  • Firebird
  • Informix
  • IBM DB2
  • Sybase
  • Cubrid
  • 4D

O PDO abstrai não apenas uma interface de conexão com banco de dados, mas também operações básicas que, de outra forma, teriam que ser repetidas centenas de vezes em cada aplicação, o que te levaria para bem longe de uma das premissas para ser um bom programador: Don’t Repeat Yourself (DRY)!

Ao contrário do mysql e do mysqli, que são ambos drivers de baixo nível servindo apenas como ponte entre o banco de dados MySQL e uma camada de abstração de nível superior, o PDO já é uma abstração pronta totalmente utilizável.

Bem, mas agora que já sabemos um pouco sobre os benefícios de se utilizar o PDO, não percamos mais tempo e vamos direto a ação! Começar a pôr a mão na massa!

Em seguida: Conectando a um banco de dados com PDO

Categories
Programação

Conectando a um Banco de Dados com PDO

O PDO tem um método de conexão sofisticado porém simples de usar, chamado Data Source Name (DSN). Tudo o que você fazer para utilizá-lo é inserir os valores para configuração nos seus locais adequados.

Para entendermos melhor o que precisamos para criar uma instância PDO vamos ver seu método construtor abaixo:

public function __construct(
    $dsn,
    $username = null,
    $passwd = null,
    $options = null
)

Perceba que ele recebe quatro parâmetros, sendo apenas o primero “dsn” obrigatório. Vamos ver cada um deles…

DSN: Como valores do tipo string, em $dsn vão: o driver do banco de dados, host, nome do banco (schema), porta, definição de charset, bem como o unix_socket quando for o caso.

$dsn = "mysql:host=localhost;dbname=test;port=3306;charset=utf8mb4";

Usuário e senha: Também como strings, passe $username e $password para conexão ao banco.

$username = "my_user";
$password = "my_password";

Options: Por último podemos passar aqui uma infinidade de outros parâmetros, dentro do último parâmetro $options, que se trata de um array.

$options = [
    PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
    PDO::ATTR_EMULATE_PREPARES   => false,
];

Pronto, agora já temos tudo o que precisamos para fazer nossa conexão… O código completo ficaria assim:

$dsn = "mysql:host=localhost;dbname=test;port=3306;charset=utf8mb4";

$username = 'my_username';
$password = 'my_password';

$options = [
    PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
    PDO::ATTR_EMULATE_PREPARES   => false,
];

try {
     $pdo = new PDO($dsn, $username, $password, $options);
} catch (\PDOException $e) {
     throw new \PDOException($e->getMessage(), (int)$e->getCode());
}

Com nossas quatro variáveis ​​mencionadas acima corretamente definidas, teremos o objeto $pdo criado, como uma nova instância da classe PDO.

Para nos certificar que tudo ocorreu bem, podemos ver as informações desse novo objeto adicionando ao final do nosso código a função de manipulação de variáveis var_dump():

var_dump($pdo);

Como resultado teremos impresso na tela:

object(PDO)#1 (0) { }

Tudo certo! Vamos continuar…

Ah, sim, uma dica para quem por algum motivo ainda está usando PHP abaixo da versão 5.3.6… Atualize para a 7.0! No mínimo! Essa semana! Por favor…

Não é que eu queira, eu preciso…

Mas sério, se em versões muito antigas do PHP, você tiver problemas para definir o tipo de charset no MySQL usando o DSN, você pode fazer isso através de uma query SQL:

$pdo->exec("set names utf8");

Em seguida: Executando queries com PDO

Categories
Programação

Instalando e configurando o Git

Checando se você já tem o Git instalado

Caso você ainda não tenha o Git instalado ou não tenho certeza disso, no Windows clique no menu Iniciar e digitar “Git”.

Para checar utilizando um sistema Linux ou Mac abra um terminal e digite:

git --version

Se o Git estiver instalado será exibido a versão corrente.

Não encontrou o Git instalado? Use estes links para fazer a instalação no Windows e Mac. Veja abaixo como instalar no Linux.

Instalando no Linux

Se você deseja instalar o Git no Linux, você pode fazer isso facilmente usando o gerenciador de pacotes da sua distribuição.

Para uma distribuição baseada em Debian como o Ubuntu, digite:

$ sudo apt-get install git-all

Se você usa outra distribuição Linux aqui está uma lista completa de como instalar o Git em quase todas as distribuições.

Configuração inicial do Git

Nome e e-mail para commit

Vamos começar configurando o nome e e-mail que serão associados aos seus commits, ou seja, que identificarão o código que você trabalhou.

Há duas formas de criar sua identificação por projeto ou global.

Identificação por Projeto

Criar uma identificação para cada projeto é útil quando você tem na mesma máquina um projeto de trabalho e outro pessoal. Vamos ver o exemplo dessa configuração abaixo.

Neste exemplo vou criar dois diretórios no sistema, um para cada projeto:

$ mkdir proj-pessoal
$ mkdir proj-empresa

Agora, vamos criar a identificação para cada projeto, dentro dos seus respectivos diretórios:

$ cd proj-pessoal

Já dentro do diretório do projeto, tente registrar seu user.name para os futuros commits:

git config user.name "Fellipe Sanches"

O seguinte erro será exibido:

fatal: not in a git directory

Isso ocorre porque o diretório proj-pessoal ainda não é reconhecido como um diretório versionado pelo Git, por enquanto ele é apenas mais uma pasta comum no sistema.

Vamos mudar isso digitando:

$ git init

A segunte mensagem de sucesso será exibida:

Initialized empty Git repository in /home/fellipe/Documents/proj-pessoal/.git/

Agora nosso diretório já é reconhecido como um repositório Git e podemos criar nossa identificação:

git config user.name "Fellipe Sanches"
git config user.email "para@fsanches.com"

Se nenhum erro foi exibido, cheque a identidade criada com:

$ git config --list

A seguinte saída será exibida:

(retorno do comando)

core.repositoryformatversion=0
core.filemode=true
core.bare=false
core.logallrefupdates=true
user.name=Fellipe Sanches <--- SEU NOME 
user.email=para@fsanches.com <--- SEU E-MAIL 

Essa identificação será válida apenas dentro desse diretório. Para confirmarmos isso basta irmos ao nosso outro diretório criado:

$ cd ..
$ cd proj-empresa
$ git init
$ git config --list

Nos comandos acima, navegamos até o outro projeto, iniciamos um repositório Git, e listamos as configurações.

Agora na saída do git config –list podemos ver que ainda não há identificação para este repositório, ou seja, de fato a identificação criada para o primeiro projeto não se aplicou ao segundo!

Configure o user.name e user.email que quiser para o projeto proj-empresa, da mesma foi feito com o proj-pessoal.

Identificação Global

Criar uma identificação global é útil para ter uma identidade padrão pré-configurada ou quando todos os projetos que você vai trabalhar na sua máquina podem receber a mesma identificação de username e e-mail.

Ela não prevalesse sobre uma identificação por projeto.

Diferente da identificação por projeto, o comando para criar uma identidade global pode ser digitada em qualquer ponto do sistema.

Para criar uma identidade global digite:

$ git config --global user.name "Fellipe Silva"
$ git config --global user.email para@fsanches.com

Para checar a identidade criada:

$ git config --global --list

A identidade global será a padrão para todos os novos projetos, exceto para aqueles que tem uma identificação por projeto.

Categories
Programação

Aprenda a usar o Git

Git, amado por quem sabe usar, odiado por quem não. Para o seu bem, aprenda a amá-lo!

O que é Git?

A explicação simples é: Git é um sistema para controlar mudanças em um código (fonte) durante o desenvolvimento de um software. Em termos mais técnicos, ele é um sistema de controle de versões.

Quando devo usar Git?

Sempre. Não há uma boa razão para não utilizá-lo, seja em um projeto pequeno onde só você é o programador, ou em um grande com uma equipe envolvida, de alguma forma ele irá facilitar o trabalho desde de que você saiba utilizá-lo! (é… a verdade dói mesmo! Mas até o final desse artigo vou te ajudar!)

Por que usar Git?

Um: para ter controle do que você fez

Quando você começa a programar em qualquer projeto, em especial um grande, é muito fácil esquecer das últimas alterações que fez, muitas vezes aquelas que trouxeram algum tipo de problema ao funcionamento do código.

Com o Git você consegue não só saber as mudanças que fez, mas quando e onde as fez.

Dois: para todos terem o controle de tudo

Agora pense em uma equipe com outros programadores além de você e centanas de arquivos sendo criados, difícil pensar nesse projeto dando certo sem uma ferramenta para organizar todo esse código. Imagine: pessoas criando o mesmo código de forma redundante (sem saber!), cada um com uma versão diferente do código total, e-mails e pendrives circulando com arquivinhos nomeados como versão1, versão1-a, versão1-b…

Acredite, é muito mais fácil aprender Git do que trabalhar nesse caos!


via GIPHY

Três: para sua carreira de programador

Hoje Git já é quase que obrigário para se trabalhar como programador na maioria das empresas, já no caso de trabalhar de forma remota Git é obrigatório, e em ambos os casos não saber essa tecnologia só vai ter fechar portas (é como eu digo… A verdade dói mesmo mas trás mudança!).

E então, vamos aprender Git?

Sim, quero aprender Git!

Não, programo em FORTRAN e não acho que Git seja útil.