Die Tabelle der Datenbank, für welche die Klasse bestimmt ist, wird mit der protected Variablen $_name angegeben. Es ist ein String, welcher den Namen der Tabelle enthalten muss, wie er in der Datenbank erscheint.

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

Wird keine Tabellenname angegeben, so wird ein Standard verwendet, welcher dem Namen der Klasse entspricht. Wird sich auf diesen Standard verlassen, so muss der Klassenname der Schreibweise der Tabelle entsprechen, wie sie in der Datenbank erscheint.

class bugs extends Zend_Db_Table_Abstract
{
    // Tabellenname entspricht dem Klassennamen
}

Es kann auch ein Schema für die Tabelle angegeben werden. Entweder mit der protected Variablen $_schema oder mit dem Schema vorangestellt in der $_name Eigenschaft. Jedes Schema welches in der $_name Eigenschaft angegeben ist wird vorrangig gegenüber dem Schema der $_schema Eigenschaft behandelt. In einigen RDBMS Marken ist die Bezeichnung für Schema "database" oder "tablespace", wird aber ähnlich verwendet.

// Erste Möglichkeit:
class Bugs extends Zend_Db_Table_Abstract
{
    protected $_schema = 'bug_db';
    protected $_name   = 'bugs';
}

// Zweite Möglichkeit:
class Bugs extends Zend_Db_Table_Abstract
{
    protected $_name = 'bug_db.bugs';
}

// Wenn Schema sowohl in $_name als auch $_schema angegeben wird, so bekommt $_name vorrang:

class Bugs extends Zend_Db_Table_Abstract
{
    protected $_name   = 'bug_db.bugs';
    protected $_schema = 'ignored';
}

Die Schema und Tabellennamen können auch mit Konstruktor Konfigurationsdirektiven angegeben werden, welche jegliche Standardwerte, angegeben in den $_name und $_schema Eigenschaften, überschreiben. Eine Schema Angabe welche mit der name Directive angegeben wurde überschreibt jeglichen Wert welcher von der schema Option bereitgestellt ist.

class Bugs extends Zend_Db_Table_Abstract
{
}

// Erste Möglichkeit:

$tableBugs = new Bugs(array('name' => 'bugs', 'schema' => 'bug_db'));

// Zweite Möglichkeit:

$tableBugs = new Bugs(array('name' => 'bug_db.bugs'));

// Wenn Schema sowohl in $_name als auch $_schema angegeben wird,
// so bekommt $_name vorrang:

$tableBugs = new Bugs(array('name' => 'bug_db.bugs',
                            'schema' => 'ignored'));

Wenn kein Schemaname angegeben wird, so wird als Standard der Schemaname des Datenbankadapters verwendet.

Jede Tabelle muss einen Primärschlüssel haben. Die Spalte des Primärschlüssels kann mit der protected Variablen $_primary angegeben werden. Sie enthält entweder einen String, welcher die einzelen Spalte benennt, oder ein Array von Spaltennamen, wenn der Primärschlüssel ein zusammengesetzter Schlüssel ist.

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

Wenn kein Primärschlüssel angegeben wird, versucht Zend_Db_Table_Abstract den Primärschlüssel mit Hilfe der describeTable() Methode zu ermitteln.

Wenn eine Instanz einer Table Klasse erzeugt wird, ruft der Konstruktor einige protected Methoden auf, die Metadaten der Tabelle initialisieren. Jede dieser Methoden kann erweitert werden um Metadaten explizit anzugeben. Dabei darf nicht vergessen werden am Ende der eigenen Methode die gleichnamige Methode der Parentklasse aufzurufen.

class Bugs extends Zend_Db_Table_Abstract
{
    protected function _setupTableName()
    {
        $this->_name = 'bugs';
        parent::_setupTableName();
    }
}

Folgende Setup Methoden sind überschreibbar:

Wenn Anwendungs-spezifische Logik initialisiert werden soll wenn eine Tabellenklasse erstellt wird, kann man entscheiden die Aufgaben in die init() Methode zu verschieben, die aufgerufen wird nachdem alle Tabellen Metadaten bearbeitet wurden. Das ist besser als die __construct() Methode wenn die Metadaten nicht programmtechnisch verändert werden sollen.

