Gecko [ www.utparral.edu.mx ]

Name	Size	Permission
Array.php	11.2 KB	-rw-r--r--
DBnested.php	2.89 KB	-rw-r--r--
DBsimple.php	14.95 KB	-rw-r--r--
Filesystem.php	7.21 KB	-rw-r--r--
MDB2nested.php	2.91 KB	-rw-r--r--
MDB2simple.php	15.86 KB	-rw-r--r--
MDBnested.php	2.89 KB	-rw-r--r--
MDBsimple.php	15.8 KB	-rw-r--r--
XML.php	9.3 KB	-rw-r--r--

Code Editor : MDBsimple.php

<?php

// +----------------------------------------------------------------------+
// | PHP Version 4 |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2003 The PHP Group |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.02 of the PHP license, |
// | that is bundled with this package in the file LICENSE, and is |
// | available at through the world-wide-web at |
// | http://www.php.net/license/2_02.txt. |
// | If you did not receive a copy of the PHP license and are unable to |
// | obtain it through the world-wide-web, please send a note to |
// | license@php.net so we can mail you a copy immediately. |
// +----------------------------------------------------------------------+
// | Authors: Wolfram Kriesing <wolfram@kriesing.de> |
// | Lorenzo Alberton <l.alberton@quipo.it> |
// +----------------------------------------------------------------------+

// $Id: MDBsimple.php 320703 2011-12-08 22:08:40Z danielc $
require_once 'Tree/OptionsMDB.php';
require_once 'Tree/Error.php';

