I am a newcomer towards the Zend Framework and MVC and I am a bit confused by Zend_DB and the best way to communicate with the database.

I am while using PDO MySQL adapter and also have produced some classes to increase the abstract classes:

class Users extends Zend_Db_Table_Abstract {
    protected $_name = 'users';
    protected $_primary = 'user_id';
    protected $_rowClass = 'User';

    public function getUserbyID($id) { /* code */ }
    // More code here
}
class User extends Zend_Db_Table_Row_Abstract {
    // Code here
}
class Widgets extends Zend_Db_Table_Abstract {
    protected $_name = 'widgets';
    protected $_rowClass = 'Widget';

    public function getWidgetsfromUser($userid) { /* code */ }
    // More code here
}
class User extends Zend_Db_Table_Row_Abstract {
    public function doSomethingWithWidget() { /* code */ }
    // More code here
}

There appears to become a lot of methods to access the DB (fetchAll(), find(), fetchAll() through adapter, place(), createRow() and save(), choose() object) which i always find myself returning towards the paperwork to determine things i ought to be doing.

SO has trained me prepared claims are what you want, and I have been attempting to use rowsets and row (must i be?), but I am still confused regarding what's the easiest method to communicate with the database?

(apologies for that terribly open ended question)

Using Zend_Db you most likely don't wish to enter into the particulars of prepared claims and so on. You want to make use of the model objects to complete fundamental CRUD (Create, Read, Update and Remove). I understand the Programmer's Reference Guide is extensive, nevertheless its an excellent summary of Zend_Db. You might want to take particular notice in the Zend_Db_Table documentation.

But to provide a fast response to your question. Unless of course you have to override some default behavior you should not have to extend the Zend_Db_Table_Row_Abstract. You can also most likely simplify the Customers class to simply be:

class Users extends Zend_Db_Table_Abstract {
  protected $_name = 'users';

  // Code here
}

Then for doing things you'd perform some of stuff you pointed out while using following:

//Create a Users Model Object
$usersDb = new Users();

//Find the record with user_id = 4 and print out their name
$row = $usersDb->find(4);
echo $row->first_name . ' ' . $row->last_name

//Change the first name of this user to Brian    
$row->first_name = 'Brian';
$row->update();

//Insert a user into the database
$data = array(
  'first_name' => 'Gilean',
  'last_name' => 'Smith');
$usersDb->insert($data);

//Retrieve all users with the last name smith and print out their full names
$rows = $usersDb->fetchAll($usersDb->select()->where('last_name = ?', 'smith'));    
foreach ($rows as $row) {
  echo $row->first_name . ' ' . $row->last_name
}

Generally, people would rather access the database with the Table and Row objects, to complement their habits of object-oriented programming.

The OO approach is helpful if you want to write code to change or validate query inputs or results. You may also write custom techniques inside a Table or Row class to encapsulate frequently-needed queries.

However the object-oriented interface is simplified, not able to do all the kinds of database procedures you will need to complete. So that you can delve much deeper and operate a SQL query from the Zend_Db_Adapter techniques like query() and fetchAll() whenever you require finer treatments for your SQL.

This really is pretty common for object-oriented connects to databases. An OO layer that may duplicate every SQL feature could be insanely complex. To compromise, an OO layer usually attempts to provide easy methods to do the most typical tasks, while providing you with a chance to go below the covers at the appropriate interval.

This is a very general response to your very general question.