EstiloCSSTutoriales y tips en español

RSS

Otra estructura para conectarse a MySQL con PHP

Por Fernando Loor en . Actualizado: 29/6/2011. Visitado 852 veces. Compartir en LinkedIn

PobreExcelente 

Basado en 4 votaciones.

Fernando LoorFernando Loor, un ingeniero en Computación de la República del Ecuador, especializado en el trabajo web y multimedia con especial gusto por trabajos creativos. En sus tiempos libres se convierte en un colaborador de Estilocss.com.

Aprenda más en:
http://twitter.com/ferchoxlm

Qué tal mi gente, Dios me los bendiga.

Bueno para empezar la explicación vale recalcar que la versión de PHP a utilizar es la 5, se preguntarán porqué. La razón es que esta versión viene con bastante soporte para POO (Programación Orientada a Objetos) paradigma esencial para nuestro pequeño tutorial.

Como sabemos por motivos de seguridad no podemos tener nuestro código de conexión con las clases o peor en la página HTML a mostrar, así que separamos en un archivo todo lo que se refiere a la conexión, en otro archivo los métodos básicos de SQL (insert, select, update y delete), yo los he nombrado así:

  • La clase de conexión a MySQL : classConexion.php
  • La clase de los métodos básicos : classQuery.php

Veamos qué contiene classConexion.php :

  1. <?php
  2.    class Conexion {
  3.     var $host = '';
  4.     var $user = '';
  5.     var $pwd = '';
  6.     var $data = '';
  7.     var $cnx = NULL;
  8.     function __construct(){
  9.        $this->host = 'localhost';
  10.        $this->user = 'root';
  11.        $this->pwd = 'root';
  12.        $this->data = 'ejemploDB';   
  13.     }//end construct   
  14.     function MET_conectar(){   
  15.        $this->cnx = mysql_connect($this->host,$this->user,$this->pwd);//conectar a la base
  16.        if(!$this->cnx){//validacion de conexion
  17.          echo "Error ".mysql_errno().": ".mysql_error();
  18.          exit;
  19.        }//endif
  20.        if(!mysql_select_db($this->data,$this->cnx)){//seleccionar la base de datos activa
  21.          echo "Error ".mysql_errno().": ".mysql_error();
  22.          exit;
  23.        }//endif
  24.        //echo "Exito en la Conexion";
  25.     }//end function
  26.    }//end class
  27. ?>

Como podemos ver empezamos con nuestro símbolo de abertura de código PHP que es <?php ?> , seguimos con la palabra class que identifica la clase y el nombre de la misma, en este caso llamada Conexion, abrimos corchete, y lo siguiente que hacemos es definir 5 variables, que significan:

host
se refiere al host, o a la dirección donde se encuentra nuestro MySQL, cuando trabajamos de manera local generalmente se llama localhost
user
se refiere al nombre de usuario que utilizamos para accesar a MySQL
pwd
se refiere a la contraseña que utilizamos para accesar a MySQL
data
se refiere al nombre de la base de datos en MySQL
cnx
la variable de la conexión

Para todos los valores se asigna un valor vacío o nulo, para los cadenas de texto; comillas simples sin espacio y para la variable de la conexión un NULL.

Como estamos trabajando con paradigma orientado a objeto, y tenemos clases, necesariamente vamos a utilizar constructores (método que sirve para inicializar una clase por defecto).

¿Qué pondremos en este constructor? Pues los valores de las primeras 4 variables, en este caso tengo localhost, root, root, ejemploDB respectivamente.

Nótese que al terminar cada método utilizo //end function o //end construct, este es un comentario que me ayuda a saber dónde termina cada método.

Continuamos con el método conectar(), este método contiene la conexión a la base,

  1. $this->cnx = mysql_connect($this->host,$this->user,$this->pwd);

El this es para referirse a una variable de la misma clase, aquí utilizamos nuestra función de conexión llamada mysql_connect, a este método le pasamos 3 variables, el nombre del host, el user, y el password, esta función retorna un valor que es falso si produjo un error, y con ello hacemos una validación, si es falso, que me muestre mensaje de error sino continua a la siguiente línea.

Lo siguiente que vamos a hacer es seleccionar la base de datos para esto utilizaremos la siguiente función mysql_select_db, que esta función le pasamos como parámetros el nombre la base y la variable conexion, y con el resultado hacemos una validación y si retorna falso mostramos el mensaje de error.

El exit; sirve para terminar cualquier proceso siguiente cuando se use y simplemente sale de la función.

Así terminamos la primera clase, que se encarga de toda la conexión respectiva a MySQL.

