Viewing file:  peardb_wrapper.php (17.49 KB) -rw-rw-rw-
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
<?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));
}
}
}
?>
|