Clase para manejar base de datos MySQL en PHP

La clase que a continuación propongo utiliza un patrón llamado Singleton. Este patrón obliga a instanciar únicamente una vez la clase para evitar 2 o más conexiones simultáneas. La clase contiene métodos para ejecutar las 4 sentencias básicas SQL (INSER, UPDATE, DELETE y SELECT), cargar resultados en forma de objetos, ver el número de consultas totales, tomar el último ID insertado, ver el último error, etc.

Actualización (8 de enero de 2013)

Como lleva ya algún tiempo quedando obsoleta la extensión Mysql, he decidio modificar la clase para utilizar la extensión Mysqli. Esta extensión requiere obligatoriamente que utlices PHP 5.0 o posterior. Se utiliza totalmente orientada a objetos y aunque tiene el mismo rendimiento de la anterior mysql, es mucho más estable y segura.

<?php

class DataBase extends MySQLi{

    private $link;
    private $result;
    private $sql;
    private $lastError;
    private $resultSize;
    private static $connection;
    private static $sqlQueries;
    private static $totalQueries;
    const DB_NAME = 'ElNombreDeTuBD';
    const DB_USER = 'TuUsuarioMysql';
    const DB_PSW = 'TuContraseña';
    const DB_HOST = 'localhost';

    public static function connect(){
	if (is_null(self::$connection)) {
	    self::$connection = new DataBase();
	}
	return self::$connection;
    }

    private function __construct(){
	$this->link = parent::__construct(self::DB_HOST, self::DB_USER, self::DB_PSW, self::DB_NAME);
        if($this->connect_errno == 0){
            self::$totalQueries = 0;
            self::$sqlQueries = array();
        }
        else {
            echo 'Error en la conexion: '.$this->connect_error;
        }
    }

    private function execute(){
        if(!($this->result = $this->query($this->sql))){
            $this->lastError = $this->error;
            return false;
        }
        self::$sqlQueries[] = $this->sql;
        self::$totalQueries++;
        $this->resultSize = $this->result->num_rows;
        return true;
    }

    public function alter(){
        if(!($this->result = $this->query($this->sql))){
            $this->lastError = $this->error;
            return false;
        }
        self::$sqlQueries[] = $this->sql;
        return true;
    }

    public function loadObjectList(){
        if (!$this->execute()){
            return null;
        }
        $resultSet = array();
        while ($objectRow = $this->result->fetch_object()){
            $resultSet[] = $objectRow;
        }
        $this->result->close();
        return $resultSet;  
    }
    
    public function loadObject(){
        if ($this->execute()){
            if ($object = $this->result->fetch_object()){
                $this->result->close();
                return $object;
            }
            else return null;
        }
        else return false;
    }
    
    public function setQuery($sql){
        if(empty($sql)){
            return false;
        }
        $this->sql = $sql;
        return true;
    }

    public function getTotalQueries(){
        return self::$totalQueries;
    }
    
    public function getSQLQueries(){
        return self::$sqlQueries;
    }
    
    public function getError(){
        return $this->lastError;
    }
    
    public function getLastID(){
        return $this->insert_id;
    }
    function __destruct(){
        $this->close();
    }
}
Lenguaje del código: PHP (php)

Si notamos, el constructor es privado. ¿Por qué? para asegurarnos de que la clase se instancie desde dentro de sí misma. Es decir, al ejecutar el método DataBase::connect() llamamos al constructor y creamos una única instancia de DataBase. Si volvemos a ejecutar ese método y la clase ya ha sido instanciada antes, entonces nos devolverá la instancia. Eso es el objetivo del patrón Singleton.

Veamos entonces como hacer una conexión, ejecutar una consulta y mostrar los resultados. Se asume que los parámetros de conexión como el host, el nombre de usuario y demás se especifican directamente en las constantes de la clase.

<?php
// Hacemos la conexión
$db = DataBase::connect();
 
// Supongamos que tenemos una tabla de usuarios
// Hacemos la consulta:
$db->setQuery('SELECT `id`,`nombre`,`grupo` FROM `usuarios`');
 
// La ejecutamos y al mismo tiempo obtenemos un arreglo de objetos
// con los campos especificados en la consulta como propiedades.
$usuarios = $db->loadObjectList();
 
// Los imprimimos directamente en pantalla...
foreach($usuarios as $usuario){
    echo 'ID: '.$usuario->id;
    echo 'Nombre: '.$usuario->nombre;
    echo 'Grupo: '.$usuario->grupo;	
    echo "\n";
}
 
// Ahora si queremos consultar a un solo usuario con ID $x:
$db->setQuery("SELECT nombre`,`grupo` FROM `usuarios` WHERE `id`={$x}");
 
// loadObject()  nos regresara la primera (y única) fila del resultado
// en modo de objeto.
$u = $db->loadObject();
// Mostramos el resultado.
echo 'El usuario con ID '.$x.' se llama '.$u->nombre.' y está en el grupo '.$u->grupo.
 
// Si queremos borrar al usuario con ID $w
$db->setQuery("DELETE FROM `usuarios` WHERE `id` = {$w}");
// Lo ejecutamos
if($db->alter()){
    echo "El usuario {$w} fue eliminado.";
}
else{
    echo 'Error: '.$db->getError();
}
 
// Si queremos mostrar cuantas consultas hemos realizado:
echo 'Se ejecutaron '.$db->getTotalQueries().' operaciones SQL';
 
// O cuáles fueron las consultas:
$queries = $db->getSQLQueries(), $i = 1;
foreach($queries as $query){
	echo $i++ .' : '. $query . "\n";
}
Lenguaje del código: PHP (php)

Y ahí tienen un pequeñísimo ejemplo de uso. Aún faltan muchas cosas, como manejar persistencia, caché, hacer INSERTS con arrays y un largo etcétera. Pero aún así se puede usar para hacer consultas básicas y manipular los resultados.

Espero que les sea de utilidad.