ORM con Zend Framework

Por zsamer en Junio 28, 2008

En el post anterior había prometido escribir un articulo sobre implementar ORM con Zend Framework.

El mapeo objeto-relacional es una técnica de programación para 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. En la práctica esto crea una base de datos orientada a objetos virtual, por sobre la base de datos relacional. Si estas interesado en como implementar esta técnica con Zend_Db_Table Relationships entonces continua leyendo.

Las tablas tienen relaciones unas con otras en una base de datos relacional. Un entidad en una tabla puede ser asociada o linkeada hacia una o más entidades en otra tabla usando restricciones de integridad referencial (referential integrity constraints) definida en el esquema de base de datos.

En nuestro caso vamos a utilizar Mysql, por lo tanto es fundamental utilizar InnoDB ya que soporta integridad referencial en Mysql AB.

Creando nuestras tablas en la base de datos

En la imagen de abajo muestra un diagrama que representa las relaciones de nuestras tablas en la base de datos.

Nos damos cuenta de que tenemos variadas relaciones, por ejemplo BugsProducts tiene muchos-a-muchos respecto a la tabla Products y a Bugs porque para un determinado bug puede ser relevante para múltiples productos, y por supuesto un determinado productos puede tener múltiples bugs.

Sin embargo la Tabla Bugs esta asociada a Muchos BugsProducts y solo uno Accounts en tres relaciones distintas reported_by, assigned_to y verified_by. Mientras que Accounts puede tener asignado mas de un Bugs (dentro de sus tres tipos de relaciones).

También notamos que la tabla bugs contiene múltiples foreign key referenciadas a la tabla accounts. Cada una de estas foreign keys hacen referencia a diferentes registros en la tabla accounts para un determinado bug.

A continuación comparto el SQL de la base de datos, en el ejemplo trataremos con Mysql, aunque podría ser cualquier otro motor de base de datos ya que Zend Framework soporta a la mayoría de los motores.

