peardb_wrapper.php

<?php
// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1998-2002 Manuel Lemos, Tomas V.V.Cox,                 |
// | Stig. S. Bakken, Lukas Smith                                         |
// | All rights reserved.                                                 |
// +----------------------------------------------------------------------+
// | MDB is a merge of PEAR DB and Metabases that provides a unified DB   |
// | API as well as database abstraction for PHP applications.            |
// | This LICENSE is in the BSD license style.                            |
// |                                                                      |
// | Redistribution and use in source and binary forms, with or without   |
// | modification, are permitted provided that the following conditions   |
// | are met:                                                             |
// |                                                                      |
// | Redistributions of source code must retain the above copyright       |
// | notice, this list of conditions and the following disclaimer.        |
// |                                                                      |
// | Redistributions in binary form must reproduce the above copyright    |
// | notice, this list of conditions and the following disclaimer in the  |
// | documentation and/or other materials provided with the distribution. |
// |                                                                      |
// | Neither the name of Manuel Lemos, Tomas V.V.Cox, Stig. S. Bakken,    |
// | Lukas Smith nor the names of his contributors may be used to endorse |
// | or promote products derived from this software without specific prior|
// | written permission.                                                  |
// |                                                                      |
// | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS  |
// | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT    |
// | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS    |
// | FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE      |
// | REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,          |
// | INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
// | BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS|
// |  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED  |
// | AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT          |
// | LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY|
// | WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE          |
// | POSSIBILITY OF SUCH DAMAGE.                                          |
// +----------------------------------------------------------------------+
// | Author: Lukas Smith <smith@dybnet.de>                                |
// +----------------------------------------------------------------------+
//
// $Id$
//

require_once (dirname(__FILE__).'/MDB.php');

/**
* Wrapper that makes MDB behave like PEAR DB
*
* @package MDB
* @author  Lukas Smith <smith@dybnet.de>
*/

class DB
{
    function &factory($type)
    {
        return MDB::factory($type);
    }

    function &connect($dsn, $options = FALSE)
    {
        if (!is_array($options) && $options) {
            $options['persistent'] = TRUE;
        }
        $db = MDB::connect($dsn, $options);
        if(PEAR::isError($db))
        {
            return $db;
        }
        $obj =& new MDB_PEAR_PROXY($db);
        return $obj;
    }

    function apiVersion()
    {
        return MDB::apiVersion();
    }

    function isError($value)
    {
        return MDB::isError($value);
    }

    function isManip($query)
    {
        return MDB::isManip($query);
    }

    function errorMessage($value)
    {
        return MDB::errorMessage($value);
    }

    function parseDSN($dsn)
    {
        return MDB::parseDSN($dsn);
    }

    function assertExtension($name)
    {
        return MDB::assertExtension($name);
    }
}

class DB_Error extends PEAR_Error
{
    function DB_Error($code = DB_ERROR, $mode = PEAR_ERROR_RETURN,
              $level = E_USER_NOTICE, $debuginfo = NULL)
    {
        if (is_int($code)) {
            $this->PEAR_Error('DB Error: ' . DB::errorMessage($code), $code, $mode, $level, $debuginfo);
        } else {
            $this->PEAR_Error("DB Error: $code", DB_ERROR, $mode, $level, $debuginfo);
        }
    }
}

class DB_result
{
    var $dbh;
    var $result;
    var $row_counter = NULL;

    var $limit_from  = NULL;

    var $limit_count = NULL;

    function DB_result(&$dbh, $result)
    {
        $this->dbh = &$dbh;
        $this->result = $result;
    }

    function fetchRow($fetchmode = DB_FETCHMODE_DEFAULT, $rownum = NULL)
    {
        $arr = $this->dbh->fetchInto($this->result, $fetchmode, $rownum);
        if(is_array($arr)) {
            return $arr;
        }
        else {
            return NULL;
        }
    }

    function fetchInto(&$arr, $fetchmode = DB_FETCHMODE_DEFAULT, $rownum = NULL)
    {
        $arr = $this->dbh->fetchInto($this->result, $fetchmode, $rownum);
        if(MDB::isError($arr)) {
            return $arr;
        }
        if($arr === NULL) {
            return $arr;
        }
        return (DB_OK);
    }

    function numCols()
    {
        return $this->dbh->numCols($this->result);
    }

    function numRows()
    {
        return $this->dbh->numRows($this->result);
    }

    function nextResult()
    {
        return $this->dbh->nextResult($this->result);
    }

    function free()
    {
        $err = $this->dbh->freeResult($this->result);
        if(DB::isError($err)) {
            return $err;
        }
        $this->result = FALSE;
        return TRUE;
    }

    function tableInfo($mode = NULL)
    {
        return $this->dbh->tableInfo($this->result, $mode);
    }

    function getRowCounter()
    {
        return $this->dbh->highest_fetched_row[$this->result];
    }
}

class DB_row
{
    function DB_row(&$arr)
    {
        for (reset($arr); $key = key($arr); next($arr)) {
            $this->$key = &$arr[$key];
        }
    }
}

class MDB_PEAR_PROXY
{
    var $MDB_object;

    function MDB_PEAR_PROXY($MDB_object)
    {
        $this->MDB_object = $MDB_object;
        $this->MDB_object->sequence_prefix = '_seq_';
    }