class Bugs extends Zend_Db_Table_Abstract
{
    protected $_observer;

    public function init()
    {
        $this->_observer = new MyObserverClass();
    }
}

Der erste Weg einen Datenbankadapter an eine Table Klasse bereitzustellen ist, ein Objekt des Typs Zend_Db_Adapter_Abstract im Options Array, bezeichnet mit dem Schlüssel 'db', zu übergeben.

$db = Zend_Db::factory('PDO_MYSQL', $options);

$table = new Bugs(array('db' => $db));

Der zweite Weg einer Table Klasse einen Datenbankadapter bereit zu stellen ist es, ein Objekt des Typs Zend_Db_Adapter_Abstract zu deklarieren und als Standard für alle nachfolgenden Instanzen von Table der Applikation zu setzen. Dies kann mit der static Methode Zend_Db_Table_Abstract::setDefaultAdapter() getan werden. Das Argument ist ein Objekt des Typs Zend_Db_Adapter_Abstract.

$db = Zend_Db::factory('PDO_MYSQL', $options);
Zend_Db_Table_Abstract::setDefaultAdapter($db);

// Später...

$table = new Bugs();

Es kann geeignet sein den Datenbankadapter an einer zentralen Stelle der Anwendung, wie dem Bootstrap, zu erzeugen, und als Standardadapter zu speichern. Dies hilft sicher zu stellen, das der verwendete Adapter in der gesamten Anwendung der gleiche ist. Allerdings kann nur eine einzelne Adapterinstanz als Standardadapter verwendet werden.

Der dritte Weg einer Table Klasse einen Datenbankadapter bereit zu stellen ist es einen String in dem Optionsarray zu übergeben, auch mit dem 'db' Schlüssel identifiziert. Der String wird als Schlüssel der statischen Zend_Registry Instanz verwendet, wo der Eintrag mit dem Schlüssel ein Objekt des Typs Zend_Db_Adapter_Abstract ist.

$db = Zend_Db::factory('PDO_MYSQL', $options);
Zend_Registry::set('my_db', $db);

// Später...

$table = new Bugs(array('db' => 'my_db'));

Wie das Setzen eines Standardadapters, bietet auch dieses sicher zu stellen das die gleiche Adapter Instanz in der gesamten Anwendung verwendet wird. Nutzen der Registry ist flexibler, da mehr als eine Adapterinstanz gepeichert werden kann. Eine angegebene Adapterinstanz ist spezifisch für eine bestimmte RDBMS Marke und Datenbankinstanz. Wenn die Anwendung Zugriff auf mehrere Datenbanken benötigt oder auch mehrere Datenbank Marken, dann müssen mehrere Adapter verwendet werden.

Ein automatischer Primärschlüssel erzeigt einen eindeutigen Integerwert wenn die Spalte des Primären Typs in der eigenen SQL INSERT Anweisung unterdrückt wird.

Wenn die geschützte Variable $_sequence, in Zend_Db_Table_Abstract, als boolscher Wert TRUE definiert wird, nimmt die Klasse an das die Tabelle einen automatischen Primärschlüssel hat.

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

    // Das ist der Standardwert in der Zend_Db_Table_Abstract Klasse;
    // er muß nicht definiert werden.
    protected $_sequence = true;
}

MySQL, Microsoft SQL Server, und SQLite sind Beispiele von RDBMS Marken die automatische Primärschlüssel unterstützen.

PostgreSQL hat eine SERIAL Notation die implizit eine Sequenz definiert die auf den Tabellen- und Spaltennamen basiert, und diese Sequenz verwendet, um einen Schlüsselwert für neue Zeilen zu erstellen. IBM DB2 hat eine IDENTITY Notation die ähnlich arbeitet. Wenn eine dieser Notationen verwendet wird, muß der Zend_Db_Table Klasse mitgeteilt werden das Sie eine automatische Spalte hat, indem $_sequence auf TRUE gesetzt wird.

Eine Sequenz ist ein Datenbank Objekt das einen eindeutigen Wert erstellt, der als Wert des Primärschlüssels in einer oder mehreren Tabellen der Datenbank verwendet werden kann.

