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


<?php
 
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
 
/**
 * The PEAR DB driver for PHP's msql extension
 * for interacting with Mini SQL databases
 *
 * PHP's mSQL extension did weird things with NULL values prior to PHP
 * 4.3.11 and 5.0.4.  Make sure your version of PHP meets or exceeds
 * those versions.
 *
 * 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 msql extension
 * for interacting with Mini SQL databases
 *
 * These methods overload the ones declared in DB_common.
 *
 * PHP's mSQL extension did weird things with NULL values prior to PHP
 * 4.3.11 and 5.0.4.  Make sure your version of PHP meets or exceeds
 * those versions.
 *
 * @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 not functional until Release 1.7.0
 */
class DB_msql extends DB_common
{
    // {{{ properties
 
    /**
     * The DB driver type (mysql, oci8, odbc, etc.)
     * @var string
     */
    var $phptype = 'msql';
 
    /**
     * The database syntax variant to be used (db2, access, etc.), if any
     * @var string
     */
    var $dbsyntax = 'msql';
 
    /**
     * 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'         => 'emulate',
        'new_link'      => false,
        'numrows'       => true,
        'pconnect'      => true,
        'prepare'       => false,
        'ssl'           => false,
        'transactions'  => false,
    );
 
    /**
     * A mapping of native error codes to DB error codes
     * @var array
     */
    var $errorcode_map = array(
    );
 
    /**
     * The raw database connection created by PHP
     * @var resource
     */
    var $connection;
 
