zend framework database 1

1. Before use database we must configurate database information first.
We can use config.ini file containing the DB info. And use function Zend_Config_Ini() to get the file content.

config.ini file:

[default]
; Database Settings
db.adapter  = PDO_MySQL    ; A Zend_Db adapter name
db.dbname   = zend_study
db.hostname = localhost
db.username = pma
db.password = 123456

usually we will use Initializer.php file to do all initialization work.

Here is two functions about configurate server info and intialize DB.

 1public function initServerConfig()
 2{
 3    include_once 'Zend/Config/Ini.php'; // this is ZEND library file.
 4    $ServerConfig = new Zend_Config_Ini($this->_root . '/config/config.ini', 'default'); // the first parameter is the directory of config.ini file
 5    Zend_Registry::set('ServerConfig', $ServerConfig); 
 6}
 7
 8public function initDb()
 9{
    include_once 'Zend/Db.php';                // ZEND library file.
    include_once 'Zend/Db/Table/Abstract.php'; // ZEND library file.
   
    $ServerConfig = Zend_Registry::get('ServerConfig'); // get configuration data
    
    $db = Zend_Db::factory($ServerConfig->db->adapter, 
    array('host' => $ServerConfig->db->hostname, 'username' => $ServerConfig->db->username, 'password' => $ServerConfig->db->password, 'dbname' => $ServerConfig->db->dbname));   
    //create an instance of an Adapter, it's same as Zend_Db::factory('PDO_MySQL', array('host' => 'localhost', 'username' => 'pma', 'password' => '123456', 'dbname' => 'zend_study'));
    //  the second parameter of function factory() is an array containing : 
    //  host: a string containing a hostname or IP address of the database server.
    //  username: account identifier for authenticating a connection to the RDBMS server.
    //  password: account password credential for authenticating a connection to the RDBMS server.
    //  dbname: database instance name on the RDBMS server.
    //  port: some RDBMS servers can accept network connections on a administrator-specified port number. The port parameter allow you to specify the port to which your PHP application connects, to match the port configured on the RDBMS server.
    //  options: this parameter is an associative array of options that are generic to all Zend_Db_Adapter classes.
    //           array(Zend_Db::CASE_FOLDING => Zend_Db::CASE_UPPER); the case of string keys in query result sets, Zend_Db::CASE_NATURAL (the default), Zend_Db::CASE_UPPER, Zend_Db::CASE_LOWER
    //           array(Zend_Db::AUTO_QUOTE_IDENTIFIERS => true); default value is true, it identifiers like table names, column names, and even aliases are delimited in all SQL syntax generated by the Adapter object, if setted to be false, should use quoteIdentifier() method to do the same thing.
    //  driver_options: this parameter is an associative array of additional options that are specific to a given database extension. One typical use of this parameter is to set attributes of a PDO driver. array( PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true );
    //  dapterNamespace: names the initial part of the class name for the adapter, instead of 'Zend_Db_Adapter'. Use this if you need to use the factory() method to load a non-Zend database adapter class.


    if($this->_env == 'test' || $this->_env == 'development') // $this->_env value is 'test' or 'development' when project isn't done, change to 'production' parameter after done
    {
        $db->getProfiler()->setEnabled(true); 
        // turn on profile. Profiles include the queries processed by the adapter as well as elapsed time to run the queries, allowing inspection of the queries that have been performed. below this function is a piece of code about profile.
    }
       
    Zend_Db_Table_Abstract::setDefaultAdapter($db); //设置table类默认使用的数据库
    Zend_Registry::set('db', $db);
    $db->query("SET NAMES 'utf8'");
}

 

