The Zend Framework in Practice » Zend_Db http://zf.gm-ram.com Developing Web Applications with the Zend Framework Mon, 02 Jan 2012 10:20:34 +0000 en hourly 1 http://wordpress.org/?v=3.3.1 The Identity Class http://zf.gm-ram.com/posts/the-identity-class/ http://zf.gm-ram.com/posts/the-identity-class/#comments Thu, 25 Nov 2010 18:30:52 +0000 James http://zf.gm-ram.com/?p=843 In my previous post about creating an authentication class, I made use of another class, called Application_Model_Identity, to store the details of the user, who has logged in. In this post, I intended to look at some of the things that can be done with such a class, drawing on some of the applications that I have developed myself.

A basic version of the class would look something like this:

class Application_Model_Identity
{
  private $_username = '';
  private $_role = '';
  private $_name = '';
 
  public function __construct($resultRow)
  {
    if (isset($resultRow->username))
    {
      $this->_username = $resultRow->username;
 
      if (isset($resultRow->role))
        $this->_role = $resultRow->role;
 
      if (isset($resultRow->name))
        $this->_name = $resultRow->name;
    }
  }
 
  public function getUsername()
  {
    return $this->_username;
  }
 
  public function getRole()
  {
    return $this->_role;
  }
 
  public function getName()
  {
    return $this->_name;
  }
}

This provides an unremarkable means of encapsulating the essential information retrieved via the result row.

As we shall see in a later post, having a role defined for each user is a basic method for providing more finely-grained access control. Typically, a site will allow users to log in at various levels, such as admin.

It is possible to do some more advanced things here.

For instance, in one application I have written, the user can be a member of one or more sales organisations. To support this we have an additional member variable to store these sales organisations:

  private $_salesOrgs = array();

We then extend the signature of the constructor to take the database adapter and logger as additional parameters:

  public function __construct($resultRow, $dbAdapter = null, $log = null)

Then in the constructor, below the lines

      if (isset($resultRow->name))
        $this->_name = $resultRow->name;

we add the following:

      $this->_salesOrgs = array();
 
      if (null !== $dbAdapter)
      {
        try
        {
          // Get the user's sales organisations
          $sql = $dbAdapter->quoteInto(
"SELECT sales_org_id, name FROM sales_org WHERE sales_org_id IN 
(SELECT DISTINCT sales_org_id FROM user_sales_org WHERE username=?)", 
$resultRow->username);
 
          $this->_salesOrgs = $dbAdapter->fetchAssoc($sql);
        }
        catch (Exception $e)
        {
          if (null !== $this->_log)
            $log->err($e->getMessage());
        }
      }
      else
      {
        if (null !== $this->_log)
          $this->_log->crit('Database adapter not specified');
      }

We also add a means to retrieve the sales organisations:

  public function getSalesOrgs()
  {
    return $this->_salesOrgs;
  }

To retrieve the user’s identity, and therefore all the above information, elsewhere in the application, we use the following code:

$auth = Zend_Auth::getInstance();
$identity = $auth->getIdentity();
]]> http://zf.gm-ram.com/posts/the-identity-class/feed/ 0 The Authentication Class http://zf.gm-ram.com/posts/the-authentication-class/ http://zf.gm-ram.com/posts/the-authentication-class/#comments Sun, 21 Nov 2010 18:07:29 +0000 James http://zf.gm-ram.com/?p=828 I prefer to encapsulate the code for logging in and out in a class. In the example I am using for this series of posts, the class is called Application_Model_Login. We have already seen in this post how it is used in the Login Controller.

The class has following methods and member variables:

class Application_Model_Login
{
  private $_dbAdapter = null;
 
  private $_log = null;
 
  public function __construct($dbAdapter = null, $log = null)
  {
    // TODO: Insert construction code here
  }
 
  public function login($username, $password)
  {
    // TODO: Insert login code here
  }
 
  public function logout()
  {
    // TODO: Insert logout code here
  }
}

When using the class, we pass the constructor references to the database adapter and log objects to use; these are stored in the appropriate member variables:

  public function __construct($dbAdapter = null, $log = null)
  {
    $this->_dbAdapter = $dbAdapter;
    $this->_log = $log;
  }

