Here is how we can use Zend_db to interact with database.

1. Database Configuration Setup

First lets set up our database configuration in config.ini (or the settings file for the particular project)

db.adapter = PDO_MYSQL

db.params.host = localhost
db.params.username = root
db.params.password =
db.params.dbname = sample_db

The above configuration is very simple specifying host, username, password and database name

2. Initiating Database configuration

Now lets load up this configuration. There are different ways we can load it like loading it just before using it in database files (model classes) or using connection manager files or load it using Bootstrap file

I prefer it using Bootstrap file. Lets write a function in Bootstrap.php file to load up the database configuration

public static function setupDatabase(){
$config   = new Zend_Config_Ini(‘/conf/config.ini’,'development’);
$db          = Zend_Db::factory($config->db);
Zend_Registry::set(‘databaseConfig’, $db);
Zend_Db_Table::setDefaultAdapter($db);
}

The above function reads the config.ini file using Zend_Config_Ini class.

Then we assign database configurations to $db and then save it into Zend_Registry so later on we can retrieve it. And lastly set up default adapter for Zend_Table

3. Model Classes

Lets prepare a model class say Profile which will map to profile table with the database

class Profile  extends Zend_Db_Table {
protected $_name = “profile”;

protected $_referenceMap    = array(
‘Users’ => array(
‘columns’           => ‘userId’,
‘refTableClass’     => ‘Users’,
‘refColumns’        => ‘id’
)
);

protected $db        = NULL;

public function __construct(){
$this->db             = Zend_Db::factory($this->config->db);
parent::__construct();
}

}

Lets see what the above code does

We give name to our table called as ‘profile’

Reference map is used to establish relationship with other tables, here we have done it with Users table where userid field will refer to id field in User table

And lastly within the constructor of the model class we are loading up the database configuration which we had setup in our Bootstrap file initially.

4. Model classes with queries

Now lets add up functions which will interact with database and get us back the results

First lets write simple select query which will fetch profile record for a particular userId

public function getProfile($userId){
try{
$this->config         = Zend_Registry::get(‘config’);
$query                     = $this->db->select()
->from(array(‘p’=>’profile’))
->where(‘p.userId = ?’,$userId);
$data                         = $this->db->fetchAll($query);

if(count($data)==1){
return $data;
}
}
catch(Exception $e){
}
return false;
}

Lets look at the query part

We provide which type of query we want to fire (in our case select by specifying $this->db->select())

Then we specify the table from which we want to fetch the data and prepare the alias  alias (p => Profile)

And lastly we specify the where condition.

The above query will return the profile row with matching userId

Now lets write up the query which will get the data using joins

(writing up the query part only rest of the code remains the same)

$query    = $this->db->select()
->from(array(‘p’=>’profile’))
->joinInner(array(‘u’=>’users’),’p.userId = u.id’,array(‘username’,'image’))

we can join the tables using joinInner function which requires the table name with which we want to join the data, then we specify the join condition and finally the fields from the other table (in our case we specify only username, image as fields to be shown from user table)

That’s all we require to interact with database using Zend_db

Zend_Controller_Front implements a Front Controller pattern. Front controller serves as a launch point for zend MVC application. The front controller’s responsibility is to accept input from web request,
identify and execute specific controller action.

Front controller has the responsibility to initialize MVC framework (that includes creating router and dispatcher) and creating proper request object. Front controller is implemented as singleton pattern which means only one instance of it throughout the application and it can be referenced from anywhere in the system.

Outcome of front controller execution is creation of instances of router and dispatcher and pass execution control of request to request for further processing.

Once router has received request object its responsibility is to examine received data and determine which controller and action to execute. Router recognizes the controller and action by mapping the url with help
of default router. Of course this is completely customizable i.e. we can create our own custom routers and map it to controller and action. Note if no router is provided Zend framework by default maps to “index” controller and its “index” action.

Once the mapping is done the request object is passed to dispatcher which dispatches to an action within the controller. The job of dispatcher is to execute the business logic by executing action depending on the
routing information provided by router.

For every action that is executed following steps are executed
1. Initialization of controller class
2. Call to init method
3. Call to preDispatch method
4. Execution of requested action.
5. Call to postDispatch method

In the simplest implementation of controller only action needs to be implemented.

Controllers are named in the form of TestController, where name of controller is Test followed by Controller suffix.

Actions are named in the form of testAction where action name is “test” followed by Action suffix.

A typical controller will look like

class TestController extends Zend_Controller_Action {

function init(){

// initialization code

}

function preDispatch(){

// code to be executed before an action gets called

}

function postDispatch(){

//  code to be executed after an action gets called

}

public function myAction(){

// action code

}

}

Note init, preDispatch and postDispatch methods are optional.

That’s all on controller section.