WebSVN – Applications.gtt – Diff – /trunk/bibliotheque/pear/DB.php


<?php
 
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
 
/**
 * Database independent query interface
 *
 * PHP version 5
 *
 * LICENSE: This source file is subject to version 3.0 of the PHP license
 * that is available through the world-wide-web at the following URI:
 * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
 * the PHP License and are unable to obtain it through the web, please
 * send a note to license@php.net so we can mail you a copy immediately.
 *
 * @category   Database
 * @package    DB
 * @author     Stig Bakken <ssb@php.net>
 * @author     Tomas V.V.Cox <cox@idecnet.com>
 * @author     Daniel Convissor <danielc@php.net>
 * @copyright  1997-2007 The PHP Group
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    CVS: $Id$
 * @link       http://pear.php.net/package/DB
 */
 
/**
 * Obtain the PEAR class so it can be extended from
 */
require_once 'PEAR.php';
 
 
// {{{ constants
// {{{ error codes
 
/**#@+
 * One of PEAR DB's portable error codes.
 * @see DB_common::errorCode(), DB::errorMessage()
 *
 * {@internal If you add an error code here, make sure you also add a textual
 * version of it in DB::errorMessage().}}
 */
 
/**
 * The code returned by many methods upon success
 */
define('DB_OK', 1);
 
/**
 * Unkown error
 */
define('DB_ERROR', -1);
 
/**
 * Syntax error
 */
define('DB_ERROR_SYNTAX', -2);
 
/**
 * Tried to insert a duplicate value into a primary or unique index
 */
define('DB_ERROR_CONSTRAINT', -3);
 
/**
 * An identifier in the query refers to a non-existant object
 */
define('DB_ERROR_NOT_FOUND', -4);
 
/**
 * Tried to create a duplicate object
 */
define('DB_ERROR_ALREADY_EXISTS', -5);
 
/**
 * The current driver does not support the action you attempted
 */
define('DB_ERROR_UNSUPPORTED', -6);
 
/**
 * The number of parameters does not match the number of placeholders
 */
define('DB_ERROR_MISMATCH', -7);
 
/**
 * A literal submitted did not match the data type expected
 */
define('DB_ERROR_INVALID', -8);
 
/**
 * The current DBMS does not support the action you attempted
 */
define('DB_ERROR_NOT_CAPABLE', -9);
 
/**
 * A literal submitted was too long so the end of it was removed
 */
define('DB_ERROR_TRUNCATED', -10);
 
/**
 * A literal number submitted did not match the data type expected
 */
define('DB_ERROR_INVALID_NUMBER', -11);
 
/**
 * A literal date submitted did not match the data type expected
 */
define('DB_ERROR_INVALID_DATE', -12);
 
/**
 * Attempt to divide something by zero
 */
define('DB_ERROR_DIVZERO', -13);
 
/**
 * A database needs to be selected
 */
define('DB_ERROR_NODBSELECTED', -14);
 
/**
 * Could not create the object requested
 */
define('DB_ERROR_CANNOT_CREATE', -15);
 
/**
 * Could not drop the database requested because it does not exist
 */
define('DB_ERROR_CANNOT_DROP', -17);
 
/**
 * An identifier in the query refers to a non-existant table
 */
define('DB_ERROR_NOSUCHTABLE', -18);
 
/**
 * An identifier in the query refers to a non-existant column
 */
define('DB_ERROR_NOSUCHFIELD', -19);
 
/**
 * The data submitted to the method was inappropriate
 */
define('DB_ERROR_NEED_MORE_DATA', -20);
 
/**
 * The attempt to lock the table failed
 */
define('DB_ERROR_NOT_LOCKED', -21);
 
/**
 * The number of columns doesn't match the number of values
 */
define('DB_ERROR_VALUE_COUNT_ON_ROW', -22);
 
/**
 * The DSN submitted has problems
 */
define('DB_ERROR_INVALID_DSN', -23);
 
/**
 * Could not connect to the database
 */
define('DB_ERROR_CONNECT_FAILED', -24);
 
/**
 * The PHP extension needed for this DBMS could not be found
 */
define('DB_ERROR_EXTENSION_NOT_FOUND',-25);
 
/**
 * The present user has inadequate permissions to perform the task requestd
 */
define('DB_ERROR_ACCESS_VIOLATION', -26);
 
/**
 * The database requested does not exist
 */
define('DB_ERROR_NOSUCHDB', -27);
 
/**
 * Tried to insert a null value into a column that doesn't allow nulls
 */
define('DB_ERROR_CONSTRAINT_NOT_NULL',-29);
/**#@-*/
 
 
// }}}
// {{{ prepared statement-related
 
 
/**#@+
 * Identifiers for the placeholders used in prepared statements.
 * @see DB_common::prepare()
 */
 
/**
 * Indicates a scalar (<kbd>?</kbd>) placeholder was used
 *
 * Quote and escape the value as necessary.
 */
define('DB_PARAM_SCALAR', 1);
 
/**
 * Indicates an opaque (<kbd>&</kbd>) placeholder was used
 *
 * The value presented is a file name.  Extract the contents of that file
 * and place them in this column.
 */
define('DB_PARAM_OPAQUE', 2);
 
/**
 * Indicates a misc (<kbd>!</kbd>) placeholder was used
 *
 * The value should not be quoted or escaped.
 */
define('DB_PARAM_MISC',   3);
/**#@-*/
 
 
// }}}
// {{{ binary data-related
 
 
/**#@+
 * The different ways of returning binary data from queries.
 */
 
/**
 * Sends the fetched data straight through to output
 */
define('DB_BINMODE_PASSTHRU', 1);
 
/**
 * Lets you return data as usual
 */
define('DB_BINMODE_RETURN', 2);
 
/**
 * Converts the data to hex format before returning it
 *
 * For example the string "123" would become "313233".
 */
define('DB_BINMODE_CONVERT', 3);
/**#@-*/
 
 
// }}}
// {{{ fetch modes
 
 
/**#@+
 * Fetch Modes.
 * @see DB_common::setFetchMode()
 */
 
/**
 * Indicates the current default fetch mode should be used
 * @see DB_common::$fetchmode
 */
define('DB_FETCHMODE_DEFAULT', 0);
 
/**
 * Column data indexed by numbers, ordered from 0 and up
 */
define('DB_FETCHMODE_ORDERED', 1);
 
/**
 * Column data indexed by column names
 */
define('DB_FETCHMODE_ASSOC', 2);
 
/**
 * Column data as object properties
 */
define('DB_FETCHMODE_OBJECT', 3);
 
/**
 * For multi-dimensional results, make the column name the first level
 * of the array and put the row number in the second level of the array
 *
 * This is flipped from the normal behavior, which puts the row numbers
 * in the first level of the array and the column names in the second level.
 */
define('DB_FETCHMODE_FLIPPED', 4);
/**#@-*/
 
/**#@+
 * Old fetch modes.  Left here for compatibility.
 */
define('DB_GETMODE_ORDERED', DB_FETCHMODE_ORDERED);
define('DB_GETMODE_ASSOC',   DB_FETCHMODE_ASSOC);
define('DB_GETMODE_FLIPPED', DB_FETCHMODE_FLIPPED);
/**#@-*/
 
 
// }}}
// {{{ tableInfo() && autoPrepare()-related
 
 
/**#@+
 * The type of information to return from the tableInfo() method.
 *
 * Bitwised constants, so they can be combined using <kbd>|</kbd>
 * and removed using <kbd>^</kbd>.
 *
 * @see DB_common::tableInfo()
 *
 * {@internal Since the TABLEINFO constants are bitwised, if more of them are
 * added in the future, make sure to adjust DB_TABLEINFO_FULL accordingly.}}
 */
define('DB_TABLEINFO_ORDER', 1);
define('DB_TABLEINFO_ORDERTABLE', 2);
define('DB_TABLEINFO_FULL', 3);
/**#@-*/
 
 
/**#@+
 * The type of query to create with the automatic query building methods.
 * @see DB_common::autoPrepare(), DB_common::autoExecute()
 */
define('DB_AUTOQUERY_INSERT', 1);
define('DB_AUTOQUERY_UPDATE', 2);
/**#@-*/
 
 
// }}}
// {{{ portability modes
 
 
/**#@+
 * Portability Modes.
 *
 * Bitwised constants, so they can be combined using <kbd>|</kbd>
 * and removed using <kbd>^</kbd>.
 *
 * @see DB_common::setOption()
 *
 * {@internal Since the PORTABILITY constants are bitwised, if more of them are
 * added in the future, make sure to adjust DB_PORTABILITY_ALL accordingly.}}
 */
 
/**
 * Turn off all portability features
 */
define('DB_PORTABILITY_NONE', 0);
 
/**
 * Convert names of tables and fields to lower case
 * when using the get*(), fetch*() and tableInfo() methods
 */
define('DB_PORTABILITY_LOWERCASE', 1);
 
/**
 * Right trim the data output by get*() and fetch*()
 */
define('DB_PORTABILITY_RTRIM', 2);
 
/**
 * Force reporting the number of rows deleted
 */
define('DB_PORTABILITY_DELETE_COUNT', 4);
 
/**
 * Enable hack that makes numRows() work in Oracle
 */
define('DB_PORTABILITY_NUMROWS', 8);
 