Wenn $_sequence als String definiert wird, nimmt Zend_Db_Table_Abstract an das der String den Namen des Sequenz Objektes in der Datenbank benennt. Die Sequenz wird aufgerufen um einen neuen Wert zu erstellen, und dieser Wert wird in der INSERT Operation verwendet.

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

    protected $_sequence = 'bug_sequence';
}

Oracle, PostgreSQL, und IBM DB2 sind Beispiele von RDBMS Marken die Sequenz Objekte in der Datenbank unterstützen.

PostgreSQL und IBM DB2 haben auch einen Syntax der Sequenzen implizit definiert und diese mit Spalten assoziiert. Wenn diese Notation verwendet wird, muß der Tabelle gesagt werden das Sie eine automatische Schlüsselspalte besitzt. Der Name der Sequenz muß nur in den Fällen als String definiert werden in denen die Sequenz explizit aufgerufen wird um den nächsten Schlüsselwert zu erhalten.

Einige Tabellen haben natürliche Schlüssel. Das bedeutet das der Schlüssel nicht automatisch durch die Tabelle oder eine Sequenz erstellt wird. Der Wert für den Primärschlüssel muß in diesem Fall selbst definiert werden.

Wenn $_sequence als boolsches FALSE definiert wird, nimmt Zend_Db_Table_Abstract an das die Tabelle einen natürlichen Primärschlüssel hat. Es müssen Werte für die Spalte des Primärschlüssels im Array der Daten definiert werden die an die insert() Methode übergeben werden, andernfalls wird diese Methode eine Zend_Db_Table_Exception werfen.

class BugStatus extends Zend_Db_Table_Abstract
{
    protected $_name = 'bug_status';

    protected $_sequence = false;
}

/**
 * Ein Rowset holen
 */
$rows = $table->fetchAll(
    'bug_status = "NEW"',
    'bug_id ASC',
    10,
    0
    );
$rows = $table->fetchAll(
    $table->select()
        ->where('bug_status = ?', 'NEW')
        ->order('bug_id ASC')
        ->limit(10, 0)
    );
