Vamos a ver como informar al magnífico ORM Doctrine de que debe tratar un par de tablas con una relación many-to-many utilizando una tabla intermedia.

Supongamos que tenemos una talba de jugadores de fútbol y una tabla de equipos. Un equipo estará compuesto por varios jugadores y a su vez, un jugador puede estar relacionado con varios equipos (el actual, más los equipos por los que ha pasado en su vida deportiva).

Para este ejemplo necesitaremos tres tablas: Team, Player  y una relacional TeamPlayer. El schema.yml de este escenario sería:

# Player table
Player:
  tableName: player
  columns:
    id:
      type: integer(4)
      unsigned: 1
      primary: true
      autoincrement: true
    first_name: string(255)
    last_name: string(255)
    weight: float(2147483647)
    height: float(2147483647)
  relations:
    Team:
      <strong>class</strong>: Team
      <strong>local</strong>: player_id
      <strong>foreign</strong>: team_id
      <strong>refClass</strong>: TeamPlayer

#Team table
tableName: team
  columns:
    id:
      type: integer(4)
      unsigned: 1
      primary: true
      autoincrement: true
    name: string(255)
  relations:
    Player:
      <strong>class</strong>: Player
      <strong>local</strong>: team_id
      <strong>foreign</strong>: player_id
      <strong>refClass</strong>: TeamPlayer

#TeamPlayer table
TeamPlayer:
  tableName: team_player
  columns:
    team_id:
      type: integer(4)
      unsigned: 1
      primary: true
    player_id:
      type: integer(4)
      unsigned: 1
      primary: true

Los puntos importantes están en las relaciones de las tablas Team y Player, donde indicaremos los campos:

• class: La clase encargada de manejar el objeto relacionado.
• local: El nombre del campo que hace de vínculo entre la tabla en la que estoy y la tabla relacional TeamPlayer
• foreign: El nombre del campo que hace de vínculo entre la tabla relacionada y la tabla relacional TeamPlayer
• refClass: Nombre del objeto encargado de realizar la relación

Siguiendo estos pasos podremos acceder a todos los equipos de un jugador y a todos los jugadores de un equipo sin ningún problema.

Symfony integra Propel ORM por defecto, sin embargo, Doctrine está ganando puntos sobre su rival.

La principal ventaja de cada uno de ellos es:

Propel: Está completamente integrado con Symfony y decenas de plugins sólo funcionan para Propel.

Doctrine: Tiene muy buen rendimiento en ejecución y una forma muy concisa al escribir consultas complejas.

Si te has decidido a utilizar Doctrine en lugar de Propel y no sabes como integrarlo con Symfony, aquí te dejo los pasos para activarlo.

1. Lo primero que deberemos hacer es habilitar sfDoctrinePlugin y deshabilitar sfPropelPlugin, esto lo haremos editando el archivo config/ProjectConfiguration.class.php :

   public function setup()
   {
     $this->enablePlugins(array('sfDoctrinePlugin'));
     $this->disablePlugins(array('sfPropelPlugin'));
   }
   

   o si lo prefieres, puedes habilitar todos los plugins por defecto excepto los que no te interesen:

   public function setup()
   {
     $this->enableAllPluginsExcept(array('sfPropelPlugin'));
   }
   

2. Activado Doctrine, borraremos la caché para asegurarnos que se cargan nuestros cambios:
   symfony cc
3. Crearemos una carpeta doctrine dentro de config que contendrá nuestro archivo schema.yml y listo, ya tenemos a Symfony funcionando con Doctrine
4. Ahora sólo queda abrir el archivo config/databases.yml y cambiar “propel” por “doctrine” (respetando mayúsculas y minúsculas) y eliminar la linea “classname:  PropelPDO“.

Recordemos que a partir de ahora, deberemos utilizar la sintaxis Doctrine, tanto en nuestra definición del schema como en el modelo de nuestra aplicación. Si son tus primeros pasos con Doctrine, puedes ver su documentación original aquí.

Qué es un ORM?

Un ORM o (Object Relation Mapper) es una técnica de programación que nos permite convertir datos entre el sistema de tipos utilizado en un lenguaje de programación orientado a objetos y el utilizado en una base de datos relacional, es decir, las tablas de nuestra base de datos pasan a ser clases y los registros objetos que podemos manejar con facilidad.

Utilizar un ORM tiene una serie de ventajas que nos facilitan enormemente tareas comúnes y de mantenimiento:

1. Reutilización: La principal ventaja que aporta un ORM es la reutilización permitiendo llamar a los métodos de un objeto de datos desde distintas partes de la aplicación e incluso desde diferentes aplicaciones.
2. Encapsulación: La capa ORM encapsula la lógica de los datos pudiendo hacer cambios que afectan a toda la aplicación únicamente modificando una función.
3. Portabilidad: Utilizar una capa de abstracción nos permite cambiar en mitad de un proyecto de una base de datos MySQL a una Oracle sin ningún tipo de complicación. Esto es debido a que no utilizamos una sintaxis MySQL, Oracle o SQLite para acceder a nuestro modelo, sino una sintaxis propia del ORM utilizado que es capaz de traducir a diferentes tipos de bases de datos.
4. Seguridad: Los ORM suelen implementar mecanísmos de seguridad que protegen nuestra aplicación de los ataques más comúnes como SQL Injections.
5. Mantenimiento del código: Gracias a la correcta ordenación de la capa de datos, modificar y mantener nuestro código es una tarea sencilla.

Qué es Doctrine?

Según la documentación oficial, Doctrine es un ORM para PHP 5.2.3 y posterior. Además de todas las ventajas que conlleva un ORM, uno de sus puntos fuertes es su lenguaje DQL (Doctrine Query Language) inspirado en el HQL de Hibernate.

Cuando trabajamos con Doctrine, necesitamos informar a su motor interno de cual es el modelo de nuestra aplicación, para ello podemos hacer ingeniería inversa de nuestra base de datos existente, o si empezamos la aplicación desde 0, crear el modelo en la sintaxis específica que nos propone Doctrine y luego generar toda la base de datos.

Para crear el modelo, doctrine nos da dos alternativas, hacer una clase por tabla e indicarle mediante PHP el tipo de datos que almacenaremos en él, un ejemplo:

// models/generated/BaseUser.php

class User extends BaseUser
{
    public function setTableDefinition()
    {
        $this->hasColumn('username', 'string', 255, array('default' => 'default username'));
        $this->hasColumn('name', 'string', 255, array('default' => 'default name'));
        $this->hasColumn('age', 'integer', 4, array('unsigned' => true));
        // ...
    }

    // ...
}

O crear un esquema en formato YAML (schema.yml) similar a XML, pero bastante más legible. El equivalente al ejemplo anterior en YAML sería:

# schema.yml

# ...
User:
# ...
  columns:
    username:
      type: string(255)
      default: default username
    name:
      type: string(255)
      default: default name
    age:
      type: integer(4)
      unsigned: true
    # ...

Además de definir los campos de cada tabla, también le indicamos las relaciones que tienen con las otras tablas y su tipo (many-to-many, one-to-many, one-to-one…), lo que deja perfectamente estructurada nuestro modelo de datos y su manera de acceder a los valores.

Más adelante seguiré escribiendo sobre las ventajas de Doctrine y añadiendo ejemplos que considere interesantes y/o útiles.