/**
 * Makes certain error messages in certain drivers compatible
 * with those from other DBMS's
 *
 * + mysql, mysqli:  change unique/primary key constraints
 *   DB_ERROR_ALREADY_EXISTS -> DB_ERROR_CONSTRAINT
 *
 * + odbc(access):  MS's ODBC driver reports 'no such field' as code
 *   07001, which means 'too few parameters.'  When this option is on
 *   that code gets mapped to DB_ERROR_NOSUCHFIELD.
 */
define('DB_PORTABILITY_ERRORS', 16);
 
/**
 * Convert null values to empty strings in data output by
 * get*() and fetch*()
 */
define('DB_PORTABILITY_NULL_TO_EMPTY', 32);
 
/**
 * Turn on all portability features
 */
define('DB_PORTABILITY_ALL', 63);
/**#@-*/
 
// }}}
 
 
// }}}
// {{{ class DB
 
/**
 * Database independent query interface
 *
 * The main "DB" class is simply a container class with some static
 * methods for creating DB objects as well as some utility functions
 * common to all parts of DB.
 *
 * The object model of DB is as follows (indentation means inheritance):
 * <pre>
 * DB           The main DB class.  This is simply a utility class
 *              with some "static" methods for creating DB objects as
 *              well as common utility functions for other DB classes.
 *
 * DB_common    The base for each DB implementation.  Provides default
 * |            implementations (in OO lingo virtual methods) for
 * |            the actual DB implementations as well as a bunch of
 * |            query utility functions.
 * |
 * +-DB_mysql   The DB implementation for MySQL.  Inherits DB_common.
 *              When calling DB::factory or DB::connect for MySQL
 *              connections, the object returned is an instance of this
 *              class.
 * </pre>
 *
 * @category   Database
 * @package    DB
 * @author     Stig Bakken <ssb@php.net>
 * @author     Tomas V.V.Cox <cox@idecnet.com>
 * @author     Daniel Convissor <danielc@php.net>
 * @copyright  1997-2007 The PHP Group
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    Release: 1.9.2
 * @link       http://pear.php.net/package/DB
 */
class DB
{
    // {{{ factory()
 
    /**
     * Create a new DB object for the specified database type but don't
     * connect to the database
     *
     * @param string $type     the database type (eg "mysql")
     * @param array  $options  an associative array of option names and values
     *
     * @return object  a new DB object.  A DB_Error object on failure.
     *
     * @see DB_common::setOption()
     */
    public static function factory($type, $options = false)
    {
        if (!is_array($options)) {
            $options = array('persistent' => $options);
        }
 
        if (isset($options['debug']) && $options['debug'] >= 2) {
            // expose php errors with sufficient debug level
            include_once "DB/{$type}.php";
        } else {
            @include_once "DB/{$type}.php";
        }
 
        $classname = "DB_${type}";
 
        if (!class_exists($classname)) {
            $tmp = PEAR::raiseError(null, DB_ERROR_NOT_FOUND, null, null,
                                    "Unable to include the DB/{$type}.php"
                                    . " file for '$dsn'",
                                    'DB_Error', true);
            return $tmp;
        }
 
        @$obj = new $classname;
 
        foreach ($options as $option => $value) {
            $test = $obj->setOption($option, $value);
            if (DB::isError($test)) {
                return $test;
            }
        }
 
        return $obj;
    }
 
    // }}}
    // {{{ connect()
 
    /**
     * Create a new DB object including a connection to the specified database
     *
     * Example 1.
     * <code>
     * require_once 'DB.php';
     *
     * $dsn = 'pgsql://user:password@host/database';
     * $options = array(
     *     'debug'       => 2,
     *     'portability' => DB_PORTABILITY_ALL,
     * );
     *
     * $db = DB::connect($dsn, $options);
     * if (PEAR::isError($db)) {
     *     die($db->getMessage());
     * }
     * </code>
     *
     * @param mixed $dsn      the string "data source name" or array in the
     *                         format returned by DB::parseDSN()
     * @param array $options  an associative array of option names and values
     *
     * @return object  a new DB object.  A DB_Error object on failure.
     *
     * @uses DB_dbase::connect(), DB_fbsql::connect(), DB_ibase::connect(),
     *       DB_ifx::connect(), DB_msql::connect(), DB_mssql::connect(),
     *       DB_mysql::connect(), DB_mysqli::connect(), DB_oci8::connect(),
     *       DB_odbc::connect(), DB_pgsql::connect(), DB_sqlite::connect(),
     *       DB_sybase::connect()
     *
     * @uses DB::parseDSN(), DB_common::setOption(), PEAR::isError()
     */
    public static function connect($dsn, $options = array())
    {
        $dsninfo = DB::parseDSN($dsn);
        $type = $dsninfo['phptype'];
 
        if (!is_array($options)) {
            /*
             * For backwards compatibility.  $options used to be boolean,
             * indicating whether the connection should be persistent.
             */
            $options = array('persistent' => $options);
        }
 
        if (isset($options['debug']) && $options['debug'] >= 2) {
            // expose php errors with sufficient debug level
            include_once "DB/${type}.php";
        } else {
            @include_once "DB/${type}.php";
        }
 
        $classname = "DB_${type}";
        if (!class_exists($classname)) {
            $tmp = PEAR::raiseError(null, DB_ERROR_NOT_FOUND, null, null,
                                    "Unable to include the DB/{$type}.php"
                                    . " file for '"
                                    . DB::getDSNString($dsn, true) . "'",
                                    'DB_Error', true);
            return $tmp;
        }
 
        @$obj = new $classname;
 
        foreach ($options as $option => $value) {
            $test = $obj->setOption($option, $value);
            if (DB::isError($test)) {
                return $test;
            }
        }
 
        $err = $obj->connect($dsninfo, $obj->getOption('persistent'));
        if (DB::isError($err)) {
            if (is_array($dsn)) {
                $err->addUserInfo(DB::getDSNString($dsn, true));
            } else {
                $err->addUserInfo($dsn);
            }
            return $err;
        }
 
        return $obj;
    }
 
    // }}}
    // {{{ apiVersion()
 
    /**
     * Return the DB API version
     *
     * @return string  the DB API version number
     */
    function apiVersion()
    {
        return '1.9.2';
    }
 
    // }}}
    // {{{ isError()
 
    /**
     * Determines if a variable is a DB_Error object
     *
     * @param mixed $value  the variable to check
     *
     * @return bool  whether $value is DB_Error object
     */
    public static function isError($value)
    {
        return is_object($value) && is_a($value, 'DB_Error');		
    }
 
    // }}}
    // {{{ isConnection()
 
    /**
     * Determines if a value is a DB_<driver> object
     *
     * @param mixed $value  the value to test
     *
     * @return bool  whether $value is a DB_<driver> object
     */
    public static function isConnection($value)
    {
        return (is_object($value) &&
                is_subclass_of($value, 'db_common') &&
                method_exists($value, 'simpleQuery'));
    }
 
    // }}}
    // {{{ isManip()
 
    /**
     * Tell whether a query is a data manipulation or data definition query
     *
     * Examples of data manipulation queries are INSERT, UPDATE and DELETE.
     * Examples of data definition queries are CREATE, DROP, ALTER, GRANT,
     * REVOKE.
     *
     * @param string $query  the query
     *
     * @return boolean  whether $query is a data manipulation query
     */
    public static function isManip($query)
    {
        $manips = 'INSERT|UPDATE|DELETE|REPLACE|'
                . 'CREATE|DROP|'
                . 'LOAD DATA|SELECT .* INTO .* FROM|COPY|'
                . 'ALTER|GRANT|REVOKE|'
                . 'LOCK|UNLOCK';
        if (preg_match('/^\s*"?(' . $manips . ')\s+/i', $query)) {
            return true;
        }
        return false;
    }
 
    // }}}
    // {{{ errorMessage()
 
    /**
     * Return a textual error message for a DB error code
     *
     * @param integer $value  the DB error code
     *
     * @return string  the error message or false if the error code was
     *                  not recognized
     */
    public static function errorMessage($value)
    {
        static $errorMessages;
        if (!isset($errorMessages)) {
            $errorMessages = array(
                DB_ERROR                    => 'unknown error',
                DB_ERROR_ACCESS_VIOLATION   => 'insufficient permissions',
                DB_ERROR_ALREADY_EXISTS     => 'already exists',
                DB_ERROR_CANNOT_CREATE      => 'can not create',
                DB_ERROR_CANNOT_DROP        => 'can not drop',
                DB_ERROR_CONNECT_FAILED     => 'connect failed',
                DB_ERROR_CONSTRAINT         => 'constraint violation',
                DB_ERROR_CONSTRAINT_NOT_NULL=> 'null value violates not-null constraint',
                DB_ERROR_DIVZERO            => 'division by zero',
                DB_ERROR_EXTENSION_NOT_FOUND=> 'extension not found',
                DB_ERROR_INVALID            => 'invalid',
                DB_ERROR_INVALID_DATE       => 'invalid date or time',
                DB_ERROR_INVALID_DSN        => 'invalid DSN',
                DB_ERROR_INVALID_NUMBER     => 'invalid number',
                DB_ERROR_MISMATCH           => 'mismatch',
                DB_ERROR_NEED_MORE_DATA     => 'insufficient data supplied',
                DB_ERROR_NODBSELECTED       => 'no database selected',
                DB_ERROR_NOSUCHDB           => 'no such database',
                DB_ERROR_NOSUCHFIELD        => 'no such field',
                DB_ERROR_NOSUCHTABLE        => 'no such table',
                DB_ERROR_NOT_CAPABLE        => 'DB backend not capable',
                DB_ERROR_NOT_FOUND          => 'not found',
                DB_ERROR_NOT_LOCKED         => 'not locked',
                DB_ERROR_SYNTAX             => 'syntax error',
                DB_ERROR_UNSUPPORTED        => 'not supported',
                DB_ERROR_TRUNCATED          => 'truncated',
                DB_ERROR_VALUE_COUNT_ON_ROW => 'value count on row',
                DB_OK                       => 'no error',
            );
        }
 
        if (DB::isError($value)) {
            $value = $value->getCode();
        }
 
        return isset($errorMessages[$value]) ? $errorMessages[$value]
                     : $errorMessages[DB_ERROR];
    }
 