La siguiente clase se llama classQuery.php :

  1. <?php
  2.     require_once('classConexion.php');
  3.     class Query extends Conexion{
  4.        var $sql       = NULL;
  5.        var $msj_query    = NULL;
  6.        var $result    = NULL;
  7.        function __construct(){
  8.          parent::__construct();
  9.          parent::MET_conectar();
  10.        }//end function
  11.        function __get($atributo){//metodo GET de la clase
  12.          $cad = "\$aux = \$this->$atributo;";
  13.          eval ($cad);      
  14.          return $aux;
  15.        }//end function
  16.        function __set($atributo,$valor){//metodo SET de la clase
  17.          $cad = '$this->'.$atributo." = '$valor';";
  18.          //$this->nombre = 'Juan Perez';
  19.          eval ($cad);      
  20.        }//end fucntion
  21.        function MET_select(){
  22.          $this->result = mysql_query($this->sql, $this->cnx);
  23.          if(!$this->result){//Evaluar Sintaxis Sql
  24.             $this->msj_query = "Error ".mysql_errno().": ".mysql_error();
  25.             return false;
  26.          }//end if
  27.          if ( mysql_num_rows($this->result) <= 0 ){
  28.             $this->msj_query = "No existen datos a consultar";
  29.             return false;
  30.          }//end if
  31.          while ( $reg = mysql_fetch_assoc($this->result) ){
  32.             $registros[] = $reg;//generar arreglo multidimensional            
  33.          }//end while
  34.          return $registros;               
  35.        }//end function
  36.        function MET_selectOne(){
  37.          $this->result = mysql_query($this->sql, $this->cnx);
  38.          if(!$this->result){//Evaluar Sintaxis Sql
  39.             $this->msj_query = "Error ".mysql_errno().": ".mysql_error();
  40.             return false;
  41.          }//end if
  42.          if ( mysql_num_rows($this->result) <= 0 ){
  43.             $this->msj_query = "No existen datos a consultar";
  44.             return false;
  45.          }//end if
  46.          $reg = mysql_fetch_assoc($this->result);
  47.          return $reg;
  48.        }//end function
  49.        function MET_insert(){
  50.          $this->result = mysql_query($this->sql, $this->cnx);
  51.          if(!$this->result){//Evaluar Sintaxis Sql
  52.             $this->msj_query = "Error ".mysql_errno().": ".mysql_error();
  53.             return false;
  54.          }//end if
  55.          if ( mysql_affected_rows($this->cnx) <= 0 ){
  56.             $this->msj_query = "No se insertaron los datos";
  57.             return false;
  58.          }//end if
  59.          return true;
  60.        }//end function
  61.        function MET_update(){
  62.          $this->result = mysql_query($this->sql, $this->cnx);
  63.          if(!$this->result){//Evaluar Sintaxis Sql
  64.             $this->msj_query = "Error ".mysql_errno().": ".mysql_error();
  65.             return false;
  66.          }//end if
  67.          if ( mysql_affected_rows($this->cnx) <= 0 ){
  68.             $this->msj_query = "No se actualizaron los datos";
  69.             return false;
  70.          }//end if
  71.          return true;
  72.        }//end function
  73.        function MET_delete(){
  74.          $this->result = mysql_query($this->sql, $this->cnx);
  75.          if(!$this->result){//Evaluar Sintaxis Sql
  76.             $this->msj_query = "Error ".mysql_errno().": ".mysql_error();
  77.             return false;
  78.          }//end if
  79.          if ( mysql_affected_rows($this->cnx) <= 0 ){
  80.             $this->msj_query = "No se eliminaron los datos";
  81.             return false;
  82.          }//end if
  83.          return true;
  84.        }//end function
  85.    }//end class
  86. ?>

Empezamos nuevamente con nuestra abertura php <?php ?> lo siguiente es tener referencia de nuestra clase Conexion, con require_once (ruta de la clase) ,luego iniciamos nuestra clase con la palabra class seguido por el nombre que en este caso es Query y seguido por la palabra extends que hace referencia que esta clase extiende de Conexion, y que sus variables se pueden usar en esta clase.

Creamos tres variables:

sql
contendra la sentencia sql que se pasara a MySQL
result
contendra el resultado de la sentencia
msj_query
contendra el mensaje de exito o de error cuando se ejecute la sentencia

Nuevamente las iniciamos con un valor NULL.

Creamos el método constructor y ahora como utilizamos la palabra extends, decimos que ejecute el constructor del pariente en este caso la clase Conexion y además que ejecute el método conectar, con esto nos ahorramos tener que utilizar el método conectar en cada método que crearemos.

