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


<?php
 
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
 
/**
 * The PEAR DB driver for PHP's mysqli extension
 * for interacting with MySQL databases
 *
 * 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     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 DB_common class so it can be extended from
 */
require_once 'DB/common.php';
 
/**
 * The methods PEAR DB uses to interact with PHP's mysqli extension
 * for interacting with MySQL databases
 *
 * This is for MySQL versions 4.1 and above.  Requires PHP 5.
 *
 * Note that persistent connections no longer exist.
 *
 * These methods overload the ones declared in DB_common.
 *
 * @category   Database
 * @package    DB
 * @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
 * @since      Class functional since Release 1.6.3
 */
class DB_mysqli extends DB_common
{
    // {{{ properties
 
    /**
     * The DB driver type (mysql, oci8, odbc, etc.)
     * @var string
     */
    var $phptype = 'mysqli';
 
    /**
     * The database syntax variant to be used (db2, access, etc.), if any
     * @var string
     */
    var $dbsyntax = 'mysqli';
 
    /**
     * The capabilities of this DB implementation
     *
     * The 'new_link' element contains the PHP version that first provided
     * new_link support for this DBMS.  Contains false if it's unsupported.
     *
     * Meaning of the 'limit' element:
     *   + 'emulate' = emulate with fetch row by number
     *   + 'alter'   = alter the query
     *   + false     = skip rows
     *
     * @var array
     */
    var $features = array(
        'limit'         => 'alter',
        'new_link'      => false,
        'numrows'       => true,
        'pconnect'      => false,
        'prepare'       => false,
        'ssl'           => true,
        'transactions'  => true,
    );
 
    /**
     * A mapping of native error codes to DB error codes
     * @var array
     */
    var $errorcode_map = array(
        1004 => DB_ERROR_CANNOT_CREATE,
        1005 => DB_ERROR_CANNOT_CREATE,
        1006 => DB_ERROR_CANNOT_CREATE,
        1007 => DB_ERROR_ALREADY_EXISTS,
        1008 => DB_ERROR_CANNOT_DROP,
        1022 => DB_ERROR_ALREADY_EXISTS,
        1044 => DB_ERROR_ACCESS_VIOLATION,
        1046 => DB_ERROR_NODBSELECTED,
        1048 => DB_ERROR_CONSTRAINT,
        1049 => DB_ERROR_NOSUCHDB,
        1050 => DB_ERROR_ALREADY_EXISTS,
        1051 => DB_ERROR_NOSUCHTABLE,
        1054 => DB_ERROR_NOSUCHFIELD,
        1061 => DB_ERROR_ALREADY_EXISTS,
        1062 => DB_ERROR_ALREADY_EXISTS,
        1064 => DB_ERROR_SYNTAX,
        1091 => DB_ERROR_NOT_FOUND,
        1100 => DB_ERROR_NOT_LOCKED,
        1136 => DB_ERROR_VALUE_COUNT_ON_ROW,
        1142 => DB_ERROR_ACCESS_VIOLATION,
        1146 => DB_ERROR_NOSUCHTABLE,
        1216 => DB_ERROR_CONSTRAINT,
        1217 => DB_ERROR_CONSTRAINT,
        1356 => DB_ERROR_DIVZERO,
        1451 => DB_ERROR_CONSTRAINT,
        1452 => DB_ERROR_CONSTRAINT,
    );
 
    /**
     * The raw database connection created by PHP
     * @var resource
     */
    var $connection;
 
    /**
     * The DSN information for connecting to a database
     * @var array
     */
    var $dsn = array();
 
 
    /**
     * Should data manipulation queries be committed automatically?
     * @var bool
     * @access private
     */
    var $autocommit = true;
 
    /**
     * The quantity of transactions begun
     *
     * {@internal  While this is private, it can't actually be designated
     * private in PHP 5 because it is directly accessed in the test suite.}}
     *
     * @var integer
     * @access private
     */
    var $transaction_opcount = 0;
 
    /**
     * The database specified in the DSN
     *
     * It's a fix to allow calls to different databases in the same script.
     *
     * @var string
     * @access private
     */
    var $_db = '';
 
    /**
     * Array for converting MYSQLI_*_FLAG constants to text values
     * @var    array
     * @access public
     * @since  Property available since Release 1.6.5
     */
    var $mysqli_flags = array(
        MYSQLI_NOT_NULL_FLAG        => 'not_null',
        MYSQLI_PRI_KEY_FLAG         => 'primary_key',
        MYSQLI_UNIQUE_KEY_FLAG      => 'unique_key',
        MYSQLI_MULTIPLE_KEY_FLAG    => 'multiple_key',
        MYSQLI_BLOB_FLAG            => 'blob',
        MYSQLI_UNSIGNED_FLAG        => 'unsigned',
        MYSQLI_ZEROFILL_FLAG        => 'zerofill',
        MYSQLI_AUTO_INCREMENT_FLAG  => 'auto_increment',
        MYSQLI_TIMESTAMP_FLAG       => 'timestamp',
        MYSQLI_SET_FLAG             => 'set',
        // MYSQLI_NUM_FLAG             => 'numeric',  // unnecessary
        // MYSQLI_PART_KEY_FLAG        => 'multiple_key',  // duplicatvie
        MYSQLI_GROUP_FLAG           => 'group_by'
    );
 
    /**
     * Array for converting MYSQLI_TYPE_* constants to text values
     * @var    array
     * @access public
     * @since  Property available since Release 1.6.5
     */
    var $mysqli_types = array(
        MYSQLI_TYPE_DECIMAL     => 'decimal',
        MYSQLI_TYPE_TINY        => 'tinyint',
        MYSQLI_TYPE_SHORT       => 'int',
        MYSQLI_TYPE_LONG        => 'int',
        MYSQLI_TYPE_FLOAT       => 'float',
        MYSQLI_TYPE_DOUBLE      => 'double',
        // MYSQLI_TYPE_NULL        => 'DEFAULT NULL',  // let flags handle it
        MYSQLI_TYPE_TIMESTAMP   => 'timestamp',
        MYSQLI_TYPE_LONGLONG    => 'bigint',
        MYSQLI_TYPE_INT24       => 'mediumint',
        MYSQLI_TYPE_DATE        => 'date',
        MYSQLI_TYPE_TIME        => 'time',
        MYSQLI_TYPE_DATETIME    => 'datetime',
        MYSQLI_TYPE_YEAR        => 'year',
        MYSQLI_TYPE_NEWDATE     => 'date',
        MYSQLI_TYPE_ENUM        => 'enum',
        MYSQLI_TYPE_SET         => 'set',
        MYSQLI_TYPE_TINY_BLOB   => 'tinyblob',
        MYSQLI_TYPE_MEDIUM_BLOB => 'mediumblob',
        MYSQLI_TYPE_LONG_BLOB   => 'longblob',
        MYSQLI_TYPE_BLOB        => 'blob',
        MYSQLI_TYPE_VAR_STRING  => 'varchar',
        MYSQLI_TYPE_STRING      => 'char',
        MYSQLI_TYPE_GEOMETRY    => 'geometry',
        /* These constants are conditionally compiled in ext/mysqli, so we'll
         * define them by number rather than constant. */
        16                      => 'bit',
        246                     => 'decimal',
    );
 
 
    // }}}
    // {{{ constructor
 
    /**
     * This constructor calls <kbd>parent::__construct()</kbd>
     *
     * @return void
     */
    function __construct()
    {
        parent::__construct();
    }
 
    // }}}
    // {{{ connect()
 
