Este artículo ha sido consultado en 3,799 ocasiones.

Active Record

ActiveRecord es un patrón de diseño el cual permite crear un objeto que "envuelve" una tabla SQL, agregándole la lógica del modelo y el control de acceso. Este patrón de diseño permite unir el mundo de la programación orientada a objetos (OOP), que es un mundo intuitivo y "natural", con el mundo matemático y rígido de los datos relacionales (SQL).

Usar POO y SQL dentro de una aplicación es como si un arquitecto quisiese usar dos tipos totalmente diferentes de materiales (con propiedades y pesos diferentes) en una misma estructura: la mezcla sería una gran y continua molestia al momento de diseñar los espacios, calcular los pesos y las distancias.

En Cake la convención es crear la tabla en plural dentro la BD y usar el singular como nombre del modelo, es decir para la tabla 'users' el modelo es 'User', para la tabla 'dogs' el modelo es 'Dog', etcétera. Active Record permite diseñar los programas usando la OOP de una manera homogénea sin tener que pensar las tablas SQL como elementos "insertados" y fuera de la lógica del modelo.  Es decir, los updates, selects y deletes son propiedades del objeto User o Dog, los cuales se manipulan a través de sus métodos.  Esto es muy conveniente pues si, por ejemplo, necesitamos ordenar los registros del modelo User podemos extender nuestra clase creando el método ordenar($field).

Otra aproximación para salvar la división Relacional-Objetal es usar ORM (object-relational mapping), que son archivos XML que mapean las tablas y crean objetos manipulables. Propel es un ORM para PHP5 que usa esta aproximación. Sin embargo este método es más engorroso (generalmente hay que crear los XML a mano), por ello la mayoría de los frameworks como CakePHP o Ruby on Rails usan ActiveRecord.

Veamos ahora el modelo User como un ejemplo de modelo típico:

<?php
//AppModel gives you all of Cake's Model functionality

class User extends AppModel
{
    // Its always good practice to include this variable.
    public $name = 'User';

    // This is used for validation, see Chapter "Data Validation".
    public $validate = array();

    // You can also define associations.
    // See section 6.3 for more information.

    public $hasMany = array('Image' =>
                                                     array('className' => 'Image')
                                                 );

    // You can also include your own functions:
    public function makeInactive($uid)
    {
        //Put your own logic here...
    }
}
?>

Entre los métodos de la clase padre Model (que es la implementación ActiveRecord de CakePHP), los más usados son:

$Model->findAll();  // encuentra todos los registros

$Model->find();    // encuentra un row

$Model->field();   //  trae sólo un campo

$Model->generateList();  // esta función se usa cuando en la vista vamos a construir un formulario con un select a partir de una tabla

$Model->findAllBy // función que encuentra todos los registros con el nombre del campo

Por ejemplo, cuando usamos el modelo Page (de la tabla 'pages'):

$Page->findAll();

Es equivalente a:

SELECT * FROM pages; 

pero podemos alterar el comportamiento y los resultados de los métodos de Model cambiando sus atributos:

$Page->findAll(
    $conditions = null,
    $fields     = null,
    $order      = null,
    $limit      = null,
    $page       = 1,
    $recursive  = null
);

Esto es:

    $conditions  = array("id"=>"> 50");
    $fields        = array("id", "title", "body", "created");
    $order        = "Page.id DESC";
    $limit         = 15;
    $page        = 1;  
    $recursive  = null;

    $data = $Page->findAll($conditions, $fields, $order, $limit); 

Es equivalente a:

SELECT id, title, body, created FROM pages WHERE id > 50 ORDER BY id DESC LIMIT 15;

El atributo $conditions (que es un array relacional), puede ser más complejo:

Existe un método de la clase Model: findbySQL() que permite hacer queries SQL, pero es un método depreciado que debemos evitar, pues el objetivo es pensar más en una arquitectura de objetos "pura" y menos en tablas.

El atributo $page de findAll() es muy útil para realizar la paginación de los resultados, mientras $recursive señala si la tabla tiene relaciones con otras tablas. Esto lo veremos a continuación.

Nota: CakePHP supone que la llave primaria en todas las tablas es el campo "id", pero si no es asi, hay que indicarlo en el modelo con la variable $primaryKey

Relaciones (Binds)

Hasta ahora sólo hemos visto modelos de tablas de PostgreSQL solas, pero ¿cómo se combinan las tablas usando ActiveRecord? En SQL usaríamos un INNER JOIN o una selección múltiple:

$sql= "SELECT w.estilo, w.urlbase, w.nombre,  w.email, w.keywords, w.author, p.titulo, p.disc FROM website as w, paginas as p WHERE p.id = " . $idp; 

CakePHP usa relaciones o "binds" que se declaran en los modelos usando palabras (atributos) clave:

$hasMany   = ("tiene muchas") , es decir que tiene muchos registros en esa tabla, por ejemplo, el modelo User tiene muchas entradas en el modelo Photos.

$hasOne    = ("tiene uno") por ejemplo el modelo Automovil solo puede tener un registro en el modelo Motor, pues no puede tener dos o más

$belongsTo = ("pertenece a") el modelo User es poseedor del modelo Project

