Sidebar

Fernando Softov | Classe Abstrata, phpOO + Mysql
109
post-template-default,single,single-post,postid-109,single-format-standard,ajax_fade,page_not_loaded,smooth_scroll,boxed,wpb-js-composer js-comp-ver-3.6.12,vc_responsive

Classe Abstrata, phpOO + Mysql

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.

AUTHOR - admin

2 Comments

0
  • Elias Gomes

    Muito bom. Bem prático.

    Humm. Cadê a segunda parte?

    • fernandooftov

      malz ae cara… nesse fim de semana eu posto um texto e uma video aula mostrando como usar… certo

Post A Comment