The login method receives the username and password from the calling function:

  public function login($username, $password)
  {

The database adapter must be set, otherwise the class cannot authenticate against the database:

    // Check that the database adapter has been set
    if (null === $this->_dbAdapter)
    {
      if (null !== $this->_log)
        $this->_log->crit('Database adapter not specified');
 
      return false;
    }

Note that the method uses the logger (if it has been supplied) to record this failure. Also, the method returns false to indicate that the login was unsuccessful.

Next, the method gets the date and time of the login attempt; this will be logged later:

    // Get the date and time of the attempt
    $date = new Zend_Date();

Then, the method gets the global authentication object:

    // Get the authentication object
    $auth = Zend_Auth::getInstance();

Next, the method creates an authentication adapter:

    // Set up the authentication adapter
    $authAdapter = new Zend_Auth_Adapter_DbTable(
      $this->_dbAdapter, 'user', 'username', 'password', 'md5(?)');
    $authAdapter->setIdentity($username);
    $authAdapter->setCredential($password);

The adapter is passed the username and password supplied to the method. In this case, the database is assumed to have a user table, with fields named username and password. Also, the password has been encrypted using MD5.

The method is now ready to authenticate the user, using the global authentication object and the adapter:

    // Attempt to authenticate the user
    $result = $auth->authenticate($authAdapter);

If the attempt is successful, the method now gets the entire row in the database table associated with the user. This information is used to create the identity object. This object is an instance of the class Application_Model_Identity, which we will examine in a subsequent post. This identity is stored in the global authentication object. The application will be able to determine whether the user is logged in by the existance of the identity.

   // Check the result of the attempt
    if ($result->isValid())
    {
      // Get the result row object
      $resultRow = $authAdapter->getResultRowObject();
 
      // Create the identity object
      $identity = new Application_Model_Identity($resultRow, 
$this->_dbAdapter, $this->_log);
 
      // Store it in the current session
      $auth->getStorage()->write($identity);

The method uses the logger (if it has been supplied) to record this success, including the date of the attempt:

      if (null !== $this->_log)
      {
        // Log the successful login
        $notice = sprintf('Successful login from %s by %s at %s',
          $_SERVER['REMOTE_ADDR'], $username, $date->toString());
        $this->_log->notice($notice);
      }

Finally, the method returns true, to indicate that the login succeded:

      return true;
    }

If the login attempt fails, the method uses the logger (if it has been supplied) to record this failure, including the date of the attempt:

    else
    {
      if (null !== $this->_log)
      {
        // Log the failed login attempt
        $warn = sprintf(
          'Failed login attempt (invalid username/password) from %s by %s at %s',
          $_SERVER['REMOTE_ADDR'], $username, $date->toString());
        $this->_log->warn($warn);
      }

It then returns false, to indicate that the login failed:

      return false;
    }
  }

The logout function is quite simple. We get the authentication object, then clear any identity stored in it:

  public function logout()
  {
    // Get the authentication object
    $auth = Zend_Auth::getInstance();
 
    // Clear the user identity to log out
    $auth->clearIdentity();
  }

The application will now regard the user as being logged out.

]]> http://zf.gm-ram.com/posts/the-authentication-class/feed/ 4 Pagination using Zend_Paginator http://zf.gm-ram.com/posts/pagination-using-zend_paginator/ http://zf.gm-ram.com/posts/pagination-using-zend_paginator/#comments Sun, 04 Jul 2010 12:54:51 +0000 James http://zf.gm-ram.com/?p=652 Any web application that retrieves large amounts of data for display is bound to have the need to split that data over several pages. Developing the code to do this from scratch is not trivial, so it is extremely useful that the Zend Framework has the Zend_Paginator module, which assists with this task.

Zend_Paginator works as follows:

  1. The paginator is passed either an actual set of data, or a database query that can be used to retrieve the data.
  2. The paginator will by default retrieve the first page and 10 items on that page; the page and the items per page can be set at this point if necessary.
  3. The paginator can be used to render a navigator, by retrieving the current page and the number of pages.
  4. The paginator can be used to render the current page, by iterating over the paginator to retrieve each item in order.

I shall give a concrete example of how this can be implemented below, based on an application I am currently developing.

First, let us start with the controller. In this instance, the controller is user and the action is index. The skeleton for this code is as follows:

class UserController extends Zend_Controller_Action
{
  public function indexAction()
  {
    // Insert implementation here
  }
}

The current page will be passed via the URL as a parameter. The first task in the action handler is therefore to retrieve the page number. If it is not specified, it will default to 1.

    // Get the current page
    $page = $this->getRequest()->getParam('page', 1);