    /**
     * Connect to the database server, log in and open the database
     *
     * Don't call this method directly.  Use DB::connect() instead.
     *
     * PEAR DB's mysqli driver supports the following extra DSN options:
     *   + When the 'ssl' $option passed to DB::connect() is true:
     *     + key      The path to the key file.
     *     + cert     The path to the certificate file.
     *     + ca       The path to the certificate authority file.
     *     + capath   The path to a directory that contains trusted SSL
     *                 CA certificates in pem format.
     *     + cipher   The list of allowable ciphers for SSL encryption.
     *
     * Example of how to connect using SSL:
     * <code>
     * require_once 'DB.php';
     * 
     * $dsn = array(
     *     'phptype'  => 'mysqli',
     *     'username' => 'someuser',
     *     'password' => 'apasswd',
     *     'hostspec' => 'localhost',
     *     'database' => 'thedb',
     *     'key'      => 'client-key.pem',
     *     'cert'     => 'client-cert.pem',
     *     'ca'       => 'cacert.pem',
     *     'capath'   => '/path/to/ca/dir',
     *     'cipher'   => 'AES',
     * );
     * 
     * $options = array(
     *     'ssl' => true,
     * );
     * 
     * $db = DB::connect($dsn, $options);
     * if (PEAR::isError($db)) {
     *     die($db->getMessage());
     * }
     * </code>
     *
     * @param array $dsn         the data source name
     * @param bool  $persistent  should the connection be persistent?
     *
     * @return int  DB_OK on success. A DB_Error object on failure.
     */
    function connect($dsn, $persistent = false)
    {
        if (!PEAR::loadExtension('mysqli')) {
            return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
        }
 
        $this->dsn = $dsn;
        if ($dsn['dbsyntax']) {
            $this->dbsyntax = $dsn['dbsyntax'];
        }
 
        $ini = ini_get('track_errors');
        @ini_set('track_errors', 1);
        $php_errormsg = '';
 
        if (((int) $this->getOption('ssl')) === 1) {
            $init = mysqli_init();
            mysqli_ssl_set(
                $init,
                empty($dsn['key'])    ? null : $dsn['key'],
                empty($dsn['cert'])   ? null : $dsn['cert'],
                empty($dsn['ca'])     ? null : $dsn['ca'],
                empty($dsn['capath']) ? null : $dsn['capath'],
                empty($dsn['cipher']) ? null : $dsn['cipher']
            );
            if ($this->connection = @mysqli_real_connect(
                    $init,
                    $dsn['hostspec'],
                    $dsn['username'],
                    $dsn['password'],
                    $dsn['database'],
                    $dsn['port'],
                    $dsn['socket']))
            {
                $this->connection = $init;
            }
        } else {
            $this->connection = @mysqli_connect(
                $dsn['hostspec'],
                $dsn['username'],
                $dsn['password'],
                $dsn['database'],
                $dsn['port'],
                $dsn['socket']
            );
        }
 
        @ini_set('track_errors', $ini);
 
        if (!$this->connection) {
            if (($err = @mysqli_connect_error()) != '') {
                return $this->raiseError(DB_ERROR_CONNECT_FAILED,
                                         null, null, null,
                                         $err);
            } else {
                return $this->raiseError(DB_ERROR_CONNECT_FAILED,
                                         null, null, null,
                                         $php_errormsg);
            }
        }
 
        if ($dsn['database']) {
            $this->_db = $dsn['database'];
        }
 
        return DB_OK;
    }
 
    // }}}
    // {{{ disconnect()
 
    /**
     * Disconnects from the database server
     *
     * @return bool  TRUE on success, FALSE on failure
     */
    function disconnect()
    {
        $ret = @mysqli_close($this->connection);
        $this->connection = null;
        return $ret;
    }
 
    // }}}
    // {{{ simpleQuery()
 
    /**
     * Sends a query to the database server
     *
     * @param string  the SQL query string
     *
     * @return mixed  + a PHP result resrouce for successful SELECT queries
     *                + the DB_OK constant for other successful queries
     *                + a DB_Error object on failure
     */
    function simpleQuery($query)
    {
        $ismanip = $this->_checkManip($query);
        $this->last_query = $query;
        $query = $this->modifyQuery($query);
        if ($this->_db) {
            if (!@mysqli_select_db($this->connection, $this->_db)) {
                return $this->mysqliRaiseError(DB_ERROR_NODBSELECTED);
            }
        }
        if (!$this->autocommit && $ismanip) {
            if ($this->transaction_opcount == 0) {
                $result = @mysqli_query($this->connection, 'SET AUTOCOMMIT=0');
                $result = @mysqli_query($this->connection, 'BEGIN');
                if (!$result) {
                    return $this->mysqliRaiseError();
                }
            }
            $this->transaction_opcount++;
        }
        $result = @mysqli_query($this->connection, $query);
        if (!$result) {
            return $this->mysqliRaiseError();
        }
        if (is_object($result)) {
            return $result;
        }
        return DB_OK;
    }
 
    // }}}
    // {{{ nextResult()
 
    /**
     * Move the internal mysql result pointer to the next available result.
     *
     * This method has not been implemented yet.
     *
     * @param resource $result a valid sql result resource
     * @return false
     * @access public
     */
    function nextResult($result)
    {
        return false;
    }
 
    // }}}
    // {{{ fetchInto()
 
    /**
     * Places a row from the result set into the given array
     *
     * Formating of the array and the data therein are configurable.
     * See DB_result::fetchInto() for more information.
     *
     * This method is not meant to be called directly.  Use
     * DB_result::fetchInto() instead.  It can't be declared "protected"
     * because DB_result is a separate object.
     *
     * @param resource $result    the query result resource
     * @param array    $arr       the referenced array to put the data in
     * @param int      $fetchmode how the resulting array should be indexed
     * @param int      $rownum    the row number to fetch (0 = first row)
     *
     * @return mixed  DB_OK on success, NULL when the end of a result set is
     *                 reached or on failure
     *
     * @see DB_result::fetchInto()
     */
    function fetchInto($result, &$arr, $fetchmode, $rownum = null)
    {
        if ($rownum !== null) {
            if (!@mysqli_data_seek($result, $rownum)) {
                return null;
            }
        }
        if ($fetchmode & DB_FETCHMODE_ASSOC) {
            $arr = @mysqli_fetch_array($result, MYSQLI_ASSOC);
            if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {
                $arr = array_change_key_case($arr, CASE_LOWER);
            }
        } else {
            $arr = @mysqli_fetch_row($result);
        }
        if (!$arr) {
            return null;
        }
        if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {
            /*
             * Even though this DBMS already trims output, we do this because
             * a field might have intentional whitespace at the end that
             * gets removed by DB_PORTABILITY_RTRIM under another driver.
             */
            $this->_rtrimArrayValues($arr);
        }
        if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {
            $this->_convertNullArrayValuesToEmpty($arr);
        }
        return DB_OK;
    }
 
    // }}}
    // {{{ freeResult()
 
    /**
     * Deletes the result set and frees the memory occupied by the result set
     *
     * This method is not meant to be called directly.  Use
     * DB_result::free() instead.  It can't be declared "protected"
     * because DB_result is a separate object.
     *
     * @param resource $result  PHP's query result resource
     *
     * @return bool  TRUE on success, FALSE if $result is invalid
     *
     * @see DB_result::free()
     */
    function freeResult($result)
    {
        if (! $result instanceof mysqli_result) {
            return false;
        }
        mysqli_free_result($result);
        return true;
    }
 
    // }}}
    // {{{ numCols()
 
    /**
     * Gets the number of columns in a result set
     *
     * This method is not meant to be called directly.  Use
     * DB_result::numCols() instead.  It can't be declared "protected"
     * because DB_result is a separate object.
     *
     * @param resource $result  PHP's query result resource
     *
     * @return int  the number of columns.  A DB_Error object on failure.
     *
     * @see DB_result::numCols()
     */
    function numCols($result)
    {
        $cols = @mysqli_num_fields($result);
        if (!$cols) {
            return $this->mysqliRaiseError();
        }
        return $cols;
    }
 
    // }}}
    // {{{ numRows()
 
    /**
     * Gets the number of rows in a result set
     *
     * This method is not meant to be called directly.  Use
     * DB_result::numRows() instead.  It can't be declared "protected"
     * because DB_result is a separate object.
     *
     * @param resource $result  PHP's query result resource
     *
     * @return int  the number of rows.  A DB_Error object on failure.
     *
     * @see DB_result::numRows()
     */
    function numRows($result)
    {
        $rows = @mysqli_num_rows($result);
        if ($rows === null) {
            return $this->mysqliRaiseError();
        }
        return $rows;
    }
 
    // }}}
    // {{{ autoCommit()
 
    /**
     * Enables or disables automatic commits
     *
     * @param bool $onoff  true turns it on, false turns it off
     *
     * @return int  DB_OK on success.  A DB_Error object if the driver
     *               doesn't support auto-committing transactions.
     */
    function autoCommit($onoff = false)
    {
        // XXX if $this->transaction_opcount > 0, we should probably
        // issue a warning here.
        $this->autocommit = $onoff ? true : false;
        return DB_OK;
    }
 
    // }}}
    // {{{ commit()
 
    /**
     * Commits the current transaction
     *
     * @return int  DB_OK on success.  A DB_Error object on failure.
     */
    function commit()
    {
        if ($this->transaction_opcount > 0) {
            if ($this->_db) {
                if (!@mysqli_select_db($this->connection, $this->_db)) {
                    return $this->mysqliRaiseError(DB_ERROR_NODBSELECTED);
                }
            }
            $result = @mysqli_query($this->connection, 'COMMIT');
            $result = @mysqli_query($this->connection, 'SET AUTOCOMMIT=1');
            $this->transaction_opcount = 0;
            if (!$result) {
                return $this->mysqliRaiseError();
            }
        }
        return DB_OK;
    }
 
