In einer relationalen Datenbank haben Tabellen Relationen zueinander. Eine Entität in einer Tabelle kann zu einer oder mehrerer Entitäten in einer anderen Tabelle, durch Verwendung von referentiellen Integritätsverknüpfungen die im Datenbank Schema definiert sind, verknüpft werden.

Die Zend_Db_Table_Row Klasse besitzt Methoden für die Abfrage von verknüpften Zeilen in anderen Tabellen.

Die Klassen für jede eigene Tabelle müssen durch das Erweitern der abstrakten Klasse Zend_Db_Table_Abstract, wie in diesem Kapitel beschrieben, definiert werden. Siehe auch in diesem Kapitel für die Beschreibung einer Beispieldatenbank für welche der folgende Beispielcode designed wurde.

Anbei sind die PHP Klassendefinitionen für diese Tabellen:

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')
        )
    );

}

Wenn Zend_Db_Table verwendet wird um kaskadierende UPDATE und DELETE Operationen zu emulieren, muß das $_dependentTables Array in der Klasse für die Eltern-Tabelle definiert werden. Der Klassenname muß für jede abhängige Komponente aufgelistet werden. Hierbei muß der Klassenname und nicht der physikalische Name der SQL Tabelle verwendet werden.

Das $_referenceMap Array muß in der Klasse für jede abhängige Tabelle deklariert werden. Das ist ein assoziatives Array von Referenz-"Regeln". Eine Referenzregel identifiziert welche Tabelle in der Relation die Elterntabelle ist, und listet auch welche Spalten in der abhängigen Tabelle welche Spalten in der Elterntabelle referenzieren.

Der Schlüssel der Regel ist ein String der als Index zum $_referenceMap Array verwendet wird. Dieser Regelschlüssel wird verwendet um jede Referenzen von Abhängigkeiten zu idenzifizieren. Es sollte ein sprechender Name für diesen Regelschlüssel ausgewählt werden. Deshalb ist es das beste einen String zu verwendet welcher Teil eines PHP Methodennamens sein kann, wie man später sieht.

Im Beispiel PHP Code von oben, sind die Regelschlüssel in der Bugs Tabelle folgende: 'Reporter', 'Engineer', 'Verifier', und 'Product'.

Die Werte von jedem Regeleintrag im $_referenceMap Array sind auch ein assoziatives Array. Die Elemente dieses Regeleintrages werden im folgenden beschrieben:

Wenn man ein Zeilen Objekt als Ergebnis einer Abfrage auf einer Elterntabelle hat, können Zeilen der abhängigen Tabellen geholt werden, welche die aktuelle Zeile referenzieren. Hierbei kann die folgende Methode verwendet werden:

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

Diese Methode gibt ein Zend_Db_Table_Rowset_Abstract Objekt zurück, welche ein Set von Zeilen der abhängigen Tabelle $table enthält die die Zeile referenzieren die durch das $row Objekt identifiziert werden.

Das erste Argument $table kann ein String sein, der die abhängige Tabelle durch Ihren Klassennamen spezifiziert. Man kann die abhängige Tabelle auch durch Verwendung eines Objekts dieser Tabellenklasse spezifizieren.

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

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

Das zweite Argument $rule ist optional. Es ist ein String der den Regelschlüssel im $_referenceMap Array der abhängigen Tebellenklasse benennt. Wenn keine Regel spezifiziert wird, wird die erste Regel im Array verwendet welche die Elterntabelle referenziert. Wenn eine andere Regel als die erste verwendet werden soll, muß der Schlüssel spezifiziert werden.

Im obigen Beispiel wird der Regelschlüssel nicht spezifiziert, sodas standardmäßig die Regel verwendet wird die als erste der Elterntabelle entspricht. Das ist die Regel 'Reporter'.

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

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

Es können auch Kriterien, Sortierungen und Limits zur Relation hinzugefügt werden indem das Select Objekt der Elternzeilen verwendet wird.

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

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

