Neste tutorial vou mostrar como você pode criar uma classe phpOO abstrata para banco de dados MySQL.
Além das funções básicas dessa classe, podemos resumir tempo total gasto com conexão e execução de consultas e contar quantas consultas foram executados durante o seu script PHP.
Etapa 1.
A primeira pergunta é por isso que precisamos se nós temos toda a função em PHP como nativa. Há mais argumentos:
* Você pode facilmente reutilizar o script em todo o seu desenvolvimento.
* Você pode alterar a base de dados sem alterar todo o seu script. Você precisará editar apenas a classe.
* Você pode fazer optimização e simplificação mais fácil.
* Você pode centralizar o acesso e manipulação de erro DB.
* Você pode fazer a depuração mais fácil.
* Você pode fácilmente implementar estatísticas em tempo de consulta e contadores de consulta.
Agora vamos resumir o tipo de função que precisamos:
* Criar uma conexão com o banco
* Execução de queries SQL
* Recebe o número de linhas selecionadas se possível
* Recebe o número de linhas modificadas, se possível
* Receber o id(auto increment) mais recente, se foi possível inserir
* Coloque um resultado da consulta em um array normal
* Mensagem de erro e / ou identificação(code), se necessário
* Obter o tempo total gasto no banco de dados
* Recebe o número de consultas realizadas
Etapa 2.
Antes que possamos iniciar a implementação das funções que precisamos de todas as variáveis de classe comum usado que armazena informações importantes.
Estes são:
* Um identificador de conexão para armazenar o link de conexão real.
* Um conjunto de resultados para armazenar resultados da consulta.
* Uma mensagem de erro e erro id para armazenar informações de erro.
* Um contador para contar as consultas executadas.
* Um contador de tempo para armazenar os tempos de consulta total.
Assim, a classe base fica assim:
MysqlAbs.class.php
<? php classe MysqlAbs ( var $conectado = ''; // link de conexao var $queryCounter = 0; // contador de query var $tempoTotal = 0; // contador de tempo var $errorCode = 0; //codigo de erro var $errorMsg = ''; // mensagem de erro var $resultSet = ''; // conexao padrao quando nao for setada var $servidor="localhost"; // host var $usuario="root"; // user var $senha=""; //senha var $banco="test"; //banco) ?>
Etapa 3.
Agora podemos implementar as funções. Vamos começar com o mais importante. Conectando-se ao banco de dados. O construtor da classe será responsável por construir a conexão com a base de dados. Portanto, se você criar um objeto de banco de dados a partir desta classe imediatamente tera uma conexão válida também.
Assim, o construtor tem os seguintes parâmetros:
* Hostname
* Usuário
* Senha
* Nome do banco de dados
Na função tentamos conectar ao servidor de banco de dados e se conseguirmos, tentamos selecionar o banco de dados. Em caso de erro temos que definir a mensagem de erro e o codigo de erro e retornar como falso.
O construtor da classe é o seguinte:
<? php
function __construct() {
$this -> conexao($this->servidor,$this->usuario,$this->senha,$this->banco);
}
function conexao($host, $user, $pass, $db){
$startTime = $this->getMicroTime();
// faz a conexao com o servidor
if (!$this->conectado = @mysql_connect($host,$user,$pass,true)){
$this->errorCode = mysql_errno();
$this->errorMsg = mysql_error();
return false;
}
// faz a selecao do banco
if (!@mysql_select_db($db,$this->conectado)){
$this->errorCode = mysql_errno();
$this->errorMsg = mysql_error();
@mysql_close($this->conectado);
return false;
}
$this->tempoTotal += $this->getMicroTime() - $startTime;
return true;
}
?>
Acima eu crio o construct que instanciará a conexao, assim como padrao fica a conexão com os dados que estao dentro da classe, se for instanciado e passado os parametros ele criara a conexao. Caso contrário ele retornará falso com uma mensagem de erro.
Etapa 4.
Como próximo passo vamos implementar a função de execução da consulta. Nesta função podemos medir o tempo de execução (veja os detalhes mais tarde), aumentando o contador de consulta e, claro, de executar a consulta em si. Se ocorrer um erro, definir a mensagem de erro e de codigo de erro e retorna como falso. Se tudo estiver funcionando voltamos bem com o conjunto de resultados.
O código é o seguinte:
<? php
function executeQuery($sql){
$startTime = $this->getMicroTime();
++$this->queryCounter;
if(!$this->resultSet = @mysql_query($sql,$this->conectado)){
$this->errorCode = mysql_errno();
$this->errorMsg = mysql_error();
$this->totalTime = $this->getMicroTime() - $startTime;
return false;
}
$this->totalTime += $this->getMicroTime() - $startTime;
return $this->resultSet;
}
?>
Se a consulta contém um Insert, Update ou o comando DELETE, pode ser importante para saber quantos registros foram afetados por esta consulta. Para obtê-lo vamos implementar uma função, como segue:
<? php
function getAffectedRows()
{
return @mysql_affected_rows($this->conectado);
}
?>
No caso de um select, o número de registros poderia ser interessante. Para obtê-lo, temos uma função semelhante:
<? php
function getSelectedRows()
{
return @mysql_num_rows($this->resultSet);
}
?>
Neste tópico, temos uma última questão importante. Em caso de Inserção talvez nós queremos saber o id que foi criado. Para obter essa informação após o registro ser inserido, podemos usar o seguinte código:
<? php
function getInsertId()
{
return @mysql_insert_id($this->conectado);
}
?>
Etapa 5.
Agora vamos criar alguma outra função útil para tornar a nossa classe melhor.
Em caso de select, por vezes, seria bom ter um array associativo em vez do MySQL result set. Então, vamos implementar uma função que retorna a essa matriz gerada a partir de um conjunto de resultados reais.
O código fica assim:
<? php
function loadResult()
{
$array = array();
while ($row = mysql_fetch_object( $this->resultSet )) {
$array[] = $row;
}
mysql_free_result( $this->resultSet );
return $array;
}
?>
Como a nossa função não enviar mensagens de erro de volta para o chamador apenas define as variáveis de erro dentro da classe por isso precisamos de função para obter essa informação. Estas são funções getter simples como o seguinte:
<? php
function getErroCode(){
return $this->errorCode;
}
function getErroMsg(){
return $this->errorMsg;
}
?>
Etapa 6.
Como passo final é preciso implementar uma função para obter tempos de consulta. Para fazê-lo, precisamos de uma função que retorna o tempo atual em milisegundos.
Chamando essa função no início e no final das chamadas de funções de conexao, query ou outras do tipo, poderemos calcular o tempo total gasto no db.
Além deste vamos implementar outras 2 funções getter para obter o número de consultas realizadas eo tempo total da consulta em um formato util.
Assim, nossas funções:
<? php
function getTempo(){
return round($this->tempoTotal,6);
}
function getSqlCount(){
return $this->queryCounter;
}
function getMicroTime() {
list($usec, $sec) = explode(" ",microtime());
return ((float)$usec + (float)$sec);
}
?>
Bom é isso, no próximo eu mostrarei como utilizar esta classe.. até breve.
