Question

Según consejo de @carlossevi quiero proceder a la creación de una clase para el tratamiento de nuestro código PHP con nuestra base de datos SQL Server. Para ello he comenzado a leer por la siguiente documentación:

http://danielbrena.blogspot.com/2014/01/crear-una-clase-en-php-para-el-manejo.html

El asunto es que cuando veo la codificación PHP que tiene en el centro de la página sobre fondo negro no entiendo algunas cosas. Por qué hace unas funciones que no hacen nada? Ni reciben parámetros ni nada?

Me refiero a las:

abstract protected function get();
abstract protected function set();
...

Después hace la función de abrir conexión y cerrar las cuales entiendo perfectamente así como la función de ejecutar una consulta y obtener resultados de consulta pero esas get(), set(), edit() y delete() no entiendo qué son ni cual es su función.

También me gustaría saber cuando hace

$this->conexion = new (en mi caso sería sqlsrv_connect) mis datos

Qué quiere decir el $this->conexion? this hace alusión a la clase y conexion a la variable conexion de la clase?
Lo siento si parezco un ignorante pero nunca había hecho esto antes.

Answer 1

Después de estar casi toda la mañana para hacerlo creo que tengo ya algo claro el asunto:

Primero he quedado un fichero config.php donde almaceno todos los datos generales sobre la conexión, este fichero quedaría tal que así:

<?php

//Database config values

//Server
$host='192.168.1.12';

//User
$user='username';

//Password
$password='password';

//Database
$db='database';

//Database system to use
$dbType='sqlsrv';
?>

Ese fichero sería el general de configuración, una vez creada la clase completa con los 3 ficheros a usar este nos valdría para cambiar de base de datos, usuario, contraseña o tipo de base de datos de forma rápida y eficaz. Además es escalable para cualquier sistema que usemos.

En segundo lugar tenemos un archivo conf.class.php que nos da la configuración concreta de la clase, este fichero sería tal que así:

<?php

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 y principal tenemos los controles concretos de la base de datos, ejecución de consultas, búsqueda de filas, etc. este fichero lo he llamado db.class.php y quedaría más o menos así, a falta de incluir muchas más funciones de sqlsrv como por ejemplo sqlsrv_errors para control de errores, etc;

<?php

/* Class for managing database */
Class Db{

   private $server;
   private $user;
   private $password;
   private $database;
   private $type;
   private $link;
   private $connstring;
   private $stmt;
   private $array;

   private static $_instance;

   /*Construct function private to avoid creating by new instances*/
   private function __construct(){
      $this->setConexion();
      $this->conectar();
   }

   /*Method for setting the paremeters of the connection*/
   private function setConexion(){
      $conf = Conf::getInstance();
      $this->server=$conf->getHostDB();
      $this->database=$conf->getDB();
      $this->user=$conf->getUserDB();
      $this->password=$conf->getPassDB();
      $this->type=$conf->getDBType();
   }

   /*We avoid clone. Singleton pattern*/
   private function __clone(){ }

   private function __wakeup(){ }

   /*Function that creates, if neccessary, the object. We must call this function to instance the object.*/
   public static function getInstance(){
      if (!(self::$_instance instanceof self)){
         self::$_instance=new self();
      }
      return self::$_instance;
   }

   /*Connect with database.*/
   private function conectar()
   {
       $this->connstring = array( "Database"=>"mplc_db", "UID"=>"php_user_rw", "PWD"=>"sh1rehampton");
       //$this->connstring = '"UID" => '.$this->user.', "PWD" => '.$this->password.', "Database" => '.$this->database;

       if ($this->type = 'sqlsrv')
       {
            echo "Database is SQL Server <br >";
            $this->link = sqlsrv_connect($this->server, $this->connstring);
            echo $this->link." <br >";
       }
       else 
       {
           echo "Server is not SQL Server";
       }      
   }

   /*Execute SQL sentence*/
   public function execute_query($sql){
      switch ($this->type){
         case 'sqlsrv':
                echo "Call to function seems to work <br>"; 
                $this->stmt=sqlsrv_query($this->link, $sql);
                break;
         break;
      }
      return $this->stmt;
   }

   /*Get a row from SQL*/
   public function get_row($stmt)
   {
       //echo "Call to function seems to work <br>"; 
       if ($this->type = 'sqlsrv')
       {
           //echo "Call to function seems to work and database is SQL Server<br>"; 
           $this->array=sqlsrv_fetch_array($stmt);
       }
       return $this->array;
   }

}

?>

Bueno esto es todo, creo que finalmente se solucionó el problema aunque me gustaría que los gurús me dieran su opinión @Peter, @Leonardo-Tadei, @carlossevi qué opinión os merece?

SaludoS!

Answer 2

Efectivamente $this-> hace referencia al objeto miembro de la clase que estás definiendo y lo que viene después puede ser variables o métodos propios de la clase.

En el caso que mencionas se hace referencia a una variable propia de la clase que está definida más arriba:

private $conexion;

Sobre esa variable almacena un nuevo objeto de conexión mysqli, en tu caso tendrás que almacenar un objeto de conexión a MS SQL.

Respecto a las líneas que no sabes lo que hacen son definiciones de métodos abstractos. A grandes rasgos son métodos que se nombran pero no se definen en este momento sino que serán definidas en la definición de futuras clases que hereden de esta.

En el enlace que te pongo hay un ejemplo que se entiende bastante bien pero necesitas una pequeña base de programación POO en PHP.