    // }}}
    // {{{ parseDSN()
 
    /**
     * Parse a data source name
     *
     * Additional keys can be added by appending a URI query string to the
     * end of the DSN.
     *
     * The format of the supplied DSN is in its fullest form:
     * <code>
     *  phptype(dbsyntax)://username:password@protocol+hostspec/database?option=8&another=true
     * </code>
     *
     * Most variations are allowed:
     * <code>
     *  phptype://username:password@protocol+hostspec:110//usr/db_file.db?mode=0644
     *  phptype://username:password@hostspec/database_name
     *  phptype://username:password@hostspec
     *  phptype://username@hostspec
     *  phptype://hostspec/database
     *  phptype://hostspec
     *  phptype(dbsyntax)
     *  phptype
     * </code>
     *
     * @param string $dsn Data Source Name to be parsed
     *
     * @return array an associative array with the following keys:
     *  + phptype:  Database backend used in PHP (mysql, odbc etc.)
     *  + dbsyntax: Database used with regards to SQL syntax etc.
     *  + protocol: Communication protocol to use (tcp, unix etc.)
     *  + hostspec: Host specification (hostname[:port])
     *  + database: Database to use on the DBMS server
     *  + username: User name for login
     *  + password: Password for login
     */
    public static function parseDSN($dsn)
    {
        $parsed = array(
            'phptype'  => false,
            'dbsyntax' => false,
            'username' => false,
            'password' => false,
            'protocol' => false,
            'hostspec' => false,
            'port'     => false,
            'socket'   => false,
            'database' => false,
        );
 
        if (is_array($dsn)) {
            $dsn = array_merge($parsed, $dsn);
            if (!$dsn['dbsyntax']) {
                $dsn['dbsyntax'] = $dsn['phptype'];
            }
            return $dsn;
        }
 
        // Find phptype and dbsyntax
        if (($pos = strpos($dsn, '://')) !== false) {
            $str = substr($dsn, 0, $pos);
            $dsn = substr($dsn, $pos + 3);
        } else {
            $str = $dsn;
            $dsn = null;
        }
 
        // Get phptype and dbsyntax
        // $str => phptype(dbsyntax)
        if (preg_match('|^(.+?)\((.*?)\)$|', $str, $arr)) {
            $parsed['phptype']  = $arr[1];
            $parsed['dbsyntax'] = !$arr[2] ? $arr[1] : $arr[2];
        } else {
            $parsed['phptype']  = $str;
            $parsed['dbsyntax'] = $str;
        }
 
        if (!count($dsn)) {
            return $parsed;
        }
 
        // Get (if found): username and password
        // $dsn => username:password@protocol+hostspec/database
        if (($at = strrpos($dsn,'@')) !== false) {
            $str = substr($dsn, 0, $at);
            $dsn = substr($dsn, $at + 1);
            if (($pos = strpos($str, ':')) !== false) {
                $parsed['username'] = rawurldecode(substr($str, 0, $pos));
                $parsed['password'] = rawurldecode(substr($str, $pos + 1));
            } else {
                $parsed['username'] = rawurldecode($str);
            }
        }
 
        // Find protocol and hostspec
 
        if (preg_match('|^([^(]+)\((.*?)\)/?(.*?)$|', $dsn, $match)) {
            // $dsn => proto(proto_opts)/database
            $proto       = $match[1];
            $proto_opts  = $match[2] ? $match[2] : false;
            $dsn         = $match[3];
 
        } else {
            // $dsn => protocol+hostspec/database (old format)
            if (strpos($dsn, '+') !== false) {
                list($proto, $dsn) = explode('+', $dsn, 2);
            }
            if (strpos($dsn, '/') !== false) {
                list($proto_opts, $dsn) = explode('/', $dsn, 2);
            } else {
                $proto_opts = $dsn;
                $dsn = null;
            }
        }
 
        // process the different protocol options
        $parsed['protocol'] = (!empty($proto)) ? $proto : 'tcp';
        $proto_opts = rawurldecode($proto_opts);
        if (strpos($proto_opts, ':') !== false) {
            list($proto_opts, $parsed['port']) = explode(':', $proto_opts);
        }
        if ($parsed['protocol'] == 'tcp') {
 
 
 
 
            $parsed['hostspec'] = $proto_opts;
 
        } elseif ($parsed['protocol'] == 'unix') {
            $parsed['socket'] = $proto_opts;
        }
 
        // Get dabase if any
        // $dsn => database
        if ($dsn) {
            if (($pos = strpos($dsn, '?')) === false) {
                // /database
                $parsed['database'] = rawurldecode($dsn);
            } else {
                // /database?param1=value1&param2=value2
                $parsed['database'] = rawurldecode(substr($dsn, 0, $pos));
                $dsn = substr($dsn, $pos + 1);
                if (strpos($dsn, '&') !== false) {
                    $opts = explode('&', $dsn);
                } else { // database?param1=value1
                    $opts = array($dsn);
                }
                foreach ($opts as $opt) {
                    list($key, $value) = explode('=', $opt);
                    if (!isset($parsed[$key])) {
                        // don't allow params overwrite
                        $parsed[$key] = rawurldecode($value);
                    }
                }
            }
        }
 
        return $parsed;
    }
 
    // }}}
    // {{{ getDSNString()
 
    /**
     * Returns the given DSN in a string format suitable for output.
     *
     * @param array|string the DSN to parse and format
     * @param boolean true to hide the password, false to include it
     * @return string
     */
    public static function getDSNString($dsn, $hidePassword) {
        /* Calling parseDSN will ensure that we have all the array elements
         * defined, and means that we deal with strings and array in the same
         * manner. */
        $dsnArray = DB::parseDSN($dsn);
        
        if ($hidePassword) {
            $dsnArray['password'] = 'PASSWORD';
        }
 
        /* Protocol is special-cased, as using the default "tcp" along with an
         * Oracle TNS connection string fails. */
        if (is_string($dsn) && strpos($dsn, 'tcp') === false && $dsnArray['protocol'] == 'tcp') {
            $dsnArray['protocol'] = false;
        }
        
        // Now we just have to construct the actual string. This is ugly.
        $dsnString = $dsnArray['phptype'];
        if ($dsnArray['dbsyntax']) {
            $dsnString .= '('.$dsnArray['dbsyntax'].')';
        }
        $dsnString .= '://'
                     .$dsnArray['username']
                     .':'
                     .$dsnArray['password']
                     .'@'
                     .$dsnArray['protocol'];
        if ($dsnArray['socket']) {
            $dsnString .= '('.$dsnArray['socket'].')';
        }
        if ($dsnArray['protocol'] && $dsnArray['hostspec']) {
            $dsnString .= '+';
        }
        $dsnString .= $dsnArray['hostspec'];
        if ($dsnArray['port']) {
            $dsnString .= ':'.$dsnArray['port'];
        }
        $dsnString .= '/'.$dsnArray['database'];
        
        /* Option handling. Unfortunately, parseDSN simply places options into
         * the top-level array, so we'll first get rid of the fields defined by
         * DB and see what's left. */
        unset($dsnArray['phptype'],
              $dsnArray['dbsyntax'],
              $dsnArray['username'],
              $dsnArray['password'],
              $dsnArray['protocol'],
              $dsnArray['socket'],
              $dsnArray['hostspec'],
              $dsnArray['port'],
              $dsnArray['database']
        );
        if (count($dsnArray) > 0) {
            $dsnString .= '?';
            $i = 0;
            foreach ($dsnArray as $key => $value) {
                if (++$i > 1) {
                    $dsnString .= '&';
                }
                $dsnString .= $key.'='.$value;
            }
        }
 
        return $dsnString;
    }
    
    // }}}
}
 
// }}}
// {{{ class DB_Error
 
/**
 * DB_Error implements a class for reporting portable database error
 * messages
 *
 * @category   Database
 * @package    DB
 * @author     Stig Bakken <ssb@php.net>
 * @copyright  1997-2007 The PHP Group
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    Release: 1.9.2
 * @link       http://pear.php.net/package/DB
 */
class DB_Error extends PEAR_Error
{
    // {{{ constructor
 
    /**
     * DB_Error constructor
     *
     * @param mixed $code       DB error code, or string with error message
     * @param int   $mode       what "error mode" to operate in
     * @param int   $level      what error level to use for $mode &
     *                           PEAR_ERROR_TRIGGER
     * @param mixed $debuginfo  additional debug info, such as the last query
     *
     * @see PEAR_Error
     */
    function __construct($code = DB_ERROR, $mode = PEAR_ERROR_RETURN,
                      $level = E_USER_NOTICE, $debuginfo = null)
    {
        if (is_int($code)) {
            parent::__construct('DB Error: ' . DB::errorMessage($code), $code,
                              $mode, $level, $debuginfo);
        } else {
            parent::__construct("DB Error: $code", DB_ERROR,
                              $mode, $level, $debuginfo);
        }
    }
 
