Buenas foro.

Voy a dar una explicación un tanto superficial pero muy útil sobre el mysqli, voy a dejar una clase de abstracción y algunos ejemplos con los que podrán trabajar en adelante.

Primero lo primero:

Requieres una versión 5.3.6 o superior de PHP.

MySQLi, es el conector para bases de datos MySQL recomendado por PHP, para interactuar desde tu aplicación con una base de datos MySQL.

¿qué es exactamente mysqli y en qué se diferencia de mysql?

Básicamente, como bien se define en el manual oficial de PHP, mysqli es “una extensión mejorada del conector mysql”.

Entre las principales diferencias, se encuentran además, sus dos grandes ventajas:

• Permite trabajar en estilo orientado a objetos (también continúa proveyendo soporte para estilo procedimental);
• Nos facilita una forma segura de filtrado de datos en sentencias SQL, para prevenir inyecciones SQL;

Sin dudas, mysqli es una gran ventaja frente al antiguo conector. Tiene una gran cantidad de clases, métodos, constantes y propiedades muy bien documentados.

Propiedades

Nuestra capa de abstracción, tendrá una única propiedad pública, destinada a almacenar los datos obtenidos tras una consulta de selección. El resto de las propiedades, serán de ámbito protegido, accesibles solo desde nuestra clase y clases que hereden de ésta.

class DBConnector {
   protected static $conn; # Objeto conector mysqli
   protected static $stmt; # preparacion de la consulta SQL
   protected static $reflection; # Objeto Reflexivo de mysqli_stmt
   protected static $sql; # Sentencia SQL a ser preparada
   protected static $data; # Array conteniendo los tipo de datos más los datos a ser enlazados.
   public static $results; # Coleccion de datos retornados por una consulta de selección
}
 

La consulta SQL, deberá ser seteada en los modelos (clases) donde se requiera, incluyendo marcadores de parámetros (embebidos con el signo ?), en la posición donde un dato deba ser enlazado. Un ejemplo de ella, podría ser el siguiente:

$sql = "INSERT INTO productos (categoria, nombre, precio)VALUES (?, ?, ?)";

Mientras que el array$data, deberá contener, como primer elemento, una string con el tipo de datos y los elementos siguientes, serán los datos a ser enlazados (todos de tipo string):

$data = array("isbd", "{$categoria}", "{$nombre}", "{$descripcion}", "{$precio}");

El primer elemento, siempre representará el tipo de datos correspondiente al marcador de parámetro que se desea enlazar. Siendo los tipos de datos posibles:
s (string), i (entero), d (doble) y b (blob).

Métodos

Conectar a la base de datos:

protected static function conectar() {
   self::$conn = new mysqli(DB_HOST, DB_USER, DB_PASS, DB_NAME);
}
 

Requerirá 4 constantes predefinidas (se recomienda definir en un archivosettings): DB_HOST,DB_USER,DB_PASSyDB_NAME.

Archivo setting.php

define("DB_HOST", "localhost");
define("DB_USER", "root");
define("DB_PASS", "password");
define("DB_NAME", "nombre_de_la_base_de_datos");
 

Preparar una sentencia SQL (con marcadores de parámetros):

protected static function preparar() {
   self::$stmt = self::$conn->prepare(self::$sql);
   self::$reflection = new ReflectionClass('mysqli_stmt');
}
 

La clase ReflectionClass de PHP, cumple un papel fundamental: solo a través de ella podemos crear un objeto mysqli_stmtreflexivo, siendo ésta, la única alternativa que tenemos para preparar sentencias SQL con marcadores de parámetros, de forma dinámica.

La propiedad estática $sql (self::$sql) será creada por el único método público que tendrá la clase.

Enlazar los datos con la sentencia SQL preparada:

protected static function set_params() {
   $method = self::$reflection->getMethod('bind_param');
   $method->invokeArgs(self::$stmt, self::$data);
}
 

La propiedad estática $data que se pasa como segundo parámetro a invokeArgs, también será seteada por el único método público.

En este método (set_params), la variable temporal $method, llama reflexivamente (a través del método getMethoddereflectionClass), al método bind_paramde la clase mysqli.

En la siguiente instrucción, a través del método invokeArgsdeReflectionClass, le pasa por referencia a bind param, los datos a ser enlazados con la sentencia preparada (almacenados en el array $data). Podría decirse que invokeArgs, se comporta de forma similar a call_user_func_array().

Enlazar resultados de una consulta de selección:

