CRUD usando OO e PDO

[Guilherme_90 33]

Boa tarde, pessoal iMasters! Bom, eu criei uma classe que faz os comandos básicos para comunicação com o Banco. Utilizei PDO, e alguns conceitos de Orientação a Objetos, mas para falar a verdade não sei está realmente OO, porque estou aprendendo, então sujestões são sempre bem-vindas! Faça sua crítica, mas para melhorar, e não para acabar com meu código!

 

<?
class Database extends PDO{

private $connect;
private $root;
private $pass;
private static $conn;

private function Database($connect, $root = '', $pass = ''){
	parent::__construct($connect, $root, $pass);
}

private static function getDatabase(){
      if(!isset(self::$conn)){
	   try{
	       self::$conn = new Database("mysql:host=localhost;dbname=testes", "root", "");
	   }

	   catch(PDOException $e){
	       throw new Exception("Erro ao conectar: " .$e->getMessage(). "Código: " .$e->getCode());
	       exit();
	   }
	}

     return self::$conn;
}

private static function CloseDatabase(){
	self::$conn = null;	
}

private static function PDO($sql){
	self::$conn = Database::getDatabase();
	$stm = self::$conn->prepare($sql);
	$stm->execute();
}

       protected static function CRUD($comandoSQL, $tabela, $colunas, $values){
     try {
                 switch($comandoSQL){
		case 'INSERT':
			$sql = "INSERT INTO {$tabela}({$colunas}) VALUES({$values})";
			self::$conn = Database::PDO($sql);
			break;

		case 'UPDATE':
			print_r($sql = "UPDATE {$tabela} WHERE id={$_GET['id']}");
			self::$conn = Database::PDO($sql);
			break;

		case 'DELETE':
			$sql = "DELETE FROM {$tabela} WHERE id={$_GET['id']}";
			self::$conn = Database::PDO($sql);
			break;

		default:
			print 'Nenhum comando SQL encontrado!';
			return false;

		}

		Database::CloseDatabase();
	}

	catch (PDOException  $e){
		print $e->getMessage();
	}

}

}
?>

 

Agora eu mostrando como utilizar.

 

<?
class Cliente extends Database{

       public static function Insert(){
	$colunas = array("nome", "email");
	$values  = array("{$_POST['nome']}", "{$_POST['email']}");
	$dados   = array(
		"{$colunas[0]}='{$values[0]}', 
 		 {$colunas[1]}='{$values[1]}'"
	);

	return parent::CRUD("INSERT","usuarios", "{$colunas[0]}, {$colunas[1]}", "'{$values[0]}', '{$values[1]}'");	
}

public static function Update(){
	$colunas = array("nome", "email");
	$values  = array("{$_POST['nome']}", "{$_POST['email']}");
	$dados   = array(
		"{$colunas[0]}='{$values[0]}', 
 		 {$colunas[1]}='{$values[1]}'"
	);

	return parent::CRUD("UPDATE", "usuarios SET {$dados[0]}", null, null);	
}

       public static function Delete(){
	return parent::CRUD("DELETE", "usuarios", null, null);	
}

}

$Insert = Cliente::Insert();
$Update = Cliente::Update();
$Delete = Cliente::Delete();

?>

 

OBS: Eu ainda não cheguei a testar a classe Cliente, por questão de tempo. Mas a lógica acredito que seja essa, se algo der errado com a segunda classe, é só postar que eu testo aqui e edito com o código funcionando!

 

É isso, espero ter ajudado alguém, e acredito que esse meu esquema não está gambiarra (os mais experientes me falam por favor..).E é tão obvio que tem falhas de segurança, como SQL Injection.

 

Faltou aí o SELECT, mas eu ainda não consegui (também por questão de tempo) fazer seguindo este padrão, e muito menos sem repetir código, então se alguém tiver a bondade e quiser implementar o SELECT seguindo este padrão, fique a vontade, e compartilhe com a galera, pois no mundo de programação nós compartilhamos conhecimentos!

 

