Em aplicações web, várias vezes precisamos salvar informações para serem utilizadas posteriormente, vemos isso claramente quando precisamos acessar uma página e nos deparamos com um formulário de login e senha: esses dados já foram posteriormente cadastrados e agora a página precisa checar se realmente os dados batem com os cadastrados. Para implementarmos esse cenário não é suficiente trabalhar com sessões, pois ela só salva os dados enquanto a aplicação não é fechada, dessa forma, na próxima vez que formos acessar uma página essas informações não estarão mais lá; também não é possível fazer isso com cookies, pois a qualquer momento o usuário poderá fazer uma limpeza dos mesmos salvos no navegador e os dados serão perdidos. Para resolver esse problema devemos utilizar um banco de dados.
Em PHP existe uma sequência lógica para se trabalhar com banco de dados, que consiste e três passos:
- Primeiro, você criará variáveis no seu arquivo PHP informando o nome do banco, a porta, o usuário e a senha, e usará a função própria do tipo de banco para abrir uma nova conexão;
- Segundo, utilizaremos as funções de manipulação para executar o código SQL que se deseja;
- Terceiro, fecharemos a conexão.
Para trabalhar com qualquer tipo de banco de dados devemos seguir essa sequência; a seguir veremos alguns exemplos para cada tipo de banco.
MySQL
O MySQL permite armazenar dados organizados em tabelas, que por sua vez, são associadas a outras tabelas, possibilitando o agrupamento de dados.
Para criar um arquivo de conexão de uma aplicação PHP com esse banco de dados iremos utilizar as funções mysql_connect() e mysql_select_db(), como podemos ver na Listagem 1.
<?php
$servidor = 'localhost';
$banco = 'mydatabase';
$usuario = 'root';
$senha = 'root';
$link = mysql_connect($servidor, $usuario, $senha);
$db = mysql_select_db($banco, $link);
if(!$link)
{
echo "Ocorreu um erro na conexão com o banco de dados.";
exit();
}
?> Nas quatro linhas iniciais definimos as variáveis $servidor, $banco, $usuario e $senha, onde estamos armazenando, respectivamente: qual servidor iremos usar, qual o nome do banco de dados, o nome de usuário e a senha de usuário.
A função mysql_connect() recebe os valores de $servidor, $usuario e $senha como parâmetros e estabelece a conexão. Em seguida, devemos informar qual o nome do banco de dados que queremos utilizar com a função mysql_select_db(), que recebe como parâmetro os valores armazenados em $banco e $link, ou seja, o nome do banco de dados e o link que foi obtida com a função mysql_connect().
Por fim, utilizamos o IF para testar se a conexão foi estabelecida com sucesso.
SQL Server
Para criarmos uma conexão entre o SQL Server e o PHP devemos utilizar a função mssql_connect(), como mostra a Listagem 2. Veremos onde será listado todos os dados de uma consulta, tal como será contado o número de registros nesse banco. Essa função é compatível com servidores Windows 2003.
<?
// Dados do banco
$dbhost = "hostbanco"; #Nome do host
$db = "nomebanco"; #Nome do nosso banco de dados
$user = "nomeusuario"; #Nome do usuário
$password = "senhabase"; #Senha do usuário
// Dados da tabela
$tabela = "nometabela"; #Nome da tabela
$campo1 = "campo1tabela"; #Nome do primeiro campo da tabela
$campo2 = "campo2tabela"; #Nome do proximo campo da tabela
@mssql_connect($dbhost,$user,$password) or die("Não foi possível estabelecer
uma conexão com o servidor!");
@mssql_select_db("$db") or die("O banco de dados não foi selecionado!");
$instrucaoSQL = "SELECT $campo1, $campo2 FROM $tabela ORDER BY $campo1";
$consulta = mssql_query($instrucaoSQL);
$numRegistros = mssql_num_rows($consulta);
echo "Esta tabela contém $numRegistros registros!\n<br>\n";
if ($numRegistros!=0) {
while ($cadaLinha = mssql_fetch_array($consulta)) {
echo "$cadaLinha[$campo1] - $cadaLinha[$campo2]\n<br>\n";
}
}?>Após criar a conexão com o banco, escolhemos qual tabela utilizaremos para contar e imprimir o total de registros que existe em cada tabela.
Para Servidores com Windows 2008 podemos utilizar a função sqlsrv_connect(), como mostra a Listagem 3, que devolve o mesmo resultado da Listagem 2.
<?
// Dados do banco
$dbhost = "hostbanco"; #Nome do host
$db = "nomebanco"; #Nome do nosso banco de dados
$user = "nomeusuario"; #Nome do usuário
$password = "senhausuario"; #Senha do usuário
// Dados da tabela
$tabela = "nometabela"; #Nome da tabela
$campo1 = "campo1tabela"; #Nome do campo da tabela
$campo2 = "campo2tabela"; #Nome de outro campo da tabela
$conninfo = array("Database" => $db, "UID" => $user, "PWD" => $password);
$conn = sqlsrv_connect($dbhost, $conninfo);
$instrucaoSQL = "SELECT $campo1, $campo2 FROM $tabela ORDER BY $campo1";
$params = array();
$options =array("Scrollable" => SQLSRV_CURSOR_KEYSET);
$consulta = sqlsrv_query($conn, $instrucaoSQL, $params, $options);
$numRegistros = sqlsrv_num_rows($consulta);
echo "Esta tabela contém $numRegistros registros!\n<hr>\n";
if ($numRegistros!=0) {
while ($cadaLinha = sqlsrv_fetch_array($consulta, SQLSRV_FETCH_ASSOC)) {
echo "$cadaLinha[$campo1] - $cadaLinha[$campo2]\n<br>\n";
}
}?>Firebird/Interbase
O Firebird é um banco de dados relacional multiplataforma e para se conectar a ele utilizamos a função ibase_connect(), que recebe uma série de parâmetros. Os principais são:
- database: caminho para o arquivo do banco de dados no servidor;
- username: nome do usuário;
- Password: senha;
- Charset: padrão de caracteres utilizados pelo banco. O tipo padrão é o ISO-8859-1, mas outro padrão interessante de trabalhar é o UTF-8, que pode representar qualquer carácter no padrão do Unicode;
- Buffers: se refere ao total de buffers do banco de dados que podem ser alocados no cache do servidor.
Veja na Listagem 4 um exemplo de arquivo PHP de conexão com o Firebird/Interbase.
<?php
$host='localhost:/path/to/your.gdb';
$dbh=ibase_connect($host,$username,$password);
$stmt = 'SELECT * FROM nometabela';
$sth = ibase_query($dbh, $stmt);
while ($row = ibase_fetch_object($sth)) {
echo $row->email, "\n";
}
ibase_free_result($sth);
ibase_close($dbh);
?>Oracle
Para conectarmos uma aplicação PHP com o Oracle devemos seguir dois passos.
O primeiro passo é abrir o arquivo php.ini, que pode ser encontrado dentro do diretório de instalação do Apache, e procurar pelo seguinte código:
;extension=php_oci8.dll
;extension=php_oracle.dll
Remova o “;” das linhas e salve. Caso as mesmas não existam no arquivo, insira ao final.
O segundo passo é a criação do arquivo de conexão usando o OCILogon para as versões anteriores a 5.1.2 e oci_connect para outras versões, como mostra o exemplo da Listagem 5.
// metodo de conexao compativel com versao 4 ou anterior do PHP
// depende da instalacao do client do oracle e configuracao do arquivo TNS
$conexao_antiga = OCILogon("usuario", "senha", "servico");
//metodo usado a partir do PHP 5.1.2
$conexao = oci_connect('usuario', 'senha', '127.0.0.1/nome_servico');
if (!$conexao) {
$erro = oci_error();
trigger_error(htmlentities($erro['message'], ENT_QUOTES), E_USER_ERROR);
exit;
}PostgreSQL
O PostgreSQL é um SGBD de código aberto que oferece uma série de funcionalidades. A conexão é bem semelhante a conexão com o MySQL, como podemos ver na Listagem 6.
<?php
// servidor onde esta o nosso banco de dados, no nosso exemplo estamos
utilizando um servidor
// local, portanto colocamos localhost
$servidor = "localhost";
// nome de usuario do banco de dados, root e o usuario ja fornecido pelo
banco
// e extremamente recomendado a criacao de um novo usuario
$usuario = "root";
// senha do usuario, no caso de estarmos usando o usuario root ele vem sem
senha por padrao
// é recomendavel adicionar uma senha para o usuario root, levando em
consideração que ele e o
// usuario com maiores privilegios no banco de dados
$senha ="";
// criacao da conexao, recebe como parametros o servidor, o usuario e a senha
$conexao = pg_connect($servidor, $usuario, $senha) or die ("Nao foi possivel
estabelecer uma conexao com o servidor PostGreSQL");
//caso a conexão seja efetuada com sucesso, exibe uma mensagem ao usuário
echo "Conexao efetuada com sucesso.";
?>SQLite
O SQLite possui muitas características interessantes, dentre as quais podemos destacar a guarda de todo o banco apenas em um arquivo, suporte a base de dados acima de dois terabytes, suporte a strings e BLOB’s com o tamanho acima de dois gigabytes, assim, não possui nenhuma dependência externa e pode processar várias operações de leitura ao mesmo tempo. Contudo, só consegue realizar uma operação de saída por vez.
Veremos a seguir como trabalhar com as duas modalidades do banco: a SQLite procedural e a SQLite Orientado a Objetos.
Para conectarmos com o SQLite devemos usar o seguir o exemplo da Listagem 7.
<?php
//testa se já existe uma base de dados, caso não exista, ele cria
if ($db = sqlite_open("c:/devmedia/databases/dbdev.db", 0666, $error)) {
echo "Banco de dados encontrado e aberto...";
//cria uma nova tabela
@sqlite_query($db, "CREATE TABLE autores( id INTEGER PRIMARY KEY, nome TEXT)");
//insere dados
sqlite_query($db, "INSERT INTO autores VALUES( NULL, 'Luciano Alexandre')");
//exibe os dados cadastrados
$sql = sqlite_query($db, "SELECT id, nome FROM autores");
//visualiza os dados gravados
while ($i = sqlite_fetch_array($sql)) {
echo "<br><br>";
echo "ID: ".$i['id']."<br>";
echo "Nome: ".$i['nome'];
}//fecha while
}
else {
die($error);
}
?>E para o SQLite Orientado a Objeto devemos utilizar o código da Listagem 8.
<?php
try {
//criando nova instancia
$db = new SQLiteDatabase("c:/devmedia/databases/dbdev.db", 0666);
}
catch( Exception $exception ){
die($exception->getMessage());
}
//criando uma nova tabela
//lembre de comentar as próximas duas linhas depois de executar o script pela primeira vez
$sqlC = "CREATE TABLE autores(id INTEGER PRIMARY KEY, nome TEXT)";
$db->queryExec($sqlC);
//inserindo dados
$sqlI = "INSERT INTO colunistas (id, nome) VALUES (NULL, 'Luciano Alexandre')";
$db->queryExec($sqlI);
//visualizando dados salvos
foreach ($db->query("SELECT id, nome FROM autores") as $row) {
print_r($row);
echo "<br>";
}?>ODBC
ODBC é uma API que permite a conexão com qualquer banco de dados, seja ele local ou remoto. Para conectar a um banco ODBC utilizamos o método odbc_connect(), que deve receber quatro parâmetros: nome do banco, nome do usuário, senha e tipo de cursor (opcional).
Depois de conectado podemos utilizar a função odbc_exec() para executarmos comandos SQL em nosso banco. Veja na Listagem 9 como usar esses métodos.
<?php
$conn = odbc_connect('banco','devmedia','devmedia');
$sql = "SELECT * FROM customers";
$rs = odbc_exec($conn , $sql);
odbc_close($conn); // Fecha a conexão com o banco
?>Na Listagem 10 vamos mostrar um exemplo de utilização da conexão com o ODBC para imprimir em uma página web o retorno de uma consulta ao banco.
<html>
<body>
<?php
$conn = odbc_connect('nomebanco','nomeusuario','senha')
or die('Falha na Conexão ');
$sql = 'select * from customers';
$rs = odbc_exec($conn, $sql)
or die('Erro no sql');
echo "<table><tr>";
echo "<th>Nome</th>";
echo "<th>Profissao</th></tr>";
while (odbc_fetch_row($rs)) {
echo "<tr><td>".odbc_result($rs, "UserName")."</td>";
echo "<td>".odbc_result($rs,"ProfessionName")."</td></tr>";
}
odbc_close($conn);
echo "</table>"
?>
</body>
</html>PHP Data Objects (PDO)
O PDO é uma camada de abstração de acesso a dados que traz como principal característica a possibilidade de migração de um banco de dados para outro. Para isso utiliza métodos de manipulação de dados que são independentes de qualquer SGDB. Dessa forma, o método que efetua uma consulta em um banco Oracle será o mesmo para o MySQL, e assim por diante.
O PHP Data Objects é uma funcionalidade disponível a partir do PHP 5.1 e é compatível com vários bancos de dados, dentre eles estão: SQL Server, Firebird/Interbase, MySQL, Oracle, ODBC, PostgreSQL, SQLite, Informix, IBM/DB2 e CUBRID.
Deve ser utilizado em projetos que utilizam mais de um banco ou que exige compatibilidade com outro SGBD, no entanto, não é aconselhável em aplicações bem definidas onde se tem clareza sobre o SGBD utilizado, pois o PDO acaba tendo como desvantagem a falta de velocidade ao ser comparado com outros bancos, como o MySQL.
Habilitando o PDO
O primeiro passo é a habilitação do seu drive, e para isso deve-se abrir o arquivo php.ini e remover o ponto e virgula (;) que comenta as linhas. Para o Windows use:
extension=php_pdo.dll
extension=php_pdo_mysql.dll
E para o Linux:
extension=pdo.so
extension=pdo_mysql.so
O PDO é puramente orientado a objetos, dessa forma, a criação de uma nova conexão com o banco de dados se dá pela criação de uma instância da classe PDO, como mostrado na Listagem 11.
<?php
// MySQL
$db1 = new PDO("mysql:host=localhost;dbname=banco", "root", "senha");
// PostgreSQL
$db2 = new PDO("pgsql:host=localhost;dbname=banco", "root", "senha");
// SQLite
$db3 = new PDO("sqlite:banco.sqlite");
//Firebird
$db4 = new PDO(“firebird:dbname=nomebanco”, “SYSDBA”, “masterkey”);
//Oracle
$host = 'localhost';
$porta = '1521';
$usuario = 'root';
$senha = 'root';
$db5 = new PDO("oci:dbname=//$host:$porta",$usuario,$senha);
?>Veja Que criamos cinco variáveis que recebem a instância da classe PDO para cada um dos tipos de bancos que queremos conectar, respectivamente, com o MySQL, PostgreSQL, SQLite, Firebird e Oracle.
Para encerrarmos uma conexão devemos usar o método unset, como na Listagem 12.
<?php
// MySQL
$db1 = new PDO("mysql:host=localhost;dbname=banco", "root", "senha");
unset($db1); // encerrando a conexão com o MySQL
// PostgreSQL
$db2 = new PDO("pgsql:host=localhost;dbname=banco", "root", "senha");
unset($db2); // encerrando a conexão com o PostgreSQL
// SQLite
$db3 = new PDO("sqlite:banco.sqlite");
unset($db3); // encerrando a conexão com o SQLite
//Firebird
$db4 = new PDO(“firebird:dbname=nomebanco”, “SYSDBA”, “masterkey”);
unset($db4); // encerrando a conexão com o FIrebird
//Oracle
$host = 'localhost';
$porta = '1521';
$usuario = 'root';
$senha = 'root';
$db5 = new PDO("oci:dbname=//$host:$porta",$usuario,$senha);
unset($db5); // encerrando a conexão com o Oracle
?>
Na Listagem 13 vemos a criação de uma conexão com o SQL Server utilizando PDO.
<?php
try {
$hostname = "localhost";
$dbname = "nomebanco";
$username = "usuariobanco";
$password = "senha";
$pdo = new PDO ("mssql:host=$hostname;dbname=$dbname","$username","$password");
} catch (PDOException $e) {
echo "Erro de Conexão " . $e->getMessage() . "<\br>";
exit;
}
unset($pdo);
?>PDO usando o ODBC para conectar o SQL Server
O Open Data Base Connectivity (ODBC) é uma estrutura criada com o objetivo de simplificar o acesso das aplicações com o banco de dados. Para utilizar o ODBC devemos seguir três passos. Inicialmente devemos ter uma aplicação ODBC instalada, sendo as mais conhecidas o Microsoft Acess e o Visual Basic. O segundo passo é possuir um driver ODBC e o terceiro é possuir um banco de dados real.
Na Listagem 14 criamos uma nova conexão com o banco de dados real o SQL Server.
*
# Usuário: Devmedia
# Banco: pdobanco
# Server: PC\SQLEXPRESS
# Senha: devmedia
# Nome da tabela: autor
# Driver usado ODBC DSN
*/
try
{
// Conexão
$banco = new PDO("odbc:Driver={SQL Server};Server=PC\SQLEXPRESS;Database=pdobanco;
Uid=sa;Pwd=devmedia;");
/* Insert no banco */
$executa = $banco->query("INSERT INTO autor (id, nome) VALUES ('', 'jose')");
if($executa){
echo 'Dados inseridos com sucesso!';
}
else{
print_r($pdo->errorInfo());
}
?>Depois que estabelecemos uma conexão com um banco de dados, o PDO nos fornece os métodos para manipulação do banco (inserção, criação, exclusão, etc.), para isso utilizamos a linguagem SQL.
Na Listagem 15 utilizaremos o método exec, que possibilita a execução de código SQL junto ao nosso banco para criar uma tabela de funcionários com os campos, id, nome, e-mail e cargo.
<?php
$db = new PDO("mysql:host=localhost;dbname=banco", "root", "");
$db->exec("CREATE TABLE funcionarios(id INT AUTO_INCREMENT, nome VARCHAR(255),
email VARCHAR(255), cargo VARCHAR(255)) ");
?>Para fazermos consultas utilizamos o método query, que executa o comando SQL SELECT, como mostra a Listagem 16.
<?php
$db = new PDO("mysql:host=localhost;dbname=banco", "root", "");
$dados = $db->query("SELECT * FROM funcionarios");
?>