Lo siguiente es crear los métodos GET y SET, para esto pasamos el atributo respectivo, para el método GET la variable cad va a guardar toda la sentencia con tipo cadena, y la variable aux va a guardar el valor del atributo, con eval procedemos a evaluar la cadena como sentencia en php y retornamos el valor de aux que es el valor del atributo que deseábamos obtener, para el método SET le pasamos el nombre del atributo y el valor que queremos actualizar, en la sentencia decimos que el valor del atributo tiene un nuevo contenido y es valor, y ejecutamos la sentencia con eval.

Seguimos con el metodo MET_select(),iniciamos con la funcion mysql_query , que se encarga de ejecutar la sentencia sql, se le pasa como argumentos la sentencia, y la variable conexion, esto lo almacenamos en la variable result, ahi hacemos la validación para confirmar si existió algún error, seguidamente utilizamos mysql_num_rows para ver cuantos valores retorna el select, si es menor o igual a 0 cambiamos el mensaje a que "no existen datos a consultar", luego de esto para obtener las filas de la consulta, podemos utilizar estas tres funciones:

mysql_fetch_array()
devuelve un índice como números y etiquetas asociativas.
mysql_fetch_row()
pone como índice de los datos del registro números.
mysql_fetch_assoc()
pone como índice una etiqueta asociativa al nombre del dato.

En este caso estamos utilizando mysql_fetch_assoc para poder obtener el valor por medio del índice como el nombre del campo de la tabla, a esta función le pasamos como argumento el resultado del query hecho anteriormente representado por la variable result

El resultado de toda esta operación la devolvemos en la variable reg, y a su vez hacemos un while, mientras la función retorne datos siga haciendo el bucle, para el cuerpo del bucle, asignamos los valores de reg que van obteniéndose a un arreglo(array) llamado registros, cuando termine de hacer el ciclo repetitivo simplemente decimos que retorne el arreglo y así obtenemos todos los datos de la consulta.

Seguimos con el MET_selectOne(), esta función sirve cuando sabemos que el resultado de nuestra consulta siempre va a ser un valor, así nos obviamos del arreglo, en este método solo es cuestión de seguir los mismos pasos anteriores pero ahora como no hay mas de una fila solo retornamos un valor y lo guardamos en reg, siguiendo solo escribimos return reg; y listo retornamos la fila resultante.

Siguiendo, tenemos el MET_insert(), esta función nos sirve para ingresar los datos a la tabla correspondiente en nuestra base MySQL, seguimos los mismos pasos realizados en el select salvo porque en esta vezno retornamos registros ni filas, sino que retornamos true o false, si nunca ingresa a los if de validación entonces quiere decir que la inserción se realizó con éxito sino la funcion retorna false, y también cambiamos el mensaje diciendo "no se ingresaron los datos" en el msj_query.

Ahora tenemos el MET_update(), es exactamente igual al método insert, su función es actualizar todos o ciertos campos de la tabla con nuevos datos, al final devolvemos true o false, y el nuevo msj_query seria "no se actualizaron los datos" si es que existió un error.

Por ultimo tenemos el MET_delete(), esta función como su nombre lo indica realiza la operación de borrado de un registro, tenemos que es similar a los métodos anteriores devolviendo true o false, y con msj_query "no se eliminaron los datos" si es que existió un error.

Espero les sirva este tutorial, próximamente estaré indicando cómo realizo una clase de una tabla de nuestra base MySQL, y cómo utilizo toda esta estructura dada en este tutorial.

Gracias

El 30 de junio de 2011, Andres Novoa dijo:

Muy buen tutorial. Ojala escribas mas tutoriales del uso de php con sql. Saludos

El 16 de julio de 2011, tUAPeXSq dijo:

I was looking eevrwyehre and this popped up like nothing!

El 13 de diciembre de 2011, Fernando Loor dijo:

Que bien que te haya servido, mira pues las 2 clases están relacionadas entre si, la verdad tu puedes fusionarlas en 1 sola clase, pero el objetivo es separar y dejar solo la conexión a la base pura sin nada más, si tienes duda me dices nomas

El 13 de diciembre de 2011, Daniel Garcia dijo:

hermano muy bueno el tutorial.. me sirvió de mucho..
una preguntica.. es necesario incluir las dos clases o solo una?

Haga clic en cualquier etiqueta para ver más tutoriales

EstiloCSS.com | Creative Commons License | Otro sitio más de Iván Bustoshttp://www.ivanbustos.com/Miami, FL 33166United States.