Declare la tabla de la base de datos para la que se define esta clase, usando la variable protegida $_name. Se trata de una cadena, y debe contener el nombre de la tabla tal y como aparece escrito en la base de datos.

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

Si no especifica el nombre de la tabla, se usa por defecto el nombre de la clase. Si confía en este comportamiento por defecto, el nombre de la clase debe coincidir con el nombre de la tabla tal y como aparece en la base de datos.

class bugs extends Zend_Db_Table_Abstract
{
    // el nombre de la tabla coincide con el nombre de la clase
}

También puede declarar el esquema de la tabla, ya sea con la variable protegida $_schema, o con el esquema anteponiéndolo al nombre de la tabla en la propiedad $_name. Cualquier esquema especificado con la propiedad $_name tiene prioridad sobre un esquema especificado con la propiedad $_schema. En algunas marcas de RDBMS, el término para esquema es "base de datos" o "tablespace", pero se usa de forma similar.

// Primera alternativa:
class Bugs extends Zend_Db_Table_Abstract
{
    protected $_schema = 'bug_db';
    protected $_name   = 'bugs';
}

// Segunda alternativa:
class Bugs extends Zend_Db_Table_Abstract
{
    protected $_name = 'bug_db.bugs';
}

// Si se especifican esquemas tanto en $_name como en $_schema, el que
// se especifica en $_name tiene prioridad:

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

El esquema y los nombres de tabla también se pueden especificar mediante directivas de configuración del constructor, que sobrescriben cualquier valor por defecto especificado con las propiedades $_name y $_schema. Una especificación de esquema dada con la directiva name sobrescribe cualquier valor proporcionado con la opción schema.

class Bugs extends Zend_Db_Table_Abstract
{
}

// Primera alternativa:

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

// Segunda alternativa:

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

// Si se especifican esquemas tanto en 'name' como en 'schema', el que
// se especifica en 'name' tiene prioridad:

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

Si no especifica el nombre del esquema, se usa por defecto el esquema al que está conectada su instancia de adaptador de base de datos.

Toda tabla debe tener una clave primaria. Puede declarar la columna de la clave primaria usando la variable protegida $_primary. Puede ser una cadena que nombre la única columna para la clave primaria, o bien un array de nombres de columnas si su clave primaria es compuesta.

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

Si no especifica la clave primaria, Zend_Db_Table_Abstract intenta descubrir la clave primaria basándose en la información proporcionada por el método describeTable()´.

	Nota
	Toda clase de tabla debe saber qué columnas se pueden usar para identificar filas de forma unívoca. Si no se especifican columnas de clave primaria en la definición de la clase de tabla o en los argumentos del constructor de la tabla, ni se descubren en los metadatos de la tabla proporcionados por describeTable(), entonces la tabla no se puede usar con Zend_Db_Table.

Cuando crea una instancia de una clase de tabla, el constructor invoca un conjunto de métodos protegidos que inicializan los metadatos de la tabla. Puede extender cualquiera de estos métodos para definir metadatos de forma explícita. Recuerde invocar el método del mismo nombre en la clase padre al final de su método.

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

Los métodos de configuración que puede sobrescribir son los siguientes:

Si la lógica específica de la aplicación necesita inicializarse cuando se construye una clase de tabla, puede optar por mover sus tareas al método init(), el cual se invoca después de que se hayan procesado todos los metadatos de la tabla. Esto se recomienda frente al método __construct() si no necesita alterar los metadatos de ninguna forma programática.