protected static function get_data($fields) {
   $method = self::$reflection->getMethod('bind_result');
   $method->invokeArgs(self::$stmt, $fields);
   while(self::$stmt->fetch()) {
      self::$results[] = unserialize(serialize($fields));
   }
}
 

Este método es uno de los más “complejos y rebuscados”, que incluso cuenta con algunas “pseudo-magias” un tanto “raras” como el uso de las funciones serialize y unserialize en la la misma instrucción. Pero analicémoslo detenidamente.

El parámetro $fields será recibido a través del único método público que crearemos en nuestra capa de abstracción (este método, a la vez, recibirá este dato, también como parámetro, pero opcional).

Este parámetro, será un array asociativo, donde las claves, serán asociadas al nombre de los campos, y el valor de esas claves, al dato contenido en el campo.

Si tuviese la siguiente consulta SQL:

SELECT nombre, descripcion, precio FROM producto WHERE categoria = ?

Mi array asociativo, podría paracerse al siguiente:

$fields = array("Producto" => "",
"Descripcion" => "",
"Precio" => "");
 

mysqli->bind_result() enlazará el campo producto.nombre a la clave Producto, producto.descripcion a la clave Descripcion y producto.precio a la clave Precio.

Las instrucciones:

$method = self::$reflection->getMethod('bind_result');
$method->invokeArgs(self::$stmt, $fields);

se comportan de forma similar, a sus homónimas en el método set_params. Llama reflexivamente al método bind_result de la clase mysqli y le pasa por referencia, el array $fields.

En el bucle while, estamos asociando iterativamente los datos obtenidos a nuestra propiedad pública$results. Pero ¿cómo lo hacemos? ¿para qué serializar y deserializar los datos?:

while(self::$stmt->fetch()) {
   self::$results[] = unserialize(serialize($fields));
}
 

En cada iteración, stmt->fetch nos está retornando nuestro array $fields, asociado al registro de la tabla, sobre el cuál se está iterando.

Es decir, que en cada iteración, stmt->fetch nos retornará algo como esto:

// contenido del array $fields
array("Producto" => "HD Magazine",
  "Descripción" => "Magazine digital de edición mensual sobre Software Libre, Hacking y Programación",
  "Precio" => "0.00");
 

Pero nuestro array $fields, ha sido pasado por referencia.

Ergo, en cada iteración, su contenido será modificado.

Si a mi propiedad estática $results, le agrego como elemento, un array que está siendo modificado por referencia en el momento que lo estoy asignando a mi propiedad estática, mi propiedad estática, será también, modificada en cada iteración.

Para prevenir eso, serializo mi array$fieldsy lo almaceno en$resultsserializado. Pero como luego necesitará recuperarlo, ahorro un paso y lo deserializo en la misma iteración.

Al serializarlo, estoy “mágicamente” emulando una “inmutabilidad” de los datos asociados.

Cerrar conexiones abiertas:

protected static function finalizar() {
   self::$stmt->close();
   self::$conn->close();
}
 

Un método público que ejecute todas las acciones:

public static function ejecutar($sql, $data, $fields=False) {
   self::$sql = $sql; # setear la propiedad $sql
   self::$data = $data; # setear la propiedad $data
   self::conectar(); # conectar a la base de datos
   self::preparar(); # preparar la consulta SQL
   self::set_params(); # enlazar los datos
   self::$stmt->execute(); # ejecutar la consulta
   if($fields) {
      self::get_data($fields);
   } else {
      if(strpos(self::$sql, strtoupper('INSERT')) === 0) {
         return self::$stmt->insert_id;
      }
   }
   self::finalizar(); # cerrar conexiones abiertas
}
 

La estructura de control de flujo condicional, que utiliza el método ejecutar(), es la encargada de discernir si se trata de una consulta de “lectura” a la base de datos para así, llamar al método get_data, o si se trata de una consulta de “escritura” (INSERT, UPDATE o DELETE). En ese caso, verifica si es una escritura de tipo “INSERT” para retornar la id del nuevo registro creado.

Clase Completa:

<?php
class DBConnector {
 
   protected static $conn; # Objeto conector mysqli
   protected static $stmt; # preparación de la consulta SQL
   protected static $reflection; # Objeto Reflexivo de mysqli_stmt
   protected static $sql; # Sentencia SQL a ser preparada
   protected static $data; # Array conteniendo los tipo de datos más los datos a ser enlazados
   public static $results; # Colección de datos retornados por una consulta de selección
 