    /**
     * Workaround to both avoid the "Redefining already defined constructor"
     * PHP error and provide backward compatibility in case someone is calling
     * DB_Error() dynamically
     */
    public function __call($method, $arguments)
    {
        if ($method == 'DB_Error') {
            return call_user_func_array(array($this, '__construct'), $arguments);
        }
        trigger_error(
            'Call to undefined method DB_Error::' . $method . '()', E_USER_ERROR
        );
    }
    // }}}
}
 
// }}}
// {{{ class DB_result
 
/**
 * This class implements a wrapper for a DB result set
 *
 * A new instance of this class will be returned by the DB implementation
 * after processing a query that returns data.
 *
 * @category   Database
 * @package    DB
 * @author     Stig Bakken <ssb@php.net>
 * @copyright  1997-2007 The PHP Group
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    Release: 1.9.2
 * @link       http://pear.php.net/package/DB
 */
class DB_result
{
    // {{{ properties
 
    /**
     * Should results be freed automatically when there are no more rows?
     * @var boolean
     * @see DB_common::$options
     */
    var $autofree;
 
    /**
     * A reference to the DB_<driver> object
     * @var object
     */
    var $dbh;
 
    /**
     * The current default fetch mode
     * @var integer
     * @see DB_common::$fetchmode
     */
    var $fetchmode;
 
    /**
     * The name of the class into which results should be fetched when
     * DB_FETCHMODE_OBJECT is in effect
     *
     * @var string
     * @see DB_common::$fetchmode_object_class
     */
    var $fetchmode_object_class;
 
    /**
     * The number of rows to fetch from a limit query
     * @var integer
     */
    var $limit_count = null;
 
    /**
     * The row to start fetching from in limit queries
     * @var integer
     */
    var $limit_from = null;
 
    /**
     * The execute parameters that created this result
     * @var array
     * @since Property available since Release 1.7.0
     */
    var $parameters;
 
    /**
     * The query string that created this result
     *
     * Copied here incase it changes in $dbh, which is referenced
     *
     * @var string
     * @since Property available since Release 1.7.0
     */
    var $query;
 
    /**
     * The query result resource id created by PHP
     * @var resource
     */
    var $result;
 
    /**
     * The present row being dealt with
     * @var integer
     */
    var $row_counter = null;
 
    /**
     * The prepared statement resource id created by PHP in $dbh
     *
     * This resource is only available when the result set was created using
     * a driver's native execute() method, not PEAR DB's emulated one.
     *
     * Copied here incase it changes in $dbh, which is referenced
     *
     * {@internal  Mainly here because the InterBase/Firebird API is only
     * able to retrieve data from result sets if the statemnt handle is
     * still in scope.}}
     *
     * @var resource
     * @since Property available since Release 1.7.0
     */
    var $statement;
 
 
    // }}}
    // {{{ constructor
 
    /**
     * This constructor sets the object's properties
     *
     * @param object   &$dbh     the DB object reference
     * @param resource $result   the result resource id
     * @param array    $options  an associative array with result options
     *
     * @return void
     */
    function __construct(&$dbh, $result, $options = array())
    {
        $this->autofree    = $dbh->options['autofree'];
        $this->dbh         = &$dbh;
        $this->fetchmode   = $dbh->fetchmode;
        $this->fetchmode_object_class = $dbh->fetchmode_object_class;
        $this->parameters  = $dbh->last_parameters;
        $this->query       = $dbh->last_query;
        $this->result      = $result;
        $this->statement   = empty($dbh->last_stmt) ? null : $dbh->last_stmt;
        foreach ($options as $key => $value) {
            $this->setOption($key, $value);
        }
    }
 
    /**
     * Set options for the DB_result object
     *
     * @param string $key    the option to set
     * @param mixed  $value  the value to set the option to
     *
     * @return void
     */
    function setOption($key, $value = null)
    {
        switch ($key) {
            case 'limit_from':
                $this->limit_from = $value;
                break;
            case 'limit_count':
                $this->limit_count = $value;
        }
    }
 
    // }}}
    // {{{ fetchRow()
 
    /**
     * Fetch a row of data and return it by reference into an array
     *
     * The type of array returned can be controlled either by setting this
     * method's <var>$fetchmode</var> parameter or by changing the default
     * fetch mode setFetchMode() before calling this method.
     *
     * There are two options for standardizing the information returned
     * from databases, ensuring their values are consistent when changing
     * DBMS's.  These portability options can be turned on when creating a
     * new DB object or by using setOption().
     *
     *   + <var>DB_PORTABILITY_LOWERCASE</var>
     *     convert names of fields to lower case
     *
     *   + <var>DB_PORTABILITY_RTRIM</var>
     *     right trim the data
     *
     * @param int $fetchmode  the constant indicating how to format the data
     * @param int $rownum     the row number to fetch (index starts at 0)
     *
     * @return mixed  an array or object containing the row's data,
     *                 NULL when the end of the result set is reached
     *                 or a DB_Error object on failure.
     *
     * @see DB_common::setOption(), DB_common::setFetchMode()
     */
    function &fetchRow($fetchmode = DB_FETCHMODE_DEFAULT, $rownum = null)
    {
        if ($fetchmode === DB_FETCHMODE_DEFAULT) {
            $fetchmode = $this->fetchmode;
        }
        if ($fetchmode === DB_FETCHMODE_OBJECT) {
            $fetchmode = DB_FETCHMODE_ASSOC;
            $object_class = $this->fetchmode_object_class;
        }
        if (is_null($rownum) && $this->limit_from !== null) {
            if ($this->row_counter === null) {
                $this->row_counter = $this->limit_from;
                // Skip rows
                if ($this->dbh->features['limit'] === false) {
                    $i = 0;
                    while ($i++ < $this->limit_from) {
                        $this->dbh->fetchInto($this->result, $arr, $fetchmode);
                    }
                }
            }
            if ($this->row_counter >= ($this->limit_from + $this->limit_count))
            {
                if ($this->autofree) {
                    $this->free();
                }
                $tmp = null;
                return $tmp;
            }
            if ($this->dbh->features['limit'] === 'emulate') {
                $rownum = $this->row_counter;
            }
            $this->row_counter++;
        }
        $res = $this->dbh->fetchInto($this->result, $arr, $fetchmode, $rownum);
        if ($res === DB_OK) {
            if (isset($object_class)) {
                // The default mode is specified in the
                // DB_common::fetchmode_object_class property
                if ($object_class == 'stdClass') {
                    $arr = (object) $arr;
                } else {
                    $arr = new $object_class($arr);
                }
            }
            return $arr;
        }
        if ($res == null && $this->autofree) {
            $this->free();
        }
        return $res;
    }
 
    // }}}
    // {{{ fetchInto()
 
    /**
     * Fetch a row of data into an array which is passed by reference
     *
     * The type of array returned can be controlled either by setting this
     * method's <var>$fetchmode</var> parameter or by changing the default
     * fetch mode setFetchMode() before calling this method.
     *
     * There are two options for standardizing the information returned
     * from databases, ensuring their values are consistent when changing
     * DBMS's.  These portability options can be turned on when creating a
     * new DB object or by using setOption().
     *
     *   + <var>DB_PORTABILITY_LOWERCASE</var>
     *     convert names of fields to lower case
     *
     *   + <var>DB_PORTABILITY_RTRIM</var>
     *     right trim the data
     *
     * @param array &$arr       the variable where the data should be placed
     * @param int   $fetchmode  the constant indicating how to format the data
     * @param int   $rownum     the row number to fetch (index starts at 0)
     *
     * @return mixed  DB_OK if a row is processed, NULL when the end of the
     *                 result set is reached or a DB_Error object on failure
     *
     * @see DB_common::setOption(), DB_common::setFetchMode()
     */
    function fetchInto(&$arr, $fetchmode = DB_FETCHMODE_DEFAULT, $rownum = null)
    {
        if ($fetchmode === DB_FETCHMODE_DEFAULT) {
            $fetchmode = $this->fetchmode;
        }
        if ($fetchmode === DB_FETCHMODE_OBJECT) {
            $fetchmode = DB_FETCHMODE_ASSOC;
            $object_class = $this->fetchmode_object_class;
        }
        if (is_null($rownum) && $this->limit_from !== null) {
            if ($this->row_counter === null) {
                $this->row_counter = $this->limit_from;
                // Skip rows
                if ($this->dbh->features['limit'] === false) {
                    $i = 0;
                    while ($i++ < $this->limit_from) {
                        $this->dbh->fetchInto($this->result, $arr, $fetchmode);
                    }
                }
            }
            if ($this->row_counter >= (
                    $this->limit_from + $this->limit_count))
            {
                if ($this->autofree) {
                    $this->free();
                }
                return null;
            }
            if ($this->dbh->features['limit'] === 'emulate') {
                $rownum = $this->row_counter;
            }
 
            $this->row_counter++;
        }
        $res = $this->dbh->fetchInto($this->result, $arr, $fetchmode, $rownum);
        if ($res === DB_OK) {
            if (isset($object_class)) {
                // default mode specified in the
                // DB_common::fetchmode_object_class property
                if ($object_class == 'stdClass') {
                    $arr = (object) $arr;
                } else {
                    $arr = new $object_class($arr);
                }
            }
            return DB_OK;
        }
        if ($res == null && $this->autofree) {
            $this->free();
        }
        return $res;
    }
 
    // }}}
    // {{{ numCols()
 