$hasAndBelongsToMany = ("tiene muchos y pertenece a muchos o HABTM") <-- en apariencia un poco caótico

Estos binds son una de las características más poderosas de CakePHP. Por ejemplo, veamos el modelo de la tabla 'pages':

Archivo: app/models/page.php

class Page extends AppModel
{

  public $name         = 'Page';

  public  $belongsTo  = 'User';

  public $validate = array(
      'title' => '/[a-z0-9-]{3,}$/i',
      'body' => VALID_NOT_EMPTY,
      'email' => VALID_EMAIL,
      'born' => VALID_NUMBER
   );

?> 

La indicación de relación $belongsTo ("pertenece a") indica que el modelo User es propietario de los datos que están en el modelo Page, por lo tanto la tabla 'pages' debe tener un campo user_id para vincularlo con 'users'. Esto es, debemos tener las tablas como sigue:

Model: User
CREATE TABLE users (
    id serial PRIMARY KEY,
    username character varying(50) DEFAULT ''::character varying NOT NULL UNIQUE, --login
    passwd character varying(50) DEFAULT ''::character varying NOT NULL,
    name character varying(50) DEFAULT ''::character varying NOT NULL UNIQUE,     --real name
    email character varying(45) DEFAULT ''::character varying NOT NULL UNIQUE,
    last_visit timestamp(0) with time zone DEFAULT now() NOT NULL,
    group_id integer NOT NULL,                                                     -- Admin, editor, normal user
    active integer DEFAULT 0 NOT NULL,
    created timestamp(0) with time zone DEFAULT now() NOT NULL
);

Model: Page
CREATE TABLE pages (   -- static pages
id serial PRIMARY KEY,
title varchar(90) NOT NULL,
body text NOT NULL,
created timestamp(0) with time zone DEFAULT now() NOT NULL,
modified timestamp(0) with time zone DEFAULT now() NOT NULL,
disc int NOT NULL DEFAULT 0,   --discution (comments) actived
state int NOT NULL DEFAULT 0,
user_id int NOT NULL REFERENCES users(id) ON DELETE CASCADE
);

Recuerda: en PostgreSQL, MySQL o Sqlite la tabla es en plural (pages) pero en CakePHP el modelo es singular: Page. Nota también que hay un campo user_id en la tabla "pages" pues lo que hay en Page pertenece al modelo User.

Ahora si podemos relacionar estos dos modelos:

    $conditions  = array("Page.state"=>1);
    $fields        = array("id", "title", "body", "created", "user_id");
    $order        = "Page.created DESC";
    $limit         = 15;
    $page        = 1;  
    $recursive  = 2;

    $data = $Page->findAll($conditions, $fields, $order, $limit, $page, $recursive); 

El valor de $recursive es importante pues indica a CakePHP que busque los datos en los "binds" del modelo Page.

Tip: $data recoge el resultado de la consulta al modelo, usa:   die(print_r($data));   y también  die(var_dump($data));  en las vistas para ver que es lo que el array $data contiene.

bind() y unbind()

Los binds son soluciones poderosas, pero a veces necesitamos un diferente tipo de bind para cierto escenario o quizás la tabla tiene varios binds y solo necesitamos poca información de ella y no requerimos un query tan grande.

La clase Model posee los métodos $Model->unbind() y $Model->bind() que "desligan" y "religan" las asociaciones "al vuelo" en el controlador. Por ejemplo si usamos: 

  $this->Gallery->unbindModel(array('hasMany' => array('Photo')));
  $this->set('data', $this->Gallery->findAll());

Estro evitara que la información del modelo Photo relacionada con Gallery sea traida al hacer el findAll(), en lugar de ello sólo obtendremos la información contenida en el modelo Gallery. $Model->unbindModel() debe usarse cuando sea posible.

<< Capítulo Anterior  

Ficha del autor:
aarkerio
manuel_ARRROBA_mononeurona.org
Manuel Montoya estudió neuropsicología en la facultad y en el Instituto de Biomédicas de la UNAM. Trabajó en Compaq de México como diseñador de software, tiene diez años de experiencia en Java, PHP y SQL. Le interesan muchas cosas y neciamente le da por escribir sobre todas ellas. Actualmente trabaja en Chipotle Software, desarrollando Karamelo, una herramienta de e-Learning. Jedit.org y WindowMaker son su editor y escritorio favoritos.

The most effective way to restrict democracy is to transfer decision making from the public arena to unaccountable institutions. Chomsky.
Ver todos los articulos de aarkerio

Última actualización: 2007-04-29 10:56:59-05

mandrake está:
esperado a que deje de chatear una chava para cerrar el cyber
7 hours, 41 minutes ago

der_teufel está:
terminandome un tarro de chela que le cabe un caguamon :-D, ya estoy alegron :-s
10 hours, 36 minutes ago

saidjose está:
aprendiendo python
12 hours, 30 minutes ago

rnstux está:
Practicando SQL
12 hours, 35 minutes ago

Almsx está:
Por cierto, esto lo estoy escribiendo desde openSolaris 2008.5. Va de maravilla!!!
15 hours, 20 minutes ago

Almsx está:
Fue el Martes 13 de Mayo, osease ayer jejeje :D
15 hours, 20 minutes ago

Que estuvimos haciendo >>

Consultoría y Soporte