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;

Hinweis: Frühere Versionen von Zend_Db_Table_Row haben diese Spalten-Zugriffsnamen mithilfe einer Zeichenketten-Transformation namens Inflection auf Spaltennamen umgeleitet.
Die Aktuelle Version von Zend_Db_Table_Row implementiert diese Funktion jedoch nicht mehr. Der Spalten-Zugriffsname muss genau so geschrieben sein, wie die Spalte in der Datenbank heißt.

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 update fä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 Zend_Db_Table Relationships 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();

Hinweis: Die Methode createRow() wurde in früheren Versionen von Zend_Db_Table fetchNew() genannt. Es wird empfohlen, den neuen Methodennamen zu benutzen, obwohl der alte Name weiterhin funktioniert, um Abwärtskompatibilität zu gewährleisten.

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;

Hinweis: Warum werden Zeilenobjekte unverbunden deserialisiert?
Ein serialisiertes Objekt ist eine Zeichenkette, die lesbar für jeden ist, dem sie vorliegt. Es könnte ein Sicherheitsrisiko sein, Parameter wie Datenbank-Loginname und -Passwort in simplem, unverschlüsseltem Text abzulegen. Es ist nicht wünschenswert, solche Daten in einer Textdatei abzulegen, die nicht geschützt ist, oder sie in einer E-Mail oder einem anderen Medium zu versenden, das leicht von potentiellen Angreifern lesbar ist. Der Leser des serialisierten Objekts sollte es nicht benutzen können, um Zugriff zur Datenbank zu erhalten, ohne richtige Logindaten zu kennen.

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 Datenbank direkt entspricht, indem eine String Transformation durchgeführt wird, die auch Inflection genannt wird.

Zend_Db Klassen implementieren Inflection standardmäßig nicht. Inflection (Beugung) in Zend_Db_Table definieren gibt eine Erklärung für diese 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.