The next step is to construct a Zend_Db_Select object that represents the database query. To do this we need a database adapter; below, we assume that this has been created during the bootstrapping process and can be retrieved via the bootstrap object. The query simply retrieves all records from the user table, ordering them by the user’s display name.

    // Get the boostrap object
    $bootstrap = $this->getInvokeArg('bootstrap');
 
    // Get the database adapter
    $dbAdapter = $bootstrap->getResource('db');
 
    // Create the selection object
    $select = $dbAdapter->select()->from('user')->order('name');

Now we have the select object, we can use it to create the paginator object.

    // Get a Paginator object using Zend_Paginator's built-in factory
    $paginator = Zend_Paginator::factory($select);

We can then set the number of items per page and the current page.

    // Set the number of items to show per page
    $paginator->setItemCountPerPage(5);
 
    // Select the requested page
    $paginator->setCurrentPageNumber($page);

Finally, we should pass the paginator object to the view script.

    $this->view->paginator = $paginator;

The view script used is given below. Note that the application uses Zend_Layout, so only the unique content of the page needs to be generated here.

<h3>User Management</h3>
 
<?php
// Display pagination control
echo $this->paginationControl($this->paginator, 'Elastic', 'paginator.phtml');
?>
<table>
  <thead>
    <tr>
      <th width="25%">Username</th>
      <th width="25%">Role</th>
      <th width="50%">Name</th>
    </tr>
  </thead>
  <tbody>
    <?php
    // Render each item for the current page in a table row
    foreach ($this->paginator as $item)
    {
    ?>
    <tr>
      <td><?php echo $this->escape($item['username']); ?></td>
      <td><?php echo $this->escape(ucfirst($item['role'])); ?></td>
      <td><?php echo $this->escape($item['name']); ?></td>
    </tr>
    <?php
    }
    ?>
  </tbody>
</table>

The script uses the PaginationControl view helper to render the navigator. The view script for the navigator markup is specified as one of the parameters as paginator.phtml; this script is found in the /application/views/scripts directory. The following standard script is used:

<?php if ($this->pageCount): ?>
<div class="paginator">
 
<!-- First page link -->
<?php if (isset($this->previous)): ?>
  <a href="<?php echo $this->url(array('page' => $this->first)); ?>">
    First
  </a> |
<?php else: ?>
  <span class="disabled">First</span> |
<?php endif; ?>
 
<!-- Previous page link -->
<?php if (isset($this->previous)): ?>
  <a href="<?php echo $this->url(array('page' => $this->previous)); ?>">
    < Previous
  </a> |
<?php else: ?>
  <span class="disabled">< Previous</span> |
<?php endif; ?>
 
<!-- Next page link -->
<?php if (isset($this->next)): ?>
  <a href="<?php echo $this->url(array('page' => $this->next)); ?>">
    Next >
  </a> |
<?php else: ?>
  <span class="disabled">Next ></span> |
<?php endif; ?>
 
<!-- Last page link -->
<?php if (isset($this->next)): ?>
  <a href="<?php echo $this->url(array('page' => $this->last)); ?>">
    Last
  </a>
<?php else: ?>
  <span class="disabled">Last</span>
<?php endif; ?>
 
</div>
<?php endif; ?>

The section used to render the current page as a table makes use of the fact that the paginator object can be iterated over to retrieve each item on the current page in turn.

The following styling is applied to the navigator:

.paginator { padding: 5px; }

The following styling is applied to the table:

table { width: 100%; }
 
th, td { padding: 5px; }
 
th { background-color: #4E7DD1; color: #FFFFFF; }
]]> http://zf.gm-ram.com/posts/pagination-using-zend_paginator/feed/ 2 The Blogs Page: The feed/digest action handler http://zf.gm-ram.com/posts/the-blogs-page-the-feeddigest-action-handler/ http://zf.gm-ram.com/posts/the-blogs-page-the-feeddigest-action-handler/#comments Fri, 09 Apr 2010 06:18:23 +0000 James http://zf.gm-ram.com/?p=594 The feed controller digest action handler is used to render a list of the five most recent blog posts on the specified blog, as exposed by the blog’s RSS feed.

The feed controller is implemented as follows:

class FeedController extends Zend_Controller_Action
{
  public function digestAction()
  {
    try
    {
      $this->_helper->layout->disableLayout();
 
      $id = $this->getRequest()->getParam('id');
 
      if (isset($id))
      {
        $dbBlog = new Default_Model_Db_Blog();
        $blog = $dbBlog->fetchBlog($id);
 
        if (isset($blog))
        {
          $this->view->blog = $blog;
        }
        else
        {
          $this->view->errorMessage = 'Blog ID not found in database';
        }
      }
      else
      {
        $this->view->errorMessage = 'Blog ID not specified';
      }
    }
    catch (Exception $e)
    {
      $this->view->errorMessage = $e->getMessage();
    }
  }
}

The function implementation is wrapped in an exception handler, mainly to catch any database errors. This is the basic use case:

  1. As it is not going to render an entire page, but rather respond to an AJAX request, it calls the layout helper to disable layout rendering.
  2. It checks the value of the id parameter, which should have been passed via the URL.
  3. If the id is set, it retrieves the database record in the blog table for that id.
  4. If a blog record is returned, it passes that to the view script.

There are three deviations from this:

  1. If the id is not set, it reports an error (‘Blog ID not specified’).
  2. If no database record is returned for the specified id, it reports an error (‘Blog ID not found in database’).
  3. If an exception is throw, it reports an error; the exact message will depend on the exception.

The implementation of Default_Model_Db_Blog has been covered in previous posts (see the post on the data classes and the post on the mapper classes).

How the blog record and any error messages are handled in the associated view script is the subject of the next post.

]]> http://zf.gm-ram.com/posts/the-blogs-page-the-feeddigest-action-handler/feed/ 0 The Blogs Page: The mapper classes http://zf.gm-ram.com/posts/the-blogs-page-the-mapper-classes/ http://zf.gm-ram.com/posts/the-blogs-page-the-mapper-classes/#comments Mon, 08 Feb 2010 23:52:43 +0000 James http://zf.gm-ram.com/?p=521 The Default_Model_Db_Mapper_Blog class is used to manage data exchange between the Default_Model_Db_Blog and the Default_Model_Db_Table_Blog classes; this exchange represents reading data from and writing data to the database.

It is derived from the abstract class Default_Model_Db_Mapper_Abstract. Here is a skeleton outline of the class implementation:

abstract class Default_Model_Db_Mapper_Abstract
{
  public function fetchAll($where = null, $order = null, 
    $count = null, $offset = null)
  {
    // TODO: Implementaion of fetchAll method
  }
 
  public function fetchRow($where = null, $order = null)
  {
    // TODO: Implementation of fetchRow method
  }
 
  public function getSelect()
  {
    // TODO: Implementation of getSelect method
  }
 
  abstract protected function _createTable();
 
  abstract protected function _createRow($result);
 
  private function _getTable()
  {
    // TODO: Implementation of _getTable method
  }
 
  private $_table;
}

The fetchAll method is called to retrieve multiple records from the table. It makes use of the abstract _getTable and _createRow methods to create the appropriate table object, and to create an instance of the appropriate data object for each row in the database.

  public function fetchAll($where = null, $order = null, 
    $count = null, $offset = null)
  {
    $results = $this->_getTable()->fetchAll(
      $where, $order, $count, $offset);
    $rows = array();
 
    foreach ($results as $result)
    {
      $row = $this->_createRow($result);
      $rows[] = $row;
    }
 
    return $rows;
  }

The fetchOne method is similar, except that it only returns one row:

  public function fetchRow($where = null, $order = null)
  {
    $result = $this->_getTable()->fetchRow($where, $order);
 
    if (isset($result))
    {
      $row = $this->_createRow($result);
    }
    else
    {
      $row = null;
    }
 
    return $row;
  }

The select object used as the where parameter of the above methods can be created using the getSelect method. This also uses the _getTable method.

  public function getSelect()
  {
    return $this->_getTable()->select();
  }

The _getTable method implements the Singleton pattern; if there is not yet a table object, the method creates it and returns a reference to it; otherwise it just returns a reference:

  private function _getTable()
  {
    if (null === $this->_table)
    {
      $this->_table = $this->_createTable();
    }
 
    return $this->_table;
  }

Default_Model_Db_Mapper_Blog derives from this class; it implements the two abstract methods, _createTable() and _createRow($result), as required. The table created is an instance of the Default_Model_Db_Table_Blog class, while each row is an instance of Default_Model_Db_Blog, which was examined in the previous post:

class Default_Model_Db_Mapper_Blog extends 
  Default_Model_Db_Mapper_Abstract
{
  protected function _createTable()
  {
    return new Default_Model_Db_Table_Blog();
  }
 
  protected function _createRow($result)
  {
    return new Default_Model_Db_Blog($result);
  }
}
]]> http://zf.gm-ram.com/posts/the-blogs-page-the-mapper-classes/feed/ 2 The Blogs Page: The data classes http://zf.gm-ram.com/posts/the-blogs-page-the-data-classes/ http://zf.gm-ram.com/posts/the-blogs-page-the-data-classes/#comments Sat, 19 Dec 2009 12:55:27 +0000 James http://zf.gm-ram.com/?p=519 The Default_Model_Db_Blog class is used to encapsulate the data contained in the rows of the blog table.

It is derived from Default_Model_Db_Abstract, which is an abstract base class for classes that encapsulate the data in a database table. Here is a skeleton outline of the class implementation:

abstract class Default_Model_Db_Abstract
{
  const INTEGER  = 'integer';
  const STRING  = 'string';
 
  public function __construct($row = null)
  {
    // TODO: Implementation of constructor
  }
 
  public function __set($name, $value)
  {
    // TODO: Implementation of set magic method
  }
 
  public function __get($name)
  {
    // TODO: Implementation of get magic method
  }
 
  public function setFields($row)
  {
    // TODO: Implementation of setFields method
  }
 
  abstract protected function _getFields();
 
  abstract protected function _createMapper();
 
  protected function _getMapper()
  {
    // TODO: Implementation of getMapper method
  }
 
  private $_mapper;
}

The constants INTEGER and STRING are used to represent that data types of the database fields. Of course, more constants could be added to represent other data types, e.g. FLOAT. It would then be necessary to add another case to the switch statement in the set magic method; the implementation of that is examined below.

The constructor is used to initialise and object used to represent a single row from the table. It takes an array as an optional parameter, which will be used to initialise the fields:

  public function __construct($row = null)
  {
    if (isset($row))
    {
      $this->setFields($row);
    }
  }

The set magic method is used to make sure that only the member variables representing the database fields can be set by classes using the object. Also, it casts the new value as the correct data type.

  public function __set($name, $value)
  {
    $fields = $this->_getFields();
 
    if (array_key_exists($name, $fields))
    {
      switch ($fields[$name])
      {
      case self::INTEGER:
        $this->$name = (int)$value;
        break;
 
      case self::STRING:
        $this->$name = (string)$value;
        break;
 
      default:
        $this->$name = $value;
      }
    }
    else
    {
      throw new Exception('Invalid field name');
    }
  }

The get magic method enforces the same thing in the opposite direction:

  public function __get($name)
  {
    $fields = $this->_getFields();
 
    if (array_key_exists($name, $fields))
    {
      if (isset($this->$name))
      {
        return $this->$name;
      }
      else
      {
        return null;
      }
    }
    else
    {
      throw new Exception('Invalid field name');
    }
  }

The setFields method is used to populate multiple fields within the row:

  public function setFields($row)
  {
    $fields = $this->_getFields();
 
    foreach ($fields as $name => $type)
    {
      if (isset($row->$name))
      {
        $this->$name = $row->$name;
      }
    }
  }

There are a couple of abstract method declared in the class, _getFields and _createMapper, which need to be implemented in the derived class.

The _getFields method should return an array of key/value pairs, where the key is the field name, and the value is one of the constants defined in this class to represent field data types.

The _createMapper should instantiate an object of the corresponding mapper class and return a reference to that object. We shall look at the implementation of the abstract base and concrete mapper classes in a subsequent post. All that needs to be noted here is that the mapper links the data class with the database table.

The _createMapper method is called the first time a call is made to _getMapper; the reference returned is stored, then returned on subsequent calls to the method.

  protected function _getMapper()
  {
    if ($this->_mapper === null)
    {
      $this->_mapper = $this->_createMapper();
    }
 
    return $this->_mapper;
  }

The Default_Model_Db_Blog class derives from this abstract class. Here is a skeleton outline of the class implementation:

class Default_Model_Db_Blog extends Default_Model_Db_Abstract
{
  protected function _getFields()
  {
    // TODO: Implementation of _getFields method
  }
 
  protected function _createMapper()
  {
    // TODO: Implementation of _createMapper method
  }
 
