POO do Mundo Real Com PHP e MySQL

() translation by (you can also view the original English article)

Inúmeros exemplos, de robôs a bicicletas, têm sido oferecidos como explicações "fáceis" sobre o que é Programação Orientada a Objetos (POO). Eu optei por mostrar como a POO trabalha com um exemplo da vida real, para programadores. Criando uma classe CRUD MySQL, você pode facilmente criar, ler, atualizar e excluir entradas em qualquer um dos seus projetos, independentemente de como o banco de dados é projetado.

Configurar o esqueleto de nossa classe é bastante simples quando entendemos exatamente do que precisamos. Primeiro, precisamos ter certeza de que podemos executar nossas funções MySQL básicas. Para fazer isso, precisamos das seguintes funções:

Select
Insert
Delete
Update
Connect
Disconnect

Elas parecem bastante básicas, mas tenho certeza de que, conforme avançamos, vamos perceber que muitas delas utilizam alguns aspectos semelhantes, por isso poderemos ter de criar mais classes. A definição da classe deve ficar conforme abaixo. Observe que os métodos foram criados com a palavra chave public.

class Database
{
  public function connect()	{	}
	public function disconnect()	{	}
	public function select()		{	}
	public function insert()		{	}
	public function delete()		{	}
	public function update()	{	}
}

public function connect()

Esta função será bastante básica, mas criá-la vai exigir que algumas variáveis sejam criadas primeiro. Como queremos ter certeza de que elas não podem ser acessadas de fora da classe, vamos defini-las como privadas. Essas variáveis serão usados para armazenar o host, nome de usuário, senha e banco de dados para a conexão. Já que elas vão permanecer constantes, não precisamos nem mesmo criar métodos para acessá-las ou modificá-las. Depois disso, só precisaríamos criar um comando mysql simples para conectar ao banco de dados. É claro, já que, como programadores, sempre temos que assumir que o usuário (mesmo que seja nós mesmos) poderá fazer algo estúpido, vamos adicionar uma camada extra de precaução. Podemos verificar se o usuário já se conectou ao banco de dados anteriormente e, em caso afirmativo, não há realmente necessidade de reconectar. Se não, podemos usar suas credenciais para conectar.

private db_host = ‘’; 
private db_user = ‘’; 
private db_pass = ‘’; 
private db_name = ‘’; 

public function connect()
    {
        if(!$this->con)
        {
            $myconn = @mysql_connect($this->db_host,$this->db_user,$this->db_pass);
            if($myconn)
            {
                $seldb = @mysql_select_db($this->db_name,$myconn);
                if($seldb)
                {
                    $this->con = true; 
                    return true; 
                } else
                {
                    return false; 
                }
            } else
            {
                return false; 
            }
        } else
        {
            return true; 
        }
    }

Como você pode ver, ela faz uso de algumas funções mysql básicas e um pouco de verificação de erros para garantir que as coisas estão indo conforme planejado. Se conectar ao banco de dados com sucesso, a função retornará true. Caso contrário, retornará false. Como um bônus, também irá atribuir true à variável de conexão se a conexão tiver sido concluída com sucesso.

public function disconnect()

Esta função irá simplesmente verificar se nossa variável de conexão está definida como verdadeira. Se estiver, isso significa que há conexão com o banco de dados, e nosso script irá desconectar e retornar true. Se não, então não é necessário fazer nada.

public function disconnect()
{
	if($this->con)
	{
		if(@mysql_close())
		{
                       $this->con = false; 
			return true; 
		}
		else
		{
			return false; 
		}
	}
}

public function select()

Esta é a primeira função em que as coisas começam a ficar um pouco complicadas. Agora estaremos lidando com receber argumentos do usuário e retornar os resultados corretamente. Já que não necessariamente usaremos os resultados imediatamente, introduziremos também uma nova variável chamada result, que irá armazenar os resultados de maneira adequada. Além disso, também vamos criar uma nova função que verifica se uma determinada tabela existe no banco de dados. Já que todas as nossas operações CRUD vão exigir essa funcionalidade, faz mais sentido criá-la separadamente em vez de integrá-la na função. Desta forma, vamos economizar espaço em nosso código e, assim, seremos capazes de otimizar melhor as coisas mais tarde. Antes de ir para a função select, aqui está a função tableExists e a variável privada result.

