<?php
// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1998-2004 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@backendmedia.com>                         |
// +----------------------------------------------------------------------+
//
// $Id: peardb_wrapper.php,v 1.32.4.2 2004/04/08 17:19:01 lsmith Exp $
//

/*
 * The method mapErrorCode in each MDB_dbtype implementation maps
 * native error codes to one of these.
 *
 * If you add an error code here, make sure you also add a textual
 * version of it in DB::errorMessage().
 */

define('DB_OK',                         MDB_OK);
define('DB_ERROR',                      MDB_ERROR);
define('DB_ERROR_SYNTAX',               MDB_ERROR_SYNTAX);
define('DB_ERROR_CONSTRAINT',           MDB_ERROR_CONSTRAINT);
define('DB_ERROR_NOT_FOUND',            MDB_ERROR_NOT_FOUND);
define('DB_ERROR_ALREADY_EXISTS',       MDB_ERROR_ALREADY_EXISTS);
define('DB_ERROR_UNSUPPORTED',          MDB_ERROR_UNSUPPORTED);
define('DB_ERROR_MISMATCH',             MDB_ERROR_MISMATCH);
define('DB_ERROR_INVALID',              MDB_ERROR_INVALID);
define('DB_ERROR_NOT_CAPABLE',          MDB_ERROR_NOT_CAPABLE);
define('DB_ERROR_TRUNCATED',            MDB_ERROR_TRUNCATED);
define('DB_ERROR_INVALID_NUMBER',       MDB_ERROR_INVALID_NUMBER);
define('DB_ERROR_INVALID_DATE',         MDB_ERROR_INVALID_DATE);
define('DB_ERROR_DIVZERO',              MDB_ERROR_DIVZERO);
define('DB_ERROR_NODBSELECTED',         MDB_ERROR_NODBSELECTED);
define('DB_ERROR_CANNOT_CREATE',        MDB_ERROR_CANNOT_CREATE);
define('DB_ERROR_CANNOT_DELETE',        MDB_ERROR_CANNOT_DELETE);
define('DB_ERROR_CANNOT_DROP',          MDB_ERROR_CANNOT_DROP);
define('DB_ERROR_NOSUCHTABLE',          MDB_ERROR_NOSUCHTABLE);
define('DB_ERROR_NOSUCHFIELD',          MDB_ERROR_NOSUCHFIELD);
define('DB_ERROR_NEED_MORE_DATA',       MDB_ERROR_NEED_MORE_DATA);
define('DB_ERROR_NOT_LOCKED',           MDB_ERROR_NOT_LOCKED);
define('DB_ERROR_VALUE_COUNT_ON_ROW',   MDB_ERROR_VALUE_COUNT_ON_ROW);
define('DB_ERROR_INVALID_DSN',          MDB_ERROR_INVALID_DSN);
define('DB_ERROR_CONNECT_FAILED',       MDB_ERROR_CONNECT_FAILED);
define('DB_ERROR_EXTENSION_NOT_FOUND',  MDB_ERROR_EXTENSION_NOT_FOUND);
define('DB_ERROR_ACCESS_VIOLATION',     MDB_ERROR_ACCESS_VIOLATION);
define('DB_ERROR_NOSUCHDB',             MDB_ERROR_NOSUCHDB);

define('DB_WARNING',           -1000);
define('DB_WARNING_READ_ONLY', -1001);

define('DB_PARAM_SCALAR',   MDB_PARAM_SCALAR);
define('DB_PARAM_OPAQUE',   MDB_PARAM_OPAQUE);
define('DB_PARAM_MISC',     MDB_PARAM_MISC);

define('DB_BINMODE_PASSTHRU',   MDB_BINMODE_PASSTHRU);
define('DB_BINMODE_RETURN',     MDB_BINMODE_RETURN);
define('DB_BINMODE_CONVERT',    MDB_BINMODE_CONVERT);

