The Bisna library integrates Zend Framework version 1.x and the Doctrine 2 ORM; however, it dids not work properly with version 2.1.0 of the DoctrineCommon package. This article shows how to get it to work.
(actually, this article is now obsolete because Bisna now works with Doctrine 2.1.0)

Bisna can be downloaded from github. To check your version of DoctrineCommon issue this command from the command line

sudo pear list -c  pear.doctrine-project.org

Add the four lines of code mentioned by Ben Eberlei at https://github.com/doctrine/doctrine2/blob/master/UPGRADE_TO_2_1. Modify this section of startORMMetadata()

// snip... 
// only the relevent section of startORMMetadata is shown here
 if ($reflClass->getName() == 'Doctrine\ORM\Mapping\Driver\AnnotationDriver' 
      || $reflClass->isSubclassOf('Doctrine\ORM\Mapping\Driver\AnnotationDriver')) {

    $annotationReaderClass = $driver['annotationReaderClass'];
    $annotationReader = new annotationReaderClass($this->getCacheInstance($driver['annotationReaderCache']));
    $annotationReader->setDefaultAnnotationNamespace('Doctrine\ORM\Mapping\\');

    foreach ($driver['annotationReaderNamespaces'] as $alias => $namespace) {

          $annotationReader->setAnnotationNamespaceAlias($namespace, $alias);
    }

  if ($reflClass->getName() == 'Doctrine\ORM\Mapping\Driver\AnnotationDriver' ||
      $reflClass->isSubclassOf('Doctrine\ORM\Mapping\Driver\AnnotationDriver')) {
      
      // For 2.1 add this line
      \Doctrine\Common\Annotations\AnnotationRegistry::registerFile('Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php'); 

      $annotationReaderClass = $driver['annotationReaderClass'];

     $annotationReader = new  annotationReaderClass($this->getCacheInstance($driver['annotationReaderCache']));

      $annotationReader->setDefaultAnnotationNamespace('Doctrine\ORM\Mapping\\');
                
     // For 2.1 add the following three lines:
     $annotationReader->setIgnoreNotImportedAnnotations(true); 
     $annotationReader->setEnableParsePhpImports(false);        
     $annotationReader = new \Doctrine\Common\Annotations\CachedReader( 
               new \Doctrine\Common\Annotations\IndexedReader($annotationReader), 
               new \Doctrine\Common\Cache\ArrayCache());

      foreach ($driver['annotationReaderNamespaces'] as $alias => $namespace) {

             $annotationReader->setAnnotationNamespaceAlias($namespace, $alias);
     }

1. I downloaded the 7z–zipped version of xampp for windows and unzipped it to c:\xampp.

2. I installed the cygwin linux command line utilties for windows.

3. I ran the cygwin “as Administrator” (right click the Cygwin desktop icon and select “run as administrator”).

4. I changed the permissions of the c:\xampp directory to 777

# cd /cygdrive/c
# chmod -R 777 xampp

5. Set the PEAR configuration settings for data_dir, test_dir and doc_dir. For example,

# cd /cygdrive/c/xampp/php
# mkdir pear/data
# ./pear.bat config-set data_dir c:\\xampp\\php\\pear\\data

Do this for data_dir, test_dir, doc_dir, and cfg_dir as necessary. You will need to create the respective directories first (as shown above for data_dir). Note the use of double slashes! Also note: You may need to do the chmod -R 777 again after the config-sets, to make the subdirectories read/write-able.

To see the current PEAR configuration do

# cd /cygdrive/c/xampp/php
# ./pear.bat config-show

after running Cygwin as Administrator.

6. Now install the packages you want. For example, this is how you would install Doctrine 2 ORM. Again, I am doing this from the Cygwin shell.

# cd /cygdrive/c/xampp/php
# ./pear.bat channel-discover pear.doctrine-project.org
# ./pear.bat install pear.doctrine-project.org/DoctrineORM

If you want to update current packages:

# cd /cygdrive/c/xampp/php
# ./pear.bat update-channels
# ./pear.bat upgrade-all

Be sure to also add the section for localhost, as explained in the article; otherwise you won’t be able to access htt://localhost, which is the XAMPP start page.

Steps to setup the database and config both cli-config.php and cookbook.php. This setup assumes you have used pear to install Doctrine 2. To do so:

UPDATED December 27th, 2010: Doctrine 2 is now no longer in beta

$sudo pear channel-discover pear.doctrine-project.org
$sudo pear install -o pear.doctrine-project.org/DoctrineORM
$sudo pear list -c pear.doctrine-project.org

This should also install the prerequisite packages: DoctrineCommon and DoctrineDBAL.
Note: pear config-set preferred_state beta is no longer necessary because Doctrine 2 is no longer in beta!

1. Generate the schema from the command line using the doctrine command line tool. For example, on Linux

   $ doctrine orm:schema-tool:create --dump-sql > generated.sql

2. Edit generated.sql and add the following lines to the top. Use the database name of your choice.

    drop database if exists bugs_db_cb;
    create database bugs_db_cb;
    use bugs_db_cb;

3. Edit cli-config.php and cookbook.php. Change the $connectionOptions array parameters, specifying the name of the database, the database’s user, and its password. Remember to create a user of the database.

   $connectionOptions = array(
        'driver' => 'pdo_mysql',
        'dbname' => 'bugs_db_cb', // your database name goes here
        'user' => 'bugs_db_cb',     // the db user goes here
        'password' => 'YOUR-PW-HERE',    // the password goes here
        'host' => 'localhost'
        );

4. Make sure that the Proxies subdirectory, the directory specified in the call to setProxyDir is writable by your webserver. This is particularly true when running in “development” mode.

$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('Proxies');

4. Now, create the database. For example, from the command line

   $ mysql -u root -p > ./generated.sql

5. Confirm that the annotation mappings and the database schema are valid.

   $ doctrine orm:validate-schema

6. This example uses the annoation driver. If you will to generate the xml mappings, do

   $ doctrine orm:convert-mapping xml ./somesubdir
  

6. Finally, run the code

   http:://localhost/cookbook

$ sudo pear channel-discover pear.doctrine-project.org

$ sudo pear install -o pear.doctrine-project.org/DoctrineCommon

# pear list -c pear.doctrine-project.org

$ ls -1 /usr/share/php/Doctrine
Common
DBAL
ORM
Symfony

Place cli-config.php in your projects directory, where your code is. Don’t place it in /usr/bin. For each project, you will need a separate cli-config.php. The only real difference, of course, between each project’s cli-config.php will be the $connectionOptions variable. You need to manually create Entities and Proxies subdirectories. Make sure that the Proxies subdirectory is writeable by your webserver.

You will need to manually create both the Entities and Proxies subdirectories, under your project folder. Note: You may need to change the namespace for your proxies. For example, if your proxies’ namespace is MyProject\Proxies, then use

 $config->setNamespaceProxies('MyProject\Proxies')

in your project’s cli-config.php. Your Doctrine 2 classes in the Entities subdirectory need to be declared in the same namespace.
You may also need to change the mapping drive. For example, if you are using xml files to provide your mappings, then you would need to do something like

$driverImpl = new Doctrine\ORM\Mapping\Driver\XmlDriver(__DIR__."/config/mappings");
$config->setMetadataDriverImpl($driverImpl);

Here is cli-config.php that uses the annotations driver.

require ‘Doctrine/ORM/Tools/Setup.php’;

// Setup Autoloader (1)
Doctrine\ORM\Tools\Setup::registerAutoloadPEAR();

// Define application environment
define('APPLICATION_ENV', "development");

/*
defined('APPLICATION_ENV')
    || define('APPLICATION_ENV', (getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV') : 'production'));
*/

 $classLoader = new \Doctrine\Common\ClassLoader('Entities', __DIR__);
 $classLoader->register();
 $classLoader = new \Doctrine\Common\ClassLoader('Proxies', __DIR__);
 $classLoader->register();

// configuration (2)
 $config = new \Doctrine\ORM\Configuration();

// Proxies (3)
 $config->setProxyDir(__DIR__ . '/Proxies');
 $config->setProxyNamespace('Proxies');

 $config->setAutoGenerateProxyClasses((APPLICATION_ENV == "development"));

// Driver (4)
 $driverImpl = $config->newDefaultAnnotationDriver(array(__DIR__."/Entities"));
 $config->setMetadataDriverImpl($driverImpl);

// Caching Configuration (5)
 if (APPLICATION_ENV == "development") {

     $cache = new \Doctrine\Common\Cache\ArrayCache();

 } else {

     $cache = new \Doctrine\Common\Cache\ApcCache();
 }

 $config->setMetadataCacheImpl($cache);
 $config->setQueryCacheImpl($cache);

 $connectionOptions = array(
    'driver' => 'pdo_mysql',
    'dbname' => 'bugs_db_cb',
    'user' => 'bugs_db_cb',
    'password' => 'kk0457',
    'host' => 'localhost');

 $em = \Doctrine\ORM\EntityManager::create($connectionOptions, $config);

 $helperSet = new \Symfony\Component\Console\Helper\HelperSet(array(
     'db' => new \Doctrine\DBAL\Tools\Console\Helper\ConnectionHelper($em->getConnection()),
     'em' => new \Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper($em)
 ));

1. Zend_Controller_Action::_forward($action, $controller = null, $module = null, array $params = null)

What does _forward do? The dispatch loop order for a request (see this illustration of the request dispatch cycle):

preDispatch()
someAction()
postDispatch()

_forward can be used to call other actions during any of these steps. If called in preDispatch, the currently requested action will be skipped in favor of the new one. Otherwise, if called in called in someAction or postDispatch, the current action is processed, and the dispatch loop is re-run, when the action requested in _forward is executed.

For example, here we forward to the indexAction in the IndexController located in the storefront module, and also set an email parameter in the request object.

class SomeController extends Zend_Controller_Action {
 public function someAction()
 {
  // snip...do some stuff and then call _forward()
   $this->_forward('index', 'index', 'storefront', array('email' => 'myemail@somedomain.com'));
 }
 // snip...
}

This is equivalent to doing:

class SomeController extends Zend_Controller_Action {
 public function someAction()
 {
  // snip...do some stuff and then call _forward()
   $request = $this->getRequest();
   $request->setModuleName('storefront')
               ->setControllerName('index')
               ->setActionName('index')
               ->setParam('email', 'myemail@somedomain.com')
               ->setDispatched(false);
  }
//snip...
}

Setting the dispatched flag to false in the request object ensures that the dispatch loop is re-run.

2. Zend_Controller_Action::_redirect($url, array $options = array())

This method takes a URL and an optional set of options. By default, it performs an HTTP 302 redirect. (A 302 code means the requested resource resides temporarily under a different URI. Since the redirection may be altered on occasion, the client SHOULD continue to use the original Request-URI for future requests.)

3. Redirector action helper’s gotoSimple(), gotoRoute(), and gotoUrl()

i. void Zend_Action_Action_Helper_Redirectorr::gotoSimple(string $action, [string $controller = null], [string $module = null],
[$params = array()])

Note: Calling $this->_helper->redirect($action, $controller, $module, $params) is a more succinct way of writing

$redirector = $this->_helper->getHelper('Redirector');
$redirector->gotoSimple($action, $controller, $module, $param);

which is equivalent to

$this->_helper->redirector->gotoSimple($action, $controller, $module, $param);

The parameters for Zend_Controller_Action_Helper_Redirector::gotoSimple() are identical to those of _forward. gotoSimple does an HTTP redirect, resulting in an new request object being created. _forward simply causes the dispatch loop for the current request to be re-run.

Examples

class Storefront_CustomerController extends Zend_Controller_Action {
	//snip ...
    public function sampleAction()
    {
	//snip...
   	$this->_helper->Redirector->gotoSimple('login');
    }
    public function loginAction()
    {
        //snip...
    }
}

$this->_helper->Redirector->gotoSimple(‘login’); or equivlantly $this->_helper->getHelper(‘Redirector’)->gotoSimple(‘login’); will cause a redirect that results in a call to loginAction, in the same controller, the Storefront_CustomerController, in the same module, which here is Storefront. If the call were changed to

$this->_helper->Redirector->gotoSimple('index', 'Customer');

this would cause a redirect that results in a call to indexAction, in the Storefront_CustomerController, in the same storefront module. If the call were $this->_helper->Redirector->gotoSimple(‘index’, ‘index’, ‘default’); , this would cause a redirect that results in a call to indexAction, in the Default_IndexController (or possibly IndexController, depending on whether the module prefix is required), in the default module.

ii. void gotoRoute([ $urlOptions = array()], [string $name = null], [boolean $reset = false], [boolean $encode = true])

gotoRoute uses a registered route to build the url. Below ‘blogArchive’ route is registered in the Boostrap class. Then later
an associate array of ‘blogArchive’ route options is used to construct the url.

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap {

  // 'blogArchive' route registered in Bootstrap
   protected function _initRoutes()
   {
   // snip...
	$route = new Zend_Controller_Router_Route('blog/:year/:month/:day/:id',
	    	array('controller' => 'archive', 'module' => 'blog', 'action' => 'view'));

	$router->addRoute('blogArchive', $route);
    }
}

class BlogAdminController extends Zend_Controller_Action {
  protected $_redirector = null;

  public function init()
  {
      $this->_redirector = $this->_helper->getHelper('Redirector');
  }
  public function returnAction()
  {
     //snip ..
     // Redirect to blog archive. Builds the following URL:  /blog/2010/4/24/42
     $this->_redirector->gotoRoute(
            array('year' => 2010,
                  'month' => 4,
                  'day' => 24,
                  'id' => 42),
            'blogArchive'
        );
    }
}

iii. void gotoUrl (string $url, [ $options = array()])

gotoUrl simply takes the URL (minus the base path).

class AlternativeController extends Zend_Controller_Action {
    protected $_redirector = null;
    public function init()
    {
        $this->_redirector = $this->_helper->getHelper('Redirector');
    }
    public function myAction()
    {
        // snip...
        $this->_redirector->gotoUrl('/my-controller/my-action/param1/test/param2/test2');
        return; // never reached since default is to goto and exit
    }
}

Don’t confuse Zend Decorators with the GOF decorator design pattern. Unlike decorator objects in the decorator design pattern, Zend Decorators do not act as transparent enclosures for Zend_Form_Elements. Decorators can’t be substituted for Zend_Form_Element because they don’t derive from a common base class or interface. Instead they serve as the rendering strategy for their associated element.

The Zend_Decorator_Interface does contains three methods shared by Zend_Form_Element. The most important is render(). All Zend_Form_Element decorators derive from Zend_Decorator_Abstract, which derives from Zend_Decorator_Interface, and they must implement the render method.

Zend_Form_Decorator_Abstract does contain a reference to the Zend_Form_Element. Zend_Form_Element, in turn, contains an array of Zend_Form_Decorator_Abstract–derived decorators. The render method of Zend_Form_Element iterates over its array of decorators to incrementally build the html for the form element. The decorators comprise the rendering strategy for the element. When an individual decorator’s render method is invoked, the decorator will call back to the Zend_Form_Element’s methods as needed.

Here is the relevant code excerpt from Zend_Form_Element::render($context)

  //...snip
  $content = '';
   foreach ($this->getDecorators() as $decorator) {
            $decorator->setElement($this);
            $content = $decorator->render($content);
   }
   return $content;

There are five default form element decorators, which are called in the following order:

1. Zend_Form_Decorator_ViewHelper
2. Zend_Form_Decorator_Errors
3. Zend_Form_Decorator_Description (if setDescription() was called)
4. Zend_Form_Decorator_HtmlTag
5. Zend_Form_Decorator_Label

The output of the ViewHelper decorator becomes the input for the Errors decorator. The output of the Errors decorator becomes the input for the Description decorator and so on for the remaining decorators. The initial input into the ViewHelper decorator is the empty string.

require_once	"Zend/Form/Decorator/Abstract.php";
class My_Decorator_SimpleInput extends Zend_Form_Decorator_Abstract {

    protected $_format = '<label for="%s">%s</label><input id="%s" name="%s" type="text" value="%s"/>';

    public function render($content)
    {
        $element = $this->getElement();
        $name    = htmlentities($element->getFullyQualifiedName());
        $label   = htmlentities($element->getLabel());
        $id      = htmlentities($element->getId());
        $value   = htmlentities($element->getValue());

        $markup  = sprintf($this->_format, $name, $label, $id, $name, $value);
        return $markup;
    }
}

$decorator = new My_Decorator_SimpleInput();
$element   = new Zend_Form_Element('foo', array( 'label' => 'Foo', 'belongsTo' => 'bar', 'value' => 'test', 'decorators' => array($decorator)));

The form itself also has a set of default decorators that are automatically called when the form is rendered:

1. Zend_Form_Decorator_FormElements
2. Zend_Form_Decorator_HtmlTag
3. Zend_Form_Decorator_Form

Likewise, display groups and subforms have a set of default decorators that comprise its default rendering strategy:

1. Zend_Form_Decorator_FormElements
2. Zend_Form_Decorator_HtmlTag
3. Zend_Form_Decorator_Fieldset
4. Zend_Form_Decorator_DtDdWrapper

custom decorators

If the My_Decorator_SimpleInput class is cut and pasted into a separate file called SimpleInput.php (note: the file name must match the class name), then the setprefixPath() method of Zend_Form_Element will ensure that My_Decorator_SimpleInput is automatically loaded.

$element1  = new Zend_Form_Element('foo', array('label' => 'Foo', 'belongsTo'  => 'bar',
          'value' => 'test',
          'prefixPath' => array('decorator' => array('My_Decorator' => '/home/kurt/public_html/test')),
           'decorators' => array('SimpleInput')) );

echo $element1;

To read further about Zend_Form_Element decorators see the tutorial at Decorator Basics on the Zend Framework website.

sudo aptitude install php5-dev php-pear

tar -xvzf xdebug-2.1.0.tgz
cd xdebug-2.1.0
phpize5
./configure
make
sudo cp modules/xdebug.so /usr/lib/php5/20090626+lfs/

zend_extension=/usr/lib/php5/20090626+lfs/xdebug.so
xdebug.remote_enable=on
xdebug.remote_handler=dbgp
xdebug.remote_host=localhost
xdebug.remote_port=9000

sudo /etc/init.d/apache2 restart

drop database if exists bugs;
create database if not exists bugs;

use bugs;

grant select, create, alter, drop, index, insert, update, delete on bugs.* to bugs@localhost identified by 'bugs'; 

CREATE TABLE IF NOT EXISTS accounts (
  account_id         INT UNSIGNED NOT NULL AUTO_INCREMENT,
  account_name      VARCHAR(100) NOT NULL,
  PRIMARY KEY       (account_id),
  UNIQUE            (account_name) 
) TYPE = InnoDB;

insert into accounts(account_name) values('kurt'), ('bill'), ('joe'), ('sam'), ('john'), ('dave');

CREATE TABLE IF NOT EXISTS products (
  product_id        INT UNSIGNED NOT NULL AUTO_INCREMENT,
  product_name      VARCHAR(100),
  PRIMARY KEY (product_id)
) TYPE = InnoDB;

insert into products(product_id, product_name) values('', 'PHP Storefont Application'), ('', 'C++ Game Application'), ('', 'C# Tax Return Application');

CREATE TABLE IF NOT EXISTS  bugs (
  bug_id            INT UNSIGNED NOT NULL AUTO_INCREMENT,
  bug_description   VARCHAR(100),
  bug_status        VARCHAR(20),
  reported_by       VARCHAR(100) REFERENCES accounts(account_id),
  assigned_to       VARCHAR(100) REFERENCES accounts(account_id),
  verified_by       VARCHAR(100) REFERENCES accounts(account_id),
  PRIMARY KEY	    (bug_id)
) TYPE=InnoDB;

insert into bugs(bug_id, bug_description, bug_status, reported_by, assigned_to, verified_by)
  values(1, 'Error 123 in PHP Storefront Application', 'NEW', 4, 1, 6),
   (2, 'Error 456 in C++ Game Application', 'NEW', 5, 2, 4),
   (3, 'Error 456 in C++ Game Application', 'NEW', 5, 1, 4),
   (4, 'Error 789 in C# Tax Return Application', 'NEW', 6, 3, 5),
   (5, 'Error 101112 C# Tax Return Application', 'NEW', 6, 3, 5),
   (6, 'Error 131415 PHP Storefront Application', 'NEW', 4, 3, 5),
   (7, 'Error 1151617 C# Tax Return Application', 'NEW', 4, 3, 4);

CREATE TABLE IF NOT EXISTS bugs_products (
  bug_id            INT UNSIGNED NOT NULL REFERENCES bugs,
  product_id        INT UNSIGNED NOT NULL REFERENCES products,
  PRIMARY KEY       (bug_id, product_id)
) TYPE=InnoDB;

insert into bugs_products(bug_id, product_id) values(1, 1), (2, 2), (3, 2), (4,3), (5,3),(6,3), (7,3);

This graphic shows the primary keys (PK) and illustrates the foreign key (FK) relationships between these tables.

.

To test findDependentRowse() and findParentrow(), we start with this code, which contains our Zend_Db_Table_Abstract derived classes corresponding to our SQL tables. Make sure that the Zend Framework library is in your include_path in php.ini.

<?php
// assumes include_path points to zend framework library directory.
require_once "Zend/Db.php";
require_once "Zend/Db/Table/Abstract.php";

class Accounts extends Zend_Db_Table_Abstract {
    protected $_name            = 'accounts';
    protected $_dependentTables = array('Bugs');
}

class Products extends Zend_Db_Table_Abstract {
    protected $_name            = 'products';
    protected $_dependentTables = array('BugsProducts');
}

class Bugs extends Zend_Db_Table_Abstract {
    protected $_name            = 'bugs';
    protected $_dependentTables = array('BugsProducts');

    protected $_referenceMap    = array(
        'Reporter' => array(
            'columns'           => 'reported_by',
            'refTableClass'     => 'Accounts',
            'refColumns'        => 'account_id'
        ),
        'Engineer' => array(
            'columns'           => 'assigned_to',
            'refTableClass'     => 'Accounts',
            'refColumns'        => 'account_id'
        ),
        'Verifier' => array(
            'columns'           => array('verified_by'),
            'refTableClass'     => 'Accounts',
            'refColumns'        => array('account_id')
        )
    );
}
class BugsProducts extends Zend_Db_Table_Abstract {
    protected $_name = 'bugs_products';

    protected $_referenceMap    = array(
        'Bug' => array(
            'columns'           => array('bug_id'),
            'refTableClass'     => 'Bugs',
            'refColumns'        => array('bug_id')
        ),
        'Product' => array(
            'columns'           => array('product_id'),
            'refTableClass'     => 'Products',
            'refColumns'        => array('product_id')
        )
    );
}

A parent table is a table referenced by a foreign key. In our database, the Bugs SQL table, for example, has three foreign keys. All three foreign keys reference the Accounts table. This is why Bug’s _referenceMap has three associative subarrays. The key of each subarray is used to identify each reference relationship. We choose descriptive names for each rule key.

In the code above, the rule keys in the Bugs table class are: ‘Reporter’, ‘Engineer’, and ‘Verifier’.

The ‘refTableClass’ is obviously the referenced table and ‘refColumns’ is the referenced column(s) that ‘columns’ references.

We will use this class for displaying Zend_Db_Table_Rowset and Zend_Db_Table_Row objects as HTML tables.

class HtmlTable { // displays Zend_Db_Table_Rowset and Zend_Db_Table_Row objects

  private $thead;
  private $info;

  public function __construct(Zend_Db_Table_Abstract $table)
  {
    $this->info = $table->info();

    $this->thead = "<thead>\n";

    foreach($this->info['cols']  as $column) {

        $this->thead .= "<th>$column</th>";
    }

	$this->thead .= "</thead>\n";
  }

function displayRowset(Zend_Db_Table_Rowset $rowset)
{
    $table = "<table border=1>";

    $table .= $this->thead;

    $table .= "<tbody>\n";
       
    foreach($rowset as $row) {

        $table .= "<tr>";
        
         foreach ($this->info['cols'] as $column) {

             $table .= "<td>$row[$column]</td>";
         }

         $table .= "</tr>\n";
    }
    
    echo $table . "</tbody>\n</table>\n";
}

function displayRow(Zend_Db_Table_Row $row, $caption = null)
{
    $table = "<table border=1>";

    if (!is_null($caption)) {

		$table .= "<caption>$caption</caption>";
    }

    $table .= $this->thead;

    $table .= "<tbody>\n<tr>\n";
   
    foreach ($this->info['cols'] as $column) {

        $table .= "<td>$row[$column]</td>";
    }

    echo $table . "</tr></tbody></table>\n";
 }
} // end class  

First, we use the factory method of Zend_Db to return a Zend_Db_Adapter instance, and set it as the default adapter. All our tables will thereafter use this default adpater.

$db = Zend_Db::factory('Pdo_Mysql', array(
    'host'             => 'localhost',
    'username'         => 'bugs',
    'password'         => 'bugs',
    'dbname'           => 'bugs'
));

// set default adapter
Zend_Db_Table_Abstract::setDefaultAdapter($db);

Next, we instantiate a Bugs object and display a Row set from it, using our HtmlTable class.

$bugs = new Bugs();

$bugs_htmlTable = new HtmlTable($bugs);

// returning an instance of Zend_Db_Table_Rowset
$bugsRowset1 = $bugs->fetchAll($bugs->select()->where('bug_id >= ?', 1)->order('bug_id'));

echo '<pre class="code">$bugs->select()->where("bug_id >= ?", 1)->order("bug_id")));</pre>'."\n";

$bugs_htmlTable->displayRowset($bugsRowset1);

Next, we instantiate an Accounts object and find the row whose account_name is sam.

$accounts = new Accounts();

$accounts_htmlTable = new HtmlTable($accounts);

$user_sam = $accounts->fetchRow($accounts->select()->where('account_name = ?', 'sam')); // searches primary key of "sam".

echo "<p>Find the bugs reported by the user whose <strong>account_name</strong> is sam.</p >\n";
echo "<p>1. First, we get the corresponding row from the <strong>accounts</strong> table where <b>account_name = sam</b></p>\n";

echo '<pre class="code">$user_sam = $accounts->fetchRow($accounts->select()->where("account_name = ?", "sam"));</pre>'."\n";

$accounts_htmlTable->displayRow($user_sam);

Next, we find all the bugs that sam has reported using findDependentRowset(‘Bugs’, ‘Reporter’). This will find all the rows in the Bugs table where reported_by equals the unique account_id for sam.

// this will be a Row set consisting of all bugs reported by user "sam".
$bugsReportedBySam = $user_sam->findDependentRowset('Bugs', 'Reporter');

echo "<hr />\n";

$bugsRowset_htmltable->display($bugsReportedBySam);

We can also add an optional select statement as a third parameter. Here, we add ORDER BY reported_by ASC LIMIT 2 to the SQL query internally generated by Zend Framework when findDependentRowset() executes.

$select = $accounts->select()->order('reported_by ASC')->limit(2);

echo '<pre class="code">$accounts->find("sam")->current()->findDependentRowset("Bugs", "Reporter", $accounts->select()->order("reported_by ASC")->limit(2));</pre>'."\n";

$bugsReportedBySamLimitToTwo = $user_sam->findDependentRowset('Bugs', 'Reporter', $select);

$bugs_htmlTable->displayRowset($bugsReportedBySamLimitToTwo);

Finally, we find all bugs whose bug_status equals “NEW”, and we get the first row from this row set using current(). Then we call

findParentRow(‘Accounts’)

on the row object returned by current(). This will retrieve the row object in the referenced or parent Accounts table.

There will be exactly one row in the parent table referenced by a dependent row, therefore findParentRow(‘Accounts’) returns a Row object, not a Rowset object.

The first argument is a string that specifies the parent table by its class name (though it can specify the parent table by using an object of that table class).

$bugsRowset2 = $bugs->fetchAll(array('bug_status = ?' => 'NEW'));

$bugRow = $bugsRowset2->current();

echo  '<pre class="code">$bugs->fetchAll(array("bug_status = ?" => "NEW")->current());</pre>';

$bugs_htmlTable->displayRow($bugRow);

$reporter = $bugRow->findParentRow('Accounts');

echo '<pre class="code">$bugs->fetchAll(array("bug_status = ?" => "NEW")->current()->findParentRow("accounts");</pre>'."\n";

$accounts_htmlTable->displayRow($reporter);