Subversion Repositories Applications.bazar

<?php

/* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */

// +----------------------------------------------------------------------+

// | PHP Version 4                                                        |

// +----------------------------------------------------------------------+

// | Copyright (c) 1997-2004 The PHP Group                                |

// +----------------------------------------------------------------------+

// | This source file is subject to version 2.02 of the PHP license,      |

// | that is bundled with this package in the file LICENSE, and is        |

// | available at through the world-wide-web at                           |

// | http://www.php.net/license/2_02.txt.                                 |

// | If you did not receive a copy of the PHP license and are unable to   |

// | obtain it through the world-wide-web, please send a note to          |

// | license@php.net so we can mail you a copy immediately.               |

// +----------------------------------------------------------------------+

// | Author: Stig Bakken <ssb@php.net>                                    |

// | Maintainer: Daniel Convissor <danielc@php.net>                       |

// +----------------------------------------------------------------------+

//

// $Id$

// XXX legend:

//

// XXX ERRORMSG: The error message from the mysql function should

//               be registered here.

//

// TODO/wishlist:

// longReadlen

// binmode

require_once 'DB/common.php';

/**

 * Database independent query interface definition for PHP's MySQL

 * extension.

 *

 * This is for MySQL versions 4.0 and below.

 *

 * @package  DB

 * @version  $Id$

 * @category Database

 * @author   Stig Bakken <ssb@php.net>

 */

class DB_mysql extends DB_common

{

    // {{{ properties

    var $connection;

    var $phptype, $dbsyntax;

    var $prepare_tokens = array();

    var $prepare_types = array();

    var $num_rows = array();

    var $transaction_opcount = 0;

    var $autocommit = true;

    var $fetchmode = DB_FETCHMODE_ORDERED; /* Default fetch mode */

    var $_db = false;

    // }}}

    // {{{ constructor

    /**

     * DB_mysql constructor.

     *

     * @access public

     */

    function DB_mysql()