define('DB_FETCHMODE_DEFAULT',      MDB_FETCHMODE_DEFAULT);
define('DB_FETCHMODE_ORDERED',      MDB_FETCHMODE_ORDERED);
define('DB_FETCHMODE_ASSOC',        MDB_FETCHMODE_ASSOC);
define('DB_FETCHMODE_OBJECT',       3);
define('DB_FETCHMODE_FLIPPED',      MDB_FETCHMODE_FLIPPED);

define('DB_GETMODE_ORDERED', DB_FETCHMODE_ORDERED);
define('DB_GETMODE_ASSOC',   DB_FETCHMODE_ASSOC);
define('DB_GETMODE_FLIPPED', DB_FETCHMODE_FLIPPED);

define('DB_TABLEINFO_ORDER',        MDB_TABLEINFO_ORDER);
define('DB_TABLEINFO_ORDERTABLE',   MDB_TABLEINFO_ORDERTABLE);
define('DB_TABLEINFO_FULL',         MDB_TABLEINFO_FULL);

define('DB_AUTOQUERY_INSERT', 1);
define('DB_AUTOQUERY_UPDATE', 2);

/**
 * Wrapper that makes MDB behave like PEAR DB
 *
 * @package MDB
 * @category Database
 * @author  Lukas Smith <smith@backendmedia.com>
 */
class DB
{
    function &factory($type)
    {
        $db =& MDB::factory($type);
        if(PEAR::isError($db)) {
            return($db);
        }
        $obj =& new MDB_PEAR_PROXY($db);
        return($obj);
    }

    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(2);
    }

    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)
    {
        if (!extension_loaded($name)) {
            $dlext = OS_WINDOWS ? '.dll' : '.so';
            @dl($name . $dlext);
        }
        return extension_loaded($name);
    }
}

/**
 * MDB_Error implements a class for reporting portable database error
 * messages.
 *
 * @package MDB
 * @category Database
 * @author  Stig Bakken <ssb@fast.no>
 */
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);
        }
    }
}

/**
 * Wrapper that makes MDB behave like PEAR DB
 *
 * @package MDB
 * @category Database
 * @author  Lukas Smith <smith@backendmedia.com>
 */
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 = 0)
    {
        $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 = 0)
    {
        $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(MDB::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->option['sequence_col_name'] = 'id';
    }

    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)
    {
        if ($string === NULL) {
            return 'NULL';
        }
        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 autoPrepare($table, $table_fields, $mode = DB_AUTOQUERY_INSERT, $where = false)
    {
        $query = $this->buildManipSQL($table, $table_fields, $mode, $where);
        return($this->prepare($query));
    }

    function autoExecute($table, $fields_values, $mode = DB_AUTOQUERY_INSERT, $where = false)
    {
        $sth = $this->autoPrepare($table, array_keys($fields_values), $mode, $where);
        return($this->execute($sth, array_values($fields_values)));
    }

    function buildManipSQL($table, $table_fields, $mode, $where = false)
    {
        if (count($table_fields) == 0) {
            $this->raiseError(DB_ERROR_NEED_MORE_DATA);
        }
        $first = true;
        switch ($mode) {
            case DB_AUTOQUERY_INSERT:
                $values = '';
                $names = '';
                while (list(, $value) = each($table_fields)) {
                    if ($first) {
                        $first = false;
                    } else {
                        $names .= ',';
                        $values .= ',';
                    }
                    $names .= $value;
                    $values .= '?';
                }
                return "INSERT INTO $table ($names) VALUES ($values)";
                break;
            case DB_AUTOQUERY_UPDATE:
                $set = '';
                while (list(, $value) = each($table_fields)) {
                    if ($first) {
                        $first = false;
                    } else {
                        $set .= ',';
                    }
                    $set .= "$value = ?";
                }
                $sql = "UPDATE $table SET $set";
                if ($where) {
                    $sql .= " WHERE $where";
                }
                return($sql);
                break;
            default:
                $this->raiseError(DB_ERROR_SYNTAX);
        }
    }

    function execute($stmt, $data = FALSE)
    {
        $result = $this->MDB_object->execute($stmt, NULL, $data);
        if (MDB::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, NULL, $from, $count);
        if (MDB::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, $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, NULL, $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));
        }
    }
}
?>