Alternativ können Zeilen von einer abhängigen Tabelle abgefragt werden indem ein spezieller Mechanismus verwendet wird der "magische Methode" genannt wird. Zend_Db_Table_Row_Abstract ruft die Methode: findDependentRowset('<TabellenKlasse>', '<Regel>') auf wenn eine Methode am Zeilenobjekt aufgerufen wird die einem der folgenden Patterns entspricht:

In den obigen Patterns, sind <TabellenKlasse> und <Regel> Strings die mit dem Klassennamen der abhängigen Tabelle korrespondieren, und der Regelschlüssel der abhängigen Tabelle der die Enterntabelle referenziert.

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

// Verwendung der standard Referenzregel
$bugsReportedBy = $user1234->findBugs();

// Eine Referenzregel spezifizieren
$bugsAssignedTo = $user1234->findBugsByEngineer();

Wenn man ein Zeilenobjekt als Ergebnis einer Abfrage auf eine abhängige Tabelle hat, kann man die Zeile vom Elternteil zu der die abhängige Zeile referenziert holen. Hierbei verwendet man die Methode:

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

Es sollte immer exakt eine Zeile in der Elterntabelle durch eine abhängige Zeile referenziert sein, deshalb gibt diese Methode ein Zeilen Objekt und kein Zeilenset Objekt zurück.

Das erste Argument $table kann ein String sein der die Elterntabelle durch Ihren Klassennamen spezifiziert. Man kann die Elterntabelle auch durch Verwendung eines Objektes dieser Tabellenklasse spezifizieren.

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

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

Das zweite Argument $rule ist optional. Es ist ein Strung der den Regelschlüssel im $_referenceMap Array der abhängigen Tabellenklasse benennt. Wenn diese Regel nicht spezifiziert wird, wird die erste Regel im Array genommen das die Elterntabelle referenziert. Wenn eine andere Regel als der erste genommen werden muß, dann muß der Schlüssel spezifiziert werden.

Im obigen Beispiel wird der Regelschlüssel nicht spezifiziert, sodas standardmäßig die Regel verwendet wird die als erste der Elterntabelle entspricht. Das ist die Regel 'Reporter'.

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

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

Alternativ, können Zeilen von der Elterntabelle abgefragt werden indem eine "magische Methode" verwendet wird. Zend_Db_Table_Row_Abstract ruft die Methode: findParentRow('<TableClass>', '<Rule>') auf wenn eine Methode auf dem Zeilenobjekt aufgerufen wird die einer der folgenden Pattern entspricht:

In den obigen Pattern sind, <TabellenKlasse> und <Regel> Strings die dem Klassennamen der Elterntabelle entsprechen, und der Regelname der abhängigen Tabelle der die Elterntabelle referenziert.

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

// Verwenden der standardmäßigen Referenzregel
$reporter = $bug1->findParentAccounts();

// Die Referenzregel spezifizieren
$engineer = $bug1->findParentAccountsByEngineer();

Wenn man ein Zeilenobjekt als Ergebnis einer Abfrage auf eine Tabelle in einer Viele-Zu-Viele Verknüpfung hat (für die Zwecke dieses Beispiels, nennen wir das die "Original" Tabelle), können entsprechende Zeilen in der anderen Tabelle (nennen wir das die "Ziel" Tabelle) über eine Verknüpfungstabelle geholt werden. Hierbei wird die folgende Methode verwendet:

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

Diese Methode gibt ein Zend_Db_Table_Rowset_Abstract zurück welches Zeilen von der Tabelle $table enthält, und der Viele-Zu-Viele Abhängigkeit entspricht. Das aktuelle Zeilenobjekt $row von der originalen Tabelle wird verwendet um Zeilen in der Verknüpfungstabelle zu finden, und es ist mit der Zieltabelle verbunden.

Das erste Argument $table kann ein String sein der die Zieltabelle in der Viele-Zu-Viele Verknüpfung durch seinen Klassennamen spezifiziert. Es kann auch die Zieltabelle durch Verwendung eines Objekts dieser Tabellenklasse spezifiziert werden.

Das zweite Argument $intersectionTable kann ein String sein, der die Verknüpfungstabelle zwischen diesen zwei Tabellen in der Viele-Zu-Viele Verknüpfung, durch seinen Klassennamen, spezifiziert. Die Verknüpfungstabelle kann auch durch Verwendung eines Objektes dieser Tabellenklasse spezifiziert werden.

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

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

