Daniel Segovia

La mayoría de las páginas web está hecha en PHP por lo tanto en este capítulo veremos la interacción que existe entre el HTML y PHP.
Aquí una lista global de lo que estaremos realizando a continuación

• Embeber código PHP en archivos HTML
• Mostrar contenido dinámico
• Recoger información de formularios
• Seguridad sobre la información recibida
• Datos persistentes a través de Cookies y Sessions
• Organizar una aplicación Web

El patrón Proxy en PHP es sencillo de entender, es utilizado como intermediario para acceder a un objeto llamado SujetoReal.
Básicamente, tenemos un objeto Proxy que actúa como un sustituto de un objeto SujetoReal. Se realiza una solicitud al Proxy y éste es el encargado de transmitirla a SujetoReal
El objeto Proxy posee una referencia al objeto SujetoReal y controla el acceso a sus métodos y propiedades, introduciendo las funcionalidades que cree necesarias.

Posibles tipos de Proxies

• Proxy Remoto: Cuando el objeto proxy está en una dirección y el objeto real está en otra. En este caso proxy puede funcionar como corta fuegos (firewall). Es muy común ver este esquema con los juegos en línea donde se necesita el mismo objeto en diferentes lugares al mismo tiempo.
• Proxy Virtual: Puede almacenar en caché información, de modo que el acceso al objeto real puede ser postergada
• Proxy de protección: Mantiene la protección de la solicitud al objeto real hasta que la solicitud es verificada por el servidor proxy de protección

Veamos un ejemplo sencillo

<?php
abstract class ISujeto{
    abstract protected function request();
}
 
 
class Proxy extends ISujeto{
    private $SujetoReal;
 
    public function request(){	
        echo "agregando funciona al inicio <br />";
        $this->SujetoReal = new SujetoReal();
        $this->SujetoReal->request();	
        echo "agregando funciona al final <br />";
    }
}
 
class SujetoReal extends ISujeto{
    protected function request(){
        echo "Ejecutando request en " . get_class() . "<br />";
    }
}
 
//implementacion
class Usuarios{
    private $proxy;
 
    public function __construct(){
        $this->proxy = new Proxy();
    }
 
    public function hacerX(){
        $this->proxy->request();
    }
}
 
$objeto = new Usuarios;
$objeto->hacerX();
 
?>

Resultado

agregando funciona al inicio
Ejecutando request en SujetoReal
agregando funciona al final

Como podemos ver, agregamos un mensaje al inicio y uno al final de la llamada al SujetoReal.
Esto es una introducción al patrón Proxy y el ejemplo intenta demostrar fácilmente una estructura del patrón y una implementación. En proyectos grandes es un común ver este tipo de esquemas.

MVC son las siglas del patrón de arquitectura Modelo Vista Controlador (model view controller en inglés) que se encarga de separar los datos en una aplicación.

Podemos ver fácilmente MVC en el diseño de una página web. Por un lado tenemos el resultado final, el HTML, en esta caso la vista, por otro lado tenemos un montón de información guardada en nuestra base de datos, toda la interacción con ella será procesada por el modelo y la toma de decisiones, por ejemplo mostrar distintos contenidos para diferentes niveles de usuarios, estará a cargo del controlador

• Modelo: El modelo se encarga del acceso a la información, independientemente de donde y como este guardada, éste será el encargado de retornar, en un formato especifico, la información que estén solicitando. Los datos o información en principio no tendrían importancia para nuestro controlador y vista, el modelo extraerá lo necesario ya sea de un archivo de texto, una base de datos, un xml o de algún otro medio
• Vista: La vista tiene como objetivo visualizar todo lo previamente procesado. Suponiendo que estamos desarrollando el juego del ta-te-ti, por lo general un jugador juega con la “X” y el otro con la “O”, nuestra vista puede mostrar esto o “X” e “Y” o “W” y “Z” para cada jugador, también cada jugador podría tener una imagen asignada. Estos cambios serán fácil implementando MVC ya que la lógica del juego estará en otras capas de la aplicación
• Controlador: El controlador será el encargado de tomar decisiones. Cualquier tipo de camino que se siga el flujo del sistema será por que el controlador desviará éste flujo según la decisión que tome. Continuando con el ta-te-ti el controlador dará turno al siguiente jugador o dirá cuando el juego esta terminado

Bueno, empecemos con el ejemplo en código.
Aquí mostraré 4 archivos, la versión completa pueden descargarla aquí

Aquí el index.php, básicamente este se encarga de juntar todas las partes, recibe dos parámetro por GET, uno es el controlador y el otro la acción (el método) que debe ejecutar.

Luego de algunas validaciones simples instancia el controlador y ejecuta la acción.

<?php
//index.php
define('CARPETACONTROLADORES', "controladores/");
define('CARPETAMODELOS', "modelos/");
define('CARPETAVISTAS', "vistas/");
 
 
if(!empty($_GET['controlador'])){
    $controlador = $_GET['controlador'];
    $file = CARPETACONTROLADORES . $controlador . ".php";
 
    if(is_file($file)){
        require_once $file;
        $objecto = new $controlador;
    }
    else{
          die('El controlador no existe');
    }
}else{
          die('No ha definido un controlador');
}
 
if(!empty($_GET['accion'])){
    $accion = $_GET['accion'];
    if(!method_exists($controlador, $accion)){
        die('El metodo '.$accion.' no existe en el controlador ' . $controlador);
    }
}else{
          die('No ha definido una accion');
}
 
$objecto->$accion();
 
?>

Controlador

<?php
//usuarios.php
require_once CARPETACONTROLADORES . "controlador.php";
 
class usuarios extends controlador {
 
    function __construct(){
        require_once CARPETAMODELOS . "modeloUsuarios.php";
        $this->modelo = new modeloUsuarios;
    }
 
    function listar(){
        $usuarios = $this->modelo->listar();
        require_once CARPETAVISTAS . "usuariosListar.php";
 
    }
}
 
?>

Modelo

<?php
//modeloUsuarios.php
require_once CARPETAMODELOS . "modelo.php";
 
class modeloUsuarios extends modelo{
 
    function __construct(){
        parent::__construct();
    }
 
    function listar(){
        $query = "SELECT nombre, apellido FROM usuarios";
        $result = $this->mysqli->query($query);
        return $result;
    }
}
 
?>

Por sí no vieron el link más arriba
Descarguen el ejemplo funcionando desde aquí

Cuando tenemos un algoritmo que por algún motivo puede llegar a cambiar en tiempo de ejecución o bien su implementación podemos trabajar con el patrón de estrategia para que éste decida que camino tomar.
Básicamente consiste en definir una interfase con los métodos del algoritmo para luego plantear cada uno de éstos en las clases que implementen la interfase.
Cada algoritmo estará encapsulado y será intercambiable independientemente de los clientes que lo utilicen.