    /**
     * Get the the number of columns in a result set
     *
     * @return int  the number of columns.  A DB_Error object on failure.
     */
    function numCols()
    {
        return $this->dbh->numCols($this->result);
    }
 
    // }}}
    // {{{ numRows()
 
    /**
     * Get the number of rows in a result set
     *
     * @return int  the number of rows.  A DB_Error object on failure.
     */
    function numRows()
    {
        if ($this->dbh->features['numrows'] === 'emulate'
            && $this->dbh->options['portability'] & DB_PORTABILITY_NUMROWS)
        {
            if ($this->dbh->features['prepare']) {
                $res = $this->dbh->query($this->query, $this->parameters);
            } else {
                $res = $this->dbh->query($this->query);
            }
            if (DB::isError($res)) {
                return $res;
            }
            $i = 0;
            while ($res->fetchInto($tmp, DB_FETCHMODE_ORDERED)) {
                $i++;
            }
            $count = $i;
        } else {
            $count = $this->dbh->numRows($this->result);
        }
 
        /* fbsql is checked for here because limit queries are implemented
         * using a TOP() function, which results in fbsql_num_rows still
         * returning the total number of rows that would have been returned,
         * rather than the real number. As a result, we'll just do the limit
         * calculations for fbsql in the same way as a database with emulated
         * limits. Unfortunately, we can't just do this in DB_fbsql::numRows()
         * because that only gets the result resource, rather than the full
         * DB_Result object. */
        if (($this->dbh->features['limit'] === 'emulate'
             && $this->limit_from !== null)
            || $this->dbh->phptype == 'fbsql') {
            $limit_count = is_null($this->limit_count) ? $count : $this->limit_count;
            if ($count < $this->limit_from) {
                $count = 0;
            } elseif ($count < ($this->limit_from + $limit_count)) {
                $count -= $this->limit_from;
            } else {
                $count = $limit_count;
            }
        }
 
        return $count;
    }
 
    // }}}
    // {{{ nextResult()
 
    /**
     * Get the next result if a batch of queries was executed
     *
     * @return bool  true if a new result is available or false if not
     */
    function nextResult()
    {
        return $this->dbh->nextResult($this->result);
    }
 
    // }}}
    // {{{ free()
 
    /**
     * Frees the resources allocated for this result set
     *
     * @return bool  true on success.  A DB_Error object on failure.
     */
    function free()
    {
        $err = $this->dbh->freeResult($this->result);
        if (DB::isError($err)) {
            return $err;
        }
        $this->result = false;
        $this->statement = false;
        return true;
    }
 
    // }}}
    // {{{ tableInfo()
 
    /**
     * @see DB_common::tableInfo()
     * @deprecated Method deprecated some time before Release 1.2
     */
    function tableInfo($mode = null)
    {
        if (is_string($mode)) {
            return $this->dbh->raiseError(DB_ERROR_NEED_MORE_DATA);
        }
        return $this->dbh->tableInfo($this, $mode);
    }
 
    // }}}
    // {{{ getQuery()
 
    /**
     * Determine the query string that created this result
     *
     * @return string  the query string
     *
     * @since Method available since Release 1.7.0
     */
    function getQuery()
    {
        return $this->query;
    }
 
    // }}}
    // {{{ getRowCounter()
 
    /**
     * Tells which row number is currently being processed
     *
     * @return integer  the current row being looked at.  Starts at 1.
     */
    function getRowCounter()
    {
        return $this->row_counter;
    }
 
    // }}}
}
 
// }}}
// {{{ class DB_row
 
/**
 * PEAR DB Row Object
 *
 * The object contains a row of data from a result set.  Each column's data
 * is placed in a property named for the column.
 *
 * @category   Database
 * @package    DB
 * @author     Stig Bakken <ssb@php.net>
 * @copyright  1997-2007 The PHP Group
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    Release: 1.9.2
 * @link       http://pear.php.net/package/DB
 * @see        DB_common::setFetchMode()
 */
class DB_row
{
    // {{{ constructor
 
    /**
     * The constructor places a row's data into properties of this object
     *
     * @param array  the array containing the row's data
     *
     * @return void
     */
    function __construct(&$arr)
    {
        foreach ($arr as $key => $value) {
            $this->$key = &$arr[$key];
        }
    }
 
    // }}}
}
 
// }}}
 
/*
 * Local variables:
 * tab-width: 4
 * c-basic-offset: 4
 * End:
 */
 
?>

