Class Model_Facture_Table extends Zend_Db_Table_Abstract { 

    protected $_name = 'facture'; 

    protected $_rowClass = 'Model_Facture_Row'; 

    public function __construct($config = array()) 

    { 

        parent::__construct($config); 

        $this->_cols[] = 'fac_total'; 

    } 

} 

SELECT * FROM tableName; 

SELECT 

    facture .*, 

    SUM(lig_prix*lig_qte) AS fac_total 

FROM facture 

INNER JOIN lignes USING (fac_id) 

GROUP BY fac_id; 

    public function update(array $data, $where) 

    { 

        unset($this->_cols[array_search('fac_total',$this->_cols)]); 

        unset($data['fac_total']); 

        $res = parent::update($data, $where); 

        $this->_cols[] = 'fac_total'; 

        return $res; 

    } 

Zend_Loader::loadClass('Zend_Db_Table'); 

Class Fast_Db_Hierarchical extends Zend _Db_Table { 

   /** 

   * left field name in table 

   * 

   * @var string 

   */ 

   protected $_left = NULL; 

   /** 

   * right field name in table 

   * 

   * @var string 

   */ 

   protected $_right = NULL; 

   /** 

   * level field name in table 

   * 

   * @var string 

   */ 

   protected $_level = NULL; 

   /** 

   * virtual field name used has id of parent 

   * 

   * @var string 

   */ 

   protected $_parent = NULL; 

   public function __construct($config = array()) 

   { 

      parent::__construct($config); 

      if (null == $this->_left)   throw new Fast_Exception_Db(Fast_Exception_Db::UNDEFINED_LEFT_KEY); 

      if (null == $this->_right)  throw new Fast_Exception_Db(Fast_Exception_Db::UNDEFINED_RIGHT_KEY); 

      if (null == $this->_level)  throw new Fast_Exception_Db(Fast_Exception_Db::UNDEFINED_LEVEL_KEY); 

      if (null == $this->_parent) throw new Fast_Exception_Db(Fast_Exception_Db::UNDEFINED_PARENT); 

      $this->_cols[] = $this->_parent; 

   } 

   public function getById($id) { 

      $rows = $this->find($id); 

      if ($rows) { 

         return $rows->current(); 

      } 

      return false; 

   } 

   public function deleteById($id) { 

      if ($id == 1) return false; // on ne peut supprimer la racine 

      $this->_db->beginTransaction(); 

      $parent = $this->_db->select(); 

      $parent->from($this->_name, array('delete_left' => $this->_left, 'delete_right' => $this->_right)) 

             ->where($this->_primary[1].' = :_deleteId'); 

      $statement = $this->_db->prepare($parent); 

      $statement->execute(array('_deleteId' => $id)); 

      list($deleteLeft, $deleteRight) = array_values($statement->fetch()); 

      $res = false; 

      if ($deleteLeft) { 

         $row = $this->getById($id); 

         $res = $row->delete(); 

         if ($res) { 

            $statement = $this->_db->prepare('UPDATE '.$this->_name.' 

                                              SET '.$this->_left.' = '.$this->_left.' - 1 

                                              WHERE '.$this->_left.' >= '.$deleteLeft.' 

                                              AND '.$this->_right.' < '.$deleteRight.';'); 

            $statement->execute(); 

         } 

         if ($res) { 

            $statement = $this->_db->prepare('UPDATE '.$this->_name.' 

                                              SET '.$this->_left.' = '.$this->_left.' - 2 

                                              WHERE '.$this->_left.' >= '.$deleteLeft.' 

                                              AND '.$this->_right.' > '.$deleteRight.';'); 

            $statement->execute(); 

         } 

         if ($res) { 

            $statement = $this->_db->prepare('UPDATE '.$this->_name.' 

                                              SET '.$this->_right.' = '.$this->_right.' - 1 

                                              WHERE '.$this->_right.' >= '.$deleteLeft.' 

                                              AND '.$this->_right.' < '.$deleteRight.';'); 

            $statement->execute(); 

         } 

         if ($res) { 

            $statement = $this->_db->prepare('UPDATE '.$this->_name.' 

                                              SET '.$this->_right.' = '.$this->_right.' - 2 

                                              WHERE '.$this->_right.' >= '.$deleteLeft.' 

                                              AND '.$this->_right.' > '.$deleteRight.';'); 

            $statement->execute(); 

         } 

         if ($res) { 

            $this->_db->commit(); 

         } else { 

            $this->_db->rollback(); 

         } 

      } 

      return $res; 

   } 

   public function UpdateById($data) { 

      // on ne peut mettre à jour les donnée hiérarchique 

      // ie on ne peut déplacer un noeud dans l'arbre. 

      unset($data[$this->_parent]); // ne fait pas partie de la table 

      unset($data[$this->_left]);   //ne peut être changé 

      unset($data[$this->_right]);  //ne peut être changé 

      unset($data[$this->_level]);  //ne peut être changé 

      $res =  parent::UpdateById($data); 

      return $res; 

   } 

	public function insert(array $data) { 

      # select left and level of parent 

      $parentId = $data[$this->_parent]; 

      $this->_db->beginTransaction(); 

      $parent = $this->_db->select(); 

      if (null != $this->_level) { 

         $fields = array('parent_left' => $this->_left, 'parent_level' => $this->_level); 

      } else { 

         $fields = array('parent_left' => $this->_left,); 

      } 

      $parent->from($this->_name, $fields) 

             ->where($this->_primary[1].' = :_parentId'); 

      $statement = $this->_db->prepare($parent); 

      $statement->execute(array('_parentId' => $parentId)); 

      list($parentLeft, $parentLevel) = array_values($statement->fetch()); 

      $res = false; 

      if ($parentLeft) { 

         #update tree 

         $statement = $this->_db->prepare('UPDATE '.$this->_name.' 

                                           SET '.$this->_left.' = '.$this->_left.' + 2 

                                           WHERE '.$this->_left.' > '.$parentLeft.';'); 

         $res = $statement->execute(); 

         if ($res) { 

            $statement = $this->_db->prepare('UPDATE '.$this->_name.' 

                                              SET '.$this->_right.' = '.$this->_right.' + 2 

                                              WHERE '.$this->_right.' > '.$parentLeft.';'); 

            $statement->execute(); 

         } 

         #insert node 

         if ($res) { 

            unset($data[$this->_parent]); 

            $data[$this->_left] = $parentLeft + 1; 

            $data[$this->_right] = $parentLeft + 2; 

            if (null != $this->_level) 

               $data[$this->_level] = $parentLevel + 1; 

            $res =  parent::insert($data); 

   		} 

         if ($res) { 

            $this->_db->commit(); 

         } else { 

            $this->_db->rollback(); 

         } 

      } 

      return $res; 

	} 

    /** 

     * Support method for fetching rows. 

     * 

     * @param  string|array $where  OPTIONAL An SQL WHERE clause. 

     * @param  string|array $order  OPTIONAL An SQL ORDER clause. 

     * @param  int          $count  OPTIONAL An SQL LIMIT count. 

     * @param  int          $offset OPTIONAL An SQL LIMIT offset. 

     * @return array The row results, in FETCH_ASSOC mode. 

     */ 

    protected function _fetch($where = null, $order = null, $count = null, $offset = null) 

    { 

        // selection tool 

        $select = $this->_db->select(); 

        //no _parent col on master table 

        $cols = $this->_cols; 

        unset($cols[array_search($this->_parent,$cols)]); 

        // the FROM clause 

        $select->from($this->_name, $cols, $this->_schema); 

        // add the parent col 

        $select->join(array('parent' => $this->_name), 

                      '(parent.'.$this->_left.' < workgroup.'.$this->_left.') AND 

                       (parent.'.$this->_right.' > workgroup.'.$this->_right.') AND 

                       (parent.'.$this->_level.' = workgroup.'.$this->_level.' -1)', 

                      array('parent_id' => 'parent.'.$this->_primary[1].'')); 

        // the WHERE clause 

        $where = (array) $where; 

        foreach ($where as $key => $val) { 

            // is $key an int? 

            if (is_int($key)) { 

                // $val is the full condition 

                $select->where($val); 

            } else { 

                // $key is the condition with placeholder, 

                // and $val is quoted into the condition 

                $select->where($key, $val); 

            } 

        } 

        // the ORDER clause 

        if (!is_array($order)) { 

            $order = array($order); 

        } 

        foreach ($order as $val) { 

            $select->order($val); 

        } 

        // the LIMIT clause 

        $select->limit($count, $offset); 

        // return the results 

        $stmt = $this->_db->query($select); 

        $data = $stmt->fetchAll(Zend_Db::FETCH_ASSOC); 

        return $data; 

    } 

    public function update(array $data, $where) 

    { 

      unset($this->_cols[array_search($this->_parent,$this->_cols)]); 

      unset($data[$this->_parent]); 

      $res = parent::update($data, $where); 

      $this->_cols[] = $this->_parent; 

      return $res; 

    } 

   protected function _parent($row, $fiels) { 

      $parent = $this->_parents($row, $fiels) 

             ->order($this->_right) 

             ->limit(1); 

      return $parent; 

   } 

   protected function _parents($row, $fiels) { 

      $parent = $this->_db->select(); 

      $parent->from($this->_name, $fiels) 

             ->where($this->_left.'  < '.$row->{$this->_left}) 

             ->where($this->_right.' > '.$row->{$this->_right}); 

      return $parent; 

   } 

   protected function _childs($row, $fiels) { 

      $childs = $this->_db->select(); 

      $childs->from($this->_name, $fiels) 

             ->where($this->_left.'  > '.$row->{$this->_left}) 

             ->where($this->_right.' < '.$row->{$this->_right}); 

      return $childs; 

   }  

    /** 

     * This is the find Zend_Db_Table Abstract method 

     * But the where closes are prefixed by the table name 

     * 

     * Fetches rows by primary key. 

     * The arguments specify the primary key values. 

     * If the table has a multi-column primary key, you must 

     * pass as many arguments as the count of column in the 

     * primary key. 

     * 

     * To find multiple rows by primary key, the argument 

     * should be an array.  If the table has a multi-column 

     * primary key, all arguments must be arrays with the 

     * same number of elements. 

     * 

     * The find() method always returns a Rowset object, 

     * even if only one row was found. 

     * 

     * @param  mixed                         The value(s) of the primary key. 

     * @return Zend_Db_Table_Rowset_Abstract Row(s) matching the criteria. 

     * @throws Zend_Db_Table_Exception 

     */ 

    public function find() 

    { 

        $args = func_get_args(); 

        $keyNames = array_values((array) $this->_primary); 

        if (empty($args)) { 

            require_once 'Zend/Db/Table/Exception.php'; 

            throw new Zend_Db_Table_Exception(”No value(s) specified for the primary key”); 

        } 

        if (count($args) != count($keyNames)) { 

            require_once 'Zend/Db/Table/Exception.php'; 

            throw new Zend_Db_Table_Exception(”Missing value(s) for the primary key”); 

        } 

        $whereList = array(); 

        $numberTerms = 0; 

        foreach ($args as $keyPosition => $keyValues) { 

            // Coerce the values to an array. 

            // Don't simply typecast to array, because the values 

            // might be Zend_Db_Expr objects. 

            if (!is_array($keyValues)) { 

                $keyValues = array($keyValues); 

            } 

            if ($numberTerms == 0) { 

                $numberTerms = count($keyValues); 

            } else if (count($keyValues) != $numberTerms) { 

                require_once 'Zend/Db/Table/Exception.php'; 

                throw new Zend_Db_Table_Exception(”Missing value(s) for the primary key”); 

            } 

            for ($i = 0; $i < count($keyValues); ++$i) { 

                $whereList[$i][$keyPosition] = $keyValues[$i]; 

            } 

        } 

        $whereClause = null; 

        if (count($whereList)) { 

            $whereOrTerms = array(); 

            foreach ($whereList as $keyValueSets) { 

                $whereAndTerms = array(); 

                foreach ($keyValueSets as $keyPosition => $keyValue) { 

                    $whereAndTerms[] = $this->_db->quoteInto( 

                        $this->_db->quoteIdentifier($this->_name).'.'.$this->_db->quoteIdentifier($keyNames[$keyPosition], true) . ' = ?', 

                        $keyValue 

                    ); 

                } 

                $whereOrTerms[] = '(' . implode(' AND ', $whereAndTerms) . ')'; 

            } 

            $whereClause = '(' . implode(' OR ', $whereOrTerms) . ')'; 

        } 

        return $this->fetchAll($whereClause); 

    } 

}