private $result = array(); 

private function tableExists($table)
    {
        $tablesInDb = @mysql_query('SHOW TABLES FROM '.$this->db_name.' LIKE "'.$table.'"');
        if($tablesInDb)
        {
            if(mysql_num_rows($tablesInDb)==1)
            {
                return true; 
            }
            else
            { 
                return false; 
            }
        }
    }

Esta função simplesmente verifica o banco de dados para ver se a tabela já existe. Se a tebela existir, a função retornará verdadeiro e, se não, retornará falso.

public function select($table, $rows = '*', $where = null, $order = null)
    {
        $q = 'SELECT '.$rows.' FROM '.$table;
        if($where != null)
            $q .= ' WHERE '.$where;
        if($order != null)
            $q .= ' ORDER BY '.$order;
        if($this->tableExists($table))
       {
        $query = @mysql_query($q);
        if($query)
        {
            $this->numResults = mysql_num_rows($query);
            for($i = 0; $i < $this->numResults; $i++)
            {
                $r = mysql_fetch_array($query);
                $key = array_keys($r); 
                for($x = 0; $x < count($key); $x++)
                {
                    // Verifica as chaves para permitir somente valores alfanuméricos
                    if(!is_int($key[$x]))
                    {
                        if(mysql_num_rows($query) > 1)
                            $this->result[$i][$key[$x]] = $r[$key[$x]];
                        else if(mysql_num_rows($query) < 1)
                            $this->result = null; 
                        else
                            $this->result[$key[$x]] = $r[$key[$x]]; 
                    }
                }
            }            
            return true; 
        }
        else
        {
            return false; 
        }
        }
else
      return false; 
    }

Embora pareça um pouco assustadora à primeira vista, esta função faz diversas coisas. Primeiro, ela aceita quatro argumentos, um dos quais é obrigatório. O nome da tabela é a única coisa que você precisa passar para a função a fim de obter resultados. No entanto, se você quiser personalizá-la um pouco mais, pode fazê-lo adicionando as linhas que serão consultadas no banco de dados, e até mesmo adicionar cláusulas where e order. Passando apenas o primeiro parâmetro, o resultado será retornado de acordo com os valores pré-definidos para os demais argumentos, de modo que você não precisa se preocupar em passar todos eles. O trecho de código logo após os argumentos apenas serve para compilar todos os nossos argumentos em uma instrução select. Uma vez feito isto, a verificação é feita para ver se a tabela existe, usando a nossa função tableExists. Se existir, a função continua e a consulta é executada. Se não existir, ela irá falhar.

A próxima seção é a verdadeira magia do código. O que ela faz é reunir as colunas e os dados que foram solicitados ao banco de dados, atribuindo-os a nossa variável result. No entanto, para tornar mais fácil para o usuário final, em vez de chaves numéricas, os nomes das colunas são usados. No caso de haver mais de um resultado, as linhas retornadas são armazenadas em uma matriz bidimensional, sendo o primeiro índice numérico e o segundo, o nome da coluna. Se apenas um resultado é retornado, um array é criado tendo os nomes das colunas como índice. Se nenhum resultado for retornado, a variável de resultado é definida como nula. Como eu disse anteriormente, parece um pouco confuso, mas quando quebramos as coisas em suas seções individuais, pode-se ver que elas são bastante simples.

public function insert()

Esta função é muito mais simples que a anterior. Ela simplesmente nos permite inserir informações no banco de dados. Nesse contexto, vamos precisar de um argumento adicional além do nome da tabela. Vamos requerir uma variável que corresponda aos valores que desejamos inserir. Podemos simplesmente separar cada valor com uma vírgula. Assim, tudo o que precisamos fazer é verificar rapidamente se a tabela existe e, em seguida, utilizar nossos argumentos para formar uma instrução de inserção. Basta, então, executar a consulta.

