Les tables possèdent des relations entre elles, dans une base de données relationnelle. Une entité d'une table peut être liée à une autre entité d'une autre table, via un procédé appelé contrainte d'intégrité référentielle

La classe Zend_Db_Table_Row possède des méthodes pour récupérer des enregistrement dans d'autres tables, liées à celle en cours.

Chaque table doit avoir sa classe étendant Zend_Db_Table_Abstract, comme décrit dans la section intitulée « Définir une classe de Table ». Voyez aussi la section intitulée « La base de données d'exemple » pour une description de la base de donnée qui servira d'exemple pour la suite de ce chapitre.

Voici les classes correspondantes à ces tables :

class Accounts extends Zend_Db_Table_Abstract
{
    protected $_name            = 'accounts';
    protected $_dependentTables = array('Bugs');
}

class Products extends Zend_Db_Table_Abstract
{
    protected $_name            = 'products';
    protected $_dependentTables = array('BugsProducts');
}

class Bugs extends Zend_Db_Table_Abstract
{
    protected $_name            = 'bugs';

    protected $_dependentTables = array('BugsProducts');

    protected $_referenceMap    = array(
        'Reporter' => array(
            'columns'           => 'reported_by',
            'refTableClass'     => 'Accounts',
            'refColumns'        => 'account_name'
        ),
        'Engineer' => array(
            'columns'           => 'assigned_to',
            'refTableClass'     => 'Accounts',
            'refColumns'        => 'account_name'
        ),
        'Verifier' => array(
            'columns'           => array('verified_by'),
            'refTableClass'     => 'Accounts',
            'refColumns'        => array('account_name')
        )
    );
}

class BugsProducts extends Zend_Db_Table_Abstract
{
    protected $_name = 'bugs_products';

    protected $_referenceMap    = array(
        'Bug' => array(
            'columns'           => array('bug_id'),
            'refTableClass'     => 'Bugs',
            'refColumns'        => array('bug_id')
        ),
        'Product' => array(
            'columns'           => array('product_id'),
            'refTableClass'     => 'Products',
            'refColumns'        => array('product_id')
        )
    );

}

Si vous utilisez Zend_Db_Table pour émuler les cascades UPDATE et DELETE, alors déclarez $_dependentTables en tant que tableau dans la classe des tables parentes. Listez ainsi le nom de chaque table dépendante. Utilisez bien le nom des classes, et non les noms physiques des tables.

Déclarez un tableau $_referenceMap dans les classes de chaque table dépendante (qui "reçoit une clé"). C'est un tableau associatif, dit de "rôles". Un rôle définit quelle table est parente dans la relation, et quelle est sa colonne de parenté.

Le rôle est utilisé comme index du tableau $_referenceMap. Il est utilisé pour définir la relation, et pourra faire partie du nom de certaines méthodes, comme nous le verrons plus tard. Choisissez ainsi un nom de rôle de manière intelligente.

Dans l'exemple du dessus, les rôles dans la classe Bugs sont : "Reporter", "Engineer", "Verifier" et "Product".

La valeur de chaque rôle dans le tableau $_referenceMap est aussi un tableau associatif. Les éléments de chaque rôle sont décrits ci-après.

Si vous possédez un enregistrement actif (Row), il est possible de récupérer ses enfants dépendants, si les dépendances ont été déclarées suivant la procédure ci-dessus. Utilisez la méthode :

$row->findDependentRowset($table, [$rule]);

Cette méthode retourne un objet instance de Zend_Db_Table_Rowset_Abstract, qui contient tous les enregistrements (Row) de la table dépendante $table faisant référence à l'enregistrement actif actuel $row.

Le paramètre $table désigne la table dépendante à utiliser. Ceci peut être une chaîne de caractères aussi bien qu'un objet de la classe de cette table.

$accountsTable      = new Accounts();
$accountsRowset     = $accountsTable->find(1234);
$user1234           = $accountsRowset->current();

$bugsReportedByUser = $user1234->findDependentRowset('Bugs');

Le second paramètre $rule est optionnel. Il s'agit du nom du rôle à utiliser depuis le tableau $_referenceMap de la classe de la table dépendante. Si vous ne le spécifiez pas, le premier rôle sera utilisé. Il n'y a dans la majorité des cas qu'un seul rôle.

Dans l'exemple ci dessus, nous ne fournissons pas de nom de rôle, le premier est donc pris en considération, et il s'agit de "Reporter".

