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
?>

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

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