PLAIN TEXT
SQL:
  1. --
  2. -- Estructura de tabla para la tabla `accounts`
  3. --
  4.  
  5. DROP TABLE IF EXISTS `accounts`;
  6. CREATE TABLE IF NOT EXISTS `accounts` (
  7.   `account_name` varchar(100) NOT NULL COMMENT 'Account Name',
  8.   PRIMARY KEY  (`account_name`)
  9. ) ENGINE=InnoDB DEFAULT CHARSET=latin1 COMMENT='Account Table';
  10.  
  11. --
  12. -- Volcar la base de datos para la tabla `accounts`
  13. --
  14.  
  15. INSERT INTO `accounts` (`account_name`) VALUES
  16. ('admin'),
  17. ('zsamer');
  18. -- --------------------------------------------------------
  19.  
  20. --
  21. -- Estructura de tabla para la tabla `bugs`
  22. --
  23.  
  24. DROP TABLE IF EXISTS `bugs`;
  25. CREATE TABLE IF NOT EXISTS `bugs` (
  26.   `bug_id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'Bug Id',
  27.   `bug_description` varchar(100) NOT NULL COMMENT 'Bug Description',
  28.   `bug_status` varchar(20) NOT NULL COMMENT 'Bug Status',
  29.   `reported_by` varchar(100) NOT NULL COMMENT 'Reported By',
  30.   `assigned_to` varchar(100) NOT NULL COMMENT 'Assigned To',
  31.   `verified_by` varchar(100) NOT NULL COMMENT 'Verified By',
  32.   PRIMARY KEY  (`bug_id`),
  33.   KEY `FK_accounts_reported_by` (`reported_by`),
  34.   KEY `FK_accounts_assigned_to` (`assigned_to`),
  35.   KEY `FK_accounts_verified_by` (`verified_by`)
  36. ) ENGINE=InnoDB  DEFAULT CHARSET=latin1 COMMENT='Bugs Table';
  37.  
  38. --
  39. -- Volcar la base de datos para la tabla `bugs`
  40. --
  41.  
  42. INSERT INTO `bugs` (`bug_id`, `bug_description`, `bug_status`, `reported_by`, `assigned_to`, `verified_by`) VALUES
  43. (1, 'Sin suela', 'activo', 'admin', 'admin', 'zsamer'),
  44. (2, 'Descosedura', 'NEW', 'zsamer', 'admin', 'zsamer');
  45.  
  46. -- --------------------------------------------------------
  47.  
  48. --
  49. -- Estructura de tabla para la tabla `bugs_products`
  50. --
  51.  
  52. DROP TABLE IF EXISTS `bugs_products`;
  53. CREATE TABLE IF NOT EXISTS `bugs_products` (
  54.   `bug_id` int(11) NOT NULL COMMENT 'Bug Id',
  55.   `product_id` int(11) NOT NULL COMMENT 'Product Id',
  56.   PRIMARY KEY  (`bug_id`,`product_id`),
  57.   KEY `product_id` (`product_id`)
  58. ) ENGINE=InnoDB DEFAULT CHARSET=latin1 COMMENT='Bugs Products Table';
  59.  
  60. --
  61. -- Volcar la base de datos para la tabla `bugs_products`
  62. --
  63.  
  64. INSERT INTO `bugs_products` (`bug_id`, `product_id`) VALUES
  65. (1, 1),
  66. (2, 2),
  67. (1, 3),
  68. (2, 3),
  69. (2, 4);
  70.  
  71. -- --------------------------------------------------------
  72.  
  73. --
  74. -- Estructura de tabla para la tabla `products`
  75. --
  76.  
  77. DROP TABLE IF EXISTS `products`;
  78. CREATE TABLE IF NOT EXISTS `products` (
  79.   `product_id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'Product Id',
  80.   `product_name` varchar(100) NOT NULL COMMENT 'Product Name',
  81.   PRIMARY KEY  (`product_id`)
  82. ) ENGINE=InnoDB  DEFAULT CHARSET=latin1 COMMENT='Product Table';
  83.  
  84. --
  85. -- Volcar la base de datos para la tabla `products`
  86. --
  87.  
  88. INSERT INTO `products` (`product_id`, `product_name`) VALUES
  89. (1, 'Zapatos'),
  90. (2, 'Pantalones'),
  91. (3, 'Zapatillas'),
  92. (4, 'Poleras');
  93.  
  94. --
  95. -- Filtros para la tabla `bugs`
  96. --
  97. ALTER TABLE `bugs`
  98.   ADD CONSTRAINT `bugs_ibfk_3` FOREIGN KEY (`verified_by`) REFERENCES `accounts` (`account_name`),
  99.   ADD CONSTRAINT `bugs_ibfk_1` FOREIGN KEY (`reported_by`) REFERENCES `accounts` (`account_name`),
  100.   ADD CONSTRAINT `bugs_ibfk_2` FOREIGN KEY (`assigned_to`) REFERENCES `accounts` (`account_name`);
  101.  
  102. --
  103. -- Filtros para la tabla `bugs_products`
  104. --
  105. ALTER TABLE `bugs_products`
  106.   ADD CONSTRAINT `bugs_products_ibfk_2` FOREIGN KEY (`product_id`) REFERENCES `products` (`product_id`) ON DELETE CASCADE,
  107.   ADD CONSTRAINT `bugs_products_ibfk_1` FOREIGN KEY (`bug_id`) REFERENCES `bugs` (`bug_id`);

Definiendo las relaciones en los Modelos

Definiendo clases por cada tabla de la base de datos, extendiendo a la clase abstracta Zend_Db_Table_Abstract.

PLAIN TEXT
PHP:
  1. <?php
  2. class Accounts extends Zend_Db_Table_Abstract
  3. {
  4.     protected $_name            = 'accounts';
  5.     protected $_dependentTables = array('Bugs');
  6. }
  7.  
  8. class Products extends Zend_Db_Table_Abstract
  9. {
  10.     protected $_name            = 'products';
  11.     protected $_dependentTables = array('BugsProducts');
  12. }
  13.  
  14. class Bugs extends Zend_Db_Table_Abstract
  15. {
  16.     protected $_name            = 'bugs';
  17.  
  18.     protected $_dependentTables = array('BugsProducts');
  19.  
  20.     protected $_referenceMap    = array(
  21.         'Reporter' => array(
  22.             'columns'           => 'reported_by',
  23.             'refTableClass'     => 'Accounts',
  24.             'refColumns'        => 'account_name'
  25.         ),
  26.         'Engineer' => array(
  27.             'columns'           => 'assigned_to',
  28.             'refTableClass'     => 'Accounts',
  29.             'refColumns'        => 'account_name'
  30.         ),
  31.         'Verifier' => array(
  32.             'columns'           => array('verified_by'),
  33.             'refTableClass'     => 'Accounts',
  34.             'refColumns'        => array('account_name')
  35.         )
  36.     );
  37. }
  38.  
  39. class BugsProducts extends Zend_Db_Table_Abstract
  40. {
  41.     protected $_name = 'bugs_products';
  42.  
  43.     protected $_referenceMap    = array(
  44.         'Bug' => array(
  45.             'columns'           => array('bug_id'),
  46.             'refTableClass'     => 'Bugs',
  47.             'refColumns'        => array('bug_id')
  48.         ),
  49.         'Product' => array(
  50.             'columns'           => array('product_id'),
  51.             'refTableClass'     => 'Products',
  52.             'refColumns'        => array('product_id')
  53.         )
  54.     );
  55.  
  56. }

