Crear una clase para conectar a la base de datos (III)

Continuemos mejorando nuestra clase. En el último tip, creamos una clase nueva para leer un fichero de configuración. Este fichero contenía los valores que nos interesase para realizar la conexión a la base de datos. Luego estuvimos adaptando el fichero de conexión a la base de datos para que fuera capaz de instanciar el objeto Conf y pudiera tener acceso a los datos necesarios para realizar la conexión.

En esta siguiente parte del tutorial vamos a realizar una sencilla mejora para hacer que nuestra clase sea capaz de conectarse a diferentes tipos de base de datos. En concreto vamos a ver cómo adaptarla para que se conecte a PostgreSQL.

Lo primero que debemos realizar es agregar una nueva variable a nuestro fichero de configuración:

config.php

Código :

//Datos de configuración de la conexión a la base de datos

//Servidor
$host='localhost';

//Usuario
$user='user';

//Password
$password='test';

//Base de datos a utilizar
$db='testDB';

//Qué sistema gestor de base de datos utilizamos, mysql, oracle, ...
$dbType='mysql'

Podemos observar una nueva última variable llamada dbType la cual utilizaremos para saber que tipo de base de datos vamos a utilizar.

Ahora vamos a adaptar nuestra clase Conf para que lea dicho valor y lo guarde ($_dbType). Además agregaremos una función getDBType() para poder obtener dicho valor.

Conf.class.php

Código :

Class Conf{
   private $_domain;
   private $_userdb;
   private $_passdb;
   private $_hostdb;
   private $_db;
   private $_dbType;

   private static $_instance;

   private function __construct(){
      require 'config.php';
      $this->_domain=$domain;
      $this->_userdb=$user;
      $this->_passdb=$password;
      $this->_hostdb=$host;
      $this->_db=$db;
      $this->_dbType=$dbType;
   }

   private function __clone(){ }

   private function __wakeup(){ }

   public static function getInstance(){
      if (!(self::$_instance instanceof self)){
         self::$_instance=new self();
      }
      return self::$_instance;
   }

   public function getUserDB(){
      $var=$this->_userdb;
      return $var;
   }

   public function getHostDB(){
      $var=$this->_hostdb;
      return $var;
   }

   public function getPassDB(){
      $var=$this->_passdb;
      return $var;
   }

   public function getDB(){
      $var=$this->_db;
      return $var;
   }

   public function getDBType(){
     $var=$this->_dbType;
     return $var;
   }

}

Por último los cambios más significativos vienen dentro de nuestra clase Db. Dentro de las funciones de conectar, ejecutar una query y obtener una fila de resultados es dónde podemos ver cómo en función del valor tipo de base de datos, la clase utiliza unas funciones u otras.

Db.class.php

Código :

/* Clase encargada de gestionar las conexiones a la base de datos */
Class Db{

   private $servidor;
   private $usuario;
   private $password;
   private $base_datos;
   private $tipo;
   private $link;
   private $stmt;
   private $array;

   private static $_instance;

   /*La función construct es privada para evitar que el objeto pueda ser creado mediante new*/
   private function __construct(){
      $this->setConexion();
      $this->conectar();
   }

   /*Método para establecer los parámetros de la conexión*/
   private function setConexion(){
      $conf = Conf::getInstance();
      $this->servidor=$conf->getHostDB();
      $this->base_datos=$conf->getDB();
      $this->usuario=$conf->getUserDB();
      $this->password=$conf->getPassDB();
      $this->tipo=$conf->getDBType();
   }

   /*Evitamos el clonaje del objeto. Patrón Singleton*/
   private function __clone(){ }

   private function __wakeup(){ }

   /*Función encargada de crear, si es necesario, el objeto. Esta es la función que debemos llamar desde fuera de la clase para instanciar el objeto, y así, poder utilizar sus métodos*/
   public static function getInstance(){
      if (!(self::$_instance instanceof self)){
         self::$_instance=new self();
      }
      return self::$_instance;
   }

   /*Realiza la conexión a la base de datos.*/
   private function conectar(){
      switch ($this->tipo){
         case 'mysql':     $this->link=mysql_connect($this->servidor, $this->usuario, $this->password);
                            mysql_select_db($this->base_datos,$this->link);
                            @mysql_query("SET NAMES 'utf8'");
                  break;

       case 'postgress':   $this->link=pg_connect("host=".$this->servidor." dbname=".$this->base_datos." user=".$this->usuario." password=".$this->password)
                        break;
       break;
      }
   }

   /*Método para ejecutar una sentencia sql*/
   public function ejecutar($sql){
      switch ($this->tipo){
         case 'mysql':     $this->stmt=mysql_query($sql,$this->link);
                  break;
         case 'postgress': $this->stmt=pg_Euery($this->link,$sql);
                   break;
         break;
      }
      return $this->stmt;
   }

   /*Método para obtener una fila de resultados de la sentencia sql*/
   public function obtener_fila($stmt,$fila){
      switch ($this->tipo){
         case 'mysql':     if ($fila==0){
                               $this->array=mysql_fetch_array($stmt);
                            }else{
                               mysql_data_seek($stmt,$fila);
                               $this->array=mysql_fetch_array($stmt);
                            }
                            break;
         case 'postgress': if ($fila==0){
                     $this->array=pg_fetch_row($stmt);
                   }else{
                      $this->array=pg_fetch_row($stmt,$fila);
                   }
                   break;
          break;
      }
      return $this->array;
   }

}

En el siguiente y última parte, veremos cómo controlar los errores.

Un saludo

Ficheros del ejemplo (en formato UTF-8 )

Temas relacionados:

Crear una clase para conectar a la base de datos
Crear una clase para conectar a la base de datos (II)

¿Sabes SQL? ¿No-SQL? Aprende MySQL, PostgreSQL, MongoDB, Redis y más con el Curso Profesional de Bases de Datos que empieza el martes, en vivo.