public function insert($table,$values,$rows = null)
    {
        if($this->tableExists($table))
        {
            $insert = 'INSERT INTO '.$table;
            if($rows != null)
            {
                $insert .= ' ('.$rows.')'; 
            }

            for($i = 0; $i < count($values); $i++)
            {
                if(is_string($values[$i]))
                    $values[$i] = '"'.$values[$i].'"';
            }
            $values = implode(',',$values);
            $insert .= ' VALUES ('.$values.')';
            $ins = @mysql_query($insert);            
            if($ins)
            {
                return true; 
            }
            else
            {
                return false; 
            }
        }
    }

Como você pode ver, esta função é muito mais simples do que a nossa bastante complexa função select. Nossa função delete será ainda mais simples.

public function delete()

Esta função simplesmente apaga uma tabela ou uma linha do nosso banco de dados. Assim, devemos passar o nome da tabela e uma opcional cláusula where. A cláusula where nos permitirá saber se devemos excluir uma linha ou a tabela inteira. Se a cláusula where é passada, significa que as entradas correspondentes no banco devem ser eliminadas. Depois de cuidarmos disso tudo, é apenas uma questão de compilar e executar nosso comando delete.

public function delete($table,$where = null)
    {
        if($this->tableExists($table))
        {
            if($where == null)
            {
                $delete = 'DELETE '.$table; 
            }
            else
            {
                $delete = 'DELETE FROM '.$table.' WHERE '.$where; 
            }
            $del = @mysql_query($delete);

            if($del)
            {
                return true; 
            }
            else
            {
               return false; 
            }
        }
        else
        {
            return false; 
        }
    }

E finalmente chegamos à nossa última grande função. Esta função serve apenas para atualizar uma linha no banco de dados com novas informações. No entanto, devido a sua natureza um pouco mais complexa, ela será um pouco maior e infinitamente mais confusa. Não tenha medo: ela segue, em grande parte, o mesmo padrão das funções anteriores. Primeiro, ela usará nossos argumentos para criar uma instrução de update. Vai, então, prosseguir verificando o banco de dados para se certificar de que a tabela existe. Se ela existir, a função irá simplesmente atualizar a linha apropriada. A parte difícil, é claro, vem quando tentamos criar a instrução de atualização. Uma vez que a instrução de update tem regras para atualizar múltiplas entradas (isto é, colunas diferentes na mesma linha, através do uso de vírgulas), teremos de criar uma maneira de lidar com isso. Optei por passar a cláusula where como um único array. O primeiro elemento do array será o nome da coluna que está sendo atualizada, e o próximo será o valor da coluna. Deste modo, cada posição par do array (incluindo 0) será o nome da coluna, e cada posição ímpar será o novo valor. O código para executar isto é muito simples, e é apresentado a seguir (isolado da função):

1	for($i = 0; $i < count($where); $i++)
2	{
3	if($i%2 != 0)
4	{
5	if(is_string($where[$i]))
6	{
7	if(($i+1) != null)
8	$where[$i] = '"'.$where[$i].'" AND ';
9	else
10	$where[$i] = '"'.$where[$i].'"';
11	}
12	else
13	{
14	if(($i+1) != null)
15	$where[$i] = $where[$i]. ' AND ';
16	else
17	$where[$i] = $where[$i];
18	}
19	}
20	}

A próxima seção irá criar a parte da instrução de update que trata da definição de variáveis. Já que você pode alterar qualquer número de valores, optei por utilizar um array em que a chave é a coluna e o valor é o novo valor da coluna. Dessa forma, podemos até mesmo fazer uma verificação para ver quantos valores diferentes foram passados para ser atualizados, e podemos adicionar vírgulas de forma adequada.