    /**
     * The DSN information for connecting to a database
     * @var array
     */
    var $dsn = array();
 
 
    /**
     * The query result resource created by PHP
     *
     * Used to make affectedRows() work.  Only contains the result for
     * data manipulation queries.  Contains false for other queries.
     *
     * @var resource
     * @access private
     */
    var $_result;
 
 
    // }}}
    // {{{ 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.
     *
     * Example of how to connect:
     * <code>
     * require_once 'DB.php';
     * 
     * // $dsn = 'msql://hostname/dbname';  // use a TCP connection
     * $dsn = 'msql:///dbname';             // use a socket
     * $options = array(
     *     'portability' => DB_PORTABILITY_ALL,
     * );
     * 
     * $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('msql')) {
            return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
        }
 
        $this->dsn = $dsn;
        if ($dsn['dbsyntax']) {
            $this->dbsyntax = $dsn['dbsyntax'];
        }
 
        $params = array();
        if ($dsn['hostspec']) {
            $params[] = $dsn['port']
                        ? $dsn['hostspec'] . ',' . $dsn['port']
                        : $dsn['hostspec'];
        }
 
        $connect_function = $persistent ? 'msql_pconnect' : 'msql_connect';
 
        $ini = ini_get('track_errors');
        $php_errormsg = '';
        if ($ini) {
            $this->connection = @call_user_func_array($connect_function,
                                                      $params);
        } else {
            @ini_set('track_errors', 1);
            $this->connection = @call_user_func_array($connect_function,
                                                      $params);
            @ini_set('track_errors', $ini);
        }
 
        if (!$this->connection) {
            if (($err = @msql_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 (!@msql_select_db($dsn['database'], $this->connection)) {
            return $this->msqlRaiseError();
        }
        return DB_OK;
    }
 
    // }}}
    // {{{ disconnect()
 
    /**
     * Disconnects from the database server
     *
     * @return bool  TRUE on success, FALSE on failure
     */
    function disconnect()
    {
        $ret = @msql_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)
    {
        $this->last_query = $query;
        $query = $this->modifyQuery($query);
        $result = @msql_query($query, $this->connection);
        if (!$result) {
            return $this->msqlRaiseError();
        }
        // Determine which queries that should return data, and which
        // should return an error code only.
        if ($this->_checkManip($query)) {
            $this->_result = $result;
            return DB_OK;
        } else {
            $this->_result = false;
            return $result;
        }
    }
 
 
    // }}}
    // {{{ nextResult()
 
    /**
     * Move the internal msql result pointer to the next available result
     *
     * @param a valid fbsql result resource
     *
     * @access public
     *
     * @return true if a result is available otherwise return false
     */
    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.
     *
     * PHP's mSQL extension did weird things with NULL values prior to PHP
     * 4.3.11 and 5.0.4.  Make sure your version of PHP meets or exceeds
     * those versions.
     *
     * @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 (!@msql_data_seek($result, $rownum)) {
                return null;
            }
        }
        if ($fetchmode & DB_FETCHMODE_ASSOC) {
            $arr = @msql_fetch_array($result, MSQL_ASSOC);
            if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {
                $arr = array_change_key_case($arr, CASE_LOWER);
            }
        } else {
            $arr = @msql_fetch_row($result);
        }
        if (!$arr) {
            return null;
        }
        if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {
            $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)
    {
        return is_resource($result) ? msql_free_result($result) : false;
    }
 
    // }}}
    // {{{ 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 = @msql_num_fields($result);
        if (!$cols) {
            return $this->msqlRaiseError();
        }
        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 = @msql_num_rows($result);
        if ($rows === false) {
            return $this->msqlRaiseError();
        }
        return $rows;
    }
 
    // }}}
    // {{{ affected()
 
    /**
     * 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->_result) {
            return 0;
        }
        return msql_affected_rows($this->_result);
    }
 
    // }}}
    // {{{ 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_msql::createSequence(), DB_msql::dropSequence()
     */
    function nextId($seq_name, $ondemand = true)
    {
        $seqname = $this->getSequenceName($seq_name);
        $repeat = false;
        do {
            $this->pushErrorHandling(PEAR_ERROR_RETURN);
            $result = $this->query("SELECT _seq FROM ${seqname}");
            $this->popErrorHandling();
            if ($ondemand && DB::isError($result) &&
                $result->getCode() == DB_ERROR_NOSUCHTABLE) {
                $repeat = true;
                $this->pushErrorHandling(PEAR_ERROR_RETURN);
                $result = $this->createSequence($seq_name);
                $this->popErrorHandling();
                if (DB::isError($result)) {
                    return $this->raiseError($result);
                }
            } else {
                $repeat = false;
            }
        } while ($repeat);
        if (DB::isError($result)) {
            return $this->raiseError($result);
        }
        $arr = $result->fetchRow(DB_FETCHMODE_ORDERED);
        $result->free();
        return $arr[0];
    }
 
    // }}}
    // {{{ createSequence()
 
    /**
     * Creates a new sequence
     *
     * Also creates a new table to associate the sequence with.  Uses
     * a separate table to ensure portability with other drivers.
     *
     * @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_msql::nextID(), DB_msql::dropSequence()
     */
    function createSequence($seq_name)
    {
        $seqname = $this->getSequenceName($seq_name);
        $res = $this->query('CREATE TABLE ' . $seqname
                            . ' (id INTEGER NOT NULL)');
        if (DB::isError($res)) {
            return $res;
        }
        $res = $this->query("CREATE SEQUENCE ON ${seqname}");
        return $res;
    }
 
    // }}}
    // {{{ 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_msql::nextID(), DB_msql::createSequence()
     */
    function dropSequence($seq_name)
    {
        return $this->query('DROP TABLE ' . $this->getSequenceName($seq_name));
    }
 
    // }}}
    // {{{ quoteIdentifier()
 
    /**
     * mSQL does not support delimited identifiers
     *
     * @param string $str  the identifier name to be quoted
     *
     * @return object  a DB_Error object
     *
     * @see DB_common::quoteIdentifier()
     * @since Method available since Release 1.7.0
     */
    function quoteIdentifier($str)
    {
        return $this->raiseError(DB_ERROR_UNSUPPORTED);
    }
 
    // }}}
    // {{{ quoteFloat()
 
    /**
     * Formats a float value for use within a query in a locale-independent
     * manner.
     *
     * @param float the float value to be quoted.
     * @return string the quoted string.
     * @see DB_common::quoteSmart()
     * @since Method available since release 1.7.8.
     */
    function quoteFloat($float) {
        return $this->escapeSimple(str_replace(',', '.', strval(floatval($float))));
    }
     
    // }}}
    // {{{ 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.7.0
     */
    function escapeSimple($str)
    {
        return addslashes($str);
    }
 
    // }}}
    // {{{ msqlRaiseError()
 
    /**
     * 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_msql::errorNative(), DB_msql::errorCode()
     */
    function msqlRaiseError($errno = null)
    {
        $native = $this->errorNative();
        if ($errno === null) {
            $errno = $this->errorCode($native);
        }
        return $this->raiseError($errno, null, null, null, $native);
    }
 
    // }}}
    // {{{ errorNative()
 
    /**
     * Gets the DBMS' native error message produced by the last query
     *
     * @return string  the DBMS' error message
     */
    function errorNative()
    {
        return @msql_error();
    }
 
    // }}}
    // {{{ errorCode()
 
    /**
     * Determines PEAR::DB error code from the database's text error message
     *
     * @param string $errormsg  the error message returned from the database
     *
     * @return integer  the error number from a DB_ERROR* constant
     */
    function errorCode($errormsg)
    {
        static $error_regexps;
        
        // PHP 5.2+ prepends the function name to $php_errormsg, so we need
        // this hack to work around it, per bug #9599.
        $errormsg = preg_replace('/^msql[a-z_]+\(\): /', '', $errormsg);
 
        if (!isset($error_regexps)) {
            $error_regexps = array(
                '/^Access to database denied/i'
                    => DB_ERROR_ACCESS_VIOLATION,
                '/^Bad index name/i'
                    => DB_ERROR_ALREADY_EXISTS,
                '/^Bad order field/i'
                    => DB_ERROR_SYNTAX,
                '/^Bad type for comparison/i'
                    => DB_ERROR_SYNTAX,
                '/^Can\'t perform LIKE on/i'
                    => DB_ERROR_SYNTAX,
                '/^Can\'t use TEXT fields in LIKE comparison/i'
                    => DB_ERROR_SYNTAX,
                '/^Couldn\'t create temporary table/i'
                    => DB_ERROR_CANNOT_CREATE,
                '/^Error creating table file/i'
                    => DB_ERROR_CANNOT_CREATE,
                '/^Field .* cannot be null$/i'
                    => DB_ERROR_CONSTRAINT_NOT_NULL,
                '/^Index (field|condition) .* cannot be null$/i'
                    => DB_ERROR_SYNTAX,
                '/^Invalid date format/i'
                    => DB_ERROR_INVALID_DATE,
                '/^Invalid time format/i'
                    => DB_ERROR_INVALID,
                '/^Literal value for .* is wrong type$/i'
                    => DB_ERROR_INVALID_NUMBER,
                '/^No Database Selected/i'
                    => DB_ERROR_NODBSELECTED,
                '/^No value specified for field/i'
                    => DB_ERROR_VALUE_COUNT_ON_ROW,
                '/^Non unique value for unique index/i'
                    => DB_ERROR_CONSTRAINT,
                '/^Out of memory for temporary table/i'
                    => DB_ERROR_CANNOT_CREATE,
                '/^Permission denied/i'
                    => DB_ERROR_ACCESS_VIOLATION,
                '/^Reference to un-selected table/i'
                    => DB_ERROR_SYNTAX,
                '/^syntax error/i'
                    => DB_ERROR_SYNTAX,
                '/^Table .* exists$/i'
                    => DB_ERROR_ALREADY_EXISTS,
                '/^Unknown database/i'
                    => DB_ERROR_NOSUCHDB,
                '/^Unknown field/i'
                    => DB_ERROR_NOSUCHFIELD,
                '/^Unknown (index|system variable)/i'
                    => DB_ERROR_NOT_FOUND,
                '/^Unknown table/i'
                    => DB_ERROR_NOSUCHTABLE,
                '/^Unqualified field/i'
                    => DB_ERROR_SYNTAX,
            );
        }
 
        foreach ($error_regexps as $regexp => $code) {
            if (preg_match($regexp, $errormsg)) {
                return $code;
            }
        }
        return DB_ERROR;
    }
 
    // }}}
    // {{{ 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)) {
            /*
             * Probably received a table name.
             * Create a result resource identifier.
             */
            $id = @msql_query("SELECT * FROM $result",
                              $this->connection);
            $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_resource($id)) {
            return $this->raiseError(DB_ERROR_NEED_MORE_DATA);
        }
 
        if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE) {
            $case_func = 'strtolower';
        } else {
            $case_func = 'strval';
        }
 
        $count = @msql_num_fields($id);
        $res   = array();
 
        if ($mode) {
            $res['num_fields'] = $count;
        }
 
        for ($i = 0; $i < $count; $i++) {
            $tmp = @msql_fetch_field($id);
 
            $flags = '';
            if ($tmp->not_null) {
                $flags .= 'not_null ';
            }
            if ($tmp->unique) {
                $flags .= 'unique_key ';
            }
            $flags = trim($flags);
 
            $res[$i] = array(
                'table' => $case_func($tmp->table),
                'name'  => $case_func($tmp->name),
                'type'  => $tmp->type,
                'len'   => msql_field_len($id, $i),
                '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) {
            @msql_free_result($id);
        }
        return $res;
    }
 
    // }}}
    // {{{ getSpecialQuery()
 
    /**
     * Obtain a list of a given type of objects
     *
     * @param string $type  the kind of objects you want to retrieve
     *
     * @return array  the array containing the list of objects requested
     *
     * @access protected
     * @see DB_common::getListOf()
     */
    function getSpecialQuery($type)
    {
        switch ($type) {
            case 'databases':
                $id = @msql_list_dbs($this->connection);
                break;
            case 'tables':
                $id = @msql_list_tables($this->dsn['database'],
                                        $this->connection);
                break;
            default:
                return null;
        }
        if (!$id) {
            return $this->msqlRaiseError();
        }
        $out = array();
        while ($row = @msql_fetch_row($id)) {
            $out[] = $row[0];
        }
        return $out;
    }
 
    // }}}
 
}
 