Veamos el siguiente ejemplo, tenemos un array con el nombre de un producto y el precio. Para algunos clientes es conveniente mostrarlos en orden alfabética y en otros en orden ascendente de precio.

<?php
 
interface estrategia{
    public function ordenar($productos);
}
 
class OrdenarPorNombre implements estrategia{
 
    public function ordenar($productos){
        ksort($productos);
        return $productos;
    }
 
}
 
class OrdenarPorPrecio implements estrategia{
 
    public function ordenar($productos){
        asort($productos);
        return $productos;
    }
 
}
 
class usuarios {
 
    private $productos;
 
    public function getProductos(){
        return $this->productos;
    }
 
    public function setProductos($productos){
        $this->productos = $productos;
    }
 
    public function mostrar($estrategia){
        print_r($estrategia->ordenar($this->getProductos()));
    }
 
}
 
$productos = array('Remera'=>20, 'Campera'=>50, 'Patalon'=>35, 'Gorro'=>10);
 
$u = new usuarios;
$u->setProductos($productos);
$u->mostrar(new OrdenarPorNombre);
$u->mostrar(new OrdenarPorPrecio);
 
?>

Resultado

Array
(
    [Campera] => 50
    [Gorro] => 10
    [Patalon] => 35
    [Remera] => 20
)
 
Array
(
    [Gorro] => 10
    [Remera] => 20
    [Patalon] => 35
    [Campera] => 50
)

El patrón observador es sencillo de entender y más fácil de ver cuando es necesario.
Tendremos 2 objetos, por un lado el observador y por el otro el observado.
El observador debe ver cuando el observado realiza algún cambio y tomar determinada acción.
El modelos antiguos el observador miraba constantemente al observado para ver cuando éste cambiada, el problema de éste modelo es que había que mirar constantemente al observado para ver cuando realizaba una modificación.
Con el patrón observador cambiaron un poco los roles, tenemos el mismo esquema, observador y observado, la diferente es que observador no estará “mirando” todo el tiempo a observado para ver cuando hay un cambio, sino que éste último le avisará mediante una notificación a su observador cuando haga efectivo dicho cambio.

En un ejemplo de la vida cotidiana:

- Un padre ve como su niño anda en bicicleta, él esta ateto el 100% del tiempo mirando que no se golpee, sí un accidente ocurriese el padre se enteraría al instante ya que ve lo que sucedió. Aquí vemos como el observador está monitoreando constantemente al observado.
- Un niño esta andando en bicicleta y al tener un incidente éste avisa a su padre. Aquí vemos como el observado notifica a su observador en determinado evento.

Vamos a los papeles, aquí el código
Separaremos las clases de la implementación, estará en 2 archivos, modelo.php e implementacion.php

<?php
//modelo.php
abstract class observable{
 
    protected $observadores;
 
    public function __construct(){
        $this->observadores = array();
    }
 
    public function registrarObservador($observador){
        if(!in_array($observador, $this->observadores)){
            array_push($this->observadores, $observador);
        }
    }
 
    public function eliminarObservador($observador){
        if(in_array($observador, $this->observadores)){
            $key = array_search($observador, $this->observadores);
            unset($this->observadores[$key]);
        }
    }
 
    abstract public function notificarObservador();
 
}
 
 
interface observador{
    public function notificar($remitente, $parametro);
}
 
class Usuario extends observable{
 
    public $parametro;
 
    public function __construct(){
        parent::__construct();
    }
 
    public function notificarObservador(){
        if(count($this->observadores)  > 0){
            foreach ($this->observadores as $observador){
                $observador->notificar($this, $this->parametro);
            }
        }else{
            echo "No hay observadores<br />";
        }
    }
 
    public function setParametro($value){
        $this->parametro = $value;
        $this->notificarObservador();
    }
 
    public function getParametro(){
        return $this->parametro;
    }
}
 
class Log implements Observador{
    public function notificar($remitente, $parametro){
        echo "El objeto " . get_class($remitente) . " ha cambiado la propiedad `parametro` al valor de '$parametro' a las " . date('H:i:s', time()) . "<br />";
    }
}
 
class LogDB implements Observador{
    public function notificar($remitente, $parametro){
        echo "El objeto " . get_class($remitente) . " ha guardado la propiedad `parametro` por valor de '$parametro' en la base de datos<br />";
    }
}
 
class LogEmail implements Observador{
    public function notificar($remitente, $parametro){
        echo get_class($remitente) . " notifica un cambio y ha sido enviado por mail<br />";
    }
}
?>

Vamos a dividir la explicación de modelo.php en 4

• Definimos una clase abstracta observable, todas las clases que extiendan de ésta podrán ser observadas, también podrán registrar y eliminar observadores y deberán implementar la notificación
• Definimos una interfaz observador, todos los observadores implementarán ésta interfaz y estarán obligadas a poseer el método notificar, sí bien éste paso podría pasarse por alto es una muy buen practica
• Definimos la clase que va a ser observada, en este ejemplo usamos una clase llamada Usuario y ésta notificará a sus observadores cuando la propiedad método haya cambiado su valor
• Por último definimos los observadores que implementan la interfaz y todos poseen el método notificar, aquí definimos 3 observadores, un muestra un mensaje, otro guarda en base de datos y el último da un aviso por mail

Aquí la implementación, veremos diferentes maneras en las implementaciones.

Implementación 1:

<?php
//implementacion1.php
$ob = new Usuario;
$ob->setParametro('Daniel');
echo "Parametro: " . $ob->getParametro() . "<br />";
?>

<!--resultado-->
No hay observadores
Parametro: Daniel

Implementación 2:

<?php
//implementacion2.php
$ob = new Usuario;
$ob->registrarObservador(new Log);
$ob->setParametro('Marcos');
echo "Parametro: " . $ob->getParametro() . "<br />";
?>

<!--resultado-->
El objeto Usuario ha cambiado la propiedad `parametro` al valor de 'Marcos' a las 18:40:46
Parametro: Marcos

Implementación 3:

<?php
//implementacion3.php
$ob = new Usuario;
$ob->registrarObservador(new Log);
$ob->registrarObservador(new LogDB);
$ob->registrarObservador(new LogEmail);
$ob->setParametro('Federico');
echo "Parametro: " . $ob->getParametro() . "<br />";
?>

<!--resultado-->
El objeto Usuario ha cambiado la propiedad `parametro` al valor de 'Federico' a las 18:42:08
El objeto Usuario ha guardado la propiedad `parametro` por valor de 'Federico' en la base de datos
Usuario notifica un cambio y ha sido enviado por mail
Parametro: Federico