class Bugs extends Zend_Db_Table_Abstract
{
    protected $_observer;

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

La primera forma de proporcionar un adaptador de base de datos a una clase de tabla es pasándolo como un objeto de tipo Zend_Db_Adapter_Abstract en el array de opciones, identificado por la clave 'db'.

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

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

La segunda forma de proporcionar un adaptador de base de datos a una clase de tabla es declarando un objeto de tipo Zend_Db_Adapter_Abstract como adaptador de base de datos por defecto para todas las instancias posteriores de tablas en su aplicación. Puede hacer esto con el método estático Zend_Db_Table_Abstract::setDefaultAdapter(). El argumento es un objeto de tipo Zend_Db_Adapter_Abstract.

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

// Más tarde...

$table = new Bugs();

Puede resultar conveniente crear el objeto adaptador de base de datos en un lugar central de su aplicación, como el bootstrap, y luego almacenarlo como el adaptador por defecto. Esto le proporciona un medio para asegurarse de que la instancia del adaptador es la misma en toda su aplicación. Sin embargo, establecer un adaptador por defecto se limita a una única instancia de adaptador.

La tercera forma de proporcionar un adaptador de base de datos a una clase de tabla es pasando una cadena en el array de opciones, también identificada por la clave 'db'. La cadena se usa como clave para la instancia estática Zend_Registry, donde la entrada en esa clave es un objeto de tipo Zend_Db_Adapter_Abstract.

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

// Más tarde...

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

Al igual que al establecer el adaptador por defecto, esto le proporciona el medio para asegurarse de que se usa la misma instancia de adaptador en toda su aplicación. Usar el registro es más flexible, porque puede almacenar más de una instancia de adaptador. Una instancia de adaptador dada es específica de una determinada marca de RDBMS e instancia de base de datos. Si su aplicación necesita acceder a múltiples bases de datos o incluso a múltiples marcas de base de datos, entonces necesita usar múltiples adaptadores.

Una clave primaria autoincremental genera un valor entero único para usted si omite la columna de clave primaria en su sentencia SQL INSERT.

En Zend_Db_Table_Abstract, si define la variable protegida $_sequence con el valor booleano TRUE, entonces la clase asume que la tabla tiene una clave primaria autoincremental.

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

    // This is the default in the Zend_Db_Table_Abstract class;
    // you do not need to define this.
    protected $_sequence = true;
}

MySQL, Microsoft SQL Server y SQLite son ejemplos de marcas de RDBMS que admiten claves primarias autoincrementales.

PostgreSQL tiene una notación SERIAL que define implícitamente una secuencia basada en el nombre de la tabla y la columna, y usa la secuencia para generar valores de clave para las nuevas filas. IBM DB2 tiene una notación IDENTITY que funciona de forma similar. Si usa cualquiera de estas notaciones, trate su clase Zend_Db_Table como si tuviera una columna autoincremental respecto a la declaración de la variable miembro $_sequence como TRUE.

Una secuencia es un objeto de base de datos que genera un valor único, que puede usarse como valor de clave primaria en una o más tablas de la base de datos.

Si define $_sequence como una cadena, entonces Zend_Db_Table_Abstract asume que la cadena nombra un objeto de secuencia en la base de datos. La secuencia se invoca para generar un nuevo valor, y este valor se usa en la operación INSERT.

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

    protected $_sequence = 'bug_sequence';
}

Oracle, PostgreSQL e IBM DB2 son ejemplos de marcas de RDBMS que admiten objetos de secuencia en la base de datos.

PostgreSQL e IBM DB2 también tienen sintaxis que define secuencias de forma implícita y asociada a columnas. Si usa esta notación, trate la tabla como si tuviera una columna de clave autoincremental. Defina el nombre de la secuencia como una cadena solo en los casos en los que invocaría la secuencia de forma explícita para obtener el siguiente valor de clave.

Algunas tablas tienen una clave natural. Esto significa que la clave no la genera automáticamente la tabla ni una secuencia. Debe especificar el valor para la clave primaria en este caso.

Si define $_sequence con el valor booleano FALSE, entonces Zend_Db_Table_Abstract asume que la tabla tiene una clave primaria natural. Debe proporcionar valores para las columnas de la clave primaria en el array de datos del método insert(), o de lo contrario este método lanza una Zend_Db_Table_Exception.

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

    protected $_sequence = false;
}

	Nota
	Todas las marcas de RDBMS admiten tablas con claves naturales. Ejemplos de tablas que a menudo se declaran con claves naturales son las tablas de consulta (lookup), las tablas de intersección en relaciones muchos a muchos, o la mayoría de las tablas con claves primarias compuestas.

Advertencia

La API para operaciones de recuperación se ha sustituido para permitir que un objeto Zend_Db_Table_Select modifique la consulta. Sin embargo, el uso obsoleto de los métodos fetchRow() y fetchAll() seguirá funcionando sin modificación. Las siguientes sentencias son todas legales y funcionalmente idénticas, sin embargo se recomienda actualizar su código para aprovechar el nuevo uso siempre que sea posible. /** * Fetching a rowset */ $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) ); // or with binding $rows = $table->fetchAll( $table->select() ->where('bug_status = :status') ->bind(array(':status'=>'NEW') ->order('bug_id ASC') ->limit(10, 0) ); /** * Fetching a single row */ $row = $table->fetchRow( 'bug_status = "NEW"', 'bug_id ASC' ); $row = $table->fetchRow( $table->select() ->where('bug_status = ?', 'NEW') ->order('bug_id ASC') ); // or with binding $row = $table->fetchRow( $table->select() ->where('bug_status = :status') ->bind(array(':status'=>'NEW') ->order('bug_id ASC') );