Using Profile:
--getTotalNumQueries() returns the total number of queries that have been profiled.
--getTotalElapsedSecs() returns the total number of seconds elapsed for all profiled queries.
--getQueryProfiles() returns an array of all query profiles.
--getLastQueryProfile() returns the last (most recent) query profile, regardless of whether or not the query has finished (if it hasn't, the end time will be null)
--clear() clears any past query profiles from the stack.
--getQuery() returns the SQL text of the query. The SQL text of a prepared statement with parameters is the text at the time the query was prepared, so it contains parameter placeholders, not the values used when the statement is executed.
--getQueryParams() returns an array of parameter values used when executing a prepared query. This includes both bound parameters and arguments to the statement's execute() method. The keys of the array are the positional (1-based) or named (string) parameter indices.

--getElapsedSecs() returns the number of seconds the query ran.

 1$profiler = $db->getProfiler();
 2$db->query('select * from user');
 3$query = $profiler->getLastQueryProfile();
 4
 5$totalTime    = $profiler->getTotalElapsedSecs(); 
 6$queryCount   = $profiler->getTotalNumQueries();
 7$longestTime  = 0;
 8$longestQuery = null;
 9
foreach ($profiler->getQueryProfiles() as $query) {
    if ($query->getElapsedSecs() > $longestTime) {
        $longestTime  = $query->getElapsedSecs();
        $longestQuery = $query->getQuery();
    }
}

echo 'Executed ' . $queryCount . ' queries in ' . $totalTime . ' seconds<br />';
echo 'Average query length: ' . $totalTime / $queryCount . ' seconds<br />';
echo 'Queries per second: ' . $queryCount / $totalTime . "<br />";
echo 'Longest query length: ' . $longestTime . "<br />";
echo "Longest query: \n" . $longestQuery . "<br />";

 

2. Zend_Db_Table

usually we will create a table class extends Zend_Db_Table_Abstract can do all execution inside the class
Here we have four DB tabls, they are associated, so when we create these table class, we must define their relationships

 1CREATE TABLE accounts (
 2  account_name      VARCHAR(100) NOT NULL PRIMARY KEY
 3);
 4
 5CREATE TABLE products (
 6  product_id        INTEGER NOT NULL PRIMARY KEY,
 7  product_name      VARCHAR(100)
 8);
 9
CREATE TABLE bugs (
  bug_id            INTEGER NOT NULL PRIMARY KEY,
  bug_description   VARCHAR(100),
  bug_status        VARCHAR(20),
  reported_by       VARCHAR(100) REFERENCES accounts(account_name),
  assigned_to       VARCHAR(100) REFERENCES accounts(account_name),
  verified_by       VARCHAR(100) REFERENCES accounts(account_name)
);

CREATE TABLE bugs_products (
  bug_id            INTEGER NOT NULL REFERENCES bugs,
  product_id        INTEGER NOT NULL REFERENCES products,
  PRIMARY KEY       (bug_id, product_id)
);

 1class Accounts extends Zend_Db_Table_Abstract
 2{
 3    protected $_name            = 'accounts';
 4    protected $_dependentTables = array('Bugs'); // parent table 父表, List the class name for each dependent table 
 5}
 6
 7class Products extends Zend_Db_Table_Abstract
 8{
 9    protected $_name            = 'products';
    protected $_dependentTables = array('BugsProducts');
}

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

    protected $_dependentTables = array('BugsProducts');

    protected $_referenceMap    = array(             //dependent table 子表, define reference rules
        'Reporter' => array( // rule name
            'columns'           => 'reported_by',    //A string or an array of strings naming the foreign key column name(s) in the dependent table. 
            'refTableClass'     => 'Accounts',       //The class name of the parent table.
            'refColumns'        => 'account_name'    //A string or an array of strings naming the primary key column name(s) in the parent table. 
                                                     // there are another two parameters: if not define default are self::CASCADE, execute synchronously
                                                     //     onDelete => self::CASCADE The rule for an action to execute if a row is deleted in the parent table
                                                     //     onUpdate => self::RESTRICT or self::NO_ACTION The rule for an action to not execute if values in primary key columns are updated in the parent table
                                                   
        ),
        'Engineer' => array(
            'columns'           => 'assigned_to',
            'refTableClass'     => 'Accounts',
            'refColumns'        => 'account_name'
        ),
        'Verifier' => array(
            'columns'           => array('verified_by'),
            'refTableClass'     => 'Accounts',
            'refColumns'        => array('account_name')
        )
    );
}

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

}

2.1 Fetching a Dependent Rowset:

 1$accountsTable = new Accounts();
 2$accountsRowset = $accountsTable->find(1234); // get the rowset by primary key,  find( $primary_key_value ) $primary_key_value can be both a single string value and an array
 3$user1234 = $accountsRowset->current();  //convert rowset object to be row object, if not use seek($position) function, it will convert first element
 4
 5$bugsReportedByUser = $user1234->findDependentRowset('Bugs'); //findDependentRowset($TableClass, [$rule, [$select]]); $rule is reference rule like 'Reporter'
 6                                                              // $select is Zend_Db_Table_Select object like $accountsTable->select()->order('name ASC')->limit(3);
 7                                                              // Also we can use magic method:
 8                                                              // -- $row->find<TableClass>() $user1234->findBugs();
 9                                                              // -- $row->find<TableClass>By<Rule>() $user1234->findBugsByReporter();

2.2 Fetching a Parent Row

 $bugsTable = new Bugs();
 $bugsRowset = $bugsTable->fetchAll(array('bug_status = ?' => 'NEW'));
 $bug1 = $bugsRowset->current();
 
 $reporter = $bug1->findParentRow('Accounts'); //findParentRow($table, [$rule]) returns a row object, $rule is optional, default is the the first reference rule like 'Report'
                                               //Also it can use function like this: $row->findParent<TableClass>([Zend_Db_Table_Select $select])
                                               //$row->findParent<TableClass>By<Rule>([Zend_Db_Table_Select $select])
 

 2.3 Fetching a Rowset via a Many-to-many Relationship

 1$bugsTable = new Bugs();
 2$bugsRowset = $bugsTable->find(1234);
 3$bug1234 = $bugsRowset->current();
 4$productsRowset = $bug1234->findManyToManyRowset('Products', 'BugsProducts'); 
 5//findManyToManyRowset($table, $intersectionTable, [$rule1, [$rule2, [Zend_Db_Table_Select $select] ] ]);
 6// $table: destination table
 7// $intersectionTable : intersection table
 8// The $rule1 : the rule for the relationship from the intersection table to the origin table. In this example, this is the relationship from BugsProducts to Bugs.
 9// The $rule2 : the rule for the relationship from the intersection table to the destination table. In this example, this is the relationship from Bugs to Products. 
// Also can use magic method: 
// -- $row->find<TableClass>Via<IntersectionTableClass> ([Zend_Db_Table_Select $select])
// -- $row->find<TableClass>Via<IntersectionTableClass>By<Rule1> ([Zend_Db_Table_Select $select])
// -- $row->find<TableClass>Via<IntersectionTableClass>By<Rule1>And<Rule2> ([Zend_Db_Table_Select $select])