  public function fetchBlogs()
  {
    // TODO: Implementation of fetchBlogs method
  }
 
  public function fetchBlog($id)
  {
    // TODO: Implementation of _fetchBlog method
  }
}

The _getFields method, declared as abstract in the base class, returns an array of five values, corresponding to the fields in the blog table:

  protected function _getFields()
  {
    return array(
      'id' => self::INTEGER, 
      'name' => self::STRING, 
      'description' => self::STRING, 
      'href' => self::STRING, 
      'feed' => self::STRING
    );
  }

The _createMapper, also declared as abstract in the base class, creates and returns an object of the appropriate type to act as the mapper for the class:

  protected function _createMapper()
  {
    return new Default_Model_Db_Mapper_Blog();
  }

There are a couple of additional functions declared here, which perform the two basic operations required against the blog table. They both make use of the mapper class.

The first fetches the details of all the blogs:

  public function fetchBlogs()
  {
    return $this->_getMapper()->fetchAll();
  }

The second retrieves the details of a specific blog, identified by its ID:

  public function fetchBlog($id)
  {
    $where = $this->_getMapper()->getSelect()->where('id = ?', $id);
    return $this->_getMapper()->fetchRow($where);
  }

In my next post, I shall look at the mapper classes.

]]> http://zf.gm-ram.com/posts/the-blogs-page-the-data-classes/feed/ 0 The Blogs Page: The index/blogs action handler http://zf.gm-ram.com/posts/the-blogs-page-the-indexblogs-action-handler/ http://zf.gm-ram.com/posts/the-blogs-page-the-indexblogs-action-handler/#comments Thu, 03 Dec 2009 23:47:48 +0000 James http://zf.gm-ram.com/?p=504 The blogs page is handled by the blogs action of the index controller. This fetches information about the blogs from a database table; it then passes this information to the view script.

The action handler is implemented by the following code:

public function blogsAction()
{
  try
  {
    $dbBlog = new Default_Model_Db_Blog();
    $this->view->blogs = $dbBlog->fetchBlogs();
  }
  catch (Exception $e)
  {
    $this->view->errorMessage = $e->getMessage();
  }
}

There are five classes used to handle access to the database:

  • Default_Model_Db_Blog
  • Default_Model_Db_Abstract
  • Default_Model_Db_Mapper_Blog
  • Default_Model_Db_Mapper_Abstract
  • Default_Model_Db_Table_Blog

Let us consider Default_Model_Db_Table_Blog first. This class extends Zend_Db_Table_Abstract. The implementation of the class is very simple:

class Default_Model_Db_Table_Blog extends Zend_Db_Table_Abstract
{
  protected $_name = 'blog';
}

Setting the member variable $_name to the name of a table in the database binds the class to that table, and allows it to be used to perform operations against the table. Note that the database connection itself has been set up during the bootstrapping process, as described in the post Bootstrapping the Application: the Standard Database Resource Plugin.

The data in the rows of the blog table is handled by the Default_Model_Db_Blog class; this is linked to the blog table class by a mapper class called Default_Model_Db_Mapper_Blog. Each class contains the code specific to the blog table; they are both derived from an abstract base class which contains the generic code for these type of classes. This allows the easy addition of classes handling other database tables.

In the next couple of posts, we shall look at the implementation of first the data classes, then the mapper classes.

]]> http://zf.gm-ram.com/posts/the-blogs-page-the-indexblogs-action-handler/feed/ 0 Bootstrapping the Application: the Standard Database Resource Plugin http://zf.gm-ram.com/posts/bootstrapping-the-application-the-standard-database-resource-plugin/ http://zf.gm-ram.com/posts/bootstrapping-the-application-the-standard-database-resource-plugin/#comments Wed, 23 Sep 2009 15:29:08 +0000 James http://zf.gm-ram.com/?p=121 The configuration of the standard database resource plugin Zend_Application_Resource_Db can be done easily via the configuration file. The following code (with sensitive settings hidden) shows how to set up the database adapter:

resources.db.adapter = "mysqli"
resources.db.params.host = "localhost"
resources.db.params.username = "username"
resources.db.params.password = "password"
resources.db.params.dbname = "database"
resources.db.isDefaultTableAdapter = true

Note that the last line sets the adapter to be the default one used by Zend_Db_Table.

]]> http://zf.gm-ram.com/posts/bootstrapping-the-application-the-standard-database-resource-plugin/feed/ 1