Até a próxima.

[Andrey Knupp Vital 136]

Amigo, Obrigado pela contribuição, mas a primeiro de tudo, você tem algumas coisas desnecessárias aí, pelo que vejo do seu objeto que vai se conectar com o banco de dados, você está dando muita volta, além do mais, implementando métodos estáticos desnecessários. Agora, já que você aceita sugestões, que tal fazer uma troca aí, usar um Registry ? Assim se focando no objetivo do método, conectar ao banco de dados, como também e desnecessário esse extends na classe Clientes.

 

Outra coisa que notei, foi esse seu exit depois do throw, na verdade ele não vai ter o efeito esperado alí, o throw, quando você disparar a exception, ele vai parar o script, então o exit ali, nunca vai cair nele.

[Guilherme_90 33]

Olá, Andrey. Quero sugestões sim, para melhorar este meu código. Como que tu faria? Fiquei curioso agora. hehehehe

E sobre o exit(), eu não sei porque coloquei aí, na verdade eu esqueci de tirar!

 

Obrigado pela sugestão.

[Deleu 0]

Troque o método "CRUD" por 4 métodos, cada um executando uma operação no banco: SELECT, INSERT, DELETE e UPDATE.

Lembrando que o SELECT é o único método em que espera-se um retorno.

Não feche a conexão com o banco a cada operação com o mesmo. É possível chamar um Script PHP que executará várias operações no banco e, se cada uma for requerir uma conexão diferente com o banco você estará desperdiçando processamento.

 

Eu não sei usar PDO, mas em breve precisarei de algo como isso, porém meu tempo está um pouco curto essa semana. Gostaria de contribuir para a construção de um CRUD eficiente.

 

Outra coisa, extender a classe de conexão na classe cliente não é uma boa ideia. Imagine que você possua 150 tabelas no sistema, cada qual com sua classe. Você teria 150 classes extendendo a classe de conexão. Na verdade, a classe cliente não é um complemento da classe database, mas sim a classe database é uma ferramenta para a classe cliente.

Seria mais interessante fazer algo do tipo:

 

<?php
require_once("database.php");
class Cliente{
     private $database;

     public function __construct($database = NULL){
          if($database === NULL){
               $this->database = new database();
          }
     }
}
?>

 

 

Com uma estrutura dessas, você poderia facilmente utilizar a mesma conexão do banco para várias operações durante a execução de um script.

Por exemplo: Vou inserir um cliente usando a classe cliente e depois vou inserir o endereço do cliente usando a classe endereco.

A primeira classe a ser construída será a classe cliente. Ela construirá uma conexão ao banco e, em seguida, usará seu método de inserção na tabela cliente. Logo em seguida, ela construirá um objeto da classe endereco entregando a conexão já existente ($this->database) para a classe endereco. Assim, o construtor de endereco não precisará construir uma nova conexão, mas sim usará a existente.

Resumindo: Você executará diferentes atividades sem a necessidade de efetuar uma conexão para cada uma, economizando processamento.

[Guilherme_90 33]

Um tópico que era de ajuda acabou virando dúvidas! hEAuhAeuhAeuahuaehAE

Mais isso é bom, pelo menos eu tentei (que é mais importante).

 

Daleu, gostei muito da sua idéia, mas eu queria evitar de ficar colocando esse método mágico em todos os arquivos que irei fazer a comunicação com o Banco de Dados, sacou?

 

Por isso eu fiz o extends, mas a forma que você explicou eu concordo, se todas as classes eu for herdar da classe "Pai", vai ser f***.

[Matias Rezende 50]

Lembrando que o SELECT é o único método em que espera-se um retorno.

Isto não é verdade. Um insert() deve retornar o ID do último elemento inserido. O update() e o delete() devem retornar a quantidade de linhas modificadas.

 

Sobre o restante não vou comentar por falta de tempo, mas esta eu não podia deixar passar.

 

Carlos Eduardo