   protected static function conectar() {
      self::$conn = new mysqli(DB_HOST, DB_USER, DB_PASS, DB_NAME);
   }
 
   protected static function preparar() {
      self::$stmt = self::$conn->prepare(self::$sql);
      self::$reflection = new ReflectionClass('mysqli_stmt');
   }
 
   protected static function set_params() {
      $method = self::$reflection->getMethod('bind_param');
      $method->invokeArgs(self::$stmt, self::$data);
   }
 
   protected static function get_data($fields) {
      $method = self::$reflection->getMethod('bind_result');
      $method->invokeArgs(self::$stmt, $fields);
      while(self::$stmt->fetch()) {
         self::$results[] = unserialize(serialize($fields));
      }
   }
 
   protected static function finalizar() {
      self::$stmt->close();
      self::$conn->close();
   }
 
   public static function ejecutar($sql, $data, $fields=False) {
      self::$sql = $sql; # setear la propiedad $sql
      self::$data = $data; # setear la propiedad $data
      self::conectar(); # conectar a la base de datos
      self::preparar(); # preparar la consulta SQL
      self::set_params(); # enlazar los datos
      self::$stmt->execute(); # ejecutar la consulta
      if($fields) {
         self::get_data($fields);
      } else {
         if(strpos(self::$sql, strtoupper('INSERT')) === 0) {
            return self::$stmt->insert_id;
         }
      }
      self::finalizar(); # cerrar conexiones abiertas
   }
}
?>
 

Realizando un INSERT:

La tabla:

CREATE TABLE IF NOT EXISTS `productos` (
  `id_productos` INT(11) NOT NULL AUTO_INCREMENT,
  `categoria` VARCHAR(50) NOT NULL,
  `nombre` VARCHAR(50) NOT NULL,
  `descripcion` VARCHAR(200) NOT NULL,
  `precio` DECIMAL(10,2) NOT NULL,
  PRIMARY KEY (`id_productos`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;
 

El codigo:

<?php 
 
require_once("setting.php");
require_once("connector.php");
 
// Estableciendo los parámetros a ingresar
 
$categoria = "Muebles";
$nombre = "Ropero";
$descripcion = "Estante de ropa";
$precio = 1200.50;
 
// Iniciando el Insert
 
$sql = "INSERT INTO productos(categoria, nombre, descripcion, precio)VALUES(?,?,?,?)";
 
// Preparando los datos a insertar
 
$data = array("sssd", "{$categoria}", "{$nombre}", "{$descripcion}", "{$precio}");
 
// Ejecutando la Consulta
 
$insert_id = DBConnector::ejecutar($sql, $data);
 
// Imprimirá el ultimo ID ingresado
 
echo $insert_id;
 
?>
 

En caso de ser un update:

<?php 
 
require_once("setting.php");
require_once("connector.php");
 
// Estableciendo los parámetros a modificar
 
$id = 1;
$nombre = "Ropero 2";
 
// Iniciando el UPDATE
 
$sql = "UPDATE productos SET nombre = ? WHERE id_productos = ?";
 
// Preparando los datos a insertar
 
$data = array("si", "{$nombre}", "{$id}");
 
// Ejecutando la Consulta
 
DBConnector::ejecutar($sql, $data);
 
?>
 

En caso de ser un DELETE

<?php 
 
require_once("setting.php");
require_once("connector.php");
 
// Estableciendo los parámetros a eliminar
 
$id = 1;
 
// Iniciando el DELETE
 
$sql = "DELETE FROM productos WHERE id_productos = ?";
 
// Preparando los datos a insertar
 
$data = array("i", "{$id}");
 
// Ejecutando la Consulta
 
DBConnector::ejecutar($sql, $data);
 
?>
 

En caso de realizar un SELECT:

<?php 
 
require_once("setting.php");
require_once("connector.php");
 
// Parametros de busqueda
 
$categoria = "Muebles";
 
// Iniciando el SQL
 
$sql = "SELECT nombre, descripcion, precio FROM productos WHERE categoria = ?";
 
$data = array("s", "{$categoria}");
 
$fields = array("Producto" => "", "Descripcion" => "", "Precio" => "");
 
// Ejecutando la Consulta
 
$values = DBConnector::ejecutar($sql, $data, $fields);
 
foreach ($fields as $key => $value) {
   echo $value."<br>";
}
 
?>
 

Espero les sirva.

Saludos cordiales