$keys = array_keys($rows); 
            for($i = 0; $i < count($rows); $i++)
            {
                if(is_string($rows[$keys[$i]]))
                {
                    $update .= $keys[$i].'="'.$rows[$keys[$i]].'"';
                }
                else
                {
                    $update .= $keys[$i].'='.$rows[$keys[$i]];
                }
                // Parsear para adicionar virgulas
                if($i != count($rows)-1)
                {
                    $update .= ','; 
                }
            }

Agora que nós tiramos esses dois pedaços de lógica do caminho, o resto da instrução de update é fácil. Ela é apresentada a seguir:

public function update($table,$rows,$where)
    {
        if($this->tableExists($table))
        {
            // Parsear os valores where
            // valores pares (incluindo o 0) contêm as linhas where
            // valores ímpares contêm as cláusulas para as linhas
            for($i = 0; $i < count($where); $i++)
            {
                if($i%2 != 0)
                {
                    if(is_string($where[$i]))
                    {
                        if(($i+1) != null)
                            $where[$i] = '"'.$where[$i].'" AND ';
                        else
                            $where[$i] = '"'.$where[$i].'"';
                    }
                }
            }
            $where = implode('=',$where);
            
            
            $update = 'UPDATE '.$table.' SET ';
            $keys = array_keys($rows); 
            for($i = 0; $i < count($rows); $i++)
           {
                if(is_string($rows[$keys[$i]]))
                {
                    $update .= $keys[$i].'="'.$rows[$keys[$i]].'"';
                }
                else
                {
                    $update .= $keys[$i].'='.$rows[$keys[$i]];
                }
                
                // Parsear para adicionar virgulas
                if($i != count($rows)-1)
                {
                    $update .= ','; 
                }
            }
            $update .= ' WHERE '.$where;
            $query = @mysql_query($update);
            if($query)
            {
                return true; 
            }
            else
            {
                return false; 
            }
        }
        else
        {
            return false; 
        }
    }

Agora que nós terminamos a última função, nossa interface CRUD simples para MySQL está completa. Agora você pode criar novas entradas, ler entradas específicas do banco de dados, atualizar entradas e apagá-las. Além disso, ao criar e reutilizar essa classe, você vai ver que está economizando muito tempo e programação. Ah, a beleza da programação orientada a objetos.

O uso

Bem, temos nossa classe pronta, mas como vamos usá-la? Essa parte é simples. Vamos começar com a criação de um banco de dados muito simples para usar em nossos testes. Eu criei um banco de dados chamado de teste e, em seguida, rodei o comando MySQL. Você pode utilizá-la em qualquer banco de dados que quiser. Apenas lembre-se de ajustar as variáveis de conexão no topo do script para que correspondam ao banco utilizado:

A primeira linha está comentada simplesmente porque nem todo mundo vai precisar dela. Se você precisar executar as instruções acima mais que uma vez, vai precisar descomentá-la na segunda vez para garantir que a tabela seja recriada.

Agora que nossa tabela está criada e preenchida, é hora de executar algumas consultas simples sobre ela.

<?php;
include('crud.php');
$db = new Database();
$db->connect();
$db->select('mysqlcrud');
$res = $db->getResult();
print_r($res);
?>

Se tudo correr bem, você deve ver o seguinte:

Da mesma forma, podemos dar um passo adiante e executar uma instrução de update, mostrando os resultados em seguida:

<?php;
$db->update('mysqlcrud',array('name'=>'Changed!'),array('id',1));
$db->update('mysqlcrud',array('name'=>'Changed2!'),array('id',2));
$res = $db->getResult();
print_r($res);
?>

Deveríamos ver isso

Agora, uma instrução de insert simples:

;<?php;
$db->insert('mysqlcrud',array(3,"Name 4","this@wasinsert.ed"));
$res = $db->getResult();
print_r($res);
?>

Seja o primeiro a saber sobre novas traduções–siga @tutsplus_pt no Twitter!