    // }}}
    // {{{ rollback()
 
    /**
     * Reverts the current transaction
     *
     * @return int  DB_OK on success.  A DB_Error object on failure.
     */
    function rollback()
    {
        if ($this->transaction_opcount > 0) {
            if ($this->_db) {
                if (!@mysqli_select_db($this->connection, $this->_db)) {
                    return $this->mysqliRaiseError(DB_ERROR_NODBSELECTED);
                }
            }
            $result = @mysqli_query($this->connection, 'ROLLBACK');
            $result = @mysqli_query($this->connection, 'SET AUTOCOMMIT=1');
            $this->transaction_opcount = 0;
            if (!$result) {
                return $this->mysqliRaiseError();
            }
        }
        return DB_OK;
    }
 
    // }}}
    // {{{ affectedRows()
 
    /**
     * Determines the number of rows affected by a data maniuplation query
     *
     * 0 is returned for queries that don't manipulate data.
     *
     * @return int  the number of rows.  A DB_Error object on failure.
     */
    function affectedRows()
    {
        if ($this->_last_query_manip) {
            return @mysqli_affected_rows($this->connection);
        } else {
            return 0;
        }
     }
 
    // }}}
    // {{{ nextId()
 
    /**
     * Returns the next free id in a sequence
     *
     * @param string  $seq_name  name of the sequence
     * @param boolean $ondemand  when true, the seqence is automatically
     *                            created if it does not exist
     *
     * @return int  the next id number in the sequence.
     *               A DB_Error object on failure.
     *
     * @see DB_common::nextID(), DB_common::getSequenceName(),
     *      DB_mysqli::createSequence(), DB_mysqli::dropSequence()
     */
    function nextId($seq_name, $ondemand = true)
    {
        $seqname = $this->getSequenceName($seq_name);
        do {
            $repeat = 0;
            $this->pushErrorHandling(PEAR_ERROR_RETURN);
            $result = $this->query('UPDATE ' . $seqname
                                   . ' SET id = LAST_INSERT_ID(id + 1)');
            $this->popErrorHandling();
            if ($result === DB_OK) {
                // COMMON CASE
                $id = @mysqli_insert_id($this->connection);
                if ($id != 0) {
                    return $id;
                }
 
                // EMPTY SEQ TABLE
                // Sequence table must be empty for some reason,
                // so fill it and return 1
                // Obtain a user-level lock
                $result = $this->getOne('SELECT GET_LOCK('
                                        . "'${seqname}_lock', 10)");
                if (DB::isError($result)) {
                    return $this->raiseError($result);
                }
                if ($result == 0) {
                    return $this->mysqliRaiseError(DB_ERROR_NOT_LOCKED);
                }
 
                // add the default value
                $result = $this->query('REPLACE INTO ' . $seqname
                                       . ' (id) VALUES (0)');
                if (DB::isError($result)) {
                    return $this->raiseError($result);
                }
 
                // Release the lock
                $result = $this->getOne('SELECT RELEASE_LOCK('
                                        . "'${seqname}_lock')");
                if (DB::isError($result)) {
                    return $this->raiseError($result);
                }
                // We know what the result will be, so no need to try again
                return 1;
 
            } elseif ($ondemand && DB::isError($result) &&
                $result->getCode() == DB_ERROR_NOSUCHTABLE)
            {
                // ONDEMAND TABLE CREATION
                $result = $this->createSequence($seq_name);
 
                // Since createSequence initializes the ID to be 1,
                // we do not need to retrieve the ID again (or we will get 2)
                if (DB::isError($result)) {
                    return $this->raiseError($result);
                } else {
                    // First ID of a newly created sequence is 1
                    return 1;
                }
 
            } elseif (DB::isError($result) &&
                      $result->getCode() == DB_ERROR_ALREADY_EXISTS)
            {
                // BACKWARDS COMPAT
                // see _BCsequence() comment
                $result = $this->_BCsequence($seqname);
                if (DB::isError($result)) {
                    return $this->raiseError($result);
                }
                $repeat = 1;
            }
        } while ($repeat);
 
        return $this->raiseError($result);
    }
 
    /**
     * Creates a new sequence
     *
     * @param string $seq_name  name of the new sequence
     *
     * @return int  DB_OK on success.  A DB_Error object on failure.
     *
     * @see DB_common::createSequence(), DB_common::getSequenceName(),
     *      DB_mysqli::nextID(), DB_mysqli::dropSequence()
     */
    function createSequence($seq_name)
    {
        $seqname = $this->getSequenceName($seq_name);
        $res = $this->query('CREATE TABLE ' . $seqname
                            . ' (id INTEGER UNSIGNED AUTO_INCREMENT NOT NULL,'
                            . ' PRIMARY KEY(id))');
        if (DB::isError($res)) {
            return $res;
        }
        // insert yields value 1, nextId call will generate ID 2
        return $this->query("INSERT INTO ${seqname} (id) VALUES (0)");
    }
 
    // }}}
    // {{{ dropSequence()
 
    /**
     * Deletes a sequence
     *
     * @param string $seq_name  name of the sequence to be deleted
     *
     * @return int  DB_OK on success.  A DB_Error object on failure.
     *
     * @see DB_common::dropSequence(), DB_common::getSequenceName(),
     *      DB_mysql::nextID(), DB_mysql::createSequence()
     */
    function dropSequence($seq_name)
    {
        return $this->query('DROP TABLE ' . $this->getSequenceName($seq_name));
    }
 
    // }}}
    // {{{ _BCsequence()
 
    /**
     * Backwards compatibility with old sequence emulation implementation
     * (clean up the dupes)
     *
     * @param string $seqname  the sequence name to clean up
     *
     * @return bool  true on success.  A DB_Error object on failure.
     *
     * @access private
     */
    function _BCsequence($seqname)
    {
        // Obtain a user-level lock... this will release any previous
        // application locks, but unlike LOCK TABLES, it does not abort
        // the current transaction and is much less frequently used.
        $result = $this->getOne("SELECT GET_LOCK('${seqname}_lock',10)");
        if (DB::isError($result)) {
            return $result;
        }
        if ($result == 0) {
            // Failed to get the lock, can't do the conversion, bail
            // with a DB_ERROR_NOT_LOCKED error
            return $this->mysqliRaiseError(DB_ERROR_NOT_LOCKED);
        }
 
        $highest_id = $this->getOne("SELECT MAX(id) FROM ${seqname}");
        if (DB::isError($highest_id)) {
            return $highest_id;
        }
 
        // This should kill all rows except the highest
        // We should probably do something if $highest_id isn't
        // numeric, but I'm at a loss as how to handle that...
        $result = $this->query('DELETE FROM ' . $seqname
                               . " WHERE id <> $highest_id");
        if (DB::isError($result)) {
            return $result;
        }
 
        // If another thread has been waiting for this lock,
        // it will go thru the above procedure, but will have no
        // real effect
        $result = $this->getOne("SELECT RELEASE_LOCK('${seqname}_lock')");
        if (DB::isError($result)) {
            return $result;
        }
        return true;
    }
 
    // }}}
    // {{{ quoteIdentifier()
 
    /**
     * Quotes a string so it can be safely used as a table or column name
     * (WARNING: using names that require this is a REALLY BAD IDEA)
     *
     * WARNING:  Older versions of MySQL can't handle the backtick
     * character (<kbd>`</kbd>) in table or column names.
     *
     * @param string $str  identifier name to be quoted
     *
     * @return string  quoted identifier string
     *
     * @see DB_common::quoteIdentifier()
     * @since Method available since Release 1.6.0
     */
    function quoteIdentifier($str)
    {
        return '`' . str_replace('`', '``', $str) . '`';
    }
 
    // }}}
    // {{{ escapeSimple()
 
    /**
     * Escapes a string according to the current DBMS's standards
     *
     * @param string $str  the string to be escaped
     *
     * @return string  the escaped string
     *
     * @see DB_common::quoteSmart()
     * @since Method available since Release 1.6.0
     */
    function escapeSimple($str)
    {
        return @mysqli_real_escape_string($this->connection, $str);
    }
 
    // }}}
    // {{{ modifyLimitQuery()
 
    /**
     * Adds LIMIT clauses to a query string according to current DBMS standards
     *
     * @param string $query   the query to modify
     * @param int    $from    the row to start to fetching (0 = the first row)
     * @param int    $count   the numbers of rows to fetch
     * @param mixed  $params  array, string or numeric data to be used in
     *                         execution of the statement.  Quantity of items
     *                         passed must match quantity of placeholders in
     *                         query:  meaning 1 placeholder for non-array
     *                         parameters or 1 placeholder per array element.
     *
     * @return string  the query string with LIMIT clauses added
     *
     * @access protected
     */
    function modifyLimitQuery($query, $from, $count, $params = array())
    {
        if (DB::isManip($query) || $this->_next_query_manip) {
            return $query . " LIMIT $count";
        } else {
            return $query . " LIMIT $from, $count";
        }
    }
 