Rev 94	Rev 187
1	`<?php`	1	`<?php`
2		2
3	`/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */`	3	`/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */`
4		4
5	`/**`	5	`/**`
6	`* Database independent query interface`	6	`* Database independent query interface`
7	`*`	7	`*`
8	`* PHP versions 4 and 5`	8	`* PHP version 5`
9	`*`	9	`*`
10	`* LICENSE: This source file is subject to version 3.0 of the PHP license`	10	`* LICENSE: This source file is subject to version 3.0 of the PHP license`
11	`* that is available through the world-wide-web at the following URI:`	11	`* that is available through the world-wide-web at the following URI:`
12	`* http://www.php.net/license/3_0.txt. If you did not receive a copy of`	12	`* http://www.php.net/license/3_0.txt. If you did not receive a copy of`
13	`* the PHP License and are unable to obtain it through the web, please`	13	`* the PHP License and are unable to obtain it through the web, please`
14	`* send a note to license@php.net so we can mail you a copy immediately.`	14	`* send a note to license@php.net so we can mail you a copy immediately.`
15	`*`	15	`*`
16	`* @category Database`	16	`* @category Database`
17	`* @package DB`	17	`* @package DB`
18	`* @author Stig Bakken <ssb@php.net>`	18	`* @author Stig Bakken <ssb@php.net>`
19	`* @author Tomas V.V.Cox <cox@idecnet.com>`	19	`* @author Tomas V.V.Cox <cox@idecnet.com>`
20	`* @author Daniel Convissor <danielc@php.net>`	20	`* @author Daniel Convissor <danielc@php.net>`
21	`* @copyright 1997-2005 The PHP Group`	21	`* @copyright 1997-2007 The PHP Group`
22	`* @license http://www.php.net/license/3_0.txt PHP License 3.0`	22	`* @license http://www.php.net/license/3_0.txt PHP License 3.0`
23	`* @version CVS: $Id: DB.php,v 1.80 2005/02/16 02:16:00 danielc Exp $`	23	`* @version CVS: $Id$`
24	`* @link http://pear.php.net/package/DB`	24	`* @link http://pear.php.net/package/DB`
25	`*/`	25	`*/`
26		26
27	`/**`	27	`/**`
28	`* Obtain the PEAR class so it can be extended from`	28	`* Obtain the PEAR class so it can be extended from`
29	`*/`	29	`*/`
30	`require_once 'PEAR.php';`	30	`require_once 'PEAR.php';`
31		31
32		32
33	`// {{{ constants`	33	`// {{{ constants`
34	`// {{{ error codes`	34	`// {{{ error codes`
35		35
36	`/**#@+`	36	`/**#@+`
37	`* One of PEAR DB's portable error codes.`	37	`* One of PEAR DB's portable error codes.`
38	`* @see DB_common::errorCode(), DB::errorMessage()`	38	`* @see DB_common::errorCode(), DB::errorMessage()`
39	`*`	39	`*`
40	`* {@internal If you add an error code here, make sure you also add a textual`	40	`* {@internal If you add an error code here, make sure you also add a textual`
41	`* version of it in DB::errorMessage().}}`	41	`* version of it in DB::errorMessage().}}`
42	`*/`	42	`*/`
43		43
44	`/**`	44	`/**`
45	`* The code returned by many methods upon success`	45	`* The code returned by many methods upon success`
46	`*/`	46	`*/`
47	`define('DB_OK', 1);`	47	`define('DB_OK', 1);`
48		48
49	`/**`	49	`/**`
50	`* Unkown error`	50	`* Unkown error`
51	`*/`	51	`*/`
52	`define('DB_ERROR', -1);`	52	`define('DB_ERROR', -1);`
53		53
54	`/**`	54	`/**`
55	`* Syntax error`	55	`* Syntax error`
56	`*/`	56	`*/`
57	`define('DB_ERROR_SYNTAX', -2);`	57	`define('DB_ERROR_SYNTAX', -2);`
58		58
59	`/**`	59	`/**`
60	`* Tried to insert a duplicate value into a primary or unique index`	60	`* Tried to insert a duplicate value into a primary or unique index`
61	`*/`	61	`*/`
62	`define('DB_ERROR_CONSTRAINT', -3);`	62	`define('DB_ERROR_CONSTRAINT', -3);`
63		63
64	`/**`	64	`/**`
65	`* An identifier in the query refers to a non-existant object`	65	`* An identifier in the query refers to a non-existant object`
66	`*/`	66	`*/`
67	`define('DB_ERROR_NOT_FOUND', -4);`	67	`define('DB_ERROR_NOT_FOUND', -4);`
68		68
69	`/**`	69	`/**`
70	`* Tried to create a duplicate object`	70	`* Tried to create a duplicate object`
71	`*/`	71	`*/`
72	`define('DB_ERROR_ALREADY_EXISTS', -5);`	72	`define('DB_ERROR_ALREADY_EXISTS', -5);`
73		73
74	`/**`	74	`/**`
75	`* The current driver does not support the action you attempted`	75	`* The current driver does not support the action you attempted`
76	`*/`	76	`*/`
77	`define('DB_ERROR_UNSUPPORTED', -6);`	77	`define('DB_ERROR_UNSUPPORTED', -6);`
78		78
79	`/**`	79	`/**`
80	`* The number of parameters does not match the number of placeholders`	80	`* The number of parameters does not match the number of placeholders`
81	`*/`	81	`*/`
82	`define('DB_ERROR_MISMATCH', -7);`	82	`define('DB_ERROR_MISMATCH', -7);`
83		83
84	`/**`	84	`/**`
85	`* A literal submitted did not match the data type expected`	85	`* A literal submitted did not match the data type expected`
86	`*/`	86	`*/`
87	`define('DB_ERROR_INVALID', -8);`	87	`define('DB_ERROR_INVALID', -8);`
88		88
89	`/**`	89	`/**`
90	`* The current DBMS does not support the action you attempted`	90	`* The current DBMS does not support the action you attempted`
91	`*/`	91	`*/`
92	`define('DB_ERROR_NOT_CAPABLE', -9);`	92	`define('DB_ERROR_NOT_CAPABLE', -9);`
93		93
94	`/**`	94	`/**`
95	`* A literal submitted was too long so the end of it was removed`	95	`* A literal submitted was too long so the end of it was removed`
96	`*/`	96	`*/`
97	`define('DB_ERROR_TRUNCATED', -10);`	97	`define('DB_ERROR_TRUNCATED', -10);`
98		98
99	`/**`	99	`/**`
100	`* A literal number submitted did not match the data type expected`	100	`* A literal number submitted did not match the data type expected`
101	`*/`	101	`*/`
102	`define('DB_ERROR_INVALID_NUMBER', -11);`	102	`define('DB_ERROR_INVALID_NUMBER', -11);`
103		103
104	`/**`	104	`/**`
105	`* A literal date submitted did not match the data type expected`	105	`* A literal date submitted did not match the data type expected`
106	`*/`	106	`*/`
107	`define('DB_ERROR_INVALID_DATE', -12);`	107	`define('DB_ERROR_INVALID_DATE', -12);`
108		108
109	`/**`	109	`/**`
110	`* Attempt to divide something by zero`	110	`* Attempt to divide something by zero`
111	`*/`	111	`*/`
112	`define('DB_ERROR_DIVZERO', -13);`	112	`define('DB_ERROR_DIVZERO', -13);`
113		113
114	`/**`	114	`/**`
115	`* A database needs to be selected`	115	`* A database needs to be selected`
116	`*/`	116	`*/`
117	`define('DB_ERROR_NODBSELECTED', -14);`	117	`define('DB_ERROR_NODBSELECTED', -14);`
118		118
119	`/**`	119	`/**`
120	`* Could not create the object requested`	120	`* Could not create the object requested`
121	`*/`	121	`*/`
122	`define('DB_ERROR_CANNOT_CREATE', -15);`	122	`define('DB_ERROR_CANNOT_CREATE', -15);`
123		123
124	`/**`	124	`/**`
125	`* Could not drop the database requested because it does not exist`	125	`* Could not drop the database requested because it does not exist`
126	`*/`	126	`*/`
127	`define('DB_ERROR_CANNOT_DROP', -17);`	127	`define('DB_ERROR_CANNOT_DROP', -17);`
128		128
129	`/**`	129	`/**`
130	`* An identifier in the query refers to a non-existant table`	130	`* An identifier in the query refers to a non-existant table`
131	`*/`	131	`*/`
132	`define('DB_ERROR_NOSUCHTABLE', -18);`	132	`define('DB_ERROR_NOSUCHTABLE', -18);`
133		133
134	`/**`	134	`/**`
135	`* An identifier in the query refers to a non-existant column`	135	`* An identifier in the query refers to a non-existant column`
136	`*/`	136	`*/`
137	`define('DB_ERROR_NOSUCHFIELD', -19);`	137	`define('DB_ERROR_NOSUCHFIELD', -19);`
138		138
139	`/**`	139	`/**`
140	`* The data submitted to the method was inappropriate`	140	`* The data submitted to the method was inappropriate`
141	`*/`	141	`*/`
142	`define('DB_ERROR_NEED_MORE_DATA', -20);`	142	`define('DB_ERROR_NEED_MORE_DATA', -20);`
143		143
144	`/**`	144	`/**`
145	`* The attempt to lock the table failed`	145	`* The attempt to lock the table failed`
146	`*/`	146	`*/`
147	`define('DB_ERROR_NOT_LOCKED', -21);`	147	`define('DB_ERROR_NOT_LOCKED', -21);`
148		148
149	`/**`	149	`/**`
150	`* The number of columns doesn't match the number of values`	150	`* The number of columns doesn't match the number of values`
151	`*/`	151	`*/`
152	`define('DB_ERROR_VALUE_COUNT_ON_ROW', -22);`	152	`define('DB_ERROR_VALUE_COUNT_ON_ROW', -22);`
153		153
154	`/**`	154	`/**`
155	`* The DSN submitted has problems`	155	`* The DSN submitted has problems`
156	`*/`	156	`*/`
157	`define('DB_ERROR_INVALID_DSN', -23);`	157	`define('DB_ERROR_INVALID_DSN', -23);`
158		158
159	`/**`	159	`/**`
160	`* Could not connect to the database`	160	`* Could not connect to the database`
161	`*/`	161	`*/`
162	`define('DB_ERROR_CONNECT_FAILED', -24);`	162	`define('DB_ERROR_CONNECT_FAILED', -24);`
163		163
164	`/**`	164	`/**`
165	`* The PHP extension needed for this DBMS could not be found`	165	`* The PHP extension needed for this DBMS could not be found`
166	`*/`	166	`*/`
167	`define('DB_ERROR_EXTENSION_NOT_FOUND',-25);`	167	`define('DB_ERROR_EXTENSION_NOT_FOUND',-25);`
168		168
169	`/**`	169	`/**`
170	`* The present user has inadequate permissions to perform the task requestd`	170	`* The present user has inadequate permissions to perform the task requestd`
171	`*/`	171	`*/`
172	`define('DB_ERROR_ACCESS_VIOLATION', -26);`	172	`define('DB_ERROR_ACCESS_VIOLATION', -26);`
173		173
174	`/**`	174	`/**`
175	`* The database requested does not exist`	175	`* The database requested does not exist`
176	`*/`	176	`*/`
177	`define('DB_ERROR_NOSUCHDB', -27);`	177	`define('DB_ERROR_NOSUCHDB', -27);`
178		178
179	`/**`	179	`/**`
180	`* Tried to insert a null value into a column that doesn't allow nulls`	180	`* Tried to insert a null value into a column that doesn't allow nulls`
181	`*/`	181	`*/`
182	`define('DB_ERROR_CONSTRAINT_NOT_NULL',-29);`	182	`define('DB_ERROR_CONSTRAINT_NOT_NULL',-29);`
183	`/*#@-/`	183	`/*#@-/`
184		184
185		185
186	`// }}}`	186	`// }}}`
187	`// {{{ prepared statement-related`	187	`// {{{ prepared statement-related`
188		188
189		189
190	`/**#@+`	190	`/**#@+`
191	`* Identifiers for the placeholders used in prepared statements.`	191	`* Identifiers for the placeholders used in prepared statements.`
192	`* @see DB_common::prepare()`	192	`* @see DB_common::prepare()`
193	`*/`	193	`*/`
194		194
195	`/**`	195	`/**`
196	`* Indicates a scalar (<kbd>?</kbd>) placeholder was used`	196	`* Indicates a scalar (<kbd>?</kbd>) placeholder was used`
197	`*`	197	`*`
198	`* Quote and escape the value as necessary.`	198	`* Quote and escape the value as necessary.`
199	`*/`	199	`*/`
200	`define('DB_PARAM_SCALAR', 1);`	200	`define('DB_PARAM_SCALAR', 1);`
201		201
202	`/**`	202	`/**`
203	`* Indicates an opaque (<kbd>&</kbd>) placeholder was used`	203	`* Indicates an opaque (<kbd>&</kbd>) placeholder was used`
204	`*`	204	`*`
205	`* The value presented is a file name. Extract the contents of that file`	205	`* The value presented is a file name. Extract the contents of that file`
206	`* and place them in this column.`	206	`* and place them in this column.`
207	`*/`	207	`*/`
208	`define('DB_PARAM_OPAQUE', 2);`	208	`define('DB_PARAM_OPAQUE', 2);`
209		209
210	`/**`	210	`/**`
211	`* Indicates a misc (<kbd>!</kbd>) placeholder was used`	211	`* Indicates a misc (<kbd>!</kbd>) placeholder was used`
212	`*`	212	`*`
213	`* The value should not be quoted or escaped.`	213	`* The value should not be quoted or escaped.`
214	`*/`	214	`*/`
215	`define('DB_PARAM_MISC', 3);`	215	`define('DB_PARAM_MISC', 3);`
216	`/*#@-/`	216	`/*#@-/`
217		217
218		218
219	`// }}}`	219	`// }}}`
220	`// {{{ binary data-related`	220	`// {{{ binary data-related`
221		221
222		222
223	`/**#@+`	223	`/**#@+`
224	`* The different ways of returning binary data from queries.`	224	`* The different ways of returning binary data from queries.`
225	`*/`	225	`*/`
226		226
227	`/**`	227	`/**`
228	`* Sends the fetched data straight through to output`	228	`* Sends the fetched data straight through to output`
229	`*/`	229	`*/`
230	`define('DB_BINMODE_PASSTHRU', 1);`	230	`define('DB_BINMODE_PASSTHRU', 1);`
231		231
232	`/**`	232	`/**`
233	`* Lets you return data as usual`	233	`* Lets you return data as usual`
234	`*/`	234	`*/`
235	`define('DB_BINMODE_RETURN', 2);`	235	`define('DB_BINMODE_RETURN', 2);`
236		236
237	`/**`	237	`/**`
238	`* Converts the data to hex format before returning it`	238	`* Converts the data to hex format before returning it`
239	`*`	239	`*`
240	`* For example the string "123" would become "313233".`	240	`* For example the string "123" would become "313233".`
241	`*/`	241	`*/`
242	`define('DB_BINMODE_CONVERT', 3);`	242	`define('DB_BINMODE_CONVERT', 3);`
243	`/*#@-/`	243	`/*#@-/`
244		244
245		245
246	`// }}}`	246	`// }}}`
247	`// {{{ fetch modes`	247	`// {{{ fetch modes`
248		248
249		249
250	`/**#@+`	250	`/**#@+`
251	`* Fetch Modes.`	251	`* Fetch Modes.`
252	`* @see DB_common::setFetchMode()`	252	`* @see DB_common::setFetchMode()`
253	`*/`	253	`*/`
254		254
255	`/**`	255	`/**`
256	`* Indicates the current default fetch mode should be used`	256	`* Indicates the current default fetch mode should be used`
257	`* @see DB_common::$fetchmode`	257	`* @see DB_common::$fetchmode`
258	`*/`	258	`*/`
259	`define('DB_FETCHMODE_DEFAULT', 0);`	259	`define('DB_FETCHMODE_DEFAULT', 0);`
260		260
261	`/**`	261	`/**`
262	`* Column data indexed by numbers, ordered from 0 and up`	262	`* Column data indexed by numbers, ordered from 0 and up`
263	`*/`	263	`*/`
264	`define('DB_FETCHMODE_ORDERED', 1);`	264	`define('DB_FETCHMODE_ORDERED', 1);`
265		265
266	`/**`	266	`/**`
267	`* Column data indexed by column names`	267	`* Column data indexed by column names`
268	`*/`	268	`*/`
269	`define('DB_FETCHMODE_ASSOC', 2);`	269	`define('DB_FETCHMODE_ASSOC', 2);`
270		270
271	`/**`	271	`/**`
272	`* Column data as object properties`	272	`* Column data as object properties`
273	`*/`	273	`*/`
274	`define('DB_FETCHMODE_OBJECT', 3);`	274	`define('DB_FETCHMODE_OBJECT', 3);`
275		275
276	`/**`	276	`/**`
277	`* For multi-dimensional results, make the column name the first level`	277	`* For multi-dimensional results, make the column name the first level`
278	`* of the array and put the row number in the second level of the array`	278	`* of the array and put the row number in the second level of the array`
279	`*`	279	`*`
280	`* This is flipped from the normal behavior, which puts the row numbers`	280	`* This is flipped from the normal behavior, which puts the row numbers`
281	`* in the first level of the array and the column names in the second level.`	281	`* in the first level of the array and the column names in the second level.`
282	`*/`	282	`*/`
283	`define('DB_FETCHMODE_FLIPPED', 4);`	283	`define('DB_FETCHMODE_FLIPPED', 4);`
284	`/*#@-/`	284	`/*#@-/`
285		285
286	`/**#@+`	286	`/**#@+`
287	`* Old fetch modes. Left here for compatibility.`	287	`* Old fetch modes. Left here for compatibility.`
288	`*/`	288	`*/`
289	`define('DB_GETMODE_ORDERED', DB_FETCHMODE_ORDERED);`	289	`define('DB_GETMODE_ORDERED', DB_FETCHMODE_ORDERED);`
290	`define('DB_GETMODE_ASSOC', DB_FETCHMODE_ASSOC);`	290	`define('DB_GETMODE_ASSOC', DB_FETCHMODE_ASSOC);`
291	`define('DB_GETMODE_FLIPPED', DB_FETCHMODE_FLIPPED);`	291	`define('DB_GETMODE_FLIPPED', DB_FETCHMODE_FLIPPED);`
292	`/*#@-/`	292	`/*#@-/`
293		293
294		294
295	`// }}}`	295	`// }}}`
296	`// {{{ tableInfo() && autoPrepare()-related`	296	`// {{{ tableInfo() && autoPrepare()-related`
297		297
298		298
299	`/**#@+`	299	`/**#@+`
300	`* The type of information to return from the tableInfo() method.`	300	`* The type of information to return from the tableInfo() method.`
301	`*`	301	`*`
302	`* Bitwised constants, so they can be combined using <kbd>\|</kbd>`	302	`* Bitwised constants, so they can be combined using <kbd>\|</kbd>`
303	`* and removed using <kbd>^</kbd>.`	303	`* and removed using <kbd>^</kbd>.`
304	`*`	304	`*`
305	`* @see DB_common::tableInfo()`	305	`* @see DB_common::tableInfo()`
306	`*`	306	`*`
307	`* {@internal Since the TABLEINFO constants are bitwised, if more of them are`	307	`* {@internal Since the TABLEINFO constants are bitwised, if more of them are`
308	`* added in the future, make sure to adjust DB_TABLEINFO_FULL accordingly.}}`	308	`* added in the future, make sure to adjust DB_TABLEINFO_FULL accordingly.}}`
309	`*/`	309	`*/`
310	`define('DB_TABLEINFO_ORDER', 1);`	310	`define('DB_TABLEINFO_ORDER', 1);`
311	`define('DB_TABLEINFO_ORDERTABLE', 2);`	311	`define('DB_TABLEINFO_ORDERTABLE', 2);`
312	`define('DB_TABLEINFO_FULL', 3);`	312	`define('DB_TABLEINFO_FULL', 3);`
313	`/*#@-/`	313	`/*#@-/`
314		314
315		315
316	`/**#@+`	316	`/**#@+`
317	`* The type of query to create with the automatic query building methods.`	317	`* The type of query to create with the automatic query building methods.`
318	`* @see DB_common::autoPrepare(), DB_common::autoExecute()`	318	`* @see DB_common::autoPrepare(), DB_common::autoExecute()`
319	`*/`	319	`*/`
320	`define('DB_AUTOQUERY_INSERT', 1);`	320	`define('DB_AUTOQUERY_INSERT', 1);`
321	`define('DB_AUTOQUERY_UPDATE', 2);`	321	`define('DB_AUTOQUERY_UPDATE', 2);`
322	`/*#@-/`	322	`/*#@-/`
323		323
324		324
325	`// }}}`	325	`// }}}`
326	`// {{{ portability modes`	326	`// {{{ portability modes`
327		327
328		328
329	`/**#@+`	329	`/**#@+`
330	`* Portability Modes.`	330	`* Portability Modes.`
331	`*`	331	`*`
332	`* Bitwised constants, so they can be combined using <kbd>\|</kbd>`	332	`* Bitwised constants, so they can be combined using <kbd>\|</kbd>`
333	`* and removed using <kbd>^</kbd>.`	333	`* and removed using <kbd>^</kbd>.`
334	`*`	334	`*`
335	`* @see DB_common::setOption()`	335	`* @see DB_common::setOption()`
336	`*`	336	`*`
337	`* {@internal Since the PORTABILITY constants are bitwised, if more of them are`	337	`* {@internal Since the PORTABILITY constants are bitwised, if more of them are`
338	`* added in the future, make sure to adjust DB_PORTABILITY_ALL accordingly.}}`	338	`* added in the future, make sure to adjust DB_PORTABILITY_ALL accordingly.}}`
339	`*/`	339	`*/`
340		340
341	`/**`	341	`/**`
342	`* Turn off all portability features`	342	`* Turn off all portability features`
343	`*/`	343	`*/`
344	`define('DB_PORTABILITY_NONE', 0);`	344	`define('DB_PORTABILITY_NONE', 0);`
345		345
346	`/**`	346	`/**`
347	`* Convert names of tables and fields to lower case`	347	`* Convert names of tables and fields to lower case`
348	`* when using the get(), fetch() and tableInfo() methods`	348	`* when using the get(), fetch() and tableInfo() methods`
349	`*/`	349	`*/`
350	`define('DB_PORTABILITY_LOWERCASE', 1);`	350	`define('DB_PORTABILITY_LOWERCASE', 1);`
351		351
352	`/**`	352	`/**`
353	`* Right trim the data output by get() and fetch()`	353	`* Right trim the data output by get() and fetch()`
354	`*/`	354	`*/`
355	`define('DB_PORTABILITY_RTRIM', 2);`	355	`define('DB_PORTABILITY_RTRIM', 2);`
356		356
357	`/**`	357	`/**`
358	`* Force reporting the number of rows deleted`	358	`* Force reporting the number of rows deleted`
359	`*/`	359	`*/`
360	`define('DB_PORTABILITY_DELETE_COUNT', 4);`	360	`define('DB_PORTABILITY_DELETE_COUNT', 4);`
361		361
362	`/**`	362	`/**`
363	`* Enable hack that makes numRows() work in Oracle`	363	`* Enable hack that makes numRows() work in Oracle`
364	`*/`	364	`*/`
365	`define('DB_PORTABILITY_NUMROWS', 8);`	365	`define('DB_PORTABILITY_NUMROWS', 8);`
366		366
367	`/**`	367	`/**`
368	`* Makes certain error messages in certain drivers compatible`	368	`* Makes certain error messages in certain drivers compatible`
369	`* with those from other DBMS's`	369	`* with those from other DBMS's`
370	`*`	370	`*`
371	`* + mysql, mysqli: change unique/primary key constraints`	371	`* + mysql, mysqli: change unique/primary key constraints`
372	`* DB_ERROR_ALREADY_EXISTS -> DB_ERROR_CONSTRAINT`	372	`* DB_ERROR_ALREADY_EXISTS -> DB_ERROR_CONSTRAINT`
373	`*`	373	`*`
374	`* + odbc(access): MS's ODBC driver reports 'no such field' as code`	374	`* + odbc(access): MS's ODBC driver reports 'no such field' as code`
375	`* 07001, which means 'too few parameters.' When this option is on`	375	`* 07001, which means 'too few parameters.' When this option is on`
376	`* that code gets mapped to DB_ERROR_NOSUCHFIELD.`	376	`* that code gets mapped to DB_ERROR_NOSUCHFIELD.`
377	`*/`	377	`*/`
378	`define('DB_PORTABILITY_ERRORS', 16);`	378	`define('DB_PORTABILITY_ERRORS', 16);`
379		379
380	`/**`	380	`/**`
381	`* Convert null values to empty strings in data output by`	381	`* Convert null values to empty strings in data output by`
382	`* get() and fetch()`	382	`* get() and fetch()`
383	`*/`	383	`*/`
384	`define('DB_PORTABILITY_NULL_TO_EMPTY', 32);`	384	`define('DB_PORTABILITY_NULL_TO_EMPTY', 32);`
385		385
386	`/**`	386	`/**`
387	`* Turn on all portability features`	387	`* Turn on all portability features`
388	`*/`	388	`*/`
389	`define('DB_PORTABILITY_ALL', 63);`	389	`define('DB_PORTABILITY_ALL', 63);`
390	`/*#@-/`	390	`/*#@-/`
391		391
392	`// }}}`	392	`// }}}`
393		393
394		394
395	`// }}}`	395	`// }}}`
396	`// {{{ class DB`	396	`// {{{ class DB`
397		397
398	`/**`	398	`/**`
399	`* Database independent query interface`	399	`* Database independent query interface`
400	`*`	400	`*`
401	`* The main "DB" class is simply a container class with some static`	401	`* The main "DB" class is simply a container class with some static`
402	`* methods for creating DB objects as well as some utility functions`	402	`* methods for creating DB objects as well as some utility functions`
403	`* common to all parts of DB.`	403	`* common to all parts of DB.`
404	`*`	404	`*`
405	`* The object model of DB is as follows (indentation means inheritance):`	405	`* The object model of DB is as follows (indentation means inheritance):`
406	`* <pre>`	406	`* <pre>`
407	`* DB The main DB class. This is simply a utility class`	407	`* DB The main DB class. This is simply a utility class`
408	`* with some "static" methods for creating DB objects as`	408	`* with some "static" methods for creating DB objects as`
409	`* well as common utility functions for other DB classes.`	409	`* well as common utility functions for other DB classes.`
410	`*`	410	`*`
411	`* DB_common The base for each DB implementation. Provides default`	411	`* DB_common The base for each DB implementation. Provides default`
412	`* \| implementations (in OO lingo virtual methods) for`	412	`* \| implementations (in OO lingo virtual methods) for`
413	`* \| the actual DB implementations as well as a bunch of`	413	`* \| the actual DB implementations as well as a bunch of`
414	`* \| query utility functions.`	414	`* \| query utility functions.`
415	`* \|`	415	`* \|`
416	`* +-DB_mysql The DB implementation for MySQL. Inherits DB_common.`	416	`* +-DB_mysql The DB implementation for MySQL. Inherits DB_common.`
417	`* When calling DB::factory or DB::connect for MySQL`	417	`* When calling DB::factory or DB::connect for MySQL`
418	`* connections, the object returned is an instance of this`	418	`* connections, the object returned is an instance of this`
419	`* class.`	419	`* class.`
420	`* </pre>`	420	`* </pre>`
421	`*`	421	`*`
422	`* @category Database`	422	`* @category Database`
423	`* @package DB`	423	`* @package DB`
424	`* @author Stig Bakken <ssb@php.net>`	424	`* @author Stig Bakken <ssb@php.net>`
425	`* @author Tomas V.V.Cox <cox@idecnet.com>`	425	`* @author Tomas V.V.Cox <cox@idecnet.com>`
426	`* @author Daniel Convissor <danielc@php.net>`	426	`* @author Daniel Convissor <danielc@php.net>`
427	`* @copyright 1997-2005 The PHP Group`	427	`* @copyright 1997-2007 The PHP Group`
428	`* @license http://www.php.net/license/3_0.txt PHP License 3.0`	428	`* @license http://www.php.net/license/3_0.txt PHP License 3.0`
429	`* @version Release: 1.7.6`	429	`* @version Release: 1.9.2`
430	`* @link http://pear.php.net/package/DB`	430	`* @link http://pear.php.net/package/DB`
431	`*/`	431	`*/`
432	`class DB`	432	`class DB`
433	`{`	433	`{`
434	`// {{{ &factory()`	434	`// {{{ factory()`
435		435
436	`/**`	436	`/**`
437	`* Create a new DB object for the specified database type but don't`	437	`* Create a new DB object for the specified database type but don't`
438	`* connect to the database`	438	`* connect to the database`
439	`*`	439	`*`
440	`* @param string $type the database type (eg "mysql")`	440	`* @param string $type the database type (eg "mysql")`
441	`* @param array $options an associative array of option names and values`	441	`* @param array $options an associative array of option names and values`
442	`*`	442	`*`
443	`* @return object a new DB object. A DB_Error object on failure.`	443	`* @return object a new DB object. A DB_Error object on failure.`
444	`*`	444	`*`
445	`* @see DB_common::setOption()`	445	`* @see DB_common::setOption()`
446	`*/`	446	`*/`
447	`function &factory($type, $options = false)`	447	`public static function factory($type, $options = false)`
448	`{`	448	`{`
449	`if (!is_array($options)) {`	449	`if (!is_array($options)) {`
450	`$options = array('persistent' => $options);`	450	`$options = array('persistent' => $options);`
451	`}`	451	`}`
452		452
453	`if (isset($options['debug']) && $options['debug'] >= 2) {`	453	`if (isset($options['debug']) && $options['debug'] >= 2) {`
454	`// expose php errors with sufficient debug level`	454	`// expose php errors with sufficient debug level`
455	`include_once "DB/{$type}.php";`	455	`include_once "DB/{$type}.php";`
456	`} else {`	456	`} else {`
457	`@include_once "DB/{$type}.php";`	457	`@include_once "DB/{$type}.php";`
458	`}`	458	`}`
459		459
460	`$classname = "DB_${type}";`	460	`$classname = "DB_${type}";`
461		461
462	`if (!class_exists($classname)) {`	462	`if (!class_exists($classname)) {`
463	`$tmp = PEAR::raiseError(null, DB_ERROR_NOT_FOUND, null, null,`	463	`$tmp = PEAR::raiseError(null, DB_ERROR_NOT_FOUND, null, null,`
464	`"Unable to include the DB/{$type}.php"`	464	`"Unable to include the DB/{$type}.php"`
465	`. " file for '$dsn'",`	465	`. " file for '$dsn'",`
466	`'DB_Error', true);`	466	`'DB_Error', true);`
467	`return $tmp;`	467	`return $tmp;`
468	`}`	468	`}`
469		469
470	`@$obj =& new $classname;`	470	`@$obj = new $classname;`
471		471
472	`foreach ($options as $option => $value) {`	472	`foreach ($options as $option => $value) {`
473	`$test = $obj->setOption($option, $value);`	473	`$test = $obj->setOption($option, $value);`
474	`if (DB::isError($test)) {`	474	`if (DB::isError($test)) {`
475	`return $test;`	475	`return $test;`
476	`}`	476	`}`
477	`}`	477	`}`
478		478
479	`return $obj;`	479	`return $obj;`
480	`}`	480	`}`
481		481
482	`// }}}`	482	`// }}}`
483	`// {{{ &connect()`	483	`// {{{ connect()`
484		484
485	`/**`	485	`/**`
486	`* Create a new DB object including a connection to the specified database`	486	`* Create a new DB object including a connection to the specified database`
487	`*`	487	`*`
488	`* Example 1.`	488	`* Example 1.`
489	`* <code>`	489	`* <code>`
490	`* require_once 'DB.php';`	490	`* require_once 'DB.php';`
491	`*`	491	`*`
492	`* $dsn = 'pgsql://user:password@host/database';`	492	`* $dsn = 'pgsql://user:password@host/database';`
493	`* $options = array(`	493	`* $options = array(`
494	`* 'debug' => 2,`	494	`* 'debug' => 2,`
495	`* 'portability' => DB_PORTABILITY_ALL,`	495	`* 'portability' => DB_PORTABILITY_ALL,`
496	`* );`	496	`* );`
497	`*`	497	`*`
498	`* $db =& DB::connect($dsn, $options);`	498	`* $db = DB::connect($dsn, $options);`
499	`* if (PEAR::isError($db)) {`	499	`* if (PEAR::isError($db)) {`
500	`* die($db->getMessage());`	500	`* die($db->getMessage());`

Subversion Repositories Applications.gtt

(root)/trunk/bibliotheque/pear/DB.php – Rev 94 → 187