El objeto Zend_Db_Table_Select es una extensión del objeto Zend_Db_Select que aplica restricciones específicas a una consulta. Las mejoras y restricciones son:

$table = new Bugs();

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

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

Las interfaces fluidas se implementan en todo el componente, por lo que esto se puede reescribir en una forma más abreviada.

$table = new Bugs();

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

Puede consultar un conjunto de filas usando cualquier criterio distinto de los valores de la clave primaria, usando el método fetchAll() de la clase de tabla. Este método devuelve un objeto de tipo Zend_Db_Table_Rowset_Abstract.

$table = new Bugs();

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

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

También puede pasar criterios de ordenación en una cláusula ORDER BY, así como valores enteros de cuenta y desplazamiento, usados para que la consulta devuelva un subconjunto específico de filas. Estos valores se usan en una cláusula LIMIT, o en lógica equivalente para marcas de RDBMS que no admiten la sintaxis LIMIT.

$table = new Bugs();

$order  = 'bug_id';

// Return the 21st through 30th rows
$count  = 10;
$offset = 20;

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

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

Todos los argumentos anteriores son opcionales. Si omite la cláusula ORDER, el conjunto de resultados incluye filas de la tabla en un orden impredecible. Si no se establece ninguna cláusula LIMIT, recupera todas las filas de la tabla que coincidan con la cláusula WHERE.

Para solicitudes más específicas y optimizadas, puede que desee limitar el número de columnas devueltas en una fila o rowset. Esto se puede lograr pasando una cláusula FROM al objeto select. El primer argumento de la cláusula FROM es idéntico al de un objeto Zend_Db_Select, con la adición de poder pasar una instancia de Zend_Db_Table_Abstract y hacer que determine automáticamente el nombre de la tabla.

$table = new Bugs();

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

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

	Importante
	El rowset contiene filas que siguen siendo 'válidas': simplemente contienen un subconjunto de las columnas de una tabla. Si se invoca un método save() en una fila parcial, solo se modificarán los campos disponibles.

También puede especificar expresiones dentro de una cláusula FROM y hacer que estas se devuelvan como una fila o rowset readOnly. En este ejemplo devolveremos filas de la tabla bugs que muestran un agregado del número de bugs nuevos reportados por individuos. Observe la cláusula GROUP. La columna 'count' se pondrá a disposición de la fila para su evaluación y se puede acceder a ella como si fuera parte del esquema.

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

También puede usar una tabla de consulta (lookup) como parte de su consulta para refinar aún más sus operaciones de recuperación. En este ejemplo, la tabla accounts se consulta como parte de una búsqueda de todos los bugs nuevos reportados por 'Bob'.

$table = new Bugs();

// retrieve with from part set, important when joining
$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 se usa principalmente para restringir y validar, de modo que pueda aplicar el criterio para una consulta SELECT legal. Sin embargo, puede haber ciertos casos en los que necesite la flexibilidad del componente Zend_Db_Table_Row y no necesite una fila escribible o eliminable. Para este caso de uso específico, es posible recuperar una fila o rowset pasando un valor FALSE a setIntegrityCheck(). La fila o rowset resultante se devolverá como una fila 'bloqueada' (lo que significa que save(), delete() y cualquier método de establecimiento de campo lanzarán una excepción).

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

Para llevar el almacenamiento en caché de metadatos un paso más allá, también puede optar por codificar los metadatos de forma fija (hardcode). En este caso particular, sin embargo, cualquier cambio en el esquema de la tabla requerirá un cambio en su código. Por ello, solo se recomienda para quienes estén optimizando para el uso en producción.

La estructura de metadatos es la siguiente:

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

Una forma fácil de obtener los valores adecuados es usar la caché de metadatos, y luego deserializar los valores almacenados en la caché.

Puede desactivar esta optimización desactivando el indicador metadataCacheInClass:

// At instantiation:
$bugs = new Bugs(array('metadataCacheInClass' => false));

// Or later:
$bugs->setMetadataCacheInClass(false);