/**
* the MDB interface to the tree class
*
* @access public
* @author Lorenzo Alberton <l.alberton@quipo.it>
* @package Tree
*/
class Tree_Memory_MDBsimple extends Tree_OptionsMDB
{
 // FIXXME should actually extend Tree_Common, to use the methods provided in there...
 // but we need to connect to the db here, so we extend optionsMDB for now, may be use
 // "aggregate" function to fix that

/**
     * @access public
     * @var array saves the options passed to the constructor. Valid options:
     *      - order: which column to order by when reading the data from the DB,
     *               this sorts the data even inside every level
     *      - whereAddOn: add on for the where clause, this string is simply
     *                    added behind the WHERE in the select, so you better make
     *                    sure its correct SQL :-), i.e. 'uid=3'.
     *                    This is needed i.e. when you are saving many trees for different
     *                    user in one table where each entry has a uid (user id)
     *      - columnNameMaps: the column-name maps are used for the "as" in the select
     *                        queries so you can use any column name in the table and "map"
     *                        it to the name that shall be used in the internal array,
     *                        that is built, see the examples (in comments)
     *      - columnNameMaps: array for id/parentId/prevId/name table column names
     */
    var $options = array('order' => '',
                         'whereAddOn' => '',
                         'table' => '',
                         'columnNameMaps' => array(
                                   /* 'id'       => 'tree_id', // use "tree_id" as "id"
                                      'parentId' => 'parent_id',
                                      'prevId'   => 'previous_id',
                                      'name'     => 'nodeName'
                                   */
                        ),
                    );

/**
     * @access public
     * @var string the table where to read the tree data from
     *             can also be set using the DSN in the constructor
     */
    var $table;

/**
     * @access private
     * @var object $dbh    the handle to the DB-object
     */
    // var $dbh;

// {{{ Tree_Memory_MDBsimple()

/**
     * set up this object
     *
     * @access public
     * @param string $dsn this is a DSN of the for that PEAR::DB uses it
     *                    only that additionally you can add parameters like ...?table=test_table
     *                    to define the table it shall work on
     * @param array $options additional options you can set
     */
    function Tree_Memory_MDBsimple($dsn, $options = array())
    {
        $this->Tree_OptionsMDB($dsn, $options); // instanciate DB
        if (is_string($options)) {
            // just to be backward compatible, or to make the second paramter shorter
            $this->setOption('order', $options);
        }

$this->table = $this->getOption('table');
    }

// }}}
    // {{{ setup()

/**
     * retrieve all the navigation data from the db and call build to build the
     * tree in the array data and structure
     *
     * @access public
     * @return boolean true on success
     */
    function setup()
    {
        // TODO sort by prevId (parentId, prevId $addQuery) too if it exists in the table,
        //      or the root might be wrong, since the prevId of the root should be 0

$whereAddOn = '';
        if ($this->options['whereAddOn']) {
            $whereAddOn = 'WHERE ' . $this->getOption('whereAddOn');
        }

$orderBy = '';
        if ($this->options['order']) {
            $orderBy = ',' . $this->options['order'];
        }

$map = $this->getOption('columnNameMaps');
 if (isset($map['parentId'])) {
 $orderBy = $map['parentId'] . $orderBy;
 } else {
 $orderBy = 'parentId' . $orderBy;
 }
 // build the query this way, that the root, which has no parent (parentId=0)
 // and no previous (prevId=0) is in first place (in case prevId is given)
 $query = sprintf("SELECT * FROM %s %s ORDER BY %s",
 $this->table,
 $whereAddOn,
 $orderBy); //,prevId !!!!
 if (MDB::isError($res = $this->dbh->getAll($query))) {
 // FIXXME remove print use debug mode instead
 printf("ERROR - Tree::setup - %s - %s ", MDB::errorMessage($res), $query);
 return $this->_throwError($res->getMessage(), __LINE__);
 }
 // if the db-column names need to be mapped to different names
 // FIXXME somehow we should be able to do this in the query, but I dont know
 // how to select only those columns, use "as" on them and select the rest,
 //without getting those columns again :-(
 if ($map) {
 foreach ($res as $id => $aResult) { // map each result
 foreach ($map as $key => $columnName) {
 $res[$id][$key] = $res[$id][$columnName];
 unset($res[$id][$columnName]);
 }
 }
 }

return $res;
    }

// }}}
    // {{{ add()

/**
 * adds _one_ new element in the tree under the given parent
 * the values' keys given have to match the db-columns, because the
 * value gets inserted in the db directly
 * to add an entire node containing children and so on see 'addNode()'
 *
 * to be compatible with the MDBnested, u can also give the parent and previd
 * as the second and third parameter
 *
 * @see addNode
 * @access public
 * @param array $newValues this array contains the values that shall be inserted in the db-table
 * the key for each element is the name of the column
 * @return mixed either boolean false on failure or the id of the inserted row
 */
 function add($newValues, $parentId = 0)
 {
 // FIXXME use $this->dbh->tableInfo to check which columns exist
 // so only data for which a column exist is inserted
 if ($parentId) {
 $newValues['parentId'] = $parentId;
 }
 $newData = array();
 foreach ($newValues as $key => $value) {
 // quote the values, as needed for the insert
 $newData[$this->_getColName($key)] = $this->_quote($value);
 }
 // use sequences to create a new id in the db-table
 $nextId = $this->dbh->nextId($this->table);
 $query = sprintf("INSERT INTO %s (%s,%s) VALUES (%s,%s)",
 $this->table ,
 $this->_getColName('id'),
 implode(',', array_keys($newData)) ,
 $nextId,
 implode(',', $newData));
 if (MDB::isError($res = $this->dbh->query($query))) {
 // TODO raise PEAR error
 printf("ERROR - Tree::add - %s - %s ", MDB::errorMessage($res), $query);
 return false;
 }

return $nextId;
    }

// }}}
    // {{{ remove()

/**
     * removes the given node
     *
     * @access public
     * @param  mixed $id the id of the node to be removed, or an array of id's to be removed
     * @return boolean true on success
     */
    function remove($id)
    {
        // if the one to remove has children, get their id's to remove them too
        if ($this->hasChildren($id)) {
            $id = $this->walk(array('_remove', $this), $id, 'array');
        }
        $idColumnName = 'id';
        $map = $this->getOption('columnNameMaps');
        if (isset($map['id'])) { // if there are maps given
                $idColumnName = $map['id'];
        }

$whereClause = "WHERE $idColumnName=$id";
        if (is_array($id)) {
            $whereClause = "WHERE $idColumnName in (" . implode(',', $id) . ')';
        }

$query = "DELETE FROM {$this->table} $whereClause";
 // print(' '.$query);
 if (MDB::isError($res = $this->dbh->query($query))) {
 // TODO raise PEAR error
 printf("ERROR - Tree::remove - %s - %s ", MDB::errormessage($res), $query);
 return false;
 }
 // TODO if remove succeeded set prevId of the following element properly
 return true;
 }

// }}}
    // {{{ move()

/**
 * move an entry under a given parent or behind a given entry
 *
 * @version 2001/10/10
 * @access public
 * @author Wolfram Kriesing <wolfram@kriesing.de>
 * @param integer $idToMove the id of the element that shall be moved
 * @param integer $newParentId the id of the element which will be the new parent
 * @param integer $newPrevId if prevId is given the element with the id idToMove
 * shall be moved _behind_ the element with id=prevId
 * if it is 0 it will be put at the beginning
 * if no prevId is in the DB it can be 0 too and won't bother
 * since it is not written in the DB anyway
 * @return boolean true for success
 */
 function move($idToMove, $newParentId, $newPrevId = 0)
 {
 $idColumnName = 'id';
 $parentIdColumnName = 'parentId';
 $map = $this->getOption('columnNameMaps');
 if (isset($map['id'])) {
 $idColumnName = $map['id'];
 }
 if (isset($map['parentId'])) {
 $parentIdColumnName = $map['parentId'];
 }
 // FIXXME todo: previous stuff
 // set the parent in the DB
 $query = "UPDATE $this->table SET $parentIdColumnName=$newParentId WHERE $idColumnName=$idToMove";
 // print($query);
 if (MDB::isError($res = $this->dbh->query($query))) {
 // TODO raise PEAR error
 printf("ERROR - Tree::move - %s - %s ", MDB::errorMessage($res), $query);
 return false;
 }
 // FIXXME update the prevId's of the elements where the element was moved away from and moved in
 return true;
 }

// }}}
    // {{{ update()

/**
 * update an element in the DB
 *
 * @version 2002/01/17
 * @access public
 * @author Wolfram Kriesing <wolfram@kriesing.de>
 * @param array $newData all the new data, the key 'id' is used to
 build the 'WHERE id=' clause and all the other
 * elements are the data to fill in the DB
 * @return boolean true for success
 */
 function update($id, $newData)
 {
 // FIXXME check $this->dbh->tableInfo to see if all the columns that shall be updated
 // really exist, this will also extract nextId etc. if given before writing it in the DB
 // in case they dont exist in the DB
 $setData = array();
 foreach ($newData as $key => $value) { // quote the values, as needed for the insert
 $setData[] = $this->_getColName($key) . '=' . $this->_quote($value);
 }

$query = sprintf('UPDATE %s SET %s WHERE %s=%s',
 $this->table,
 implode(',', $setData),
 $this->_getColName('id'),
 $id
 );
 if (MDB::isError($res = $this->dbh->query($query))) {
 // FIXXME raise PEAR error
 printf("ERROR - Tree::update - %s - %s ", MDB::errormessage($res), $query);
 return false;
 }

return true;
    }

// }}}
    // {{{ _throwError()

/**
 *
 * @access private
 * @version 2002/03/02
 * @author Wolfram Kriesing <wolfram@kriesing.de>
 */
 function _throwError($msg, $line, $mode = null)
 {
 return new Tree_Error($msg, $line, __FILE__, $mode, $this->dbh->last_query);
 }

// }}}
    // {{{ _prepareResults()

/**
 * prepare multiple results
 *
 * @see _prepareResult
 * @access private
 * @version 2002/03/03
 * @author Wolfram Kriesing <wolfram@kriesing.de>
 */
 function _prepareResults($results)
 {
 $newResults = array();
 foreach ($results as $aResult) {
 $newResults[] = $this->_prepareResult($aResult);
 }
 return $newResults;
 }

// }}}
    // {{{ _prepareResult()

/**
 * map back the index names to get what is expected
 *
 * @access private
 * @version 2002/03/03
 * @author Wolfram Kriesing <wolfram@kriesing.de>
 */
 function _prepareResult($result)
 {
 $map = $this->getOption('columnNameMaps');

if ($map) {
            foreach ($map as $key => $columnName) {
                $result[$key] = $result[$columnName];
                unset($result[$columnName]);
            }
        }
        return $result;
    }

// }}}
    // {{{ _getColName()

/**
 * this method retreives the real column name, as used in the DB
 * since the internal names are fixed, to be portable between different
 * DB-column namings, we map the internal name to the real column name here
 *
 * @access private
 * @version 2002/03/02
 * @author Wolfram Kriesing <wolfram@kriesing.de>
 */
 function _getColName($internalName)
 {
 if ($map = $this->getOption('columnNameMaps')) {
 if (isset($map[$internalName])) {
 return $map[$internalName];
 }
 }
 return $internalName;
 }

// }}}
    // {{{ _quoteArray()

/**
     * quotes all the data in this array
     *
     * @param array $data Array to quote
     */
    function _quoteArray($data)
    {
        foreach ($data as $key => $val) {
            $data[$key] = $this->_quote($val);
        }
        return $data;
    }

// }}}
    // {{{ _quote()

/**
     * quotes all the data in this var (can be any type except object)
     * @param mixed $data data to quote
     */
    function _quote($data)
    {
        switch(gettype($data)) {
            case 'array':
                return $this->_quoteArray($data);
                break;
            case 'boolean':
                return $this->dbh->getBooleanValue($data);
                break;
            case 'double':
                return $this->dbh->getFloatValue($data);
                break;
            case 'integer':
                return $this->dbh->getIntegerValue($data);
                break;
            case 'string':  //if 'string' or 'unknown', quote as text
            default:
                return $this->dbh->getTextValue($data);
        }
    }

// }}}
}

${this.title}

Code Editor : MDBsimple.php