// oder mit Bindung
$rows = $table->fetchAll(
    $table->select()
        ->where('bug_status = :status')
        ->bind(array(':status'=>'NEW')
        ->order('bug_id ASC')
        ->limit(10, 0)
    );

/**
 * Eine einzelne Zeile holen
 */
$row = $table->fetchRow(
    'bug_status = "NEW"',
    'bug_id ASC'
    );
$row = $table->fetchRow(
    $table->select()
        ->where('bug_status = ?', 'NEW')
        ->order('bug_id ASC')
    );
// oder mit Bindung
$row = $table->fetchRow(
    $table->select()
        ->where('bug_status = :status')
        ->bind(array(':status'=>'NEW')
        ->order('bug_id ASC')
    );

Das Zend_Db_Table_Select Objekt ist eine Erweiterung des Zend_Db_Select Objekts das spezielle Einschränkungen zu einer Abfrage hinzufügt. Die Verbesserungen und Einschränkungen sind folgende:

$table = new Bugs();

$select = $table->select();
$select->where('bug_status = ?', 'NEW');

$rows = $table->fetchAll($select);

Flüssige Interfaces sind über alle Komponenten hinweg implementiert, sodass dies zu einer abgekürzteren Form umgeschrieben werden kann.

$table = new Bugs();

$rows =
    $table->fetchAll($table->select()->where('bug_status = ?', 'NEW'));

Ein Set von Zeilen kann abgefragt werden indem irgendein Kriterium verwendet wird, das anders als die Werte des Primärschlüssels sind, indem die fetchAll() Methode der Tabellen Klasse verwendet wird. Diese Methode gibt ein Objekt vom Typ Zend_Db_Table_Rowset_Abstract zurück.

$table = new Bugs();

$select = $table->select()->where('bug_status = ?', 'NEW');

$rows = $table->fetchAll($select);

Der ORDER BY kann auch ein Sortier-Kriterium übergeben werden, genauso wie auch Count und Offset Integer Werte, verwendet werden können damit die Abfrage ein spezielles Subset von Zeilen zurück gibt. Diese Werte werden in einer LIMIT Klausel verwendet oder in einer ähnlichen Logik für RDBMS Marken welche die LIMIT Syntax nicht unterstützen.

$table = new Bugs();

$order  = 'bug_id';

// Gibt die Zeilen 21 bis 30 zurück
$count  = 10;
$offset = 20;

$select = $table->select()->where('bug_status = ?' => 'NEW')
                          ->order($order)
                          ->limit($count, $offset);

$rows = $table->fetchAll($select);

Alle diese Argumente sind optional. Wenn die ORDER Klausel unterdrückt wird, dann enthält das Ergebnis die Zeilen der Tabelle in einer unvorhersagbaren Reihenfolge. Wenn keine LIMIT Klausel gesetzt ist, dann wird jede Zeile dieser Tabelle zurückgegeben die der WHERE Klausen entspricht.

Für speziellere und optimierte Ergebnisse, kann es gewünscht sein die Anzahl der zurückgegebenen Zeilen oder Sets zu limitieren. Das kann durch die Übergabe einer FROM Klausel an das Select Objekt getan werden. Das erste Argument in der FROM Klausel ist identisch mit den des Zend_Db_Select Objekts wobei man zusätzlich eine Instanz von Zend_Db_Table_Abstract übergeben und damit den Tabellen Namen automatisch ermitteln lassen kann.

$table = new Bugs();

$select = $table->select();
$select->from($table, array('bug_id', 'bug_description'))
       ->where('bug_status = ?', 'NEW');

$rows = $table->fetchAll($select);

Es können Ausdrücke in einer FROM Klausel spezifiziert werden die dann als readOnly Zeile oder Set zurückgegeben werden. In diesem Beispiel werden Zeilen von der Bugs Tabelle zurückgegeben die einen Bereich von Nummern neuer Bugs zeigen die von Individuen mitgeteilt wurden. Die GROUP Klausel ist zu beachten. Die 'count' Spalte wird der Zeile für Evaluation angefügt und es kann auch Sie zugegriffen werden wie wenn Sie ein Teil des Schemas wäre.

$table = new Bugs();

$select = $table->select();
$select->from($table,
              array('COUNT(reported_by) as `count`', 'reported_by'))
       ->where('bug_status = ?', 'NEW')
       ->group('reported_by');

$rows = $table->fetchAll($select);

Es kann auch ein Lookup als Teil der Abfrage verwendet werden um die Fetch Operation zu verfeinern. In diesem Beispiel wird die Accounts Tabelle als Teil einer Suche nach allen Bugs die von 'Bob' gemeldet wurden, abgefragt.

$table = new Bugs();

// Bei gesetztem From Abschnitt empfangen, wichtig wenn gejoint werden soll
$select = $table->select(Zend_Db_Table::SELECT_WITH_FROM_PART);
$select->setIntegrityCheck(false)
       ->where('bug_status = ?', 'NEW')
       ->join('accounts', 'accounts.account_name = bugs.reported_by')
       ->where('accounts.account_name = ?', 'Bob');

$rows = $table->fetchAll($select);

Zend_Db_Table_Select wird primär verwendet um zu verbinden und zu prüfen um die Kriterien für einen legalen SELECT Query sicherzustellen. Trotzdem gibt es viele Fälle in denen man die Flexibilität der Zend_Db_Table_Row benötigt und Zeilen nicht geschrieben oder gelöscht werden müssen. Für diesen speziellen Fall ist es möglich Zeilen/-sets durch die Übergabe eines FALSE Wertes an setIntegrityCheck() zu erhalten. Das resultierende Zeilen oder Zeilenset wird als eine 'locked' Zeile zurückgegeben (das bedeutet das save(), delete() und jede andere Methode die Felder setzt wird eine Ausnahme werfen).

$table = new Bugs();

$select = $table->select(Zend_Db_Table::SELECT_WITH_FROM_PART)
                ->setIntegrityCheck(false);
$select->where('bug_status = ?', 'NEW')
       ->join('accounts',
              'accounts.account_name= bugs.reported_by',
              'account_name')
       ->where('accounts.account_name = ?', 'Bob');

$rows = $table->fetchAll($select);

Um das Cachen von Metadaten einen weiteren Schritt weiterzubringen, kann man sich auch entscheiden die Metadaten hardzucoden. In diesem speziellen Fall benötigt jede Änderung trotzdem eine Änderung im Code. Als solches, ist es nur empfohlen für jene die eine Produktionsumgebung optimieren wollen.

Die Struktur der Metadaten ist wie folgt:

protected $_metadata = array(
    '<column_name>' => array(
        'SCHEMA_NAME'      => <string>,
        'TABLE_NAME'       => <string>,
        'COLUMN_NAME'      => <string>,
        'COLUMN_POSITION'  => <int>,
        'DATA_TYPE'        => <string>,
        'DEFAULT'          => NULL|<value>,
        'NULLABLE'         => <bool>,
        'LENGTH'           => <string - length>,
        'SCALE'            => NULL|<value>,
        'PRECISION'        => NULL|<value>,
        'UNSIGNED'         => NULL|<bool>,
        'PRIMARY'          => <bool>,
        'PRIMARY_POSITION' => <int>,
        'IDENTITY'         => <bool>,
    ),
    // additional columns...
);

Ein einfacher Weg um die richtigen Werte zu erhalten ist es den Metadaten Cache zu verwenden, und dann die Werte die im Cache gespeichert sind, zu deserialisieren.

Diese Optimierung kann ausgeschaltet werden indem das metadataCacheInClass Flag ausgeschaltet wird:

// Bei der Instanziierung:
$bugs = new Bugs(array('metadataCacheInClass' => false));

// Oder später:
$bugs->setMetadataCacheInClass(false);

Das Flag ist standardmäßig aktiviert, was sicherstellt dass das $_metadata Array nur einmal pro Instanz ausgeliefert wird.

Standardmäßig geben die Methoden der Table Klasse ein Rowset als Instanzen der konkreten Klasse Zend_Db_Table_Rowset, und Rowsets enthalten eine Kollektion von Instanzen der konkreten Klasse Zend_Db_Table_Row. Eine alternative Klasse kann für jede von Ihnen als alternative Klasse definiert werden die verwendet werden soll, aber es müssen Klassen sein die Zend_Db_Table_Rowset_Abstract erweitern und respektiv Zend_Db_Table_Row_Abstract.

Es können Zeilen und Rowset Klassen definiert werden indem das Optionsarray des Table Konstruktors verwendet wird, respektiv die Schlüssel 'rowClass' und 'rowsetClass'. Die Namen der Klassen müssen spezifiziert werden indem Strings verwendet werden.

class My_Row extends Zend_Db_Table_Row_Abstract
{
    ...
}

class My_Rowset extends Zend_Db_Table_Rowset_Abstract
{
    ...
}

$table = new Bugs(
    array(
        'rowClass'    => 'My_Row',
        'rowsetClass' => 'My_Rowset'
    )
);

$where = $table->getAdapter()->quoteInto('bug_status = ?', 'NEW')

// Gibt ein Objekt des Typs My_Rowset zurück
// das ein Array von Objekten des Typs My_Row enthält.
$rows = $table->fetchAll($where);

Die Klassen können geändert werden indem Sie mit den setRowClass() und setRowsetClass() Methoden spezifiziert werden. Das entspricht den Zeilen und Rowsets die nachfolgend erstellt werden; es ändert aber nicht die Klasse von Zeilen- oder Rowsetobjekten die bereits davor erstellt wurden.

$table = new Bugs();

$where = $table->getAdapter()->quoteInto('bug_status = ?', 'NEW')

// Gibt ein Objekt vom Typ Zend_Db_Table_Rowset zurück das ein Array
// von Objekten des Typs Zend_Db_Table_Row enthält.
$rowsStandard = $table->fetchAll($where);

$table->setRowClass('My_Row');
$table->setRowsetClass('My_Rowset');

// Gibt ein Objekt vom Typ My_Rowset zurück das ein Array
// von Objekten des Typs My_Row enthält.
$rowsCustom = $table->fetchAll($where);

// Das $rowsStandard Objekt existiert noch immer, und es bleibt unverändert.

Für weitere Informationen über Zeilen und Rowset Klassenm siehe dieses Kapitel und dieses hier.

Die insert() und update() Methoden in der Table Klasse können überschrieben werden. Das bietet die Möglichkeit eigenen Code einzufügen der ausgeführt wird bevor die Datenbank Operation durchgeführt wird. Es muß sichergestellt werden das die Methode der Elternklasse aufgerufen wird wenn man fertig ist.

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

    public function insert(array $data)
    {
        // Einen Zeitstempel hinzufügen
        if (empty($data['created_on'])) {
            $data['created_on'] = time();
        }
        return parent::insert($data);
    }

    public function update(array $data, $where)
    {
        // Einen Zeitstempel hinzufügen
        if (empty($data['updated_on'])) {
            $data['updated_on'] = time();
        }
        return parent::update($data, $where);
    }
}

Auch die delete() Methode kann überschrieben werden.

Es können eigene Abfrage Methoden in der Table Klasse implementiert werden, wenn oft die Notwendigkeit besteht Abragen mit speziellen Kriterien auf der Table Klasse durchzuführen. Die meisten Abfragen können mit fetchAll() geschrieben werden, das bedeutet aber das Code dupliziert werden muß um Abfragekonditionen zu formen die Abfrage in verschiedenen Orten der Anwendung auszuführen. Hierfür kann es nützlich sein eine Methode in der Table Klasse zu definieren um oft benutzte Abfragen an dieser Tabelle durchzuführen.

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

    public function findByStatus($status)
    {
        $where = $this->getAdapter()->quoteInto('bug_status = ?', $status);
        return $this->fetchAll($where, 'bug_id');
    }
}