    // }}}
    // {{{ mysqliRaiseError()
 
    /**
     * Produces a DB_Error object regarding the current problem
     *
     * @param int $errno  if the error is being manually raised pass a
     *                     DB_ERROR* constant here.  If this isn't passed
     *                     the error information gathered from the DBMS.
     *
     * @return object  the DB_Error object
     *
     * @see DB_common::raiseError(),
     *      DB_mysqli::errorNative(), DB_common::errorCode()
     */
    function mysqliRaiseError($errno = null)
    {
        if ($errno === null) {
            if ($this->options['portability'] & DB_PORTABILITY_ERRORS) {
                $this->errorcode_map[1022] = DB_ERROR_CONSTRAINT;
                $this->errorcode_map[1048] = DB_ERROR_CONSTRAINT_NOT_NULL;
                $this->errorcode_map[1062] = DB_ERROR_CONSTRAINT;
            } else {
                // Doing this in case mode changes during runtime.
                $this->errorcode_map[1022] = DB_ERROR_ALREADY_EXISTS;
                $this->errorcode_map[1048] = DB_ERROR_CONSTRAINT;
                $this->errorcode_map[1062] = DB_ERROR_ALREADY_EXISTS;
            }
            $errno = $this->errorCode(mysqli_errno($this->connection));
        }
        return $this->raiseError($errno, null, null, null,
                                 @mysqli_errno($this->connection) . ' ** ' .
                                 @mysqli_error($this->connection));
    }
 
    // }}}
    // {{{ errorNative()
 
    /**
     * Gets the DBMS' native error code produced by the last query
     *
     * @return int  the DBMS' error code
     */
    function errorNative()
    {
        return @mysqli_errno($this->connection);
    }
 
    // }}}
    // {{{ tableInfo()
 
    /**
     * Returns information about a table or a result set
     *
     * @param object|string  $result  DB_result object from a query or a
     *                                 string containing the name of a table.
     *                                 While this also accepts a query result
     *                                 resource identifier, this behavior is
     *                                 deprecated.
     * @param int            $mode    a valid tableInfo mode
     *
     * @return array  an associative array with the information requested.
     *                 A DB_Error object on failure.
     *
     * @see DB_common::setOption()
     */
    function tableInfo($result, $mode = null)
    {
        if (is_string($result)) {
            // Fix for bug #11580.
            if ($this->_db) {
                if (!@mysqli_select_db($this->connection, $this->_db)) {
                    return $this->mysqliRaiseError(DB_ERROR_NODBSELECTED);
                }
            }
 
            /*
             * Probably received a table name.
             * Create a result resource identifier.
             */
            $id = @mysqli_query($this->connection,
                                "SELECT * FROM $result LIMIT 0");
            $got_string = true;
        } elseif (isset($result->result)) {
            /*
             * Probably received a result object.
             * Extract the result resource identifier.
             */
            $id = $result->result;
            $got_string = false;
        } else {
            /*
             * Probably received a result resource identifier.
             * Copy it.
             * Deprecated.  Here for compatibility only.
             */
            $id = $result;
            $got_string = false;
        }
 
        if (!is_object($id) || !is_a($id, 'mysqli_result')) {
            return $this->mysqliRaiseError(DB_ERROR_NEED_MORE_DATA);
        }
 
        if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE) {
            $case_func = 'strtolower';
        } else {
            $case_func = 'strval';
        }
 
        $count = @mysqli_num_fields($id);
        $res   = array();
 
        if ($mode) {
            $res['num_fields'] = $count;
        }
 
        for ($i = 0; $i < $count; $i++) {
            $tmp = @mysqli_fetch_field($id);
 
            $flags = '';
            foreach ($this->mysqli_flags as $const => $means) {
                if ($tmp->flags & $const) {
                    $flags .= $means . ' ';
                }
            }
            if ($tmp->def) {
                $flags .= 'default_' . rawurlencode($tmp->def);
            }
            $flags = trim($flags);
 
            $res[$i] = array(
                'table' => $case_func($tmp->table),
                'name'  => $case_func($tmp->name),
                'type'  => isset($this->mysqli_types[$tmp->type])
                                    ? $this->mysqli_types[$tmp->type]
                                    : 'unknown',
                // http://bugs.php.net/?id=36579
                //  Doc Bug #36579: mysqli_fetch_field length handling
                // https://bugs.php.net/bug.php?id=62426
                //  Bug #62426: mysqli_fetch_field_direct returns incorrect
                //  length on UTF8 fields
                'len'   => $tmp->length,
                'flags' => $flags,
            );
 
            if ($mode & DB_TABLEINFO_ORDER) {
                $res['order'][$res[$i]['name']] = $i;
            }
            if ($mode & DB_TABLEINFO_ORDERTABLE) {
                $res['ordertable'][$res[$i]['table']][$res[$i]['name']] = $i;
            }
        }
 
        // free the result only if we were called on a table
        if ($got_string) {
            @mysqli_free_result($id);
        }
        return $res;
    }
 
    // }}}
    // {{{ getSpecialQuery()
 
    /**
     * Obtains the query string needed for listing a given type of objects
     *
     * @param string $type  the kind of objects you want to retrieve
     *
     * @return string  the SQL query string or null if the driver doesn't
     *                  support the object type requested
     *
     * @access protected
     * @see DB_common::getListOf()
     */
    function getSpecialQuery($type)
    {
        switch ($type) {
            case 'tables':
                return 'SHOW TABLES';
            case 'users':
                return 'SELECT DISTINCT User FROM mysql.user';
            case 'databases':
                return 'SHOW DATABASES';
            default:
                return null;
        }
    }
 
    // }}}
 
}
 