Implementación 4:

<?php
//implementacion4.php
$ob = new Usuario;
$ob->registrarObservador(new Log);
$ob->registrarObservador(new LogDB);
$ob->registrarObservador(new LogEmail);
$ob->setParametro('Hugo');
echo "Parametro: " . $ob->getParametro() . "<br />";
 
sleep(2);
 
$ob->eliminarObservador(new LogDB);
$ob->setParametro('Diego');
echo "Parametro: " . $ob->getParametro() . "<br />";
?>

<!--resultado-->
El objeto Usuario ha cambiado la propiedad `parametro` al valor de 'Hugo' a las 18:43:45
El objeto Usuario ha guardado la propiedad `parametro` por valor de 'Hugo' en la base de datos
Usuario notifica un cambio y ha sido enviado por mail
Parametro: Hugo
El objeto Usuario ha cambiado la propiedad `parametro` al valor de 'Diego' a las 18:43:47
Usuario notifica un cambio y ha sido enviado por mail
Parametro: Diego

El patrón de diseño Singleton tiene como finalidad asegurar que sólo se pueda crear una instancia de determinada clase.

Es muy común ver este patrón aplicado en las conexiones a la base de datos, no es necesario tener 10, 20 o 30 conexiones abiertas a la misma base de datos, con una es más que suficiente. Entonces cuando tenemos un proyecto en el cual varias clases harán uso de la base de datos las instancias las haremos con Singleton y esto nos asegurará tener 1 sola instancia del objeto lo cual reducirá ampliamente los consumos de memoria.

La lógica del patrón es simple, sí el objeto nunca fue creado éste es instanciado y devuelto pero sí previamente había sido instanciado el patrón devolverá objeto.

Veamos un ejemplo de un contador, noten como en la implementación se crean varias instancias del mismo objeto pero la propiedad que lleva la cuenta siempre conserva el mismo valor, naturalmente esto se debe a que el objeto siempre es el mismo.

<?php 
 
class Singleton {
   private static $instancia;
   private $contador;
   protected $cantidad;
 
 
   private function __construct(){
      echo "Primera Instancia de " . __CLASS__ . " ha sido creada\n<br/>";
      $this->contador = 0;
      $this->setCantidad(10);
   }
 
   public static function getInstance() {
      if (  !self::$instancia instanceof self) {
         self::$instancia = new self;
      }
      return self::$instancia;
   }
 
   public function getCantidad(){
      return $this->cantidad;
   }
 
   public function setCantidad($value){
      $this->cantidad = intval($value);
   }
 
   public function incrementar(){
      return $this->contador+= $this->getCantidad();
   }
 
   public function disminuir() {
      return $this->contador-= $this->getCantidad();
   }
}
?>
 
<?php
$primeraInstancia = Singleton::getInstance();
echo "Primera Instancia (+): " . $primeraInstancia->incrementar() . "\n<br/>";
echo "Primera Instancia (+): " .$primeraInstancia->incrementar() . "\n<br/>";
echo "Primera Instancia (+): " .$primeraInstancia->incrementar() . "\n<br/>";
$segundaInstancia = Singleton::getInstance();
echo "Segunda Instancia (-): " .$segundaInstancia->disminuir() . "\n<br/>";
echo "Segunda Instancia (+): " .$segundaInstancia->incrementar() . "\n<br/>";
$terceraInstancia = Singleton::getInstance();
echo "Tercera Instancia (-): " .$terceraInstancia->disminuir() . "\n<br/>";
?>

Resultado

Primera Instancia de Singleton ha sido creada
Primera Instancia (+): 10
Primera Instancia (+): 20
Primera Instancia (+): 30
Segunda Instancia (-): 20
Segunda Instancia (+): 30
Tercera Instancia (-): 20

Ahora para estar bien seguros de tener una sola instancia, debemos prevenir que el objeto sea clonado y también que sea serializado y deserializado.

Para evitar la clonación agregaremos el método __clone a nuestra clase y para la serialización el método __wakeup
Nuestra clase quedará de la siguiente manera

<?php 
 
class Singleton {
   private static $instancia;
   private $contador;
   protected $cantidad;
 
 
   private function __construct(){
      echo "Primera Instancia de " . __CLASS__ . " ha sido creada\n<br/>";
      $this->contador = 0;
      $this->setCantidad(10);
   }
 
   public static function getInstance() {
      if (  !self::$instancia instanceof self) {
         self::$instancia = new self;
      }
      return self::$instancia;
   }
 
   public function getCantidad(){
      return $this->cantidad;
   }
 
   public function setCantidad($value){
      $this->cantidad = intval($value);
   }
 
   public function incrementar(){
      return $this->contador+= $this->getCantidad();
   }
 
   public function disminuir() {
      return $this->contador-= $this->getCantidad();
   }
 
   public function __clone(){
      trigger_error("Operación Invalida: No es posible clonar una instancia de ". get_class($this) ." class.", E_USER_ERROR );
   }
 
   public function __wakeup(){
      trigger_error("Operación Invalida: No es posible deserializar una instancia de ". get_class($this) ." class.", E_USER_ERROR );
   }
}
?>

Ahora sí tenemos asegurado que la clase Singleton solo estará instanciada 1 vez.

El patrón de diseño factory, está basado en la instancia de objetos en tiempo de ejecución.

En pequeños proyectos no es frecuente usar éste patrón pero cuando los proyectos son grandes o trabajen muchas personas es muy común implementarlo.

Wikipedia posee una explicación perfecta

Factory Method consiste en utilizar una clase constructora (al estilo del Abstract Factory) abstracta con unos cuantos métodos definidos y otro(s) abstracto(s): el dedicado a la construcción de objetos de un subtipo de un tipo determinado. Es una simplificación del Abstract Factory, en la que la clase abstracta tiene métodos concretos que usan algunos de los abstractos; según usemos una u otra hija de esta clase abstracta, tendremos uno u otro comportamiento.

He aquí un ejemplo con varias clases para conectarse a diferentes base de datos, sin importar donde desee conectarme concentraré la instancia en una clase llamada BaseDeDatos

<?php
 
class MySQL{
  public function __construct(){
    echo "Instancio MySQL";
  }
}
 
class PostgreSQL{
  public function __construct(){
    echo "Instancio PostgreSQL";
  }
}
 
abstract class BaseDeDatos{
    public static function cargar($tipo){
        try {
            if (class_exists($tipo)) {
                return new $tipo;
            } else {
                throw new Exception("No existe la clase '$tipo'");
            }
        } catch (Exception $e) {
            echo 'Excepción capturada: ',  $e->getMessage(), "\n";
        }
    }
}
 