    {

        $this->DB_common();

        $this->phptype = 'mysql';

        $this->dbsyntax = 'mysql';

        $this->features = array(

            'prepare' => false,

            'pconnect' => true,

            'transactions' => true,

            'limit' => 'alter'

        );

        $this->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,

            1046 => DB_ERROR_NODBSELECTED,

            1048 => DB_ERROR_CONSTRAINT,

            1050 => DB_ERROR_ALREADY_EXISTS,

            1051 => DB_ERROR_NOSUCHTABLE,

            1054 => DB_ERROR_NOSUCHFIELD,

            1062 => DB_ERROR_ALREADY_EXISTS,

            1064 => DB_ERROR_SYNTAX,

            1100 => DB_ERROR_NOT_LOCKED,

            1136 => DB_ERROR_VALUE_COUNT_ON_ROW,

            1146 => DB_ERROR_NOSUCHTABLE,

            1216 => DB_ERROR_CONSTRAINT,

            1217 => DB_ERROR_CONSTRAINT,

        );

    }

    // }}}

    // {{{ connect()

    /**

     * Connect to a database and log in as the specified user.

     *

     * @param $dsn the data source name (see DB::parseDSN for syntax)

     * @param $persistent (optional) whether the connection should

     *        be persistent

     * @access public

     * @return int DB_OK on success, a DB error on failure

     */

    function connect($dsninfo, $persistent = false)

    {

        if (!DB::assertExtension('mysql')) {

            return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);

        }

        $this->dsn = $dsninfo;

        if ($dsninfo['protocol'] && $dsninfo['protocol'] == 'unix') {

            $dbhost = ':' . $dsninfo['socket'];

        } else {

            $dbhost = $dsninfo['hostspec'] ? $dsninfo['hostspec'] : 'localhost';

            if ($dsninfo['port']) {

                $dbhost .= ':' . $dsninfo['port'];

            }

        }

        $connect_function = $persistent ? 'mysql_pconnect' : 'mysql_connect';

        if ($dbhost && $dsninfo['username'] && isset($dsninfo['password'])) {

            $conn = @$connect_function($dbhost, $dsninfo['username'],

                                       $dsninfo['password']);

        } elseif ($dbhost && $dsninfo['username']) {

            $conn = @$connect_function($dbhost, $dsninfo['username']);

        } elseif ($dbhost) {

            $conn = @$connect_function($dbhost);

        } else {

            $conn = false;

        }

        if (!$conn) {

            if (($err = @mysql_error()) != '') {

                return $this->raiseError(DB_ERROR_CONNECT_FAILED, null, null,

                                         null, $err);

            } elseif (empty($php_errormsg)) {

                return $this->raiseError(DB_ERROR_CONNECT_FAILED);

            } else {

                return $this->raiseError(DB_ERROR_CONNECT_FAILED, null, null,

                                         null, $php_errormsg);

            }

        }

        if ($dsninfo['database']) {

            if (!@mysql_select_db($dsninfo['database'], $conn)) {

               switch(mysql_errno($conn)) {

                        case 1049:

                            return $this->raiseError(DB_ERROR_NOSUCHDB, null, null,

                                                     null, @mysql_error($conn));

                        case 1044:

                             return $this->raiseError(DB_ERROR_ACCESS_VIOLATION, null, null,

                                                      null, @mysql_error($conn));

                        default:

                            return $this->raiseError(DB_ERROR, null, null,

                                                     null, @mysql_error($conn));

                    }

            }

            // fix to allow calls to different databases in the same script

            $this->_db = $dsninfo['database'];

        }

        $this->connection = $conn;

        return DB_OK;

    }

    // }}}

    // {{{ disconnect()

    /**

     * Log out and disconnect from the database.

     *

     * @access public

     *

     * @return bool true on success, false if not connected.

     */

    function disconnect()

    {

        $ret = @mysql_close($this->connection);

        $this->connection = null;

        return $ret;

    }

    // }}}

    // {{{ simpleQuery()

    /**

     * Send a query to MySQL and return the results as a MySQL resource

     * identifier.

     *

     * @param the SQL query

     *

     * @access public

     *

     * @return mixed returns a valid MySQL result for successful SELECT

     * queries, DB_OK for other successful queries.  A DB error is

     * returned on failure.

     */

    function simpleQuery($query)

    {

        $ismanip = DB::isManip($query);

        $this->last_query = $query;

        $query = $this->modifyQuery($query);

        if ($this->_db) {

            if (!@mysql_select_db($this->_db, $this->connection)) {

                return $this->mysqlRaiseError(DB_ERROR_NODBSELECTED);

            }

        }

        if (!$this->autocommit && $ismanip) {

            if ($this->transaction_opcount == 0) {

                $result = @mysql_query('SET AUTOCOMMIT=0', $this->connection);

                $result = @mysql_query('BEGIN', $this->connection);

                if (!$result) {

                    return $this->mysqlRaiseError();

                }

            }

            $this->transaction_opcount++;

        }

        $result = @mysql_query($query, $this->connection);

        if (!$result) {

            return $this->mysqlRaiseError();

        }

        if (is_resource($result)) {

            $numrows = $this->numrows($result);

            if (is_object($numrows)) {

                return $numrows;

            }

            $this->num_rows[(int)$result] = $numrows;

            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 a valid sql result resource

     *

     * @access public

     *

     * @return false

     */

    function nextResult($result)

    {

        return false;

    }

    // }}}

    // {{{ fetchInto()

    /**

     * Fetch a row and insert the data into an existing array.

     *

     * Formating of the array and the data therein are configurable.

     * See DB_result::fetchInto() for more information.

     *

     * @param resource $result    query result identifier

     * @param array    $arr       (reference) array where data from the row

     *                            should be placed

     * @param int      $fetchmode how the resulting array should be indexed

     * @param int      $rownum    the row number to fetch

     *

     * @return mixed DB_OK on success, null when end of result set is

     *               reached or on failure

     *

     * @see DB_result::fetchInto()

     * @access private

     */

    function fetchInto($result, &$arr, $fetchmode, $rownum=null)

    {

        if ($rownum !== null) {

            if (!@mysql_data_seek($result, $rownum)) {

                return null;

            }

        }

        if ($fetchmode & DB_FETCHMODE_ASSOC) {

            $arr = @mysql_fetch_array($result, MYSQL_ASSOC);

            if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {

                $arr = array_change_key_case($arr, CASE_LOWER);

            }

        } else {

            $arr = @mysql_fetch_row($result);

        }

        if (!$arr) {

            // See: http://bugs.php.net/bug.php?id=22328

            // for why we can't check errors on fetching

            return null;

            /*

            $errno = @mysql_errno($this->connection);

            if (!$errno) {

                return null;

            }

            return $this->mysqlRaiseError($errno);

            */

        }

        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()

    /**

     * Free the internal resources associated with $result.

     *

     * @param $result MySQL result identifier

     *

     * @access public

     *

     * @return bool true on success, false if $result is invalid

     */

    function freeResult($result)

    {

        unset($this->num_rows[(int)$result]);

        return @mysql_free_result($result);

    }

    // }}}

    // {{{ numCols()

    /**

     * Get the number of columns in a result set.

     *

     * @param $result MySQL result identifier

     *

     * @access public

     *

     * @return int the number of columns per row in $result

     */

    function numCols($result)

    {

        $cols = @mysql_num_fields($result);

        if (!$cols) {

            return $this->mysqlRaiseError();

        }

        return $cols;

    }

    // }}}

    // {{{ numRows()

    /**

     * Get the number of rows in a result set.

     *

     * @param $result MySQL result identifier

     *

     * @access public

     *

     * @return int the number of rows in $result

     */

    function numRows($result)

    {

        $rows = @mysql_num_rows($result);

        if ($rows === null) {

            return $this->mysqlRaiseError();

        }

        return $rows;

    }

    // }}}

    // {{{ autoCommit()

    /**

     * Enable/disable automatic commits

     */

    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()

    /**

     * Commit the current transaction.

     */

    function commit()

    {

        if ($this->transaction_opcount > 0) {

            if ($this->_db) {

                if (!@mysql_select_db($this->_db, $this->connection)) {

                    return $this->mysqlRaiseError(DB_ERROR_NODBSELECTED);

                }

            }

            $result = @mysql_query('COMMIT', $this->connection);

            $result = @mysql_query('SET AUTOCOMMIT=1', $this->connection);

            $this->transaction_opcount = 0;

            if (!$result) {

                return $this->mysqlRaiseError();

            }

        }

        return DB_OK;

    }

    // }}}

    // {{{ rollback()

    /**

     * Roll back (undo) the current transaction.

     */

    function rollback()

    {

        if ($this->transaction_opcount > 0) {

            if ($this->_db) {

                if (!@mysql_select_db($this->_db, $this->connection)) {

                    return $this->mysqlRaiseError(DB_ERROR_NODBSELECTED);

                }

            }

            $result = @mysql_query('ROLLBACK', $this->connection);

            $result = @mysql_query('SET AUTOCOMMIT=1', $this->connection);

            $this->transaction_opcount = 0;

            if (!$result) {

                return $this->mysqlRaiseError();

            }

        }

        return DB_OK;

    }

    // }}}

    // {{{ affectedRows()

    /**

     * Gets the number of rows affected by the data manipulation

     * query.  For other queries, this function returns 0.

     *

     * @return number of rows affected by the last query

     */

    function affectedRows()

    {

        if (DB::isManip($this->last_query)) {

            return @mysql_affected_rows($this->connection);

        } else {

            return 0;

        }

     }

    // }}}

    // {{{ errorNative()

    /**

     * Get the native error code of the last error (if any) that

     * occured on the current connection.

     *

     * @access public

     *

     * @return int native MySQL error code

     */

    function errorNative()

    {

        return @mysql_errno($this->connection);

    }

    // }}}

    // {{{ 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.  DB_Error if problem.

     *

     * @internal

     * @see DB_common::nextID()

     * @access public

     */

    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 = @mysql_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) {

                    // Failed to get the lock, bail with a DB_ERROR_NOT_LOCKED error

                    return $this->mysqlRaiseError(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;

            /** ONDEMAND TABLE CREATION **/

            } elseif ($ondemand && DB::isError($result) &&

                $result->getCode() == DB_ERROR_NOSUCHTABLE)

            {

                $result = $this->createSequence($seq_name);

                if (DB::isError($result)) {

                    return $this->raiseError($result);

                } else {

                    $repeat = 1;

                }

            /** BACKWARDS COMPAT **/

            } elseif (DB::isError($result) &&

                      $result->getCode() == DB_ERROR_ALREADY_EXISTS)

            {

                // see _BCsequence() comment

                $result = $this->_BCsequence($seqname);

                if (DB::isError($result)) {

                    return $this->raiseError($result);

                }

                $repeat = 1;

            }

        } while ($repeat);

        return $this->raiseError($result);

    }

    // }}}

    // {{{ createSequence()

    /**

     * Creates a new sequence

     *

     * @param string $seq_name  name of the new sequence

     *

     * @return int  DB_OK on success.  A DB_Error object is returned if

     *              problems arise.

     *

     * @internal

     * @see DB_common::createSequence()

     * @access public

     */

    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

        $res = $this->query("INSERT INTO ${seqname} (id) VALUES (0)");

        if (DB::isError($res)) {

            return $res;

        }

        // so reset to zero

        return $this->query("UPDATE ${seqname} SET id = 0;");

    }

    // }}}

    // {{{ dropSequence()

    /**

     * Deletes a sequence

     *

     * @param string $seq_name  name of the sequence to be deleted

     *

     * @return int  DB_OK on success.  DB_Error if problems.

     *

     * @internal

     * @see DB_common::dropSequence()

     * @access public

     */

    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 mixed DB_Error or true

     */

    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->mysqlRaiseError(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()

    /**

     * Quote a string so it can be safely used as a table or column name

     *

     * Quoting style depends on which database driver is being used.

     *

     * 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

     *

     * @since 1.6.0

     * @access public

     * @internal

     */

    function quoteIdentifier($str)

    {

        return '`' . $str . '`';

    }

    // }}}

    // {{{ quote()

    /**

     * @deprecated  Deprecated in release 1.6.0

     * @internal

     */

    function quote($str) {

        return $this->quoteSmart($str);

    }

    // }}}

    // {{{ escapeSimple()

    /**

     * Escape a string according to the current DBMS's standards

     *

     * @param string $str  the string to be escaped

     *

     * @return string  the escaped string

     *

     * @internal

     */

    function escapeSimple($str) {

        if (function_exists('mysql_real_escape_string')) {

            return @mysql_real_escape_string($str, $this->connection);

        } else {

            return @mysql_escape_string($str);

        }

    }

    // }}}

    // {{{ modifyQuery()

    function modifyQuery($query)

    {

        if ($this->options['portability'] & DB_PORTABILITY_DELETE_COUNT) {

            // "DELETE FROM table" gives 0 affected rows in MySQL.

            // This little hack lets you know how many rows were deleted.

            if (preg_match('/^\s*DELETE\s+FROM\s+(\S+)\s*$/i', $query)) {

                $query = preg_replace('/^\s*DELETE\s+FROM\s+(\S+)\s*$/',

                                      'DELETE FROM \1 WHERE 1=1', $query);

            }

        }

        return $query;

    }

    // }}}

    // {{{ modifyLimitQuery()

    function modifyLimitQuery($query, $from, $count, $params = array())

    {

        if (DB::isManip($query)) {

            return $query . " LIMIT $count";

        } else {

            return $query . " LIMIT $from, $count";

        }

    }

    // }}}

    // {{{ mysqlRaiseError()

    /**

     * Gather information about an error, then use that info to create a

     * DB error object and finally return that object.

     *

     * @param  integer  $errno  PEAR error number (usually a DB constant) if

     *                          manually raising an error

     * @return object  DB error object

     * @see DB_common::errorCode()

     * @see DB_common::raiseError()

     */

    function mysqlRaiseError($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(mysql_errno($this->connection));

        }

        return $this->raiseError($errno, null, null, null,

                                 @mysql_errno($this->connection) . ' ** ' .

                                 @mysql_error($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

     * @param int            $mode    a valid tableInfo mode

     * @return array  an associative array with the information requested

     *                or an error object if something is wrong

     * @access public

     * @internal

     * @see DB_common::tableInfo()

     */

    function tableInfo($result, $mode = null) {

        if (isset($result->result)) {

            /*

             * Probably received a result object.

             * Extract the result resource identifier.

             */

            $id = $result->result;

            $got_string = false;

        } elseif (is_string($result)) {

            /*

             * Probably received a table name.

             * Create a result resource identifier.

             */

            $id = @mysql_list_fields($this->dsn['database'],

                                     $result, $this->connection);

            $got_string = true;

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

        }

        if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE) {

            $case_func = 'strtolower';

        } else {

            $case_func = 'strval';

        }

        $count = @mysql_num_fields($id);

        // made this IF due to performance (one if is faster than $count if's)

        if (!$mode) {

            for ($i=0; $i<$count; $i++) {

                $res[$i]['table'] = $case_func(@mysql_field_table($id, $i));

                $res[$i]['name']  = $case_func(@mysql_field_name($id, $i));

                $res[$i]['type']  = @mysql_field_type($id, $i);

                $res[$i]['len']   = @mysql_field_len($id, $i);

                $res[$i]['flags'] = @mysql_field_flags($id, $i);

            }

        } else { // full

            $res['num_fields']= $count;

            for ($i=0; $i<$count; $i++) {

                $res[$i]['table'] = $case_func(@mysql_field_table($id, $i));

                $res[$i]['name']  = $case_func(@mysql_field_name($id, $i));

                $res[$i]['type']  = @mysql_field_type($id, $i);

                $res[$i]['len']   = @mysql_field_len($id, $i);

                $res[$i]['flags'] = @mysql_field_flags($id, $i);

                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) {

            @mysql_free_result($id);

        }

        return $res;

    }

    // }}}

    // {{{ getSpecialQuery()

    /**

     * Returns the query needed to get some backend info

     * @param string $type What kind of info you want to retrieve

     * @return string The SQL query string

     */

    function getSpecialQuery($type)

    {

        switch ($type) {

            case 'tables':

                return 'SHOW TABLES';

            case 'views':

                return DB_ERROR_NOT_CAPABLE;

            case 'users':

                $sql = 'select distinct User from user';

                if ($this->dsn['database'] != 'mysql') {

                    $dsn = $this->dsn;

                    $dsn['database'] = 'mysql';

                    if (DB::isError($db = DB::connect($dsn))) {

                        return $db;

                    }

                    $sql = $db->getCol($sql);

                    $db->disconnect();

                    // XXX Fixme the mysql driver should take care of this

                    if (!@mysql_select_db($this->dsn['database'], $this->connection)) {

                        return $this->mysqlRaiseError(DB_ERROR_NODBSELECTED);

                    }

                }

                return $sql;

            case 'databases':

                return 'SHOW DATABASES';

            default:

                return null;

        }

    }

    // }}}

}

/*

 * Local variables:

 * tab-width: 4

 * c-basic-offset: 4

 * End:

 */

?>