    function connect($dsninfo, $persistent = FALSE)
    {
        return $this->MDB_object->connect($dsninfo, $persistent);
    }

    function disconnect()
    {
        return $this->MDB_object->disconnect();
    }

    function quoteString($string)
    {
        $string = $this->_quote($string);
        if ($string{0} == "'") {
            return substr($string, 1, -1);
        }
        return $string;
    }

    function quote($string)
    {
        return $this->MDB_object->_quote($string);
    }

    function provides($feature)
    {
        return $this->MDB_object->support($feature);
    }

    function errorCode($nativecode)
    {
        return $this->MDB_object->errorCode($nativecode);
    }

    function errorMessage($dbcode)
    {
        return $this->MDB_object->errorMessage($dbcode);
    }

    function &raiseError($code = DB_ERROR, $mode = NULL, $options = NULL,
                         $userinfo = NULL, $nativecode = NULL)
    {
        return $this->MDB_object->raiseError($code = DB_ERROR, $mode, $options, $userinfo, $nativecode);
    }

    function setFetchMode($fetchmode, $object_class = NULL)
    {
        return $this->MDB_object->setFetchMode($fetchmode, $object_class);
    }

    function setOption($option, $value)
    {
        return $this->MDB_object->setOption($option, $value);
    }

    function getOption($option)
    {
        return $this->MDB_object->getOption($option);
    }

    function prepare($query)
    {
        return $this->MDB_object->prepareQuery($query);
    }

    function execute($stmt, $data = FALSE)
    {
        $result = $this->MDB_object->execute($stmt, NULL, $data);
        if (DB::isError($result) || $result === DB_OK) {
            return $result;
        } else {
            return new DB_result($this->MDB_object, $result);
        }
    }

    function executeMultiple( $stmt, &$data )
    {
        return $this->MDB_object->executeMultiple($stmt, NULL, $data);
    }

    function &query($query, $params = array()) {
        if (sizeof($params) > 0) {
            $sth = $this->MDB_object->prepare($query);
            if (MDB::isError($sth)) {
                return $sth;
            }
            return $this->MDB_object->execute($sth, $params);
        } else {
            $result = $this->MDB_object->query($query);
            if (MDB::isError($result) || $result === DB_OK) {
                return $result;
            } else {
                return new DB_result($this->MDB_object, $result);
            }
        }
    }

    function simpleQuery($query) {
        return $this->MDB_object->query($query);
    }

    function limitQuery($query, $from, $count)
    {
        $result = $this->MDB_object->limitQuery($query, $from, $count);
        if (DB::isError($result) || $result === DB_OK) {
            return $result;
        } else {
            return new DB_result($this->MDB_object, $result);
        }
    }

    function &getOne($query, $params = array())
    {
        return $this->MDB_object->getOne($query, NULL, $params);
    }

    function &getRow($query,
                     $params = NULL,
                     $fetchmode = DB_FETCHMODE_DEFAULT)
    {
        return $this->MDB_object->getRow($query, NULL, $params, NULL, $fetchmode);
    }

    function &getCol($query, $col = 0, $params = array())
    {
        return $this->MDB_object->getCol($query, NULL, $params, NULL, DB_FETCHMODE_DEFAULT, $col);
    }

    function &getAssoc($query, $force_array = FALSE, $params = array(),
                       $fetchmode = DB_FETCHMODE_ORDERED, $group = FALSE)
    {
        return $this->MDB_object->getAssoc($query, NULL, $params, NULL, $fetchmode, $force_array, $group);
    }

    function &getAll($query,
                     $params = NULL,
                     $fetchmode = DB_FETCHMODE_DEFAULT)
    {
        return $this->MDB_object->getAll($query, $params, NULL, $fetchmode);
    }

    function autoCommit($onoff = FALSE)
    {
        return $this->MDB_object->autoCommit($onoff);
    }

    function commit()
    {
        return $this->MDB_object->commit();
    }

    function rollback()
    {
        return $this->MDB_object->rollback();
    }

    function numRows($result)
    {
        return $this->MDB_object->numRows($result);
    }

    function affectedRows()
    {
        return $this->MDB_object->affectedRows();
    }

    function errorNative()
    {
        return $this->MDB_object->errorNative();
    }

    function nextId($seq_name, $ondemand = TRUE)
    {
        return $this->MDB_object->nextId($seq_name, $ondemand);
    }

    function createSequence($seq_name)
    {
        return $this->MDB_object->createSequence($seq_name, 1);
    }

    function dropSequence($seq_name)
    {
        return $this->MDB_object->dropSequence($seq_name);
    }

    function tableInfo($result, $mode = NULL)
    {
        return $this->MDB_object->tableInfo($result, $mode);
    }

    function getTables()
    {
        return $this->getListOf('tables');
    }

    function getListOf($type)
    {
        switch ($type) {
            case 'tables':
                return $this->MDB_object->listTables();
            case 'views':
                return $this->MDB_object->listViews();
            case 'users':
                return $this->MDB_object->listUsers();
            case 'functions':
                return $this->MDB_object->listFunctions();
            case 'databases':
                return $this->MDB_object->listDatabases();
            default:
                return $this->raiseError(DB_ERROR_UNSUPPORTED);
        }
    }
}
?>