BaseDeDatos::cargar("MySQL");
echo "<br >";
BaseDeDatos::cargar("PostgreSQL");
echo "<br >";
BaseDeDatos::cargar("Oracle");
?>

Resultado

Instancio MySQL
Instancio PostgreSQL
Excepción capturada: No existe la clase 'Oracle'

Como resumen podemos decir que todo queda centralizado en la clase BaseDeDatos, y como puede observarse realiza una pequeña validación antes de realizar la instancia.

Me resulto un tanto difícil comenzar la introducción para éste capítulo, simplificar la explicación de los patrones de diseño no fue tarea sencilla, la pregunta obligada es:
¿Qué son los patrones de diseño?
Para esto busqué algunos conceptos que me guíen en la explicación y me tope en muchos lugares con la siguiente definición.
“Los patrones de diseño son el esqueleto de las soluciones a problemas comunes en el desarrollo de software”
Explicado con mis palabras, éstos ofrecen soluciones simples a problemas comunes en el desarrollo de software.
Con la gran cantidad de diseños de aplicaciones hay problemas que se repiten frecuentemente, entonces éstos responden a un cierto patrón.
Los patrones de diseño son un conjunto de buenas prácticas que pueden nos aliviarán el trabajo en muchas situaciones cuando realizamos una aplicación orientada a objetos

Sí vemos la introducción de éste capítulo como un problema y la frase que hallé como una solución ya probada podríamos decir que encontré un patrón de diseño para mi problema, a grandes rasgos éste es el concepto.

La seguridad en los parámetros es un concepto muy viejo pero es muy efectivo.
Los ataques SQL Injection son más comunes de lo que uno piensa, por ende las cadenas de texto (SQL) que enviamos al motor de la base de datos deben, como mínimo, prevenir este tipo de ataques.
La forma más común en estos ataques es cuando ingresamos valores externos a nuestro código a la base de datos, es decir un parámetro que venga por POST o GET.

Sí enviamos el siguiente query a la base

<?php
$query = "SELECT * FROM personas WHERE id = 5";
//envio el query
?>

no existe tal SQL Injection por que id = 5 será siempre id = 5 ya que esta embebido en nuestro código.

Un ejemplo diferente con una vulnerabilidad visible es el siguiente.

<?php
$query = "SELECT * FROM personas WHERE id = " . $_GET['id'];
//envio el query
?>

en este caso debemos prevenir que $_GET['id'] no contenga ningún código malicioso.

Cuando trabajamos con bases de datos Oracle tenemos a nuestro disposición la función oci_bind_by_name que realizará un blindaje sobre los parámetros, un metodología similar a stmt de mysqli.

<?php
$conn = oci_connect("usuario", "contraseña", "localhost/XE");
if (!$conn) {
    $m = oci_error();
    trigger_error(htmlentities($m['message']), E_USER_ERROR);
}
 
$sql = 'SELECT id,nombre,apellido FROM personas WHERE id = :id';
$stid = oci_parse($conn, $sql);
$id = $_GET['id'];
oci_bind_by_name($stid, ':id', $id);
oci_execute($stid);
$fila = oci_fetch_array($stid, OCI_ASSOC);
print_r($fila);
 
oci_free_statement($stid);
oci_close($conn);
?>

oci_fetch_array es la función que usaremos para transformar la fila de base de datos en array para tenerlo disponible y poder imprimirlo o procesarlo donde querramos

<?php
 
$conn = oci_connect('usuario', 'contraseña', 'localhost/XE');
if (!$conn) {
    $e = oci_error();
    trigger_error(htmlentities($e['message'], ENT_QUOTES), E_USER_ERROR);
}
 
$stid = oci_parse($conn, 'SELECT id, nombre FROM personas');
oci_execute($stid);
 
while (($row = oci_fetch_array($stid, OCI_BOTH))) {
    // El array asociativo poseerá los índices en mayúsculas
    echo $row['ID'] . " - " . $row['NOMBRE'] . "\n<br/>";
}
 
oci_free_statement($stid); //libero la memoria
oci_close($conn); //cierro la conexión
 
?>

Como en otras secciones del libro, mysql, sqlite y Microsoft SQL Server, para realizar un ABM necesitamos tener el código SQL correcto para enviarlo a la base de datos a través de una función que nos provee PHP, la función especifica para Oracle es oci_execute, pero para ejecutarla primero debemos preparar la cadena de texto SQL con oci_parse

<?php
//alta.php
$conn = oci_connect('usuario', 'contraseña', 'localhost/XE');
$query = "INSERT INTO mitabla (columna) VALUES ('valor')";
$stid = oci_parse($conn, $query);
oci_execute($stid); // La fila es comiteada y quedará disponible para todos los usuarios
?>

<?php
//baja.php
$conn = oci_connect('usuario', 'contraseña', 'localhost/XE');
$query = "DELETE FROM mitabla id = 10";
$stid = oci_parse($conn, $query);
oci_execute($stid); // La fila es comiteada y quedará disponible para todos los usuarios
?>

<?php
//modificacion.php
$conn = oci_connect('usuario', 'contraseña', 'localhost/XE');
$query = "UPDATE mitabla set columna='otro valor' WHERE id = 5";
$stid = oci_parse($conn, $query);
oci_execute($stid); // La fila es comiteada y quedará disponible para todos los usuarios
?>

Cuando tenemos que buscar dentro de un campo determinada cadena de texto podemos encontrarnos con la dificultad de de distinguir entre mayúsculas y minúsculas.
El charset (en español cotejamiento) es la respuesta a nuestro conflicto, éste es definido al momento de crear el campo, podemos decir que es case sensitive (cs) o que no lo es (ci)

Sí no elegimos un charset el campo tomará como predeterminado el charset de la tabla, cuando la creamos debemos indicarlo.

Empecemos creando una tabla indicando un charset que no sea case sensitive