El indicador está activado por defecto, lo que asegura que el array $_metadata solo se rellene una vez por instancia.

Por defecto, los métodos de la clase Table devuelven un Rowset en instancias de la clase concreta Zend_Db_Table_Rowset, y los Rowsets contienen una colección de instancias de la clase concreta Zend_Db_Table_Row. Puede especificar una clase alternativa para usar en cualquiera de ellas, pero deben ser clases que extiendan Zend_Db_Table_Rowset_Abstract y Zend_Db_Table_Row_Abstract, respectivamente.

Puede especificar las clases Row y Rowset usando el array de opciones del constructor de la tabla, en las claves 'rowClass' y 'rowsetClass' respectivamente. Especifique los nombres de las clases usando cadenas.

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

// Returns an object of type My_Rowset,
// containing an array of objects of type My_Row.
$rows = $table->fetchAll($where);

Puede cambiar las clases especificándolas con los métodos setRowClass() y setRowsetClass(). Esto se aplica a las filas y rowsets creados posteriormente; no cambia la clase de ninguna fila o rowset que haya creado previamente.

$table = new Bugs();

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

// Returns an object of type Zend_Db_Table_Rowset
// containing an array of objects of type Zend_Db_Table_Row.
$rowsStandard = $table->fetchAll($where);

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

// Returns an object of type My_Rowset,
// containing an array of objects of type My_Row.
$rowsCustom = $table->fetchAll($where);

// The $rowsStandard object still exists, and it is unchanged.

Para más información sobre las clases Row y Rowset, consulte este capítulo y este otro.

Puede sobrescribir los métodos insert() y update() en su clase de tabla. Esto le da la oportunidad de implementar código personalizado que se ejecuta antes de realizar la operación de base de datos. Asegúrese de invocar el método de la clase padre cuando haya terminado.

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

    public function insert(array $data)
    {
        // add a timestamp
        if (empty($data['created_on'])) {
            $data['created_on'] = time();
        }
        return parent::insert($data);
    }

    public function update(array $data, $where)
    {
        // add a timestamp
        if (empty($data['updated_on'])) {
            $data['updated_on'] = time();
        }
        return parent::update($data, $where);
    }
}

También puede sobrescribir el método delete().

Puede implementar métodos de consulta personalizados en su clase de tabla, si tiene necesidad frecuente de realizar consultas contra esta tabla con criterios específicos. La mayoría de las consultas se pueden escribir usando fetchAll(), pero esto requiere que duplique código para formar las condiciones de la consulta si necesita ejecutar la consulta en varios lugares de su aplicación. Por lo tanto, puede resultar conveniente implementar un método en la clase de tabla para realizar consultas de uso frecuente contra esta tabla.

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

Algunas personas prefieren que el nombre de la clase de tabla coincida con un nombre de tabla en el RDBMS mediante una transformación de cadena llamada inflexión.

Por ejemplo, si el nombre de su clase de tabla es "BugsProducts", coincidiría con la tabla física en la base de datos llamada "bugs_products", si omite la declaración explícita de la propiedad de clase $_name. En este mapeo de inflexión, el nombre de la clase escrito en formato "CamelCase" se transformaría a minúsculas, y las palabras se separarían con un guion bajo.

Puede especificar el nombre de la tabla de base de datos independientemente del nombre de la clase declarando el nombre de la tabla con la propiedad de clase $_name en cada una de sus clases de tabla.

Zend_Db_Table_Abstract no realiza ninguna inflexión para mapear el nombre de la clase al nombre de la tabla. Si omite la declaración de $_name en su clase de tabla, la clase se mapea a una tabla de base de datos que coincide exactamente con el nombre de la clase.

Es inapropiado transformar identificadores de la base de datos, porque esto puede producir ambigüedad o hacer que algunos identificadores sean inaccesibles. Usar los identificadores SQL exactamente tal y como aparecen en la base de datos hace que Zend_Db_Table_Abstract sea a la vez más simple y más flexible.

Si prefiere usar inflexión, entonces debe implementar la transformación usted mismo, sobrescribiendo el método _setupTableName() en sus clases de tabla. Una forma de hacerlo es definir una clase abstracta que extienda Zend_Db_Table_Abstract, y luego hacer que el resto de sus tablas extiendan su nueva clase abstracta.

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
{
}

Usted es responsable de escribir las funciones para realizar la transformación de inflexión. Zend Framework no proporciona tal función.