Zend_Db_Table_Row_Abstract possède des accesseurs. Les colonnes SQL du résultat sont disponibles en lecture et écriture, via des propriétés de classe.

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

// Affiche la valeur de la colonne bug_description
echo $row->bug_description;

Note: Les versions antérieures de Zend_Db_Table_Row utilisaient un processus de transformation nommé inflection pour récupérer les valeurs des colonnes dans un résultat.
Actuellement, Zend_Db_Table_Row n'utilise pas d'inflection. Les noms des propriétés de l'objet doivent correspondre à l'orthographe des noms des colonnes dans la base de données sous jascente

Vous pouvez accéder aux données d'un row sous forme de tableau grâce à la méthode toArray(). Celle-ci retourne un tableau associatif.

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

// Récupère un tableau associatif column/value
$rowArray = $row->toArray();

// Utilisation comme un tableau normal
foreach ($rowArray as $column => $value) {
    echo "Column: $column\n";
    echo "Value:  $value\n";
}

Le tableau retourné par toArray() n'est pas une référence. Vous pouvez modifier ses valeurs, cela n'aura aucune répercussion dans la base de données.

Zend_Db_Table_Row_Abstract possède des méthodes permettant de récupérer des données des tables liées à la table interrogée. Voyez Zend_Db_Table Relations pour plus d'informations sur les relations entre les tables.

Vous pouvez changer les valeurs de chaque colonne du résultat Row, simplement avec les accesseurs, comme en lecture. Effectuez une banale affectation.

Utiliser l'accesseur pour spécifier une valeur à une colonne d'un résultat Row ne repercute pas le comportement immédiatement en base de données. Vous devez utiliser explicitement la méthode save() pour ceci.

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

// Change la valeur d'une ou plusieurs colonnes
$row->bug_status = 'FIXED';

// MET A JOUR l'enregistrement dans la base de données
$row->save();

Vous pouvez créer un nouvel enregistrement vierge (Row) pour une table avec la méthode createRow() issue de la classe de cette Table. Vous pouvez alors affecter des valeurs à ses colonnes grâce aux accesseurs, comme déja vu, puis enegistrer le Row en base de données avec sa méthode save().

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

// affecte des valeurs aux colonnes
$newRow->bug_description = '...description...';
$newRow->bug_status = 'NEW';

// INSERT le nouvel enregistrement dans la base de données
$newRow->save();

L'argument optionnel de createRow() est un tableau associatif qui sert à peupler tout de suite l'objet de valeurs.

<?php
$data = array(
    'bug_description' => '...description...',
    'bug_status'      => 'NEW'
);

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

// INSERT l'enregistrement en base de données
$newRow->save();

Note: La méthode createRow() était nommée fetchNew() dans les anciennes version de Zend_Db_Table.Il est recommandé de ne plus utiliser cette ancienne appellation, même si celle-ci fonctionne toujours actuellement.

Zend_Db_Table_Row_Abstract possède une méthode setFromArray() qui permet de lui peupler ses valeurs avec celles issues d'un tableau associatif nom de la colonne / valeur..

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

// Les données sont dans un tableau associatif
$data = array(
    'bug_description' => '...description...',
    'bug_status'      => 'NEW'
);

// Affecte toutes les valeurs des colonnes en une seule fois
$newRow->setFromArray($data);

// INSERT l'enregistrement en base de données
$newRow->save();

You can call the delete() method on a Row object. This deletes rows in the database matching the primary key in the Row object.

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

// EFFACE cet enregistrement de la base de données
$row->delete();

Notez qu'il n'est pas nécessaire d'appeler save() pour un effacement. Celui-ci est à effet immédiat.

Utilisez simplement la fonction PHP serialize() pour créer une chaine de caractères représentant votre objet Row.

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

// Convertit l'objet en une forme sérialisée
$serializedRow = serialize($row);

// Maintenant vous pouvez utiliser $serializedRow pour l'écrire dans un fichier, etc.

Utilisez simplement la fonction PHP unserialize(). L'objet Row originel est alors recrée.

Notez que l'objet retourné fonctionne alors en mode déconnecté. Vous pouvez lire les valeurs des colonnes, mais pas les modifier ni enregistrer l'objet en base de données (save()).

<?php
$rowClone = unserialize($serializedRow);

// Vous ne pouvez faire qu'une utilisation en lecture seule
echo $rowClone->bug_description;

Note: Pourquoi ce mode déconnecté imposé ?
Un objet sérialisé est une chaine de caractère, humainement visible. Il est donc peut sécurisé d'y laisser un mot de passe vers un serveur de base de données. Le lecteur d'un objet Row sérialisé ne devrait pas pouvoir accéder à la base de données. De plus, une connexion à une base de données est un type non sérialisable par PHP (ressource).

Il est bien entendu possible de reconnecter l'objet Row à la base de données, et plus précisémment à la Table dont il fut issu. Utilisez la méthode setTable() et passez lui une instance héritant de Zend_Db_Table_Abstract. Une fois reconnecté, l'objet Row possède de nouveau un accès à la base de données, et n'est donc plus en mode lecture seule.

<?php
$rowClone = unserialize($serializedRow);

$bugs = new Bugs();

// Reconnecte le Row à la table et donc,
// à la base de données
$rowClone->setTable($bugs);

// Maintenant il est possible de l'utiliser en mode écriture
$rowClone->bug_status = 'FIXED';
$rowClone->save();

Si vous avez un besoin spécifique d'implémenter une logicque spéciale après la création d'une instance de Row, vous pouvez utiliser sa méthode init(), qui est appelée dans son constructeur, mais après que les méta données aient été calculées.

<?php
class MyApplicationRow extends Zend_Db_Table_Row_Abstract
{
    protected $_role;

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

La classe des Rows appelle les méthodes protégées _insert(), _update(), et _delete() avant d'effectuer chacune des opérations respectives INSERT, UPDATE, et DELETE. Il est donc possible de définir sa propre logique dans votre sous-classe de Row.

Ci-dessous vous trouverez des exemples d'utilisation d'une logique personnalisée dans les classes de Row :

<?php
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 est une variable d'exemple qui définit si
// la journalisation est activée ou pas
if ($loggingEnabled) {
    $bugs = new Bugs(array('rowClass' => 'MyLoggingRow'));
} else {
    $bugs = new Bugs();
}

<?php
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';
}

Il peut être intéréssant de personnaliser l'accès aux colonnes de la table représentée par un résultat Row, plutôt que d'utiliser le nom des colonnes telles que définies dans le SGBDR sous-jascent. La transformation de l'un vers l'autre est appelée inflection.

Les classes Zend_Db n'utilisent pas l'inflection par défaut. Voyez Utiliser l'inflection dans Zend_Db_Table pour plus de détails sur ce procédé.

Ainsi si vous voulez utiliser l'inflection, vous devez implémenter vous-même la transformation à effectuer en redéfinissant la méthode _transformColumn() dans votre classe de Row, et bien entendu utiliser cette classe de Row pour votre Table.

<?php
class MyInflectedRow extends Zend_Db_Table_Row_Abstract
{
    protected function _transformColumn($columnName)
    {
        $nativeColumnName = myCustomInflector($columnName);
        return $nativeColumnName;
    }
}

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

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

// Utilisez des nom de colonnes CamelCase, l'inflecteur les
// transformera alors pour vous afin d'établir la correspondance
// avec les noms natifs des colonnes.
$row->bugDescription = 'New description';

En revanche, c'est à vous d'écrire votre mécanisme d'inflection.