CREATE TABLE `personas` (
  `id` INT(11) NOT NULL DEFAULT '0',
  `nombre` VARCHAR(255) NOT NULL,
  `apellido` VARCHAR(255) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_spanish_ci;

Supongamos que yo tengo el siguiente registro

1 Daniel Segovia

Busquemos la cadena de texto “daniel” (en minúscula) en el campo nombre

SELECT * FROM personas WHERE nombre LIKE 'daniel'

MySQL me devolverá este registro ya que el campo nombre no esta definido como case sensitve

Cambiemos el charset de una tabla case sensitive (latin1_spanish_ci) a no case sensitive (latin1_bin)

ALTER TABLE `personas` 
CHARSET=latin1 COLLATE=latin1_bin;

Sí realizamos la misma búsqueda que hicimos antes el resultado sería el mismo, nos devolvería el registro. Esto se debe a que no estamos cambiando el charset del campo nombre, solo estamos cambiando la definición de la tabla, esto producirá que cuando se cree un campo de texto nuevo y no se defina un charset este ahora será latin1_bin.

Para cambiar la definición del campo debemos hacerlo con el siguiente código

ALTER TABLE `personas` 
CHANGE `nombre` `nombre` VARCHAR( 255 ) 
CHARACTER SET latin1 COLLATE latin1_bin

Ahora sí dentro de una consulta “Daniel” será distinto de “daniel” entonces la consulta previa que realizamos no nos retornará ningún resultado.

Por último, sí tenemos un campo que es case sensitive podemos realizar una búsqueda y decirle al motor de base de datos para ésta búsqueda que no sea case sensitive

SELECT * FROM `personas` WHERE nombre LIKE 'daniel' COLLATE utf8_spanish_ci

PHP nos ofrece 2 posibilidad para conectarnos a Oracle

php_oracle
Es una librería un tanto antigua pero es una muy buena opción sí no deseamos trabajar con datos tipo BLOB o CLOB.

php_oci8
Librería que permite conectarse a Oracle Database desde la versión 8.0 y posteriores. Posee muchas más funciones y funciona con BLOB y CLOB.

Usaremos oci8 a lo largo de esta sección, para conectarnos lo haremos con la función oci_connect

<?php
// Conectandose al servicio "XE" sobre la dirección "localhost"
$conn = oci_connect('usuario', 'contraseña', 'localhost/XE');
if (!$conn) {
    $e = oci_error();
    trigger_error(htmlentities($e['message'], ENT_QUOTES), E_USER_ERROR);
}
echo 'Conectado';
?>

OCI8 nos brinda una serie de funciones para trabajar con bases de datos Oracle 11g, 10g, 9i y 8i. Soportan sentencias SQL y PL/SQL. Incluyen transacciones, marcadores de posición oracle, LOB, colecciones, escalabilidad de la base de datos Oracle, agrupamiento de conexiones residentes o Resident Connection Pooling (DRCP) y el almacenamiento en cache de resultados

La página oficial de Oracle posee un manual de PHP y Oracle
Link directo al manual

Leí un muy buen artículo en catswhocode sobre htaccess

1) Forzar la barra final: Como agregar la barra final en las url, ideal para SEO

<IfModule mod_rewrite.c>
 RewriteCond %{REQUEST_URI} /+[^\.]+$
 RewriteRule ^(.+[^/])$ %{REQUEST_URI}/ [R=301,L]
</IfModule>

2) Prevenir hotlinks: Para que no usen las imágenes desde nuestro servidor directamente y nos consuman el tráfico

RewriteEngine On
#Replace ?mysite\.com/ reemplace por su URL
RewriteCond %{HTTP_REFERER} !^http://(.+\.)?mysite\.com/ [NC]
RewriteCond %{HTTP_REFERER} !^$
#Replace /images/nohotlink.jpg reemplace por la imagen que desea mostrar
RewriteRule .*\.(jpe?g|gif|bmp|png)$ /images/nohotlink.jpg [L]

3) Redireccionar dispositivos moviles: Detecta sí es un dispositivo móvil y redirecciona a donde indiquen

RewriteEngine On
RewriteCond %{REQUEST_URI} !^/m/.*$
RewriteCond %{HTTP_ACCEPT} "text/vnd.wap.wml|application/vnd.wap.xhtml+xml" [NC,OR]
RewriteCond %{HTTP_USER_AGENT} "acs|alav|alca|amoi|audi|aste|avan|benq|bird|blac|blaz|brew|cell|cldc|cmd-" [NC,OR]
RewriteCond %{HTTP_USER_AGENT} "dang|doco|eric|hipt|inno|ipaq|java|jigs|kddi|keji|leno|lg-c|lg-d|lg-g|lge-" [NC,OR]
RewriteCond %{HTTP_USER_AGENT}  "maui|maxo|midp|mits|mmef|mobi|mot-|moto|mwbp|nec-|newt|noki|opwv" [NC,OR]
RewriteCond %{HTTP_USER_AGENT} "palm|pana|pant|pdxg|phil|play|pluc|port|prox|qtek|qwap|sage|sams|sany" [NC,OR]
RewriteCond %{HTTP_USER_AGENT} "sch-|sec-|send|seri|sgh-|shar|sie-|siem|smal|smar|sony|sph-|symb|t-mo" [NC,OR]
RewriteCond %{HTTP_USER_AGENT} "teli|tim-|tosh|tsm-|upg1|upsi|vk-v|voda|w3cs|wap-|wapa|wapi" [NC,OR]
RewriteCond %{HTTP_USER_AGENT} "wapp|wapr|webc|winw|winw|xda|xda-" [NC,OR]
RewriteCond %{HTTP_USER_AGENT} "up.browser|up.link|windowssce|iemobile|mini|mmp" [NC,OR]
RewriteCond %{HTTP_USER_AGENT} "symbian|midp|wap|phone|pocket|mobile|pda|psp" [NC]
#------------- The line below excludes the iPad
RewriteCond %{HTTP_USER_AGENT} !^.*iPad.*$
#-------------
RewriteCond %{HTTP_USER_AGENT} !macintosh [NC] #*SEE NOTE BELOW
RewriteRule ^(.*)$ /m/ [L,R=302]

4) Descargar archivos: Forzar a descargar determinados tipos de archivos

<Files *.xls>
  ForceType application/octet-stream
  Header set Content-Disposition attachment
</Files>
<Files *.eps>
  ForceType application/octet-stream
  Header set Content-Disposition attachment
</Files>

5) Incrustar una fuente en Firefox: Al incrustar una fuente, Firefox no le permiten integrar de una página web externa. con el siguiente código puede evitar esta limitación.

<FilesMatch "\.(ttf|otf|eot|woff)$">
<IfModule mod_headers.c>
    Header set Access-Control-Allow-Origin "http://yourdomain.com"
</IfModule>
</FilesMatch>

6) Acelerar la velocidad de tu sitio: Acelerar el sitio con cache para los archivos que creamos conveniente

# 1 año
<FilesMatch "\.(ico|pdf|flv)$">
Header set Cache-Control "max-age=29030400, public"
</FilesMatch>
# 1 semana
<FilesMatch "\.(jpg|jpeg|png|gif|swf)$">
Header set Cache-Control "max-age=604800, public"
</FilesMatch>
# 2 días
<FilesMatch "\.(xml|txt|css|js)$">
Header set Cache-Control "max-age=172800, proxy-revalidate"
</FilesMatch>
# 1 minuto
<FilesMatch "\.(html|htm|php)$">
Header set Cache-Control "max-age=60, private, proxy-revalidate"
</FilesMatch>