$accountsTable      = new Accounts();
$accountsRowset     = $accountsTable->find(1234);
$user1234           = $accountsRowset->current();

$bugsAssignedToUser = $user1234->findDependentRowset('Bugs',
                                                     'Engineer');

Vous pouvez rajouter des critères à vos relations, comme l'ordre ou la limite, ceci en utilisant l'objet select de l'enregistrement parent.

$accountsTable      = new Accounts();
$accountsRowset     = $accountsTable->find(1234);
$user1234           = $accountsRowset->current();
$select             = $accountsTable->select()->order('name ASC')
                                              ->limit(3);

$bugsAssignedToUser = $user1234->findDependentRowset('Bugs',
                                                     'Engineer',
                                                     $select);

Vous pouvez récupérer les enregistrements dépendants d'une autre manière. En utilisant les "méthodes magiques". En effet, Zend_Db_Table_Row_Abstract va utiliser la méthode findDependentRowset('<TableClass>', '<Rule>') si vous appelez sur l'enregistrement une méthode correspondante à un de ces motifs :

Dans les motifs ci-dessus, <TableClass> et <Rule> désignent respectivement le nom de la table dépendante et le rôle à utiliser.

$accountsTable    = new Accounts();
$accountsRowset   = $accountsTable->find(1234);
$user1234         = $accountsRowset->current();

// Utilise le rôle par défaut (le premier de la liste)
$bugsReportedBy   = $user1234->findBugs();

// Utilise un rôle spécifique
$bugsAssignedTo   = $user1234->findBugsByEngineer();

Si vous possédez un enregistrement (Row) dont la table possède une table parente, il est possible alors de récupérer l'enregistrement parent. Utilisez pour cela la méthode :

$row->findParentRow($table, [$rule]);

La logique veut qu'il ne puisse y avoir qu'un et un seul parent par enregistrement. Ainsi, cette méthode retourne un objet Row et non un objet Rowset

Le premier paramètre $table désigne la table parente. Ceci peut être une chaîne de caractères, ou un objet instance de la classe de la table parente.

$bugsTable   = new Bugs();
$bugsRowset  = $bugsTable->fetchAll(array('bug_status = ?' => 'NEW'));
$bug1        = $bugsRowset->current();

$reporter    = $bug1->findParentRow('Accounts');

Le second paramètre $rule est optionnel. Il s'agit du nom du rôle à utiliser depuis le tableau $_referenceMap de la classe de la table dépendante. Si vous ne le spécifiez pas, le premier rôle sera utilisé. Il n'y a dans la majorité des cas qu'un seul rôle.

Dans l'exemple ci dessus, nous ne fournissons pas de nom de rôle, le premier est donc pris en considération, et il s'agit de "Reporter".

$bugsTable   = new Bugs();
$bugsRowset  = $bugsTable->fetchAll(array('bug_status = ?', 'NEW'));
$bug1        = $bugsRowset->current();

$engineer    = $bug1->findParentRow('Accounts', 'Engineer');

Vous pouvez récupérer l'enregistrement parent d'une autre manière. En utilisant les "méthodes magiques". En effet, Zend_Db_Table_Row_Abstract va utiliser la méthodefindParentRow('<TableClass>', '<Rule>') si vous appelez sur l'enregistrement une méthode correspondante à un de ces motifs :

Dans les motifs ci-dessus, <TableClass> et <Rule> représentent respectivement le nom de la classe de la table parente, et le rôle à utiliser éventuellement.

$bugsTable   = new Bugs();
$bugsRowset  = $bugsTable->fetchAll(array('bug_status = ?', 'NEW'));
$bug1        = $bugsRowset->current();

// Utilise le rôle par défaut ( le premier déclaré)
$reporter    = $bug1->findParentAccounts();

// Utilise un rôle spécifique
$engineer    = $bug1->findParentAccountsByEngineer();

Si vous possédez un enregistrement sur une table (appelons la "table d'origine") ayant une relation plusieurs à plusieurs vers une autre table (appelons la "table de destination"), vous pouvez alors accéder aux enregistrements de la table de destination, via une table dite "d'intersection". Utilisez la méthode :

$row->findManyToManyRowset($table,
                           $intersectionTable,
                           [$rule1,
                           [$rule2,
                           [Zend_Db_Table_Select $select]]]);

Cette méthode retourne un objet instance de Zend_Db_Table_Rowset_Abstract qui contient les enregistrements de la table $table qui correspondent à la relation plusieurs à plusieurs. L'enregistrement courant de la table courante, $row, est utilisé comme point de départ pour effectuer une jointure vers la table de destination, via la table d'intersection.