Das dritte und vierte Argument $rule1 und $rule2 sind optional. Das sind Strings die den Regelschlüssel im $_referenceMap Array der verknüpfungstabelle benennen.

Der $rule1 Schlüssel benennt die Regel für die Verknüpfung der Verknüpfungstabelle zur Originaltabelle. In diesem Beispiel ist das die verknüpfung von BugsProducts zu Bugs.

Der $rule2 Schlüssel benennt die Regel für die Verknüpfung der Verknüpfungstabelle zur Zieltabelle. In diesem Beispiel ist der die Verknüpfung von Bugs zu Products.

Ähnlich den Methoden für das finden von Eltern- und abhängigen Zeilen verwendet die Methode, wenn keine Regel spezifiziert wird, die erste Regel im $_referenceMap Array das den Tabellen in der Verknüpfung entspricht. Wenn eine andere Regel als die erste verwendet werden soll, muß der Schlüssel spezifiziert werden.

Im obigen Beispiel wird der Regelschlüssel nicht spezifiziert, sodas standardmäßig die ersten passenden Regeln verwendet werden. In diesem Fall ist $rule1 'Reporter' und $rule2 ist 'Product'.

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

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

Alternativ können Zeilen von der Zieltabelle in einer Viele-Zu-Viele Verknüpfung abgefragt werden inden eine "magische Methode" verwendet wird. Zend_Db_Table_Row_Abstract ruft die Methode: findManyToManyRowset('<TabellenKlasse>', '<VerknüpfungTabellenKlasse>', '<Regel1>', '<Regel2>') auf, wenn eine Methode aufgerufen wird die einem der folgenden Pattern entspricht:

In den oben gezeigten Pattern sind <TabellenKlasse> und <VerknüpfungsTabellenKlasse> Strings die den Klassennamen der Zieltabelle und der Verknüpfungstabelle entsprechen. <Regel1> und <Regel2> sind Strings die den Regelschlüssel in der Verknüpfungstabelle entsprechen, welche die Originaltabelle und die Zieltabelle referenzieren.

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

// Verwendung der standardmäßigen Referenzregel
$products = $bug1234->findProductsViaBugsProducts();

// Spezifizieren der Referenzregel
$products = $bug1234->findProductsViaBugsProductsByBug();

Kaskadierende Operationen können deklariert werden um anhand einer abhängigen Tabelle ausgeführt zu werden wenn ein UPDATE oder ein DELETE an einer Zeile in einer Elterntabelle ausgeführt wird.

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

$product1234->delete();
// Kaskadiert automatisch zur Bugs Tabelle und löscht abhängige Zeilen.

Genauso kann es gewünscht sein, wenn man ein UPDATE verwendet um den Wert eines primären Schlüssels in einer Elterntabelle zu verändern, das sich auch den Wert im entfernten Schlüssel der abhängigen Tabellen automatisch von selbst aktualisiert um dem neuen Wert zu entsprechen, sodas solche Referenzen aktuel gehalten werden.

Normalerweise ist es nicht notwendig die Werte eines primären Schlüssels, der durch eine Sequenz von anderen Mechanismen erstellt wurde, zu aktualisieren. Aber wenn man einen natürlichen Schlüssel verwendet, der den Wert plötzlich ändert, ist es besser kaskadierende Aktualisierungen auf abhängigen Tabellen durchzuführen.

Um eine kaskadierende Abhängigkeit in Zend_Db_Table zu deklarieren, müssen die Regeln in $_referenceMap bearbeitet werden. Die assoziativen Arrayschlüssel 'onDelete' und 'onUpdate' müssen auf den String 'cascade' (oder die Konstante self::CASCADE) gesetzt werden. Bevor eine Zeile von der Elterntabelle gelöscht wird oder dessen Wert des primären Schlüssels aktualisiert wird, werden alle Zeilen in der abhängigen Tabelle, welche die Eltern-Zeilen referenzieren, zuerst gelöscht oder aktualisiert.

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
        ),
        ...
    );
}