7) Frenar el spam en tú página: Tenés un wordpress? Sabes de lo que estoy hablando, bloquea el spam en tu wordpress de una manera sencilla

<IfModule mod_rewrite.c>
RewriteEngine On
RewriteCond %{REQUEST_METHOD} POST
RewriteCond %{REQUEST_URI} .wp-comments-post\.php*
RewriteCond %{HTTP_REFERER} !.*yourdomainname.* [OR]
RewriteCond %{HTTP_USER_AGENT} ^$
RewriteRule (.*) ^http://%{REMOTE_ADDR}/$ [R=301,L]
</IfModule>

8 ) Redirigir a diferentes lugares: Te permite redirigir diferentes feeds RSS, Atom o RDF a diferentes lugares

<IfModule mod_alias.c>
 RedirectMatch 301 /feed/(atom|rdf|rss|rss2)/?$ http://example.com/feed/
 RedirectMatch 301 /comments/feed/(atom|rdf|rss|rss2)/?$ http://example.com/comments/feed/
</IfModule>

9) Configure su sitio web para videos HTML5

RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_URI} !=/favicon.ico
AddType video/ogg .ogv
AddType video/ogg .ogg
AddType video/mp4 .mp4
AddType video/webm .webm
AddType application/x-shockwave-flash swf

10) Corre PHP dentro de archivos Javascript

AddType application/x-httpd-php .js
AddHandler x-httpd-php5 .js
 
<FilesMatch "\.(js|php)$">
SetHandler application/x-httpd-php
</FilesMatch>

PHP nos ofrece varias posibilidades para recuperar la información guardada en la base de datos MS SQL Server.
Veremos 2 funciones, mssql_fetch_array que nos recuperará el contenido de una fila como un array con índices numéricos y también mssql_fetch_assoc que nos traerá el contenido en forma de array con los índices de texto iguales a los nombres de los campos en la base de datos.

<?php
//fetch_array
$server = 'MISERVER\SQLEXPRESS';
 
// Conectando a MSSQL
$link = mssql_connect($server, 'sa', 'password');
 
if (!$link) {
    die('Ha ocurrido un error mientras intentaba conectarse a MSSQL');
}
 
$query = mssql_query('SELECT [usuario], [email] FROM [php].[dbo].[usuarios]');
 
while ($row = mssql_fetch_array($query, MSSQL_NUM)) {
    echo "Usuario: " . $row[0] . " - Email: " . $row[1] . "<br />";
}
?>

<?php
//fetch_assoc
$server = 'MISERVER\SQLEXPRESS';
 
// Conectando a MSSQL
$link = mssql_connect($server, 'sa', 'password');
 
if (!$link) {
    die('Ha ocurrido un error mientras intentaba conectarse a MSSQL');
}
 
$query = mssql_query('SELECT [usuario], [email] FROM [php].[dbo].[usuarios]');
 
while ($row = mssql_fetch_assoc($query)) {
    echo "Usuario: " . $row['usuario'] . " - Email: " . $row['email'] . "<br />";
}
?>

Tenemos la función mssql_query para ejecutar los querys, con la cadena de texto con sintaxis correcta de SQL procederemos a ejecutarlos en el motor de base de datos.

Código SQL

// Insertar
INSERT INTO clientes (razon_social, direccion) VALUES ('Pepsico', 'Florida 55202');
// Actualizar
UPDATE clientes SET razon_social = 'Pepsico Snack' WHERE id = 15;
// Eliminar
DELETE FROM clientes WHERE id = 15

Código para insertarlo en el motor MS SQL Server

<?php
//actualizar.php
$server = 'MISERVER\SQLEXPRESS';
 
// Conectando a MSSQL
$link = mssql_connect($server, 'sa', 'password');
 
if (!$link) {
    die('Ha ocurrido un error mientras intentaba conectarse a MSSQL');
}
$sql = "INSERT INTO clientes (razon_social, direccion) VALUES ('Pepsico', 'Florida 55202')";
mssql_query($sql);
?>

<?php
//insertar.php
$server = 'MISERVER\SQLEXPRESS';
 
// Conectando a MSSQL
$link = mssql_connect($server, 'sa', 'password');
 
if (!$link) {
    die('Ha ocurrido un error mientras intentaba conectarse a MSSQL');
}
$sql = "UPDATE clientes set razon_social = 'Pepsico Snack' WHERE id = 15";
mssql_query($sql);
?>

<?php
//eliminar.php
$server = 'MISERVER\SQLEXPRESS';
 
// Conectando a MSSQL
$link = mssql_connect($server, 'sa', 'password');
 
if (!$link) {
    die('Ha ocurrido un error mientras intentaba conectarse a MSSQL');
}
$sql = "DELETE FROM clientes WHERE id = 15";
mssql_query($sql);
?>

Para conectarnos a una base de datos Microsoft SQL Server PHP nos proporciona la función mssql_connect
Posee 4 parámetros, servidor, usuario, contraseña y nuevo link (devuelve un nuevo identificador), usualmente los 3 primeros son los más usados.

<?php
$server = 'MISERVER\SQLEXPRESS';
 
// Conectando a MSSQL
$link = mssql_connect($server, 'sa', 'password');
 
if (!$link) {
    die('Ha ocurrido un error mientras intentaba conectarse a MSSQL');
}
?>

PHP brinda soporte para base de datos Microsoft SQL Server pero sobre la plataforma de Windows a partir de la versión 5.3 dejo de brindarle soporte.
Un driver alternativo para MS SQL está disponible para Microsoft: http://msdn.microsoft.com/en-us/sqlserver/ff657782.aspx

La lista de funciones disponibles son las siguientes