/*
 * 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	`* The PEAR DB driver for PHP's mysqli extension`	6	`* The PEAR DB driver for PHP's mysqli extension`
7	`* for interacting with MySQL databases`	7	`* for interacting with MySQL databases`
8	`*`	8	`*`
9	`* PHP versions 4 and 5`	9	`* PHP version 5`
10	`*`	10	`*`
11	`* LICENSE: This source file is subject to version 3.0 of the PHP license`	11	`* LICENSE: This source file is subject to version 3.0 of the PHP license`
12	`* that is available through the world-wide-web at the following URI:`	12	`* that is available through the world-wide-web at the following URI:`
13	`* http://www.php.net/license/3_0.txt. If you did not receive a copy of`	13	`* http://www.php.net/license/3_0.txt. If you did not receive a copy of`
14	`* the PHP License and are unable to obtain it through the web, please`	14	`* the PHP License and are unable to obtain it through the web, please`
15	`* send a note to license@php.net so we can mail you a copy immediately.`	15	`* send a note to license@php.net so we can mail you a copy immediately.`
16	`*`	16	`*`
17	`* @category Database`	17	`* @category Database`
18	`* @package DB`	18	`* @package DB`
19	`* @author Daniel Convissor <danielc@php.net>`	19	`* @author Daniel Convissor <danielc@php.net>`
20	`* @copyright 1997-2005 The PHP Group`	20	`* @copyright 1997-2007 The PHP Group`
21	`* @license http://www.php.net/license/3_0.txt PHP License 3.0`	21	`* @license http://www.php.net/license/3_0.txt PHP License 3.0`
22	`* @version CVS: $Id: mysqli.php,v 1.69 2005/03/04 23:12:36 danielc Exp $`	22	`* @version CVS: $Id$`
23	`* @link http://pear.php.net/package/DB`	23	`* @link http://pear.php.net/package/DB`
24	`*/`	24	`*/`
25		25
26	`/**`	26	`/**`
27	`* Obtain the DB_common class so it can be extended from`	27	`* Obtain the DB_common class so it can be extended from`
28	`*/`	28	`*/`
29	`require_once 'DB/common.php';`	29	`require_once 'DB/common.php';`
30		30
31	`/**`	31	`/**`
32	`* The methods PEAR DB uses to interact with PHP's mysqli extension`	32	`* The methods PEAR DB uses to interact with PHP's mysqli extension`
33	`* for interacting with MySQL databases`	33	`* for interacting with MySQL databases`
34	`*`	34	`*`
35	`* This is for MySQL versions 4.1 and above. Requires PHP 5.`	35	`* This is for MySQL versions 4.1 and above. Requires PHP 5.`
36	`*`	36	`*`
37	`* Note that persistent connections no longer exist.`	37	`* Note that persistent connections no longer exist.`
38	`*`	38	`*`
39	`* These methods overload the ones declared in DB_common.`	39	`* These methods overload the ones declared in DB_common.`
40	`*`	40	`*`
41	`* @category Database`	41	`* @category Database`
42	`* @package DB`	42	`* @package DB`
43	`* @author Daniel Convissor <danielc@php.net>`	43	`* @author Daniel Convissor <danielc@php.net>`
44	`* @copyright 1997-2005 The PHP Group`	44	`* @copyright 1997-2007 The PHP Group`
45	`* @license http://www.php.net/license/3_0.txt PHP License 3.0`	45	`* @license http://www.php.net/license/3_0.txt PHP License 3.0`
46	`* @version Release: 1.7.6`	46	`* @version Release: 1.9.2`
47	`* @link http://pear.php.net/package/DB`	47	`* @link http://pear.php.net/package/DB`
48	`* @since Class functional since Release 1.6.3`	48	`* @since Class functional since Release 1.6.3`
49	`*/`	49	`*/`
50	`class DB_mysqli extends DB_common`	50	`class DB_mysqli extends DB_common`
51	`{`	51	`{`
52	`// {{{ properties`	52	`// {{{ properties`
53		53
54	`/**`	54	`/**`
55	`* The DB driver type (mysql, oci8, odbc, etc.)`	55	`* The DB driver type (mysql, oci8, odbc, etc.)`
56	`* @var string`	56	`* @var string`
57	`*/`	57	`*/`
58	`var $phptype = 'mysqli';`	58	`var $phptype = 'mysqli';`
59		59
60	`/**`	60	`/**`
61	`* The database syntax variant to be used (db2, access, etc.), if any`	61	`* The database syntax variant to be used (db2, access, etc.), if any`
62	`* @var string`	62	`* @var string`
63	`*/`	63	`*/`
64	`var $dbsyntax = 'mysqli';`	64	`var $dbsyntax = 'mysqli';`
65		65
66	`/**`	66	`/**`
67	`* The capabilities of this DB implementation`	67	`* The capabilities of this DB implementation`
68	`*`	68	`*`
69	`* The 'new_link' element contains the PHP version that first provided`	69	`* The 'new_link' element contains the PHP version that first provided`
70	`* new_link support for this DBMS. Contains false if it's unsupported.`	70	`* new_link support for this DBMS. Contains false if it's unsupported.`
71	`*`	71	`*`
72	`* Meaning of the 'limit' element:`	72	`* Meaning of the 'limit' element:`
73	`* + 'emulate' = emulate with fetch row by number`	73	`* + 'emulate' = emulate with fetch row by number`
74	`* + 'alter' = alter the query`	74	`* + 'alter' = alter the query`
75	`* + false = skip rows`	75	`* + false = skip rows`
76	`*`	76	`*`
77	`* @var array`	77	`* @var array`
78	`*/`	78	`*/`
79	`var $features = array(`	79	`var $features = array(`
80	`'limit' => 'alter',`	80	`'limit' => 'alter',`
81	`'new_link' => false,`	81	`'new_link' => false,`
82	`'numrows' => true,`	82	`'numrows' => true,`
83	`'pconnect' => false,`	83	`'pconnect' => false,`
84	`'prepare' => false,`	84	`'prepare' => false,`
85	`'ssl' => true,`	85	`'ssl' => true,`
86	`'transactions' => true,`	86	`'transactions' => true,`
87	`);`	87	`);`
88		88
89	`/**`	89	`/**`
90	`* A mapping of native error codes to DB error codes`	90	`* A mapping of native error codes to DB error codes`
91	`* @var array`	91	`* @var array`
92	`*/`	92	`*/`
93	`var $errorcode_map = array(`	93	`var $errorcode_map = array(`
94	`1004 => DB_ERROR_CANNOT_CREATE,`	94	`1004 => DB_ERROR_CANNOT_CREATE,`
95	`1005 => DB_ERROR_CANNOT_CREATE,`	95	`1005 => DB_ERROR_CANNOT_CREATE,`
96	`1006 => DB_ERROR_CANNOT_CREATE,`	96	`1006 => DB_ERROR_CANNOT_CREATE,`
97	`1007 => DB_ERROR_ALREADY_EXISTS,`	97	`1007 => DB_ERROR_ALREADY_EXISTS,`
98	`1008 => DB_ERROR_CANNOT_DROP,`	98	`1008 => DB_ERROR_CANNOT_DROP,`
99	`1022 => DB_ERROR_ALREADY_EXISTS,`	99	`1022 => DB_ERROR_ALREADY_EXISTS,`
100	`1044 => DB_ERROR_ACCESS_VIOLATION,`	100	`1044 => DB_ERROR_ACCESS_VIOLATION,`
101	`1046 => DB_ERROR_NODBSELECTED,`	101	`1046 => DB_ERROR_NODBSELECTED,`
102	`1048 => DB_ERROR_CONSTRAINT,`	102	`1048 => DB_ERROR_CONSTRAINT,`
103	`1049 => DB_ERROR_NOSUCHDB,`	103	`1049 => DB_ERROR_NOSUCHDB,`
104	`1050 => DB_ERROR_ALREADY_EXISTS,`	104	`1050 => DB_ERROR_ALREADY_EXISTS,`
105	`1051 => DB_ERROR_NOSUCHTABLE,`	105	`1051 => DB_ERROR_NOSUCHTABLE,`
106	`1054 => DB_ERROR_NOSUCHFIELD,`	106	`1054 => DB_ERROR_NOSUCHFIELD,`
107	`1061 => DB_ERROR_ALREADY_EXISTS,`	107	`1061 => DB_ERROR_ALREADY_EXISTS,`
108	`1062 => DB_ERROR_ALREADY_EXISTS,`	108	`1062 => DB_ERROR_ALREADY_EXISTS,`
109	`1064 => DB_ERROR_SYNTAX,`	109	`1064 => DB_ERROR_SYNTAX,`
110	`1091 => DB_ERROR_NOT_FOUND,`	110	`1091 => DB_ERROR_NOT_FOUND,`
111	`1100 => DB_ERROR_NOT_LOCKED,`	111	`1100 => DB_ERROR_NOT_LOCKED,`
112	`1136 => DB_ERROR_VALUE_COUNT_ON_ROW,`	112	`1136 => DB_ERROR_VALUE_COUNT_ON_ROW,`
113	`1142 => DB_ERROR_ACCESS_VIOLATION,`	113	`1142 => DB_ERROR_ACCESS_VIOLATION,`
114	`1146 => DB_ERROR_NOSUCHTABLE,`	114	`1146 => DB_ERROR_NOSUCHTABLE,`
115	`1216 => DB_ERROR_CONSTRAINT,`	115	`1216 => DB_ERROR_CONSTRAINT,`
116	`1217 => DB_ERROR_CONSTRAINT,`	116	`1217 => DB_ERROR_CONSTRAINT,`
-		117	`1356 => DB_ERROR_DIVZERO,`
-		118	`1451 => DB_ERROR_CONSTRAINT,`
-		119	`1452 => DB_ERROR_CONSTRAINT,`
117	`);`	120	`);`
118		121
119	`/**`	122	`/**`
120	`* The raw database connection created by PHP`	123	`* The raw database connection created by PHP`
121	`* @var resource`	124	`* @var resource`
122	`*/`	125	`*/`
123	`var $connection;`	126	`var $connection;`
124		127
125	`/**`	128	`/**`
126	`* The DSN information for connecting to a database`	129	`* The DSN information for connecting to a database`
127	`* @var array`	130	`* @var array`
128	`*/`	131	`*/`
129	`var $dsn = array();`	132	`var $dsn = array();`
130		133
131		134
132	`/**`	135	`/**`
133	`* Should data manipulation queries be committed automatically?`	136	`* Should data manipulation queries be committed automatically?`
134	`* @var bool`	137	`* @var bool`
135	`* @access private`	138	`* @access private`
136	`*/`	139	`*/`
137	`var $autocommit = true;`	140	`var $autocommit = true;`
138		141
139	`/**`	142	`/**`
140	`* The quantity of transactions begun`	143	`* The quantity of transactions begun`
141	`*`	144	`*`
142	`* {@internal While this is private, it can't actually be designated`	145	`* {@internal While this is private, it can't actually be designated`
143	`* private in PHP 5 because it is directly accessed in the test suite.}}`	146	`* private in PHP 5 because it is directly accessed in the test suite.}}`
144	`*`	147	`*`
145	`* @var integer`	148	`* @var integer`
146	`* @access private`	149	`* @access private`
147	`*/`	150	`*/`
148	`var $transaction_opcount = 0;`	151	`var $transaction_opcount = 0;`
149		152
150	`/**`	153	`/**`
151	`* The database specified in the DSN`	154	`* The database specified in the DSN`
152	`*`	155	`*`
153	`* It's a fix to allow calls to different databases in the same script.`	156	`* It's a fix to allow calls to different databases in the same script.`
154	`*`	157	`*`
155	`* @var string`	158	`* @var string`
156	`* @access private`	159	`* @access private`
157	`*/`	160	`*/`
158	`var $_db = '';`	161	`var $_db = '';`
159		162
160	`/**`	163	`/**`
161	`* Array for converting MYSQLI_*_FLAG constants to text values`	164	`* Array for converting MYSQLI_*_FLAG constants to text values`
162	`* @var array`	165	`* @var array`
163	`* @access public`	166	`* @access public`
164	`* @since Property available since Release 1.6.5`	167	`* @since Property available since Release 1.6.5`
165	`*/`	168	`*/`
166	`var $mysqli_flags = array(`	169	`var $mysqli_flags = array(`
167	`MYSQLI_NOT_NULL_FLAG => 'not_null',`	170	`MYSQLI_NOT_NULL_FLAG => 'not_null',`
168	`MYSQLI_PRI_KEY_FLAG => 'primary_key',`	171	`MYSQLI_PRI_KEY_FLAG => 'primary_key',`
169	`MYSQLI_UNIQUE_KEY_FLAG => 'unique_key',`	172	`MYSQLI_UNIQUE_KEY_FLAG => 'unique_key',`
170	`MYSQLI_MULTIPLE_KEY_FLAG => 'multiple_key',`	173	`MYSQLI_MULTIPLE_KEY_FLAG => 'multiple_key',`
171	`MYSQLI_BLOB_FLAG => 'blob',`	174	`MYSQLI_BLOB_FLAG => 'blob',`
172	`MYSQLI_UNSIGNED_FLAG => 'unsigned',`	175	`MYSQLI_UNSIGNED_FLAG => 'unsigned',`
173	`MYSQLI_ZEROFILL_FLAG => 'zerofill',`	176	`MYSQLI_ZEROFILL_FLAG => 'zerofill',`
174	`MYSQLI_AUTO_INCREMENT_FLAG => 'auto_increment',`	177	`MYSQLI_AUTO_INCREMENT_FLAG => 'auto_increment',`
175	`MYSQLI_TIMESTAMP_FLAG => 'timestamp',`	178	`MYSQLI_TIMESTAMP_FLAG => 'timestamp',`
176	`MYSQLI_SET_FLAG => 'set',`	179	`MYSQLI_SET_FLAG => 'set',`
177	`// MYSQLI_NUM_FLAG => 'numeric', // unnecessary`	180	`// MYSQLI_NUM_FLAG => 'numeric', // unnecessary`
178	`// MYSQLI_PART_KEY_FLAG => 'multiple_key', // duplicatvie`	181	`// MYSQLI_PART_KEY_FLAG => 'multiple_key', // duplicatvie`
179	`MYSQLI_GROUP_FLAG => 'group_by'`	182	`MYSQLI_GROUP_FLAG => 'group_by'`
180	`);`	183	`);`
181		184
182	`/**`	185	`/**`
183	`* Array for converting MYSQLI_TYPE_* constants to text values`	186	`* Array for converting MYSQLI_TYPE_* constants to text values`
184	`* @var array`	187	`* @var array`
185	`* @access public`	188	`* @access public`
186	`* @since Property available since Release 1.6.5`	189	`* @since Property available since Release 1.6.5`
187	`*/`	190	`*/`
188	`var $mysqli_types = array(`	191	`var $mysqli_types = array(`
189	`MYSQLI_TYPE_DECIMAL => 'decimal',`	192	`MYSQLI_TYPE_DECIMAL => 'decimal',`
190	`MYSQLI_TYPE_TINY => 'tinyint',`	193	`MYSQLI_TYPE_TINY => 'tinyint',`
191	`MYSQLI_TYPE_SHORT => 'int',`	194	`MYSQLI_TYPE_SHORT => 'int',`
192	`MYSQLI_TYPE_LONG => 'int',`	195	`MYSQLI_TYPE_LONG => 'int',`
193	`MYSQLI_TYPE_FLOAT => 'float',`	196	`MYSQLI_TYPE_FLOAT => 'float',`
194	`MYSQLI_TYPE_DOUBLE => 'double',`	197	`MYSQLI_TYPE_DOUBLE => 'double',`
195	`// MYSQLI_TYPE_NULL => 'DEFAULT NULL', // let flags handle it`	198	`// MYSQLI_TYPE_NULL => 'DEFAULT NULL', // let flags handle it`
196	`MYSQLI_TYPE_TIMESTAMP => 'timestamp',`	199	`MYSQLI_TYPE_TIMESTAMP => 'timestamp',`
197	`MYSQLI_TYPE_LONGLONG => 'bigint',`	200	`MYSQLI_TYPE_LONGLONG => 'bigint',`
198	`MYSQLI_TYPE_INT24 => 'mediumint',`	201	`MYSQLI_TYPE_INT24 => 'mediumint',`
199	`MYSQLI_TYPE_DATE => 'date',`	202	`MYSQLI_TYPE_DATE => 'date',`
200	`MYSQLI_TYPE_TIME => 'time',`	203	`MYSQLI_TYPE_TIME => 'time',`
201	`MYSQLI_TYPE_DATETIME => 'datetime',`	204	`MYSQLI_TYPE_DATETIME => 'datetime',`
202	`MYSQLI_TYPE_YEAR => 'year',`	205	`MYSQLI_TYPE_YEAR => 'year',`
203	`MYSQLI_TYPE_NEWDATE => 'date',`	206	`MYSQLI_TYPE_NEWDATE => 'date',`
204	`MYSQLI_TYPE_ENUM => 'enum',`	207	`MYSQLI_TYPE_ENUM => 'enum',`
205	`MYSQLI_TYPE_SET => 'set',`	208	`MYSQLI_TYPE_SET => 'set',`
206	`MYSQLI_TYPE_TINY_BLOB => 'tinyblob',`	209	`MYSQLI_TYPE_TINY_BLOB => 'tinyblob',`
207	`MYSQLI_TYPE_MEDIUM_BLOB => 'mediumblob',`	210	`MYSQLI_TYPE_MEDIUM_BLOB => 'mediumblob',`
208	`MYSQLI_TYPE_LONG_BLOB => 'longblob',`	211	`MYSQLI_TYPE_LONG_BLOB => 'longblob',`
209	`MYSQLI_TYPE_BLOB => 'blob',`	212	`MYSQLI_TYPE_BLOB => 'blob',`
210	`MYSQLI_TYPE_VAR_STRING => 'varchar',`	213	`MYSQLI_TYPE_VAR_STRING => 'varchar',`
211	`MYSQLI_TYPE_STRING => 'char',`	214	`MYSQLI_TYPE_STRING => 'char',`
212	`MYSQLI_TYPE_GEOMETRY => 'geometry',`	215	`MYSQLI_TYPE_GEOMETRY => 'geometry',`
-		216	`/* These constants are conditionally compiled in ext/mysqli, so we'll`
-		217	`* define them by number rather than constant. */`
-		218	`16 => 'bit',`
-		219	`246 => 'decimal',`
213	`);`	220	`);`
214		221
215		222
216	`// }}}`	223	`// }}}`
217	`// {{{ constructor`	224	`// {{{ constructor`
218		225
219	`/**`	226	`/**`
220	`* This constructor calls <kbd>$this->DB_common()</kbd>`	227	`* This constructor calls <kbd>parent::__construct()</kbd>`
221	`*`	228	`*`
222	`* @return void`	229	`* @return void`
223	`*/`	230	`*/`
224	`function DB_mysqli()`	231	`function __construct()`
225	`{`	232	`{`
226	`$this->DB_common();`	233	`parent::__construct();`
227	`}`	234	`}`
228		235
229	`// }}}`	236	`// }}}`
230	`// {{{ connect()`	237	`// {{{ connect()`
231		238
232	`/**`	239	`/**`
233	`* Connect to the database server, log in and open the database`	240	`* Connect to the database server, log in and open the database`
234	`*`	241	`*`
235	`* Don't call this method directly. Use DB::connect() instead.`	242	`* Don't call this method directly. Use DB::connect() instead.`
236	`*`	243	`*`
237	`* PEAR DB's mysqli driver supports the following extra DSN options:`	244	`* PEAR DB's mysqli driver supports the following extra DSN options:`
238	`* + When the 'ssl' $option passed to DB::connect() is true:`	245	`* + When the 'ssl' $option passed to DB::connect() is true:`
239	`* + key The path to the key file.`	246	`* + key The path to the key file.`
240	`* + cert The path to the certificate file.`	247	`* + cert The path to the certificate file.`
241	`* + ca The path to the certificate authority file.`	248	`* + ca The path to the certificate authority file.`
242	`* + capath The path to a directory that contains trusted SSL`	249	`* + capath The path to a directory that contains trusted SSL`
243	`* CA certificates in pem format.`	250	`* CA certificates in pem format.`
244	`* + cipher The list of allowable ciphers for SSL encryption.`	251	`* + cipher The list of allowable ciphers for SSL encryption.`
245	`*`	252	`*`
246	`* Example of how to connect using SSL:`	253	`* Example of how to connect using SSL:`
247	`* <code>`	254	`* <code>`
248	`* require_once 'DB.php';`	255	`* require_once 'DB.php';`
249	`*`	256	`*`
250	`* $dsn = array(`	257	`* $dsn = array(`
251	`* 'phptype' => 'mysqli',`	258	`* 'phptype' => 'mysqli',`
252	`* 'username' => 'someuser',`	259	`* 'username' => 'someuser',`
253	`* 'password' => 'apasswd',`	260	`* 'password' => 'apasswd',`
254	`* 'hostspec' => 'localhost',`	261	`* 'hostspec' => 'localhost',`
255	`* 'database' => 'thedb',`	262	`* 'database' => 'thedb',`
256	`* 'key' => 'client-key.pem',`	263	`* 'key' => 'client-key.pem',`
257	`* 'cert' => 'client-cert.pem',`	264	`* 'cert' => 'client-cert.pem',`
258	`* 'ca' => 'cacert.pem',`	265	`* 'ca' => 'cacert.pem',`
259	`* 'capath' => '/path/to/ca/dir',`	266	`* 'capath' => '/path/to/ca/dir',`
260	`* 'cipher' => 'AES',`	267	`* 'cipher' => 'AES',`
261	`* );`	268	`* );`
262	`*`	269	`*`
263	`* $options = array(`	270	`* $options = array(`
264	`* 'ssl' => true,`	271	`* 'ssl' => true,`
265	`* );`	272	`* );`
266	`*`	273	`*`
267	`* $db =& DB::connect($dsn, $options);`	274	`* $db = DB::connect($dsn, $options);`
268	`* if (PEAR::isError($db)) {`	275	`* if (PEAR::isError($db)) {`
269	`* die($db->getMessage());`	276	`* die($db->getMessage());`
270	`* }`	277	`* }`
271	`* </code>`	278	`* </code>`
272	`*`	279	`*`
273	`* @param array $dsn the data source name`	280	`* @param array $dsn the data source name`
274	`* @param bool $persistent should the connection be persistent?`	281	`* @param bool $persistent should the connection be persistent?`
275	`*`	282	`*`
276	`* @return int DB_OK on success. A DB_Error object on failure.`	283	`* @return int DB_OK on success. A DB_Error object on failure.`
277	`*/`	284	`*/`
278	`function connect($dsn, $persistent = false)`	285	`function connect($dsn, $persistent = false)`
279	`{`	286	`{`
280	`if (!PEAR::loadExtension('mysqli')) {`	287	`if (!PEAR::loadExtension('mysqli')) {`
281	`return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);`	288	`return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);`
282	`}`	289	`}`
283		290
284	`$this->dsn = $dsn;`	291	`$this->dsn = $dsn;`
285	`if ($dsn['dbsyntax']) {`	292	`if ($dsn['dbsyntax']) {`
286	`$this->dbsyntax = $dsn['dbsyntax'];`	293	`$this->dbsyntax = $dsn['dbsyntax'];`
287	`}`	294	`}`
288		295
289	`$ini = ini_get('track_errors');`	296	`$ini = ini_get('track_errors');`
290	`ini_set('track_errors', 1);`	297	`@ini_set('track_errors', 1);`
291	`$php_errormsg = '';`	298	`$php_errormsg = '';`
292		299
293	`if ($this->getOption('ssl') === true) {`	300	`if (((int) $this->getOption('ssl')) === 1) {`
294	`$init = mysqli_init();`	301	`$init = mysqli_init();`
295	`mysqli_ssl_set(`	302	`mysqli_ssl_set(`
296	`$init,`	303	`$init,`
297	`empty($dsn['key']) ? null : $dsn['key'],`	304	`empty($dsn['key']) ? null : $dsn['key'],`
298	`empty($dsn['cert']) ? null : $dsn['cert'],`	305	`empty($dsn['cert']) ? null : $dsn['cert'],`
299	`empty($dsn['ca']) ? null : $dsn['ca'],`	306	`empty($dsn['ca']) ? null : $dsn['ca'],`
300	`empty($dsn['capath']) ? null : $dsn['capath'],`	307	`empty($dsn['capath']) ? null : $dsn['capath'],`
301	`empty($dsn['cipher']) ? null : $dsn['cipher']`	308	`empty($dsn['cipher']) ? null : $dsn['cipher']`
302	`);`	309	`);`
303	`if ($this->connection = @mysqli_real_connect(`	310	`if ($this->connection = @mysqli_real_connect(`
304	`$init,`	311	`$init,`
305	`$dsn['hostspec'],`	312	`$dsn['hostspec'],`
306	`$dsn['username'],`	313	`$dsn['username'],`
307	`$dsn['password'],`	314	`$dsn['password'],`
308	`$dsn['database'],`	315	`$dsn['database'],`
309	`$dsn['port'],`	316	`$dsn['port'],`
310	`$dsn['socket']))`	317	`$dsn['socket']))`
311	`{`	318	`{`
312	`$this->connection = $init;`	319	`$this->connection = $init;`
313	`}`	320	`}`
314	`} else {`	321	`} else {`
315	`$this->connection = @mysqli_connect(`	322	`$this->connection = @mysqli_connect(`
316	`$dsn['hostspec'],`	323	`$dsn['hostspec'],`
317	`$dsn['username'],`	324	`$dsn['username'],`
318	`$dsn['password'],`	325	`$dsn['password'],`
319	`$dsn['database'],`	326	`$dsn['database'],`
320	`$dsn['port'],`	327	`$dsn['port'],`
321	`$dsn['socket']`	328	`$dsn['socket']`
322	`);`	329	`);`
323	`}`	330	`}`
324		331
325	`ini_set('track_errors', $ini);`	332	`@ini_set('track_errors', $ini);`
326		333
327	`if (!$this->connection) {`	334	`if (!$this->connection) {`
328	`if (($err = @mysqli_connect_error()) != '') {`	335	`if (($err = @mysqli_connect_error()) != '') {`
329	`return $this->raiseError(DB_ERROR_CONNECT_FAILED,`	336	`return $this->raiseError(DB_ERROR_CONNECT_FAILED,`
330	`null, null, null,`	337	`null, null, null,`
331	`$err);`	338	`$err);`
332	`} else {`	339	`} else {`
333	`return $this->raiseError(DB_ERROR_CONNECT_FAILED,`	340	`return $this->raiseError(DB_ERROR_CONNECT_FAILED,`
334	`null, null, null,`	341	`null, null, null,`
335	`$php_errormsg);`	342	`$php_errormsg);`
336	`}`	343	`}`
337	`}`	344	`}`
338		345
339	`if ($dsn['database']) {`	346	`if ($dsn['database']) {`
340	`$this->_db = $dsn['database'];`	347	`$this->_db = $dsn['database'];`
341	`}`	348	`}`
342		349
343	`return DB_OK;`	350	`return DB_OK;`
344	`}`	351	`}`
345		352
346	`// }}}`	353	`// }}}`
347	`// {{{ disconnect()`	354	`// {{{ disconnect()`
348		355
349	`/**`	356	`/**`
350	`* Disconnects from the database server`	357	`* Disconnects from the database server`
351	`*`	358	`*`
352	`* @return bool TRUE on success, FALSE on failure`	359	`* @return bool TRUE on success, FALSE on failure`
353	`*/`	360	`*/`
354	`function disconnect()`	361	`function disconnect()`
355	`{`	362	`{`
356	`$ret = @mysqli_close($this->connection);`	363	`$ret = @mysqli_close($this->connection);`
357	`$this->connection = null;`	364	`$this->connection = null;`
358	`return $ret;`	365	`return $ret;`
359	`}`	366	`}`
360		367
361	`// }}}`	368	`// }}}`
362	`// {{{ simpleQuery()`	369	`// {{{ simpleQuery()`
363		370
364	`/**`	371	`/**`
365	`* Sends a query to the database server`	372	`* Sends a query to the database server`
366	`*`	373	`*`
367	`* @param string the SQL query string`	374	`* @param string the SQL query string`
368	`*`	375	`*`
369	`* @return mixed + a PHP result resrouce for successful SELECT queries`	376	`* @return mixed + a PHP result resrouce for successful SELECT queries`
370	`* + the DB_OK constant for other successful queries`	377	`* + the DB_OK constant for other successful queries`
371	`* + a DB_Error object on failure`	378	`* + a DB_Error object on failure`
372	`*/`	379	`*/`
373	`function simpleQuery($query)`	380	`function simpleQuery($query)`
374	`{`	381	`{`
375	`$ismanip = DB::isManip($query);`	382	`$ismanip = $this->_checkManip($query);`
376	`$this->last_query = $query;`	383	`$this->last_query = $query;`
377	`$query = $this->modifyQuery($query);`	384	`$query = $this->modifyQuery($query);`
378	`if ($this->_db) {`	385	`if ($this->_db) {`
379	`if (!@mysqli_select_db($this->connection, $this->_db)) {`	386	`if (!@mysqli_select_db($this->connection, $this->_db)) {`
380	`return $this->mysqliRaiseError(DB_ERROR_NODBSELECTED);`	387	`return $this->mysqliRaiseError(DB_ERROR_NODBSELECTED);`
381	`}`	388	`}`
382	`}`	389	`}`
383	`if (!$this->autocommit && $ismanip) {`	390	`if (!$this->autocommit && $ismanip) {`
384	`if ($this->transaction_opcount == 0) {`	391	`if ($this->transaction_opcount == 0) {`
385	`$result = @mysqli_query($this->connection, 'SET AUTOCOMMIT=0');`	392	`$result = @mysqli_query($this->connection, 'SET AUTOCOMMIT=0');`
386	`$result = @mysqli_query($this->connection, 'BEGIN');`	393	`$result = @mysqli_query($this->connection, 'BEGIN');`
387	`if (!$result) {`	394	`if (!$result) {`
388	`return $this->mysqliRaiseError();`	395	`return $this->mysqliRaiseError();`
389	`}`	396	`}`
390	`}`	397	`}`
391	`$this->transaction_opcount++;`	398	`$this->transaction_opcount++;`
392	`}`	399	`}`
393	`$result = @mysqli_query($this->connection, $query);`	400	`$result = @mysqli_query($this->connection, $query);`
394	`if (!$result) {`	401	`if (!$result) {`
395	`return $this->mysqliRaiseError();`	402	`return $this->mysqliRaiseError();`
396	`}`	403	`}`
397	`if (is_object($result)) {`	404	`if (is_object($result)) {`
398	`return $result;`	405	`return $result;`
399	`}`	406	`}`
400	`return DB_OK;`	407	`return DB_OK;`
401	`}`	408	`}`
402		409
403	`// }}}`	410	`// }}}`
404	`// {{{ nextResult()`	411	`// {{{ nextResult()`
405		412
406	`/**`	413	`/**`
407	`* Move the internal mysql result pointer to the next available result.`	414	`* Move the internal mysql result pointer to the next available result.`
408	`*`	415	`*`
409	`* This method has not been implemented yet.`	416	`* This method has not been implemented yet.`
410	`*`	417	`*`
411	`* @param resource $result a valid sql result resource`	418	`* @param resource $result a valid sql result resource`
412	`* @return false`	419	`* @return false`
413	`* @access public`	420	`* @access public`
414	`*/`	421	`*/`
415	`function nextResult($result)`	422	`function nextResult($result)`
416	`{`	423	`{`
417	`return false;`	424	`return false;`
418	`}`	425	`}`
419		426
420	`// }}}`	427	`// }}}`
421	`// {{{ fetchInto()`	428	`// {{{ fetchInto()`
422		429
423	`/**`	430	`/**`
424	`* Places a row from the result set into the given array`	431	`* Places a row from the result set into the given array`
425	`*`	432	`*`
426	`* Formating of the array and the data therein are configurable.`	433	`* Formating of the array and the data therein are configurable.`
427	`* See DB_result::fetchInto() for more information.`	434	`* See DB_result::fetchInto() for more information.`
428	`*`	435	`*`
429	`* This method is not meant to be called directly. Use`	436	`* This method is not meant to be called directly. Use`
430	`* DB_result::fetchInto() instead. It can't be declared "protected"`	437	`* DB_result::fetchInto() instead. It can't be declared "protected"`
431	`* because DB_result is a separate object.`	438	`* because DB_result is a separate object.`
432	`*`	439	`*`
433	`* @param resource $result the query result resource`	440	`* @param resource $result the query result resource`
434	`* @param array $arr the referenced array to put the data in`	441	`* @param array $arr the referenced array to put the data in`
435	`* @param int $fetchmode how the resulting array should be indexed`	442	`* @param int $fetchmode how the resulting array should be indexed`
436	`* @param int $rownum the row number to fetch (0 = first row)`	443	`* @param int $rownum the row number to fetch (0 = first row)`
437	`*`	444	`*`
438	`* @return mixed DB_OK on success, NULL when the end of a result set is`	445	`* @return mixed DB_OK on success, NULL when the end of a result set is`
439	`* reached or on failure`	446	`* reached or on failure`
440	`*`	447	`*`
441	`* @see DB_result::fetchInto()`	448	`* @see DB_result::fetchInto()`
442	`*/`	449	`*/`
443	`function fetchInto($result, &$arr, $fetchmode, $rownum = null)`	450	`function fetchInto($result, &$arr, $fetchmode, $rownum = null)`
444	`{`	451	`{`
445	`if ($rownum !== null) {`	452	`if ($rownum !== null) {`
446	`if (!@mysqli_data_seek($result, $rownum)) {`	453	`if (!@mysqli_data_seek($result, $rownum)) {`
447	`return null;`	454	`return null;`
448	`}`	455	`}`
449	`}`	456	`}`
450	`if ($fetchmode & DB_FETCHMODE_ASSOC) {`	457	`if ($fetchmode & DB_FETCHMODE_ASSOC) {`
451	`$arr = @mysqli_fetch_array($result, MYSQLI_ASSOC);`	458	`$arr = @mysqli_fetch_array($result, MYSQLI_ASSOC);`
452	`if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {`	459	`if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {`
453	`$arr = array_change_key_case($arr, CASE_LOWER);`	460	`$arr = array_change_key_case($arr, CASE_LOWER);`
454	`}`	461	`}`
455	`} else {`	462	`} else {`
456	`$arr = @mysqli_fetch_row($result);`	463	`$arr = @mysqli_fetch_row($result);`
457	`}`	464	`}`
458	`if (!$arr) {`	465	`if (!$arr) {`
459	`return null;`	466	`return null;`
460	`}`	467	`}`
461	`if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {`	468	`if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {`
462	`/*`	469	`/*`
463	`* Even though this DBMS already trims output, we do this because`	470	`* Even though this DBMS already trims output, we do this because`
464	`* a field might have intentional whitespace at the end that`	471	`* a field might have intentional whitespace at the end that`
465	`* gets removed by DB_PORTABILITY_RTRIM under another driver.`	472	`* gets removed by DB_PORTABILITY_RTRIM under another driver.`
466	`*/`	473	`*/`
467	`$this->_rtrimArrayValues($arr);`	474	`$this->_rtrimArrayValues($arr);`
468	`}`	475	`}`
469	`if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {`	476	`if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {`
470	`$this->_convertNullArrayValuesToEmpty($arr);`	477	`$this->_convertNullArrayValuesToEmpty($arr);`
471	`}`	478	`}`
472	`return DB_OK;`	479	`return DB_OK;`
473	`}`	480	`}`
474		481
475	`// }}}`	482	`// }}}`
476	`// {{{ freeResult()`	483	`// {{{ freeResult()`
477		484
478	`/**`	485	`/**`
479	`* Deletes the result set and frees the memory occupied by the result set`	486	`* Deletes the result set and frees the memory occupied by the result set`
480	`*`	487	`*`
481	`* This method is not meant to be called directly. Use`	488	`* This method is not meant to be called directly. Use`
482	`* DB_result::free() instead. It can't be declared "protected"`	489	`* DB_result::free() instead. It can't be declared "protected"`
483	`* because DB_result is a separate object.`	490	`* because DB_result is a separate object.`
484	`*`	491	`*`
485	`* @param resource $result PHP's query result resource`	492	`* @param resource $result PHP's query result resource`
486	`*`	493	`*`
487	`* @return bool TRUE on success, FALSE if $result is invalid`	494	`* @return bool TRUE on success, FALSE if $result is invalid`
488	`*`	495	`*`
489	`* @see DB_result::free()`	496	`* @see DB_result::free()`
490	`*/`	497	`*/`
491	`function freeResult($result)`	498	`function freeResult($result)`
492	`{`	499	`{`
-		500	`if (! $result instanceof mysqli_result) {`

Subversion Repositories Applications.gtt

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