/*
 * 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 msql extension`	6	`* The PEAR DB driver for PHP's msql extension`
7	`* for interacting with Mini SQL databases`	7	`* for interacting with Mini SQL databases`
8	`*`	8	`*`
9	`* PHP's mSQL extension did weird things with NULL values prior to PHP`	9	`* PHP's mSQL extension did weird things with NULL values prior to PHP`
10	`* 4.3.11 and 5.0.4. Make sure your version of PHP meets or exceeds`	10	`* 4.3.11 and 5.0.4. Make sure your version of PHP meets or exceeds`
11	`* those versions.`	11	`* those versions.`
12	`*`	12	`*`
13	`* PHP versions 4 and 5`	13	`* PHP version 5`
14	`*`	14	`*`
15	`* LICENSE: This source file is subject to version 3.0 of the PHP license`	15	`* LICENSE: This source file is subject to version 3.0 of the PHP license`
16	`* that is available through the world-wide-web at the following URI:`	16	`* that is available through the world-wide-web at the following URI:`
17	`* http://www.php.net/license/3_0.txt. If you did not receive a copy of`	17	`* http://www.php.net/license/3_0.txt. If you did not receive a copy of`
18	`* the PHP License and are unable to obtain it through the web, please`	18	`* the PHP License and are unable to obtain it through the web, please`
19	`* send a note to license@php.net so we can mail you a copy immediately.`	19	`* send a note to license@php.net so we can mail you a copy immediately.`
20	`*`	20	`*`
21	`* @category Database`	21	`* @category Database`
22	`* @package DB`	22	`* @package DB`
23	`* @author Daniel Convissor <danielc@php.net>`	23	`* @author Daniel Convissor <danielc@php.net>`
24	`* @copyright 1997-2005 The PHP Group`	24	`* @copyright 1997-2007 The PHP Group`
25	`* @license http://www.php.net/license/3_0.txt PHP License 3.0`	25	`* @license http://www.php.net/license/3_0.txt PHP License 3.0`
26	`* @version CVS: $Id: msql.php,v 1.57 2005/02/22 07:26:46 danielc Exp $`	26	`* @version CVS: $Id$`
27	`* @link http://pear.php.net/package/DB`	27	`* @link http://pear.php.net/package/DB`
28	`*/`	28	`*/`
29		29
30	`/**`	30	`/**`
31	`* Obtain the DB_common class so it can be extended from`	31	`* Obtain the DB_common class so it can be extended from`
32	`*/`	32	`*/`
33	`require_once 'DB/common.php';`	33	`require_once 'DB/common.php';`
34		34
35	`/**`	35	`/**`
36	`* The methods PEAR DB uses to interact with PHP's msql extension`	36	`* The methods PEAR DB uses to interact with PHP's msql extension`
37	`* for interacting with Mini SQL databases`	37	`* for interacting with Mini SQL databases`
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	`* PHP's mSQL extension did weird things with NULL values prior to PHP`	41	`* PHP's mSQL extension did weird things with NULL values prior to PHP`
42	`* 4.3.11 and 5.0.4. Make sure your version of PHP meets or exceeds`	42	`* 4.3.11 and 5.0.4. Make sure your version of PHP meets or exceeds`
43	`* those versions.`	43	`* those versions.`
44	`*`	44	`*`
45	`* @category Database`	45	`* @category Database`
46	`* @package DB`	46	`* @package DB`
47	`* @author Daniel Convissor <danielc@php.net>`	47	`* @author Daniel Convissor <danielc@php.net>`
48	`* @copyright 1997-2005 The PHP Group`	48	`* @copyright 1997-2007 The PHP Group`
49	`* @license http://www.php.net/license/3_0.txt PHP License 3.0`	49	`* @license http://www.php.net/license/3_0.txt PHP License 3.0`
50	`* @version Release: 1.7.6`	50	`* @version Release: 1.9.2`
51	`* @link http://pear.php.net/package/DB`	51	`* @link http://pear.php.net/package/DB`
52	`* @since Class not functional until Release 1.7.0`	52	`* @since Class not functional until Release 1.7.0`
53	`*/`	53	`*/`
54	`class DB_msql extends DB_common`	54	`class DB_msql extends DB_common`
55	`{`	55	`{`
56	`// {{{ properties`	56	`// {{{ properties`
57		57
58	`/**`	58	`/**`
59	`* The DB driver type (mysql, oci8, odbc, etc.)`	59	`* The DB driver type (mysql, oci8, odbc, etc.)`
60	`* @var string`	60	`* @var string`
61	`*/`	61	`*/`
62	`var $phptype = 'msql';`	62	`var $phptype = 'msql';`
63		63
64	`/**`	64	`/**`
65	`* The database syntax variant to be used (db2, access, etc.), if any`	65	`* The database syntax variant to be used (db2, access, etc.), if any`
66	`* @var string`	66	`* @var string`
67	`*/`	67	`*/`
68	`var $dbsyntax = 'msql';`	68	`var $dbsyntax = 'msql';`
69		69
70	`/**`	70	`/**`
71	`* The capabilities of this DB implementation`	71	`* The capabilities of this DB implementation`
72	`*`	72	`*`
73	`* The 'new_link' element contains the PHP version that first provided`	73	`* The 'new_link' element contains the PHP version that first provided`
74	`* new_link support for this DBMS. Contains false if it's unsupported.`	74	`* new_link support for this DBMS. Contains false if it's unsupported.`
75	`*`	75	`*`
76	`* Meaning of the 'limit' element:`	76	`* Meaning of the 'limit' element:`
77	`* + 'emulate' = emulate with fetch row by number`	77	`* + 'emulate' = emulate with fetch row by number`
78	`* + 'alter' = alter the query`	78	`* + 'alter' = alter the query`
79	`* + false = skip rows`	79	`* + false = skip rows`
80	`*`	80	`*`
81	`* @var array`	81	`* @var array`
82	`*/`	82	`*/`
83	`var $features = array(`	83	`var $features = array(`
84	`'limit' => 'emulate',`	84	`'limit' => 'emulate',`
85	`'new_link' => false,`	85	`'new_link' => false,`
86	`'numrows' => true,`	86	`'numrows' => true,`
87	`'pconnect' => true,`	87	`'pconnect' => true,`
88	`'prepare' => false,`	88	`'prepare' => false,`
89	`'ssl' => false,`	89	`'ssl' => false,`
90	`'transactions' => false,`	90	`'transactions' => false,`
91	`);`	91	`);`
92		92
93	`/**`	93	`/**`
94	`* A mapping of native error codes to DB error codes`	94	`* A mapping of native error codes to DB error codes`
95	`* @var array`	95	`* @var array`
96	`*/`	96	`*/`
97	`var $errorcode_map = array(`	97	`var $errorcode_map = array(`
98	`);`	98	`);`
99		99
100	`/**`	100	`/**`
101	`* The raw database connection created by PHP`	101	`* The raw database connection created by PHP`
102	`* @var resource`	102	`* @var resource`
103	`*/`	103	`*/`
104	`var $connection;`	104	`var $connection;`
105		105
106	`/**`	106	`/**`
107	`* The DSN information for connecting to a database`	107	`* The DSN information for connecting to a database`
108	`* @var array`	108	`* @var array`
109	`*/`	109	`*/`
110	`var $dsn = array();`	110	`var $dsn = array();`
111		111
112		112
113	`/**`	113	`/**`
114	`* The query result resource created by PHP`	114	`* The query result resource created by PHP`
115	`*`	115	`*`
116	`* Used to make affectedRows() work. Only contains the result for`	116	`* Used to make affectedRows() work. Only contains the result for`
117	`* data manipulation queries. Contains false for other queries.`	117	`* data manipulation queries. Contains false for other queries.`
118	`*`	118	`*`
119	`* @var resource`	119	`* @var resource`
120	`* @access private`	120	`* @access private`
121	`*/`	121	`*/`
122	`var $_result;`	122	`var $_result;`
123		123
124		124
125	`// }}}`	125	`// }}}`
126	`// {{{ constructor`	126	`// {{{ constructor`
127		127
128	`/**`	128	`/**`
129	`* This constructor calls <kbd>$this->DB_common()</kbd>`	129	`* This constructor calls <kbd>parent::__construct()</kbd>`
130	`*`	130	`*`
131	`* @return void`	131	`* @return void`
132	`*/`	132	`*/`
133	`function DB_msql()`	133	`function __construct()`
134	`{`	134	`{`
135	`$this->DB_common();`	135	`parent::__construct();`
136	`}`	136	`}`
137		137
138	`// }}}`	138	`// }}}`
139	`// {{{ connect()`	139	`// {{{ connect()`
140		140
141	`/**`	141	`/**`
142	`* Connect to the database server, log in and open the database`	142	`* Connect to the database server, log in and open the database`
143	`*`	143	`*`
144	`* Don't call this method directly. Use DB::connect() instead.`	144	`* Don't call this method directly. Use DB::connect() instead.`
145	`*`	145	`*`
146	`* Example of how to connect:`	146	`* Example of how to connect:`
147	`* <code>`	147	`* <code>`
148	`* require_once 'DB.php';`	148	`* require_once 'DB.php';`
149	`*`	149	`*`
150	`* // $dsn = 'msql://hostname/dbname'; // use a TCP connection`	150	`* // $dsn = 'msql://hostname/dbname'; // use a TCP connection`
151	`* $dsn = 'msql:///dbname'; // use a socket`	151	`* $dsn = 'msql:///dbname'; // use a socket`
152	`* $options = array(`	152	`* $options = array(`
153	`* 'portability' => DB_PORTABILITY_ALL,`	153	`* 'portability' => DB_PORTABILITY_ALL,`
154	`* );`	154	`* );`
155	`*`	155	`*`
156	`* $db =& DB::connect($dsn, $options);`	156	`* $db = DB::connect($dsn, $options);`
157	`* if (PEAR::isError($db)) {`	157	`* if (PEAR::isError($db)) {`
158	`* die($db->getMessage());`	158	`* die($db->getMessage());`
159	`* }`	159	`* }`
160	`* </code>`	160	`* </code>`
161	`*`	161	`*`
162	`* @param array $dsn the data source name`	162	`* @param array $dsn the data source name`
163	`* @param bool $persistent should the connection be persistent?`	163	`* @param bool $persistent should the connection be persistent?`
164	`*`	164	`*`
165	`* @return int DB_OK on success. A DB_Error object on failure.`	165	`* @return int DB_OK on success. A DB_Error object on failure.`
166	`*/`	166	`*/`
167	`function connect($dsn, $persistent = false)`	167	`function connect($dsn, $persistent = false)`
168	`{`	168	`{`
169	`if (!PEAR::loadExtension('msql')) {`	169	`if (!PEAR::loadExtension('msql')) {`
170	`return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);`	170	`return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);`
171	`}`	171	`}`
172		172
173	`$this->dsn = $dsn;`	173	`$this->dsn = $dsn;`
174	`if ($dsn['dbsyntax']) {`	174	`if ($dsn['dbsyntax']) {`
175	`$this->dbsyntax = $dsn['dbsyntax'];`	175	`$this->dbsyntax = $dsn['dbsyntax'];`
176	`}`	176	`}`
177		177
178	`$params = array();`	178	`$params = array();`
179	`if ($dsn['hostspec']) {`	179	`if ($dsn['hostspec']) {`
180	`$params[] = $dsn['port']`	180	`$params[] = $dsn['port']`
181	`? $dsn['hostspec'] . ',' . $dsn['port']`	181	`? $dsn['hostspec'] . ',' . $dsn['port']`
182	`: $dsn['hostspec'];`	182	`: $dsn['hostspec'];`
183	`}`	183	`}`
184		184
185	`$connect_function = $persistent ? 'msql_pconnect' : 'msql_connect';`	185	`$connect_function = $persistent ? 'msql_pconnect' : 'msql_connect';`
186		186
187	`$ini = ini_get('track_errors');`	187	`$ini = ini_get('track_errors');`
188	`$php_errormsg = '';`	188	`$php_errormsg = '';`
189	`if ($ini) {`	189	`if ($ini) {`
190	`$this->connection = @call_user_func_array($connect_function,`	190	`$this->connection = @call_user_func_array($connect_function,`
191	`$params);`	191	`$params);`
192	`} else {`	192	`} else {`
193	`ini_set('track_errors', 1);`	193	`@ini_set('track_errors', 1);`
194	`$this->connection = @call_user_func_array($connect_function,`	194	`$this->connection = @call_user_func_array($connect_function,`
195	`$params);`	195	`$params);`
196	`ini_set('track_errors', $ini);`	196	`@ini_set('track_errors', $ini);`
197	`}`	197	`}`
198		198
199	`if (!$this->connection) {`	199	`if (!$this->connection) {`
200	`if (($err = @msql_error()) != '') {`	200	`if (($err = @msql_error()) != '') {`
201	`return $this->raiseError(DB_ERROR_CONNECT_FAILED,`	201	`return $this->raiseError(DB_ERROR_CONNECT_FAILED,`
202	`null, null, null,`	202	`null, null, null,`
203	`$err);`	203	`$err);`
204	`} else {`	204	`} else {`
205	`return $this->raiseError(DB_ERROR_CONNECT_FAILED,`	205	`return $this->raiseError(DB_ERROR_CONNECT_FAILED,`
206	`null, null, null,`	206	`null, null, null,`
207	`$php_errormsg);`	207	`$php_errormsg);`
208	`}`	208	`}`
209	`}`	209	`}`
210		210
211	`if (!@msql_select_db($dsn['database'], $this->connection)) {`	211	`if (!@msql_select_db($dsn['database'], $this->connection)) {`
212	`return $this->msqlRaiseError();`	212	`return $this->msqlRaiseError();`
213	`}`	213	`}`
214	`return DB_OK;`	214	`return DB_OK;`
215	`}`	215	`}`
216		216
217	`// }}}`	217	`// }}}`
218	`// {{{ disconnect()`	218	`// {{{ disconnect()`
219		219
220	`/**`	220	`/**`
221	`* Disconnects from the database server`	221	`* Disconnects from the database server`
222	`*`	222	`*`
223	`* @return bool TRUE on success, FALSE on failure`	223	`* @return bool TRUE on success, FALSE on failure`
224	`*/`	224	`*/`
225	`function disconnect()`	225	`function disconnect()`
226	`{`	226	`{`
227	`$ret = @msql_close($this->connection);`	227	`$ret = @msql_close($this->connection);`
228	`$this->connection = null;`	228	`$this->connection = null;`
229	`return $ret;`	229	`return $ret;`
230	`}`	230	`}`
231		231
232	`// }}}`	232	`// }}}`
233	`// {{{ simpleQuery()`	233	`// {{{ simpleQuery()`
234		234
235	`/**`	235	`/**`
236	`* Sends a query to the database server`	236	`* Sends a query to the database server`
237	`*`	237	`*`
238	`* @param string the SQL query string`	238	`* @param string the SQL query string`
239	`*`	239	`*`
240	`* @return mixed + a PHP result resrouce for successful SELECT queries`	240	`* @return mixed + a PHP result resrouce for successful SELECT queries`
241	`* + the DB_OK constant for other successful queries`	241	`* + the DB_OK constant for other successful queries`
242	`* + a DB_Error object on failure`	242	`* + a DB_Error object on failure`
243	`*/`	243	`*/`
244	`function simpleQuery($query)`	244	`function simpleQuery($query)`
245	`{`	245	`{`
246	`$this->last_query = $query;`	246	`$this->last_query = $query;`
247	`$query = $this->modifyQuery($query);`	247	`$query = $this->modifyQuery($query);`
248	`$result = @msql_query($query, $this->connection);`	248	`$result = @msql_query($query, $this->connection);`
249	`if (!$result) {`	249	`if (!$result) {`
250	`return $this->msqlRaiseError();`	250	`return $this->msqlRaiseError();`
251	`}`	251	`}`
252	`// Determine which queries that should return data, and which`	252	`// Determine which queries that should return data, and which`
253	`// should return an error code only.`	253	`// should return an error code only.`
254	`if (DB::isManip($query)) {`	254	`if ($this->_checkManip($query)) {`
255	`$this->_result = $result;`	255	`$this->_result = $result;`
256	`return DB_OK;`	256	`return DB_OK;`
257	`} else {`	257	`} else {`
258	`$this->_result = false;`	258	`$this->_result = false;`
259	`return $result;`	259	`return $result;`
260	`}`	260	`}`
261	`}`	261	`}`
262		262
263		263
264	`// }}}`	264	`// }}}`
265	`// {{{ nextResult()`	265	`// {{{ nextResult()`
266		266
267	`/**`	267	`/**`
268	`* Move the internal msql result pointer to the next available result`	268	`* Move the internal msql result pointer to the next available result`
269	`*`	269	`*`
270	`* @param a valid fbsql result resource`	270	`* @param a valid fbsql result resource`
271	`*`	271	`*`
272	`* @access public`	272	`* @access public`
273	`*`	273	`*`
274	`* @return true if a result is available otherwise return false`	274	`* @return true if a result is available otherwise return false`
275	`*/`	275	`*/`
276	`function nextResult($result)`	276	`function nextResult($result)`
277	`{`	277	`{`
278	`return false;`	278	`return false;`
279	`}`	279	`}`
280		280
281	`// }}}`	281	`// }}}`
282	`// {{{ fetchInto()`	282	`// {{{ fetchInto()`
283		283
284	`/**`	284	`/**`
285	`* Places a row from the result set into the given array`	285	`* Places a row from the result set into the given array`
286	`*`	286	`*`
287	`* Formating of the array and the data therein are configurable.`	287	`* Formating of the array and the data therein are configurable.`
288	`* See DB_result::fetchInto() for more information.`	288	`* See DB_result::fetchInto() for more information.`
289	`*`	289	`*`
290	`* This method is not meant to be called directly. Use`	290	`* This method is not meant to be called directly. Use`
291	`* DB_result::fetchInto() instead. It can't be declared "protected"`	291	`* DB_result::fetchInto() instead. It can't be declared "protected"`
292	`* because DB_result is a separate object.`	292	`* because DB_result is a separate object.`
293	`*`	293	`*`
294	`* PHP's mSQL extension did weird things with NULL values prior to PHP`	294	`* PHP's mSQL extension did weird things with NULL values prior to PHP`
295	`* 4.3.11 and 5.0.4. Make sure your version of PHP meets or exceeds`	295	`* 4.3.11 and 5.0.4. Make sure your version of PHP meets or exceeds`
296	`* those versions.`	296	`* those versions.`
297	`*`	297	`*`
298	`* @param resource $result the query result resource`	298	`* @param resource $result the query result resource`
299	`* @param array $arr the referenced array to put the data in`	299	`* @param array $arr the referenced array to put the data in`
300	`* @param int $fetchmode how the resulting array should be indexed`	300	`* @param int $fetchmode how the resulting array should be indexed`
301	`* @param int $rownum the row number to fetch (0 = first row)`	301	`* @param int $rownum the row number to fetch (0 = first row)`
302	`*`	302	`*`
303	`* @return mixed DB_OK on success, NULL when the end of a result set is`	303	`* @return mixed DB_OK on success, NULL when the end of a result set is`
304	`* reached or on failure`	304	`* reached or on failure`
305	`*`	305	`*`
306	`* @see DB_result::fetchInto()`	306	`* @see DB_result::fetchInto()`
307	`*/`	307	`*/`
308	`function fetchInto($result, &$arr, $fetchmode, $rownum = null)`	308	`function fetchInto($result, &$arr, $fetchmode, $rownum = null)`
309	`{`	309	`{`
310	`if ($rownum !== null) {`	310	`if ($rownum !== null) {`
311	`if (!@msql_data_seek($result, $rownum)) {`	311	`if (!@msql_data_seek($result, $rownum)) {`
312	`return null;`	312	`return null;`
313	`}`	313	`}`
314	`}`	314	`}`
315	`if ($fetchmode & DB_FETCHMODE_ASSOC) {`	315	`if ($fetchmode & DB_FETCHMODE_ASSOC) {`
316	`$arr = @msql_fetch_array($result, MSQL_ASSOC);`	316	`$arr = @msql_fetch_array($result, MSQL_ASSOC);`
317	`if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {`	317	`if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {`
318	`$arr = array_change_key_case($arr, CASE_LOWER);`	318	`$arr = array_change_key_case($arr, CASE_LOWER);`
319	`}`	319	`}`
320	`} else {`	320	`} else {`
321	`$arr = @msql_fetch_row($result);`	321	`$arr = @msql_fetch_row($result);`
322	`}`	322	`}`
323	`if (!$arr) {`	323	`if (!$arr) {`
324	`return null;`	324	`return null;`
325	`}`	325	`}`
326	`if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {`	326	`if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {`
327	`$this->_rtrimArrayValues($arr);`	327	`$this->_rtrimArrayValues($arr);`
328	`}`	328	`}`
329	`if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {`	329	`if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {`
330	`$this->_convertNullArrayValuesToEmpty($arr);`	330	`$this->_convertNullArrayValuesToEmpty($arr);`
331	`}`	331	`}`
332	`return DB_OK;`	332	`return DB_OK;`
333	`}`	333	`}`
334		334
335	`// }}}`	335	`// }}}`
336	`// {{{ freeResult()`	336	`// {{{ freeResult()`
337		337
338	`/**`	338	`/**`
339	`* Deletes the result set and frees the memory occupied by the result set`	339	`* Deletes the result set and frees the memory occupied by the result set`
340	`*`	340	`*`
341	`* This method is not meant to be called directly. Use`	341	`* This method is not meant to be called directly. Use`
342	`* DB_result::free() instead. It can't be declared "protected"`	342	`* DB_result::free() instead. It can't be declared "protected"`
343	`* because DB_result is a separate object.`	343	`* because DB_result is a separate object.`
344	`*`	344	`*`
345	`* @param resource $result PHP's query result resource`	345	`* @param resource $result PHP's query result resource`
346	`*`	346	`*`
347	`* @return bool TRUE on success, FALSE if $result is invalid`	347	`* @return bool TRUE on success, FALSE if $result is invalid`
348	`*`	348	`*`
349	`* @see DB_result::free()`	349	`* @see DB_result::free()`
350	`*/`	350	`*/`
351	`function freeResult($result)`	351	`function freeResult($result)`
352	`{`	352	`{`
353	`return @msql_free_result($result);`	353	`return is_resource($result) ? msql_free_result($result) : false;`
354	`}`	354	`}`
355		355
356	`// }}}`	356	`// }}}`
357	`// {{{ numCols()`	357	`// {{{ numCols()`
358		358
359	`/**`	359	`/**`
360	`* Gets the number of columns in a result set`	360	`* Gets the number of columns in a result set`
361	`*`	361	`*`
362	`* This method is not meant to be called directly. Use`	362	`* This method is not meant to be called directly. Use`
363	`* DB_result::numCols() instead. It can't be declared "protected"`	363	`* DB_result::numCols() instead. It can't be declared "protected"`
364	`* because DB_result is a separate object.`	364	`* because DB_result is a separate object.`
365	`*`	365	`*`
366	`* @param resource $result PHP's query result resource`	366	`* @param resource $result PHP's query result resource`
367	`*`	367	`*`
368	`* @return int the number of columns. A DB_Error object on failure.`	368	`* @return int the number of columns. A DB_Error object on failure.`
369	`*`	369	`*`
370	`* @see DB_result::numCols()`	370	`* @see DB_result::numCols()`
371	`*/`	371	`*/`
372	`function numCols($result)`	372	`function numCols($result)`
373	`{`	373	`{`
374	`$cols = @msql_num_fields($result);`	374	`$cols = @msql_num_fields($result);`
375	`if (!$cols) {`	375	`if (!$cols) {`
376	`return $this->msqlRaiseError();`	376	`return $this->msqlRaiseError();`
377	`}`	377	`}`
378	`return $cols;`	378	`return $cols;`
379	`}`	379	`}`
380		380
381	`// }}}`	381	`// }}}`
382	`// {{{ numRows()`	382	`// {{{ numRows()`
383		383
384	`/**`	384	`/**`
385	`* Gets the number of rows in a result set`	385	`* Gets the number of rows in a result set`
386	`*`	386	`*`
387	`* This method is not meant to be called directly. Use`	387	`* This method is not meant to be called directly. Use`
388	`* DB_result::numRows() instead. It can't be declared "protected"`	388	`* DB_result::numRows() instead. It can't be declared "protected"`
389	`* because DB_result is a separate object.`	389	`* because DB_result is a separate object.`
390	`*`	390	`*`
391	`* @param resource $result PHP's query result resource`	391	`* @param resource $result PHP's query result resource`
392	`*`	392	`*`
393	`* @return int the number of rows. A DB_Error object on failure.`	393	`* @return int the number of rows. A DB_Error object on failure.`
394	`*`	394	`*`
395	`* @see DB_result::numRows()`	395	`* @see DB_result::numRows()`
396	`*/`	396	`*/`
397	`function numRows($result)`	397	`function numRows($result)`
398	`{`	398	`{`
399	`$rows = @msql_num_rows($result);`	399	`$rows = @msql_num_rows($result);`
400	`if ($rows === false) {`	400	`if ($rows === false) {`
401	`return $this->msqlRaiseError();`	401	`return $this->msqlRaiseError();`
402	`}`	402	`}`
403	`return $rows;`	403	`return $rows;`
404	`}`	404	`}`
405		405
406	`// }}}`	406	`// }}}`
407	`// {{{ affected()`	407	`// {{{ affected()`
408		408
409	`/**`	409	`/**`
410	`* Determines the number of rows affected by a data maniuplation query`	410	`* Determines the number of rows affected by a data maniuplation query`
411	`*`	411	`*`
412	`* 0 is returned for queries that don't manipulate data.`	412	`* 0 is returned for queries that don't manipulate data.`
413	`*`	413	`*`
414	`* @return int the number of rows. A DB_Error object on failure.`	414	`* @return int the number of rows. A DB_Error object on failure.`
415	`*/`	415	`*/`
416	`function affectedRows()`	416	`function affectedRows()`
417	`{`	417	`{`
418	`if (!$this->_result) {`	418	`if (!$this->_result) {`
419	`return 0;`	419	`return 0;`
420	`}`	420	`}`
421	`return msql_affected_rows($this->_result);`	421	`return msql_affected_rows($this->_result);`
422	`}`	422	`}`
423		423
424	`// }}}`	424	`// }}}`
425	`// {{{ nextId()`	425	`// {{{ nextId()`
426		426
427	`/**`	427	`/**`
428	`* Returns the next free id in a sequence`	428	`* Returns the next free id in a sequence`
429	`*`	429	`*`
430	`* @param string $seq_name name of the sequence`	430	`* @param string $seq_name name of the sequence`
431	`* @param boolean $ondemand when true, the seqence is automatically`	431	`* @param boolean $ondemand when true, the seqence is automatically`
432	`* created if it does not exist`	432	`* created if it does not exist`
433	`*`	433	`*`
434	`* @return int the next id number in the sequence.`	434	`* @return int the next id number in the sequence.`
435	`* A DB_Error object on failure.`	435	`* A DB_Error object on failure.`
436	`*`	436	`*`
437	`* @see DB_common::nextID(), DB_common::getSequenceName(),`	437	`* @see DB_common::nextID(), DB_common::getSequenceName(),`
438	`* DB_msql::createSequence(), DB_msql::dropSequence()`	438	`* DB_msql::createSequence(), DB_msql::dropSequence()`
439	`*/`	439	`*/`
440	`function nextId($seq_name, $ondemand = true)`	440	`function nextId($seq_name, $ondemand = true)`
441	`{`	441	`{`
442	`$seqname = $this->getSequenceName($seq_name);`	442	`$seqname = $this->getSequenceName($seq_name);`
443	`$repeat = false;`	443	`$repeat = false;`
444	`do {`	444	`do {`
445	`$this->pushErrorHandling(PEAR_ERROR_RETURN);`	445	`$this->pushErrorHandling(PEAR_ERROR_RETURN);`
446	`$result =& $this->query("SELECT _seq FROM ${seqname}");`	446	`$result = $this->query("SELECT _seq FROM ${seqname}");`
447	`$this->popErrorHandling();`	447	`$this->popErrorHandling();`
448	`if ($ondemand && DB::isError($result) &&`	448	`if ($ondemand && DB::isError($result) &&`
449	`$result->getCode() == DB_ERROR_NOSUCHTABLE) {`	449	`$result->getCode() == DB_ERROR_NOSUCHTABLE) {`
450	`$repeat = true;`	450	`$repeat = true;`
451	`$this->pushErrorHandling(PEAR_ERROR_RETURN);`	451	`$this->pushErrorHandling(PEAR_ERROR_RETURN);`
452	`$result = $this->createSequence($seq_name);`	452	`$result = $this->createSequence($seq_name);`
453	`$this->popErrorHandling();`	453	`$this->popErrorHandling();`
454	`if (DB::isError($result)) {`	454	`if (DB::isError($result)) {`
455	`return $this->raiseError($result);`	455	`return $this->raiseError($result);`
456	`}`	456	`}`
457	`} else {`	457	`} else {`
458	`$repeat = false;`	458	`$repeat = false;`
459	`}`	459	`}`
460	`} while ($repeat);`	460	`} while ($repeat);`
461	`if (DB::isError($result)) {`	461	`if (DB::isError($result)) {`
462	`return $this->raiseError($result);`	462	`return $this->raiseError($result);`
463	`}`	463	`}`
464	`$arr = $result->fetchRow(DB_FETCHMODE_ORDERED);`	464	`$arr = $result->fetchRow(DB_FETCHMODE_ORDERED);`
465	`$result->free();`	465	`$result->free();`
466	`return $arr[0];`	466	`return $arr[0];`
467	`}`	467	`}`
468		468
469	`// }}}`	469	`// }}}`
470	`// {{{ createSequence()`	470	`// {{{ createSequence()`
471		471
472	`/**`	472	`/**`
473	`* Creates a new sequence`	473	`* Creates a new sequence`
474	`*`	474	`*`
475	`* Also creates a new table to associate the sequence with. Uses`	475	`* Also creates a new table to associate the sequence with. Uses`
476	`* a separate table to ensure portability with other drivers.`	476	`* a separate table to ensure portability with other drivers.`
477	`*`	477	`*`
478	`* @param string $seq_name name of the new sequence`	478	`* @param string $seq_name name of the new sequence`
479	`*`	479	`*`
480	`* @return int DB_OK on success. A DB_Error object on failure.`	480	`* @return int DB_OK on success. A DB_Error object on failure.`
481	`*`	481	`*`
482	`* @see DB_common::createSequence(), DB_common::getSequenceName(),`	482	`* @see DB_common::createSequence(), DB_common::getSequenceName(),`
483	`* DB_msql::nextID(), DB_msql::dropSequence()`	483	`* DB_msql::nextID(), DB_msql::dropSequence()`
484	`*/`	484	`*/`
485	`function createSequence($seq_name)`	485	`function createSequence($seq_name)`
486	`{`	486	`{`
487	`$seqname = $this->getSequenceName($seq_name);`	487	`$seqname = $this->getSequenceName($seq_name);`
488	`$res = $this->query('CREATE TABLE ' . $seqname`	488	`$res = $this->query('CREATE TABLE ' . $seqname`
489	`. ' (id INTEGER NOT NULL)');`	489	`. ' (id INTEGER NOT NULL)');`
490	`if (DB::isError($res)) {`	490	`if (DB::isError($res)) {`
491	`return $res;`	491	`return $res;`
492	`}`	492	`}`
493	`$res = $this->query("CREATE SEQUENCE ON ${seqname}");`	493	`$res = $this->query("CREATE SEQUENCE ON ${seqname}");`
494	`return $res;`	494	`return $res;`
495	`}`	495	`}`
496		496
497	`// }}}`	497	`// }}}`
498	`// {{{ dropSequence()`	498	`// {{{ dropSequence()`
499		499
500	`/**`	500	`/**`

Subversion Repositories Applications.gtt

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