Zend_Db_Table_Row_Abstract bietet Zugriffsmethoden an, damit die Spalten einer Zeile als Objekteigenschaften angesprochen werden können.

$bugs = new Bugs();
$row = $bugs->fetchRow($bugs->select()->where('bug_id = ?', 1));

// Wert der Spalte bug_description ausgeben
echo $row->bug_description;

Die Tabellenzeile kann mithilfe der toArray() Methode des Zeilenobjekts auch als Array gelesen werden. Diese gibt ein assoziatives Array zurück, mit Spaltennamen als Index und ihren Inhalten als Werten.

$bugs = new Bugs();
$row = $bugs->fetchRow($bugs->select()->where('bug_id = ?', 1));

// Das assoziative Array aus dem Zeilenobjekt holen
$rowArray = $row->toArray();

// Jetzt einfach wie ein normales Array verwenden
foreach ($rowArray as $column => $value) {
    echo "Spalte: $column\n";
    echo "Wert:  $value\n";
}

Das Array, das von toArray() zurückgegeben wird, ist nicht updatefähig. Die Werte des Arrays können wie in jedem Array modifiziert werden, aber Änderungen an diesem Array werden nicht direkt in der Datenbank gespeichert.

Die Klasse Zend_Db_Table_Row_Abstract bietet Methoden, um Zeilen und Zeilensätze aus verwandten Tabellen auszulesen. Siehe das Kapitel über Beziehungen für weitere Informationen über Tabellenbeziehungen.

Individuelle Werte von Spalten können mit Hilfe der Zugriffsvariablen gesetzt werden, so ähnlich wie Spalten in obiegen Beispiel als Objekteigenschaften gelesen werden.

Das Ändern eines Werts über eine Zugriffsvariable ändert den Spaltenwert des Zeilenobjekts in der Anwendung, aber noch wird die Änderung nicht in die Datenbank übernommen. Das wird mit der Methode save() erledigt.

$bugs = new Bugs();
$row = $bugs->fetchRow($bugs->select()->where('bug_id = ?', 1));

// Wert einer oder mehrerer Spalten ändern
$row->bug_status = 'FIXED';

// Die Datenbankzeile mit den neuen Werten aktualisieren
$row->save();

Eine neue Zeile kann in einer Tabelle mit der createRow() Methode der Tabellenklasse angelegt werden. Auf Felder dieser Zeile können mit dem Objektorientierten Interface zugegriffen werden, aber die Zeile wird nicht in der Datenbank geschrieben, bis die save() Methode aufgerufen wird.

$bugs = new Bugs();
$newRow = $bugs->createRow();

// Spaltenwerte setzen, wie es in der Anwendung üblich ist
$newRow->bug_description = '...Beschreibung...';
$newRow->bug_status = 'NEW';

// Neue Zeile in die Datenbank einfügen
$newRow->save();

Das optionale Argument der createRow() Methode ist ein assoziatives Array, mit dem Felder der neuen Zeile eingefügt werden können.

$data = array(
    'bug_description' => '...Beschreibung...',
    'bug_status'      => 'NEW'
);

$bugs = new Bugs();
$newRow = $bugs->createRow($data);

// Neue Zeile in die Datenbank einfugen
$newRow->save();

Zend_Db_Table_Row_Abstract beinhaltet eine Methode namens setFromArray(), die es ermöglicht, mehrere Spalten einer Zeile mithilfe eines assoziativen Arrays mit Spaltenname/Wert-Paaren gleichzeitig zu setzen. Diese Methode ist nützlich, um Werte für neue Zeilen oder Zeilen, die aktualisiert werden müssen, zu setzen.

$bugs = new Bugs();
$newRow = $bugs->createRow();

// Daten in ein assoziatives Array schreiben
$data = array(
    'bug_description' => '...Beschreibung...',
    'bug_status'      => 'NEW'
);

// Alle Spaltenwerte auf einmal setzen
$newRow->setFromArray($data);

// Neue Zeile in die Datenbank schreiben
$newRow->save();

Das Zeilenobjekt hat eine Methode namens delete(). Diese löscht Zeilen in der Datenbank, deren Primärschlüssel dem im Zeilenobjekt entspricht.

$bugs = new Bugs();
$row = $bugs->fetchRow('bug_id = 1');

// Zeile löschen
$row->delete();

save() muss nicht aufgerufen werden, um den Löschvorgang abzuschließen; er wird sofort auf der Datenbank ausgeführt.

Es kann einfach PHPs serialize() Funktion verwendet werden, um einen String zu erstellen, der einen Byte-Stream enthält welcher das Zeilen-Objekt repräsentiert.

$bugs = new Bugs();
$row = $bugs->fetchRow('bug_id = 1');

// Objekt serialisieren
$serializedRow = serialize($row);

// Jetzt kann $serializedRow z.B. in einer Datei gespeichert werden

PHPs unserialize() Funktion stellt ein Objekt aus einem Byte-Stream wieder her. Die Funktion gibt das Original Objekt zurück.

Bitte beachten: Das zurückgegebene Zeilen-Objekt ist nicht mit der Datenbank verbunden. Das Zeilenobjekt und seine Eigenschaften können gelesen werden, aber es können keine Zeilenwerte verändert oder andere Operationen ausgeführt werden, die eine Datenbankverbindung benötigen.