Einige Leute bevorzugen das der Name der Table Klasse einem Tabellennamen in der RDBMS, durch eine Stringumwandlung die Inflection (Beugung) genannt wird, entspricht.

Wenn zum Beispiel der Name der Table Klasse "BugsProducts" ist, würde Sie der physikalischen Tabelle in der Datenbank entsprechen die "bugs_products" heißt, wenn die explizite Definition der $_name Eigenschaft der Klasse unterdrückt wird. In dieser Übereinstimmung der Beugung, wird der Klassenname im "CamelCase" Format geschrieben und in Kleinschreibung transformiert, und Wörter mit einem Unterstrich seperiert.

Der Tabellenname der Datenbank kann unabhängig vom Klassennamen spezifiziert werden indem der Tabellenname mit der Klasseneigenschaft $_name in jeder der eigenen Tabellenklassen deklariert wird.

Zend_Db_Table_Abstract führt keine Beugung durch um die Klassennamen mit den Tabellennamen in Übereinstimmung zu bringen. Wenn die Deklaration von $_name in der eigenen Tabellenklasse unterdrückt wird, wird die Klasse mit der Datenbanktabelle in Verbindung gebracht die der Schreibweise des Klassennamens exakt entspricht.

Es ist unzureichend Identifizierer von der Datenbank zu transformieren, da das zu Doppeldeutigkeiten führen kann oder einige Identifizierer sogar unerreichbar macht. Die Verwendung der SQL Identifizierer exakt so wie Sie in der Datenbank vorhanden sind, macht Zend_Db_Table_Abstract sowohl einfacher als auch flexibler.

Wenn man es vorzieht Beugung zu verwenden, muß die Transformation selbst durch das Überschreiben der _setupTableName() Methode in der eigenen Tabellenklasse implementiert werden. Ein Weg um das zu tun ist die Definition einer abstrakten Klase die Zend_Db_Table_Abstract erweitert. Der Rest der eigenen Klassen erweitert dann die eigene neue abstrakte Klasse.

abstract class MyAbstractTable extends Zend_Db_Table_Abstract
{
    protected function _setupTableName()
    {
        if (!$this->_name) {
            $this->_name = myCustomInflector(get_class($this));
        }
        parent::_setupTableName();
    }
}

class BugsProducts extends MyAbstractTable
{
}

Man ist selbst für das Schreiben von Funktionen verantwortlich um die Transformation der Beugung auszuführen. Zend Framework bietet solche Funktionen nicht an.