Ejemplos de uso

PLAIN TEXT
PHP:
  1. public function ejemploUnoAction()
  2.     {
  3.         require_once 'Accounts.php';
  4.        
  5.         $bugsTable         = new Bugs();
  6.         $bugsRowset        = $bugsTable->fetchAll(array('bug_status = ?' => 'NEW'));
  7.         $bug1              = $bugsRowset->current();
  8.  
  9.         // Specify the reference rule
  10.         $engineer          = $bug1->findParentAccountsByEngineer();
  11.                
  12.                 //Obtenemos al Ingeniero asociado al Bugs currente con status NEW
  13.         print '<pre>';
  14.         var_dump($engineer);
  15.     }
  16.    
  17.     public function ejemploDosAction()
  18.     {
  19.         require_once 'Accounts.php';
  20.        
  21.         $bugsTable         = new Bugs();
  22.         $bugsRowset        = $bugsTable->fetchAll(array('bug_status = ?' => 'NEW'));
  23.         $bug1              = $bugsRowset->current();
  24.  
  25.                 //Obtenemos al Reporteador asociado al Bugs currente con status NEW
  26.                 //Obtenemos al Reporter ya que por defecto toma al primero en el $_referenceMap, a menos que se indiquemos cual.
  27.         $reporter          = $bug1->findParentAccounts();
  28.         print '<pre>';
  29.         var_dump($reporter);
  30.     }
  31.    
  32.     public function ejemploTresAction()
  33.     {
  34.         require_once 'Accounts.php';
  35.  
  36.         $accountsTable = new Accounts();
  37.         $accountsRowset = $accountsTable->find('admin');
  38.         $user1234 = $accountsRowset->current();
  39.         $select = $accountsTable->select()->order('reported_by DESC')->limit(3);
  40.  
  41.         $bugsReportedByUser = $user1234->findDependentRowset('Bugs', 'Engineer', $select);
  42.        
  43.         // Use the default reference rule
  44.         $bugsReportedBy   = $user1234->findBugs();
  45.  
  46.         // Specify the reference rule
  47.         $bugsAssignedTo   = $user1234->findBugsByEngineer();
  48.        
  49.         print '<pre>';
  50.         var_dump($bugsReportedByUser);
  51.        
  52.         print '<pre>';
  53.         var_dump($bugsReportedBy);
  54.        
  55.         print '<pre>';
  56.         var_dump($bugsAssignedTo);
  57.     }
  58.    
  59.     public function ejemploCuatroAction()
  60.     {
  61.         require_once 'Accounts.php';
  62.        
  63.         $bugsTable        = new Bugs();
  64.         $bugsRowset       = $bugsTable->find(2);
  65.         $bug1234          = $bugsRowset->current();
  66.  
  67.         $products          = $bug1234->findProductsViaBugsProductsByBug();
  68.        
  69.         print '<pre>';
  70.         var_dump($products);
  71.     }
  72.    
  73.     public function ejemploCincoAction()
  74.     {
  75.         require_once 'Accounts.php';
  76.        
  77.         $bugsTable        = new Bugs();
  78.         $bugsRowset       = $bugsTable->find(2);
  79.         $bug1234          = $bugsRowset->current();
  80.  
  81.         $products   = $bug1234->findManyToManyRowset('Products', 'BugsProducts');
  82.        
  83.         // Use the default reference rule
  84.         //$products          = $bug1234->findProductsViaBugsProducts();
  85.  
  86.         // Specify the reference rule
  87.         $products          = $bug1234->findProductsViaBugsProductsByBug();
  88.        
  89.         print '<pre>';
  90.         var_dump($products);
  91.     }

Espero que sirva, para más detalle ver el manual, hay mucha información ahi.

Categoría: Model, ORM, PHP5, Patron de Diseño, Zend Framwork

 

Comentarios

2 Responses to “ORM con Zend Framework”

  1. Sergio ArmaNDO on Julio 18th, 2008 5:06 am

    Espero te encuentres muy bien, ojala y pronto saques algo nuevo sobre zendFramework ya que todas tus entradas en el blog an estado muy interesantes.

  2. zsamer on Julio 18th, 2008 1:29 pm

    Gracias ArmaNDO, muy luego viene el próximo, no te preocupes porque tengo pensado al menos sacar 1 o 2 post al mes como mínimo.

    Que estés bien,

    Andrés.

Deja tu comentario




XHTML: puedes usar estas etiquetas: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>