$rowClone = unserialize($serializedRow);

// Jetzt können die Objekteigenschaften genutzt werden
// allerdings nur lesend.
echo $rowClone->bug_description;

Ein nicht verbundenes Zeilenobjekt kann mithilfe der Methode setTable() reaktiviert werden. Das Argument dieser Methode ist ein gültiges Zend_Db_Table_Abstract-Objekt, das vom Benutzer erstellt wird. Für das Erstellen eines Tabellenobjekts wird eine aktive Datenbankverbindung benötigt, also wird, indem die Tabelle wieder mit dem Zeilenobjekt verknüpft wird, auch der Datenbankzugriff wiederhergestellt. Ab diesem Zeitpunkt können Werte im Zeilenobjekt wieder verändert und in der Datenbank gespeichert werden.

$rowClone = unserialize($serializedRow);

$bugs = new Bugs();

// Das Zeilenobjekt wieder mit einer Tabelle
// und damit mit einer aktiven Datenbankverbindung verknüpfen
$rowClone->setTable($bugs);

// Jetzt können wieder Werte geändert und danach gespeichert werden
$rowClone->bug_status = 'FIXED';
$rowClone->save();

Wenn Anwendungs-spezifische Logik benötigt wird die initialisiert werden soll wenn eine Zeile erstellt wird, kann entschieden werden die Aufgaben in die init() Methode zu verschieben, welche aufgerufen wird nachdem alle Metadaten der Zeile bearbeitet wurden. Das wird empfohlen statt der __construct() Methode wenn die Metadaten nicht programtechnisch verändert werden müssen.

class MyApplicationRow extends Zend_Db_Table_Row_Abstract
{
    protected $_role;

    public function init()
    {
        $this->_role = new MyRoleClass();
    }
}

Die Zeilenklasse ruft geschützte Methoden namens _insert(), _update(), und _delete() auf, bevor die entsprechenden Operationen in der INSERT, UPDATE, und DELETE ausgeführt werden. In diesen Methoden kann in den eigenen Zeilenklassen auch eigene Logik implementiert werden.

Wenn es nötig ist, eigene Logik in einer bestimmten Tabelle auszuführen, und diese Logik bei jeder Operation ausgeführt werden muss, die auf die Tabelle angewendet wird, hat es vielleicht mehr Sinn, diesen eigenen Code in den insert(), update() und delete()-Methoden der eigenen Tabellenklasse zu implementieren. Trotzdem kann es manchmal nötig sein, eigene Logik in der Zeilenklasse einzubauen.

Unten sind beispielhaft Fälle aufgeführt, in denen es Sinn haben könnte, eigene Logik in der Zeilenklasse anstatt der Tabellenklasse einzubauen:

class MyLoggingRow extends Zend_Db_Table_Row_Abstract
{
    protected function _insert()
    {
        $log = Zend_Registry::get('database_log');
        $log->info(Zend_Debug::dump($this->_data,
                                    "INSERT: $this->_tableClass",
                                    false)
                  );
    }
}

// $loggingEnabled sei ein Beispiel
// für eine Konfigurationseinstellung
if ($loggingEnabled) {
    $bugs = new Bugs(array('rowClass' => 'MyLoggingRow'));
} else {
    $bugs = new Bugs();
}

class MyLoggingRow extends Zend_Db_Table_Row_Abstract
{
    protected function _insert()
    {
        $log = Zend_Registry::get('database_log');
        $log->info(Zend_Debug::dump($this->_data,
                                    "INSERT: $this->_tableClass",
                                    false)
                  );
    }
}

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

class Products extends Zend_Db_Table_Abstract
{
    protected $_name = 'products';
    protected $_rowClass = 'MyLoggingRow';
}

Manche Personen ziehen es vor, dass der Klassenname der Tabelle dem Tabellennamen in der RDBMS direkt entspricht, indem eine String Transformation durchgeführt wird, die auch Inflection genannt wird.

Zend_Db Klassen implementieren Inflection standardmäßig nicht. Siehe das Kapitel über die Erweiterung der Inflection für eine Erklärung diesr Richtlinie.

Wenn Inflection genutzt werden soll, dann muss die Manipulation selbst implementiert werden, indem die Methode _transformColumn() in einer eigenen Zeilenklasse überschrieben wird und Objekte dieser Klasse für Abfragen an die Datenbank genutzt werden.

class MyInflectedRow extends Zend_Db_Table_Row_Abstract
{
    protected function _transformColumn($columnName)
    {
        $nativeColumnName = meineEigeneInflectionFunktion($columnName);
        return $nativeColumnName;
    }
}

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

$bugs = new Bugs();
$row = $bugs->fetchNew();

// Benutzung von Spaltennamen im camelCase.
// _transformColumn() wandelt den Spaltennamen wieder um.
$row->bugDescription = 'New description';

Es liegt in der Verantwortung des Entwicklers, Funktionen für Inflection zu schreiben. Zend Framework bietet solche Funktionen wie bereits erwähnt von Haus aus nicht an.