• mssql_bind: Agrega un parámetro a un procedimiento almacenado o a un procedimiento almacenado remoto
• mssql_close: Cierra una conexión MS SQL Server
• mssql_connect: Abre una conexión MS SQL Server
• mssql_data_seek: Mueve el puntero a la fila deseada
• mssql_execute: Ejecuta un procedimiento almacenado sobre una base de datos MS SQL Server
• mssql_fetch_array: Devuelve una fila del resultado como matriz asociativa, numérica o ambas
• mssql_fetch_assoc: Devuelve una fila del resultado como matriz asociativa, con índices de texto
• mssql_fetch_batch: Devuelve el siguiente lote de registros
• mssql_fetch_field: Obtiene información del campo
• mssql_fetch_object: Devuelve la fila como objeto
• mssql_fetch_row: Obtiene registros como un array enumerado
• mssql_field_length: Obtener la longitud de un campo
• mssql_field_name: Obtener el nombre de un campo
• mssql_field_seek: Mueve el puntero a un campo especifico
• mssql_field_type: Obtiene el tipo de un campo
• mssql_free_result: Libera el resultado de la memoria
• mssql_free_statement: Libera la declaración de la memoria
• mssql_get_last_message: Devuelve el último mensaje proveniente del Server
• mssql_guid_string: Convierte un binario de 16 byte a un texto
• mssql_init: Inicializa un procedimiento almacenado o un procedimiento almacenado remoto
• mssql_min_error_severity: Establece la gravedad del error mínimo
• mssql_min_message_severity: Establece la gravedad del mensaje mínimo
• mssql_next_result: Mueve el puntero al siguiente resultado
• mssql_num_fields: Gets the number of fields in result
• mssql_num_rows: Obtiene el número de filas en el resultado
• mssql_pconnect: Abre una conexión persistente/li>
• mssql_query: Envía un query a la base MS SQL Server
• mssql_result: Obtiene el resultado
• mssql_rows_affected: Retorno el número de registros afectados por el query
• mssql_select_db: Selecciona una base de datos MS SQL Server

Una transacción es una secuencia de operaciones realizadas como una sola unidad lógica, ésta debe exponer 4 propiedades.

1. Atomicidad: Asegura que la operación se ha realizado o no.
2. Consistencia: Asegura que sólo empieza todo lo que se puede acabar.
3. Aislamiento: Asegura que una operación no puede afectar a otras. Es decir, la realización de dos o más transacciones sobre la misma información sean independientes y no esto no producirá ningún tipo de error.
4. Durabilidad: Asegura que una vez realizada la operación, ésta quedará persistente y no podrá deshacerse aunque el sistema.

Sí el motor de base de datos posee estás 4 propiedades éste puede ser considerado ACID Compliant (Atomicity, Consistency, Isolation and Durability)

Veamos el ejemplo de recuperar los datos con una transacción

<?php
$db = new SQLiteDatabase("db.sqlite");
 
// Traigo todos los registros de la tabla personas
$result = $db->query("BEGIN; SELECT * FROM personas; COMMIT;");
 
// ciclo el resultado
while($result->valid()) {
    $row = $result->current();
    echo $row['id'].' - '.$row['nombre'].' - '.$row['apellido'].'<br />';
    $result->next();
}
?>

Como puede observarse en el query poseemos BEGIN; y COMMIT; en medio de nuestra consulta que recupera los datos (los puntos y comas separan cada consulta). Esto se debe a que iniciamos una transacción en la base de datos, BEGIN da comienzo a ésta, luego se realiza el o los querys y por último COMMIT hace efectivos estos querys. Las transacciones nos dan la posibilidad de volver atrás en cualquier momento y deshacer todo lo hecho previamente con ROLLBACK.
Por ejemplo sí tenemos que crear 10 tablas podemos iniciar una transacción, sí por algún motivo los 6 primeros querys tienen la sintaxis correcta y no hacen ningún tipo de colisión y nuestra séptima instrucción da algún error con ROLLBACK podemos deshacer todos los querys después del comienzo de la transacción.

Es un tema muy amplio el de las transacciones y las bases de datos en general, así que como dije al principio del capítulo estaremos más abocados a aprender PHP

El procedimiento es similar a los demás motores de base de datos.
Ejecutamos el query, ciclamos el resultado y cuando no hay más contenido el método nos devolverá false y esto acabará con el ciclo while

<?php
$db = new SQLiteDatabase("db.sqlite");
 
// Traigo todos los registros de la tabla personas
$result = $db->query("SELECT * FROM personas");
 
// ciclo el resultado
while($result->valid()) {
    $row = $result->current();
    echo $row['id'].' - '.$row['nombre'].' - '.$row['apellido'].'<br />';
    $result->next();
}
?>

Era una caída anunciada que ni todo el dinero del mundo podía detenerla, eso sí, su posición económica lo ayudo a estirar su enfermedad un largo tiempo.
Éstas últimas semanas no paré de escuchar todo tipo de adjetivos referidos a su persona, pero el que poderosamente me llama la atención es el de revolucionario.
No entiendo del todo por el que termino se usa con tanta liviandad, tengo la sensación de que el mote le queda un tanto grande.

Veamos un párrafo que se filtro de su biografía que saldrá el próximo lunes 24 de octubre
“Dedicaré hasta mi último suspiro si lo necesito, y voy a gastar cada centavo de los 40.000 millones de dólares que Apple tiene en el banco para terminar con esta injusticia. Voy a destruir Android porque es un producto robado. Estoy dispuesto a ir a una guerra termonuclear.”

Ahora bien, él sostenia que Android era un producto robado, su afirmación es discutible, los Apple Fan dirán que si, los Android Fan dirán que no y estarán los que opinan que algunas cosas tiene del producto de la manzanita mezclado con sus ideas.

Veamos los productos de Apple entonces.

Ipod + Itunes, no es cierto que el Ipod fue el primer reproductor digital de música portátil, el primer MP3 vio la luz en el año 1998 cuando el Ipod lanzó su primera versión en 2001

El Itunes es una plataforma para descargar contenido, no le veo gran revolución en éste producto. Recordemos que 2 años ya estaba en el mercado el entrañable Napster. Qué tendrá que ver Itunes con Napster? En principio nada, pero sí sabemos que Napster consistía en un programa para descargar y compartir música con otros usuarios Itunes pierde un poco de genialidad ya que realizaba está acción como principal característica con algún valor agregado y sus particularidades que encajaban con sus productos.

Vamos al Iphone, qué me perdí?, invento el teléfono?, lo miro de un lado o del otro y sigo viendo un teléfono, tiene algunas características muy buenas como la cámara de fotos, que en su primera versión no tenía y para esa época ya había muchos dispositivos móviles ésta particularidad, recuerdo que después de unos cuantos Iphone X lanzaron finalmente el producto con cámara, fue un verdadero revuelo, un Iphone con cámara.
Ahora sí vamos lo que el Iphone tenía que el resto no, el Touch Screen, un teléfono sin botones, todo se realiza tocando la pantalla, brillante!!.
Tiene sus méritos mezclo un producto de 1983 (el celular) con uno de 1971 (pantalla tactil invento de Sam Hurst).

En fin, cada uno puede tener su visión sobre Steve Jobs, personalmente creo que fue una persona inteligente que supo combinar ideas existentes lanzando muy buenos productos. Éstos siempre estuvieron acompañados de monstruosas campañas de marketing que generaban cierta “adicción” en los usuarios y lo convirtieron a él en “revolucionario”.

La perdida de un verdadero genio fue la de Dennis Ritchie, uno de los creadores de C, unos pocos días después de Steve. Me hubiera gustado verlo un poco más en la televisión y más gente diciéndole gracias, pero bueno, seguramente falló en no tener un bueno departamento de marketing.