Le premier paramètre $table peut être soit une chaîne soit un objet instance de la classe de la table de destination dans la relation plusieurs à plusieurs.

Le second paramètre $intersectionTable peut être soit une chaîne soit un objet instance de la classe de la table d'intersection dans la relation plusieurs à plusieurs.

$bugsTable        = new Bugs();
$bugsRowset       = $bugsTable->find(1234);
$bug1234          = $bugsRowset->current();

$productsRowset   = $bug1234->findManyToManyRowset('Products',
                                                   'BugsProducts');

Les troisième et quatrième paramètres, $rule1 et $rule2, sont optionnels. Ce sont des chaînes de caractères qui désignent les rôles à utiliser dans le tableau $_referenceMap de la table d'intersection.

$rule1 nomme le rôle dans la relation entre la table d'origine et la table d'intersection. Dans notre exemple, il s'agit donc de la relation de Bugs à BugsProducts.

$rule2nomme le rôle dans la relation entre la table d'origine et la table d'intersection. Dans notre exemple, il s'agit donc de la relation de BugsProducts à Products.

Si vous ne spécifiez pas de rôles, alors le premier rôle trouvé pour la table, dans le tableau $_referenceMap, sera utilisé. Dans la grande majorité des cas, il n'y a qu'un rôle.

Dans l'exemple ci-dessus, les rôles ne sont pas spécifiés. Ainsi $rule1 prend la valeur "Reporter" et $rule2 prend la valeur "Product".

$bugsTable        = new Bugs();
$bugsRowset       = $bugsTable->find(1234);
$bug1234          = $bugsRowset->current();

$productsRowset   = $bug1234->findManyToManyRowset('Products',
                                                   'BugsProducts',
                                                   'Bug');

Vous pouvez récupérer l'enregistrement de destination d'une autre manière. En utilisant les "méthodes magiques". En effet, Zend_Db_Table_Row_Abstract va utiliser la méthode findManyToManyRowset('<TableClass>', '<IntersectionTableClass>', '<Rule1>', '<Rule2>') si vous appelez sur l'enregistrement une méthode correspondante à un de ces motifs :

Dans les motifs ci dessus, <TableClass> et <IntersectionTableClass> sont des chaînes de caractères correspondantes aux noms des classes des tables de destination et d'intersection (respectivement). <Rule1> et <Rule2> sont respectivement des chaînes désignant les rôles dans la table d'intersection pour la table de référence, et de destination.

$bugsTable   = new Bugs();
$bugsRowset  = $bugsTable->find(1234);
$bug1234     = $bugsRowset->current();

// Utilisation des rôles par défaut
$products    = $bug1234->findProductsViaBugsProducts();

// Utilisation d'un rôle spécifique
$products    = $bug1234->findProductsViaBugsProductsByBug();

Vous pouvez déclarer des opérations de cascade sur un UPDATE ou un DELETE, à appliquer sur les enregistrements dépendants à la table en cours.

$productsTable  = new Products();
$productsRowset = $productsTable->find(1234);
$product1234    = $productsRowset->current();

$product1234->delete();
// Cascades automatiques vers le table Bugs
// et suppression des enregistrements dépendants.

De la même manière, si vous utilisez un UPDATE pour changer la valeur de la clé primaire d'une table parente, vous pourriez nécessiter que les clés étrangères des tables dépendantes soient mises à jour.

En général s'il s'agit d'une séquence, il n'est pas nécessaire de mettre à jour les enregistrements dépendants. En revanche concernant les clé dites naturelles , il peut s'avérer nécessaire de propager un changement de valeur.

Afin de déclarer une relation de cascades dans Zend_Db_Table, éditer les rôles dans $_referenceMap. Ajoutez les clés 'onDelete' et 'onUpdate' et donnez leur la valeur 'cascade' (ou la constante self::CASCADE). Avant qu'un enregistrement ne soit modifié(sa clé primaire) / supprimé, tous les enregistrements dans les tables dépendantes seront modifiés / supprimés.

class BugsProducts extends Zend_Db_Table_Abstract
{
    ...
    protected $_referenceMap    = array(
        'Product' => array(
            'columns'           => array('product_id'),
            'refTableClass'     => 'Products',
            'refColumns'        => array('product_id'),
            'onDelete'          => self::CASCADE,
            'onUpdate'          => self::RESTRICT
        ),
        ...
    );
}