Añado esto que encontré en Facebook

Jobs: Elogiado por los medios de comunicación como Jesús de la computación
Ritchie: Ignorado

Como hemos visto en el ejemplo de creación de tablas con sqlite, solamente tenemos que enviar el código correcto en lenguaje SQL a través del método query, para realizar un ABM seguiremos éste mismo camino.
Tendremos nuestro código SQL y lo enviaremos al motor de base de datos.
Usaremos el modelo de la tabla que ya hemos creado.

Aquí todo en lenguaje SQL

//Insetar (A = alta)
INSERT INTO personas (nombre, apellido) VALUES ('Juan', 'Car');
//Actualizar (M = modificar)
UPDATE personas SET apellido = 'Perez' WHERE id = 5
//Eliminar (B = baja)
DELETE FROM personas WHERE id = 10

Código para insertar en Sqlite

<?php
$db = new SQLiteDatabase("db.sqlite");
// Inserto un registro en la tabla personas
$sql = "INSERT INTO personas (nombre, apellido) VALUES ('Juan', 'Car');";
$db->query($sql);
?>

Código para actualizar en Sqlite

<?php
$db = new SQLiteDatabase("db.sqlite");
// Actualizo el registro id=5 en la tabla personas
$sql = "UPDATE personas set apellido = 'Perez' WHERE id = 5";
$db->query($sql);
?>

Código para eliminar en Sqlite

<?php
$db = new SQLiteDatabase("db.sqlite");
// Elimino el registro id=10 en la tabla personas
$sql = "DELETE FROM personas WHERE id = 10";
$db->query($sql);
?>

Actualmente no he probado ningún gestor de Sqlite, mi manera para crear las tablas es a la vieja usanza, con el código SQL.
El código SQL (al igual que en los motores de base de datos que ya hemos visto) es simplemente una cadena de texto que mediante un método o función le es enviada a la base de datos para que sea procesado.
Al instanciar la clase sqlite nos encontramos con una lista de métodos, query es el que nos permitirá realizar el envío del código a la base.
Para crear las tablas usaremos el siguiente código SQL

    CREATE TABLE personas (
      id INTEGER PRIMARY KEY,
      nombre VARCHAR(255) NOT NULL,
      apellido VARCHAR(255) NOT NULL
    );

Ahora el ejemplo completo con PHP

<?php
$db = new SQLiteDatabase("db.sqlite");
// Creo la tabla personas
$db->query("
    CREATE TABLE personas (
      id INTEGER PRIMARY KEY,
      nombre varchar(255) NOT NULL,
      apellido varchar(255) NOT NULL
    );
");
?>

Crear una base de datos con sqlite es sumamente sencillo, solo basta con instanciar la clase para que esta sea creada.
En la instancia el primer parámetro será el nombre de la base, sí no existe intentara crearla y sí ya previamente existe solamente generará la instancia de la clase y la base quedará seleccionada.

<?php
$bd_nombre = 'base';
 
$objeto = new SQLiteDatabase($bd_nombre, 0666, $error);
if ($error){
    exit($error);
}
?>

SQLite es una librería escrita en C que implementa un motor de base de datos SQL.
Con PHP podemos tener acceso a una base de datos SQL, sin tener que ejecutar un programa de RDBMS separado, esto reduce el tiempo de conexión y también de las transacciones siguientes.
La base de datos y su definición (tablas, índices y los datos), son guardados como un sólo archivo en donde esta corriendo el script. Este diseño simple se logra bloqueando todo el fichero de base de datos al principio de cada transacción.

Sus desarrolladores resaltan que sus principales características:

• Completo soporte para tablas e índices en un único archivo por base de datos
• Soporte transaccional
• Rapidez, unas 2 veces mas veloz que MySQL y PostgreSQL
• Escaso tamaño de la librería
• Completa portabilidad.

La seguridad en las consultas enviadas a la base de datos la daremos con el método bind_param.
Éste método agrega variables a una sentencia preparada como parámetros.
bind_param buscará en la sentencia preparada todos los signos de pregunta ? y los reemplazará por las variables que le asignemos.
Es obligatorio indicar de que tipo es el valor que estamos inyectando, la sintaxis es la siguiente

SELECT * from paises WHERE nombre = ?
bind_param('s', 'Argentina');
SELECT * from paises WHERE nombre = 'Argentina'

Como puede observarse en la primera línea tenemos “nombre = ?”, no escapamos los caracteres ni tampoco agregamos las comillas que encierran la cadena de texto.
El primer parámetro ‘s’ indica que la variable que vamos a reemplazar es de tipo string, aquí la tabla con los tipos permitidos

• i variable de tipo entero
• d variable de tipo doble
• s variable de tipo texto
• b variable de tipo blob y se envía en paquetes

Un ejemplo concreto

<?php
$mysqli = new mysqli("localhost", "usuario", "password", "base");
 
if (mysqli_connect_errno()) {
    printf("Imposible conectarse: %s\n", mysqli_connect_error());
    exit();
}
 
$cliente = 'coto'; 
 
$query = "SELECT client, partner FROM business WHERE client=?";
 
/* Ejecuto el método prepare y este me va a devolver el objeto */
if ($stmt = $mysqli->prepare($query)) {
 
    $stmt->bind_param('s', $cliente);
 
    /* ejecuto el  query */
    $stmt->execute();
 
    $stmt->bind_result($client, $partner);
 
    $stmt->fetch();
 
    /* cierro stmt */
    $stmt->close();
}
 
echo $client . "<br />";
echo $partner . "<br />";
 
$mysqli->close();
?>

Muchas veces necesitamos inyectar más de una variable en una misma consulta preparada, de esta manera podemos ingresar ilimitadas variables

<?php
$mysqli = new mysqli("localhost", "usuario", "password", "base");
 
if (mysqli_connect_errno()) {
    printf("Imposible conectarse: %s\n", mysqli_connect_error());
    exit();
}
 
$cliente = 'coto'; 
$product_id = 1;
 
$query = "SELECT client, partner FROM business WHERE client=? AND product_id=?";
 
/* Ejecuto el método prepare y este me va a devolver el objeto */
if ($stmt = $mysqli->prepare($query)) {
    /* El primero parámetro es tipo string y el segundo es entero */
    $stmt->bind_param('si', $cliente, $product_id);
 
    /* ejecuto el  query */
    $stmt->execute();
 
    $stmt->bind_result($client, $partner);
 
    $stmt->fetch();
 
    /* cierro stmt */
    $stmt->close();
}
 
echo $client . "<br />";
echo $partner . "<br />";
 
$mysqli->close();
?>