Database.php

Go to the documentation of this file.

<?php
 
interface DatabaseType {
    function getType();
 
    function open( $server, $user, $password, $dbName );
 
    function fetchObject( $res );
 
    function fetchRow( $res );
 
    function numRows( $res );
 
    function numFields( $res );
 
    function fieldName( $res, $n );
 
    function insertId();
 
    function dataSeek( $res, $row );
 
    function lastErrno();
 
    function lastError();
 
    function fieldInfo( $table, $field );
 
    function indexInfo( $table, $index, $fname = __METHOD__ );
 
    function affectedRows();
 
    function strencode( $s );
 
    function getSoftwareLink();
 
    function getServerVersion();
 
    function getServerInfo();
}
 
interface IDatabase {
}
 
abstract class DatabaseBase implements IDatabase, DatabaseType {
    const DEADLOCK_TRIES = 4;
 
    const DEADLOCK_DELAY_MIN = 500000;
 
    const DEADLOCK_DELAY_MAX = 1500000;
 
# ------------------------------------------------------------------------------
# Variables
# ------------------------------------------------------------------------------
 
    protected $mLastQuery = '';
    protected $mDoneWrites = false;
    protected $mPHPError = false;
 
    protected $mServer, $mUser, $mPassword, $mDBname;
 
    protected $mConn = null;
    protected $mOpened = false;
 
    protected $mTrxIdleCallbacks = array();
    protected $mTrxPreCommitCallbacks = array();
 
    protected $mTablePrefix;
    protected $mSchema;
    protected $mFlags;
    protected $mForeign;
    protected $mErrorCount = 0;
    protected $mLBInfo = array();
    protected $mDefaultBigSelects = null;
    protected $mSchemaVars = false;
 
    protected $preparedArgs;
 
    protected $htmlErrors;
 
    protected $delimiter = ';';
 
    protected $mTrxLevel = 0;
 
    private $mTrxFname = null;
 
    private $mTrxDoneWrites = false;
 
    private $mTrxAutomatic = false;
 
    private $mTrxAtomicLevels;
 
    private $mTrxAutomaticAtomic = false;
 
    protected $fileHandle = null;
 
    protected $allViews = null;
 
# ------------------------------------------------------------------------------
# Accessors
# ------------------------------------------------------------------------------
    # These optionally set a variable and return the previous state
 
    public function getServerInfo() {
        return $this->getServerVersion();
    }
 
    public function getDelimiter() {
        return $this->delimiter;
    }
 
    public function debug( $debug = null ) {
        return wfSetBit( $this->mFlags, DBO_DEBUG, $debug );
    }
 
    public function bufferResults( $buffer = null ) {
        if ( is_null( $buffer ) ) {
            return !(bool)( $this->mFlags & DBO_NOBUFFER );
        } else {
            return !wfSetBit( $this->mFlags, DBO_NOBUFFER, !$buffer );
        }
    }
 
    public function ignoreErrors( $ignoreErrors = null ) {
        return wfSetBit( $this->mFlags, DBO_IGNORE, $ignoreErrors );
    }
 
    public function trxLevel() {
        return $this->mTrxLevel;
    }
 
    public function errorCount( $count = null ) {
        return wfSetVar( $this->mErrorCount, $count );
    }
 
    public function tablePrefix( $prefix = null ) {
        return wfSetVar( $this->mTablePrefix, $prefix );
    }
 
    public function dbSchema( $schema = null ) {
        return wfSetVar( $this->mSchema, $schema );
    }
 
    public function setFileHandle( $fh ) {
        $this->fileHandle = $fh;
    }
 
    public function getLBInfo( $name = null ) {
        if ( is_null( $name ) ) {
            return $this->mLBInfo;
        } else {
            if ( array_key_exists( $name, $this->mLBInfo ) ) {
                return $this->mLBInfo[$name];
            } else {
                return null;
            }
        }
    }
 
    public function setLBInfo( $name, $value = null ) {
        if ( is_null( $value ) ) {
            $this->mLBInfo = $name;
        } else {
            $this->mLBInfo[$name] = $value;
        }
    }
 
    public function setFakeSlaveLag( $lag ) {
    }
 
    public function setFakeMaster( $enabled = true ) {
    }
 
    public function cascadingDeletes() {
        return false;
    }
 
    public function cleanupTriggers() {
        return false;
    }
 
    public function strictIPs() {
        return false;
    }
 
    public function realTimestamps() {
        return false;
    }
 
    public function implicitGroupby() {
        return true;
    }
 
    public function implicitOrderby() {
        return true;
    }
 
    public function searchableIPs() {
        return false;
    }
 
    public function functionalIndexes() {
        return false;
    }
 
    public function lastQuery() {
        return $this->mLastQuery;
    }
 
    public function doneWrites() {
        return $this->mDoneWrites;
    }
 
    public function writesOrCallbacksPending() {
        return $this->mTrxLevel && (
            $this->mTrxDoneWrites || $this->mTrxIdleCallbacks || $this->mTrxPreCommitCallbacks
        );
    }
 
    public function isOpen() {
        return $this->mOpened;
    }
 
    public function setFlag( $flag ) {
        global $wgDebugDBTransactions;
        $this->mFlags |= $flag;
        if ( ( $flag & DBO_TRX ) && $wgDebugDBTransactions ) {
            wfDebug( "Implicit transactions are now enabled.\n" );
        }
    }
 
    public function clearFlag( $flag ) {
        global $wgDebugDBTransactions;
        $this->mFlags &= ~$flag;
        if ( ( $flag & DBO_TRX ) && $wgDebugDBTransactions ) {
            wfDebug( "Implicit transactions are now disabled.\n" );
        }
    }
 
    public function getFlag( $flag ) {
        return !!( $this->mFlags & $flag );
    }
 
    public function getProperty( $name ) {
        return $this->$name;
    }
 
    public function getWikiID() {
        if ( $this->mTablePrefix ) {
            return "{$this->mDBname}-{$this->mTablePrefix}";
        } else {
            return $this->mDBname;
        }
    }
 
    public function getSchemaPath() {
        global $IP;
        if ( file_exists( "$IP/maintenance/" . $this->getType() . "/tables.sql" ) ) {
            return "$IP/maintenance/" . $this->getType() . "/tables.sql";
        } else {
            return "$IP/maintenance/tables.sql";
        }
    }
 
# ------------------------------------------------------------------------------
# Other functions
# ------------------------------------------------------------------------------
 
    function __construct( $params = null ) {
        global $wgDBprefix, $wgDBmwschema, $wgCommandLineMode, $wgDebugDBTransactions;
 
        $this->mTrxAtomicLevels = new SplStack;
 
        if ( is_array( $params ) ) { // MW 1.22
            $server = $params['host'];
            $user = $params['user'];
            $password = $params['password'];
            $dbName = $params['dbname'];
            $flags = $params['flags'];
            $tablePrefix = $params['tablePrefix'];
            $schema = $params['schema'];
            $foreign = $params['foreign'];
        } else { // legacy calling pattern
            wfDeprecated( __METHOD__ . " method called without parameter array.", "1.23" );
            $args = func_get_args();
            $server = isset( $args[0] ) ? $args[0] : false;
            $user = isset( $args[1] ) ? $args[1] : false;
            $password = isset( $args[2] ) ? $args[2] : false;
            $dbName = isset( $args[3] ) ? $args[3] : false;
            $flags = isset( $args[4] ) ? $args[4] : 0;
            $tablePrefix = isset( $args[5] ) ? $args[5] : 'get from global';
            $schema = 'get from global';
            $foreign = isset( $args[6] ) ? $args[6] : false;
        }
 
        $this->mFlags = $flags;
        if ( $this->mFlags & DBO_DEFAULT ) {
            if ( $wgCommandLineMode ) {
                $this->mFlags &= ~DBO_TRX;
                if ( $wgDebugDBTransactions ) {
                    wfDebug( "Implicit transaction open disabled.\n" );
                }
            } else {
                $this->mFlags |= DBO_TRX;
                if ( $wgDebugDBTransactions ) {
                    wfDebug( "Implicit transaction open enabled.\n" );
                }
            }
        }
 
        if ( $tablePrefix == 'get from global' ) {
            $this->mTablePrefix = $wgDBprefix;
        } else {
            $this->mTablePrefix = $tablePrefix;
        }
 
        if ( $schema == 'get from global' ) {
            $this->mSchema = $wgDBmwschema;
        } else {
            $this->mSchema = $schema;
        }
 
        $this->mForeign = $foreign;
 
        if ( $user ) {
            $this->open( $server, $user, $password, $dbName );
        }
    }
 
    public function __sleep() {
        throw new MWException( 'Database serialization may cause problems, since ' .
            'the connection is not restored on wakeup.' );
    }
 
    final public static function factory( $dbType, $p = array() ) {
        $canonicalDBTypes = array(
            'mysql' => array( 'mysqli', 'mysql' ),
            'postgres' => array(),
            'sqlite' => array(),
            'oracle' => array(),
            'mssql' => array(),
        );
 
        $driver = false;
        $dbType = strtolower( $dbType );
        if ( isset( $canonicalDBTypes[$dbType] ) && $canonicalDBTypes[$dbType] ) {
            $possibleDrivers = $canonicalDBTypes[$dbType];
            if ( !empty( $p['driver'] ) ) {
                if ( in_array( $p['driver'], $possibleDrivers ) ) {
                    $driver = $p['driver'];
                } else {
                    throw new MWException( __METHOD__ .
                        " cannot construct Database with type '$dbType' and driver '{$p['driver']}'" );
                }
            } else {
                foreach ( $possibleDrivers as $posDriver ) {
                    if ( extension_loaded( $posDriver ) ) {
                        $driver = $posDriver;
                        break;
                    }
                }
            }
        } else {
            $driver = $dbType;
        }
        if ( $driver === false ) {
            throw new MWException( __METHOD__ .
                " no viable database extension found for type '$dbType'" );
        }
 
        // Determine schema defaults. Currently Microsoft SQL Server uses $wgDBmwschema,
        // and everything else doesn't use a schema (e.g. null)
        // Although postgres and oracle support schemas, we don't use them (yet)
        // to maintain backwards compatibility
        $defaultSchemas = array(
            'mysql' => null,
            'postgres' => null,
            'sqlite' => null,
            'oracle' => null,
            'mssql' => 'get from global',
        );
 
        $class = 'Database' . ucfirst( $driver );
        if ( class_exists( $class ) && is_subclass_of( $class, 'DatabaseBase' ) ) {
            $params = array(
                'host' => isset( $p['host'] ) ? $p['host'] : false,
                'user' => isset( $p['user'] ) ? $p['user'] : false,
                'password' => isset( $p['password'] ) ? $p['password'] : false,
                'dbname' => isset( $p['dbname'] ) ? $p['dbname'] : false,
                'flags' => isset( $p['flags'] ) ? $p['flags'] : 0,
                'tablePrefix' => isset( $p['tablePrefix'] ) ? $p['tablePrefix'] : 'get from global',
                'schema' => isset( $p['schema'] ) ? $p['schema'] : $defaultSchemas[$dbType],
                'foreign' => isset( $p['foreign'] ) ? $p['foreign'] : false
            );
 
            return new $class( $params );
        } else {
            return null;
        }
    }
 
    protected function installErrorHandler() {
        $this->mPHPError = false;
        $this->htmlErrors = ini_set( 'html_errors', '0' );
        set_error_handler( array( $this, 'connectionErrorHandler' ) );
    }
 
    protected function restoreErrorHandler() {
        restore_error_handler();
        if ( $this->htmlErrors !== false ) {
            ini_set( 'html_errors', $this->htmlErrors );
        }
        if ( $this->mPHPError ) {
            $error = preg_replace( '!\[<a.*</a>\]!', '', $this->mPHPError );
            $error = preg_replace( '!^.*?:\s?(.*)$!', '$1', $error );
 
            return $error;
        } else {
            return false;
        }
    }
 
    public function connectionErrorHandler( $errno, $errstr ) {
        $this->mPHPError = $errstr;
    }
 
    public function close() {
        if ( count( $this->mTrxIdleCallbacks ) ) { // sanity
            throw new MWException( "Transaction idle callbacks still pending." );
        }
        $this->mOpened = false;
        if ( $this->mConn ) {
            if ( $this->trxLevel() ) {
                if ( !$this->mTrxAutomatic ) {
                    wfWarn( "Transaction still in progress (from {$this->mTrxFname}), " .
                        " performing implicit commit before closing connection!" );
                }
 
                $this->commit( __METHOD__, 'flush' );
            }
 
            $ret = $this->closeConnection();
            $this->mConn = false;
 
            return $ret;
        } else {
            return true;
        }
    }
 
    abstract protected function closeConnection();
 
    function reportConnectionError( $error = 'Unknown error' ) {
        $myError = $this->lastError();
        if ( $myError ) {
            $error = $myError;
        }
 
        # New method
        throw new DBConnectionError( $this, $error );
    }
 
    abstract protected function doQuery( $sql );
 
    public function isWriteQuery( $sql ) {
        return !preg_match( '/^(?:SELECT|BEGIN|ROLLBACK|COMMIT|SET|SHOW|EXPLAIN|\(SELECT)\b/i', $sql );
    }
 
    public function query( $sql, $fname = __METHOD__, $tempIgnore = false ) {
        global $wgUser, $wgDebugDBTransactions;
 
        $this->mLastQuery = $sql;
        if ( !$this->mDoneWrites && $this->isWriteQuery( $sql ) ) {
            # Set a flag indicating that writes have been done
            wfDebug( __METHOD__ . ": Writes done: $sql\n" );
            $this->mDoneWrites = true;
        }
 
        # Add a comment for easy SHOW PROCESSLIST interpretation
        if ( is_object( $wgUser ) && $wgUser->isItemLoaded( 'name' ) ) {
            $userName = $wgUser->getName();
            if ( mb_strlen( $userName ) > 15 ) {
                $userName = mb_substr( $userName, 0, 15 ) . '...';
            }
            $userName = str_replace( '/', '', $userName );
        } else {
            $userName = '';
        }
 
        // Add trace comment to the begin of the sql string, right after the operator.
        // Or, for one-word queries (like "BEGIN" or COMMIT") add it to the end (bug 42598)
        $commentedSql = preg_replace( '/\s|$/', " /* $fname $userName */ ", $sql, 1 );
 
        # If DBO_TRX is set, start a transaction
        if ( ( $this->mFlags & DBO_TRX ) && !$this->mTrxLevel &&
            $sql != 'BEGIN' && $sql != 'COMMIT' && $sql != 'ROLLBACK'
        ) {
            # Avoid establishing transactions for SHOW and SET statements too -
            # that would delay transaction initializations to once connection
            # is really used by application
            $sqlstart = substr( $sql, 0, 10 ); // very much worth it, benchmark certified(tm)
            if ( strpos( $sqlstart, "SHOW " ) !== 0 && strpos( $sqlstart, "SET " ) !== 0 ) {
                if ( $wgDebugDBTransactions ) {
                    wfDebug( "Implicit transaction start.\n" );
                }
                $this->begin( __METHOD__ . " ($fname)" );
                $this->mTrxAutomatic = true;
            }
        }
 
        # Keep track of whether the transaction has write queries pending
        if ( $this->mTrxLevel && !$this->mTrxDoneWrites && $this->isWriteQuery( $sql ) ) {
            $this->mTrxDoneWrites = true;
            Profiler::instance()->transactionWritingIn( $this->mServer, $this->mDBname );
        }
 
        $queryProf = '';
        $totalProf = '';
        $isMaster = !is_null( $this->getLBInfo( 'master' ) );
 
        if ( !Profiler::instance()->isStub() ) {
            # generalizeSQL will probably cut down the query to reasonable
            # logging size most of the time. The substr is really just a sanity check.
            if ( $isMaster ) {
                $queryProf = 'query-m: ' . substr( DatabaseBase::generalizeSQL( $sql ), 0, 255 );
                $totalProf = 'DatabaseBase::query-master';
            } else {
                $queryProf = 'query: ' . substr( DatabaseBase::generalizeSQL( $sql ), 0, 255 );
                $totalProf = 'DatabaseBase::query';
            }
            wfProfileIn( $totalProf );
            wfProfileIn( $queryProf );
        }
 
        if ( $this->debug() ) {
            static $cnt = 0;
 
            $cnt++;
            $sqlx = substr( $commentedSql, 0, 500 );
            $sqlx = strtr( $sqlx, "\t\n", '  ' );
 
            $master = $isMaster ? 'master' : 'slave';
            wfDebug( "Query {$this->mDBname} ($cnt) ($master): $sqlx\n" );
        }
 
        $queryId = MWDebug::query( $sql, $fname, $isMaster );
 
        # Do the query and handle errors
        $ret = $this->doQuery( $commentedSql );
 
        MWDebug::queryTime( $queryId );
 
        # Try reconnecting if the connection was lost
        if ( false === $ret && $this->wasErrorReissuable() ) {
            # Transaction is gone, like it or not
            $hadTrx = $this->mTrxLevel; // possible lost transaction
            $this->mTrxLevel = 0;
            wfDebug( "Connection lost, reconnecting...\n" );
 
            if ( $this->ping() ) {
                wfDebug( "Reconnected\n" );
                $sqlx = substr( $commentedSql, 0, 500 );
                $sqlx = strtr( $sqlx, "\t\n", '  ' );
                global $wgRequestTime;
                $elapsed = round( microtime( true ) - $wgRequestTime, 3 );
                if ( $elapsed < 300 ) {
                    # Not a database error to lose a transaction after a minute or two
                    wfLogDBError( "Connection lost and reconnected after {$elapsed}s, query: $sqlx" );
                }
                if ( !$hadTrx ) {
                    # Should be safe to silently retry
                    $ret = $this->doQuery( $commentedSql );
                }
            } else {
                wfDebug( "Failed\n" );
            }
        }
 
        if ( false === $ret ) {
            $this->reportQueryError( $this->lastError(), $this->lastErrno(), $sql, $fname, $tempIgnore );
        }
 
        if ( !Profiler::instance()->isStub() ) {
            wfProfileOut( $queryProf );
            wfProfileOut( $totalProf );
        }
 
        return $this->resultObject( $ret );
    }
 
    public function reportQueryError( $error, $errno, $sql, $fname, $tempIgnore = false ) {
        # Ignore errors during error handling to avoid infinite recursion
        $ignore = $this->ignoreErrors( true );
        ++$this->mErrorCount;
 
        if ( $ignore || $tempIgnore ) {
            wfDebug( "SQL ERROR (ignored): $error\n" );
            $this->ignoreErrors( $ignore );
        } else {
            $sql1line = mb_substr( str_replace( "\n", "\\n", $sql ), 0, 5 * 1024 );
            wfLogDBError( "$fname\t{$this->mServer}\t$errno\t$error\t$sql1line" );
            wfDebug( "SQL ERROR: " . $error . "\n" );
            throw new DBQueryError( $this, $error, $errno, $sql, $fname );
        }
    }
 
    protected function prepare( $sql, $func = 'DatabaseBase::prepare' ) {
        /* MySQL doesn't support prepared statements (yet), so just
         * pack up the query for reference. We'll manually replace
         * the bits later.
         */
        return array( 'query' => $sql, 'func' => $func );
    }
 
    protected function freePrepared( $prepared ) {
        /* No-op by default */
    }
 
    public function execute( $prepared, $args = null ) {
        if ( !is_array( $args ) ) {
            # Pull the var args
            $args = func_get_args();
            array_shift( $args );
        }
 
        $sql = $this->fillPrepared( $prepared['query'], $args );
 
        return $this->query( $sql, $prepared['func'] );
    }
 
    public function fillPrepared( $preparedQuery, $args ) {
        reset( $args );
        $this->preparedArgs =& $args;
 
        return preg_replace_callback( '/(\\\\[?!&]|[?!&])/',
            array( &$this, 'fillPreparedArg' ), $preparedQuery );
    }
 
    protected function fillPreparedArg( $matches ) {
        switch ( $matches[1] ) {
            case '\\?':
                return '?';
            case '\\!':
                return '!';
            case '\\&':
                return '&';
        }
 
        list( /* $n */, $arg ) = each( $this->preparedArgs );
 
        switch ( $matches[1] ) {
            case '?':
                return $this->addQuotes( $arg );
            case '!':
                return $arg;
            case '&':
                # return $this->addQuotes( file_get_contents( $arg ) );
                throw new DBUnexpectedError(
                    $this,
                    '& mode is not implemented. If it\'s really needed, uncomment the line above.'
                );
            default:
                throw new DBUnexpectedError(
                    $this,
                    'Received invalid match. This should never happen!'
                );
        }
    }
 
    public function freeResult( $res ) {
    }
 
    public function selectField( $table, $var, $cond = '', $fname = __METHOD__,
        $options = array()
    ) {
        if ( !is_array( $options ) ) {
            $options = array( $options );
        }
 
        $options['LIMIT'] = 1;
 
        $res = $this->select( $table, $var, $cond, $fname, $options );
 
        if ( $res === false || !$this->numRows( $res ) ) {
            return false;
        }
 
        $row = $this->fetchRow( $res );
 
        if ( $row !== false ) {
            return reset( $row );
        } else {
            return false;
        }
    }
 
    public function makeSelectOptions( $options ) {
        $preLimitTail = $postLimitTail = '';
        $startOpts = '';
 
        $noKeyOptions = array();
 
        foreach ( $options as $key => $option ) {
            if ( is_numeric( $key ) ) {
                $noKeyOptions[$option] = true;
            }
        }
 
        $preLimitTail .= $this->makeGroupByWithHaving( $options );
 
        $preLimitTail .= $this->makeOrderBy( $options );
 
        // if (isset($options['LIMIT'])) {
        //  $tailOpts .= $this->limitResult('', $options['LIMIT'],
        //      isset($options['OFFSET']) ? $options['OFFSET']
        //      : false);
        // }
 
        if ( isset( $noKeyOptions['FOR UPDATE'] ) ) {
            $postLimitTail .= ' FOR UPDATE';
        }
 
        if ( isset( $noKeyOptions['LOCK IN SHARE MODE'] ) ) {
            $postLimitTail .= ' LOCK IN SHARE MODE';
        }
 
        if ( isset( $noKeyOptions['DISTINCT'] ) || isset( $noKeyOptions['DISTINCTROW'] ) ) {
            $startOpts .= 'DISTINCT';
        }
 
        # Various MySQL extensions
        if ( isset( $noKeyOptions['STRAIGHT_JOIN'] ) ) {
            $startOpts .= ' /*! STRAIGHT_JOIN */';
        }
 
        if ( isset( $noKeyOptions['HIGH_PRIORITY'] ) ) {
            $startOpts .= ' HIGH_PRIORITY';
        }
 
        if ( isset( $noKeyOptions['SQL_BIG_RESULT'] ) ) {
            $startOpts .= ' SQL_BIG_RESULT';
        }
 
        if ( isset( $noKeyOptions['SQL_BUFFER_RESULT'] ) ) {
            $startOpts .= ' SQL_BUFFER_RESULT';
        }
 
        if ( isset( $noKeyOptions['SQL_SMALL_RESULT'] ) ) {
            $startOpts .= ' SQL_SMALL_RESULT';
        }
 
        if ( isset( $noKeyOptions['SQL_CALC_FOUND_ROWS'] ) ) {
            $startOpts .= ' SQL_CALC_FOUND_ROWS';
        }
 
        if ( isset( $noKeyOptions['SQL_CACHE'] ) ) {
            $startOpts .= ' SQL_CACHE';
        }
 
        if ( isset( $noKeyOptions['SQL_NO_CACHE'] ) ) {
            $startOpts .= ' SQL_NO_CACHE';
        }
 
        if ( isset( $options['USE INDEX'] ) && is_string( $options['USE INDEX'] ) ) {
            $useIndex = $this->useIndexClause( $options['USE INDEX'] );
        } else {
            $useIndex = '';
        }
 
        return array( $startOpts, $useIndex, $preLimitTail, $postLimitTail );
    }
 
    public function makeGroupByWithHaving( $options ) {
        $sql = '';
        if ( isset( $options['GROUP BY'] ) ) {
            $gb = is_array( $options['GROUP BY'] )
                ? implode( ',', $options['GROUP BY'] )
                : $options['GROUP BY'];
            $sql .= ' GROUP BY ' . $gb;
        }
        if ( isset( $options['HAVING'] ) ) {
            $having = is_array( $options['HAVING'] )
                ? $this->makeList( $options['HAVING'], LIST_AND )
                : $options['HAVING'];
            $sql .= ' HAVING ' . $having;
        }
 
        return $sql;
    }
 
    public function makeOrderBy( $options ) {
        if ( isset( $options['ORDER BY'] ) ) {
            $ob = is_array( $options['ORDER BY'] )
                ? implode( ',', $options['ORDER BY'] )
                : $options['ORDER BY'];
 
            return ' ORDER BY ' . $ob;
        }
 
        return '';
    }
 
    public function select( $table, $vars, $conds = '', $fname = __METHOD__,
        $options = array(), $join_conds = array() ) {
        $sql = $this->selectSQLText( $table, $vars, $conds, $fname, $options, $join_conds );
 
        return $this->query( $sql, $fname );
    }
 
    public function selectSQLText( $table, $vars, $conds = '', $fname = __METHOD__,
        $options = array(), $join_conds = array()
    ) {
        if ( is_array( $vars ) ) {
            $vars = implode( ',', $this->fieldNamesWithAlias( $vars ) );
        }
 
        $options = (array)$options;
        $useIndexes = ( isset( $options['USE INDEX'] ) && is_array( $options['USE INDEX'] ) )
            ? $options['USE INDEX']
            : array();
 
        if ( is_array( $table ) ) {
            $from = ' FROM ' .
                $this->tableNamesWithUseIndexOrJOIN( $table, $useIndexes, $join_conds );
        } elseif ( $table != '' ) {
            if ( $table[0] == ' ' ) {
                $from = ' FROM ' . $table;
            } else {
                $from = ' FROM ' .
                    $this->tableNamesWithUseIndexOrJOIN( array( $table ), $useIndexes, array() );
            }
        } else {
            $from = '';
        }
 
        list( $startOpts, $useIndex, $preLimitTail, $postLimitTail ) =
            $this->makeSelectOptions( $options );
 
        if ( !empty( $conds ) ) {
            if ( is_array( $conds ) ) {
                $conds = $this->makeList( $conds, LIST_AND );
            }
            $sql = "SELECT $startOpts $vars $from $useIndex WHERE $conds $preLimitTail";
        } else {
            $sql = "SELECT $startOpts $vars $from $useIndex $preLimitTail";
        }
 
        if ( isset( $options['LIMIT'] ) ) {
            $sql = $this->limitResult( $sql, $options['LIMIT'],
                isset( $options['OFFSET'] ) ? $options['OFFSET'] : false );
        }
        $sql = "$sql $postLimitTail";
 
        if ( isset( $options['EXPLAIN'] ) ) {
            $sql = 'EXPLAIN ' . $sql;
        }
 
        return $sql;
    }
 
    public function selectRow( $table, $vars, $conds, $fname = __METHOD__,
        $options = array(), $join_conds = array()
    ) {
        $options = (array)$options;
        $options['LIMIT'] = 1;
        $res = $this->select( $table, $vars, $conds, $fname, $options, $join_conds );
 
        if ( $res === false ) {
            return false;
        }
 
        if ( !$this->numRows( $res ) ) {
            return false;
        }
 
        $obj = $this->fetchObject( $res );
 
        return $obj;
    }
 
    public function estimateRowCount( $table, $vars = '*', $conds = '',
        $fname = __METHOD__, $options = array()
    ) {
        $rows = 0;
        $res = $this->select( $table, array( 'rowcount' => 'COUNT(*)' ), $conds, $fname, $options );
 
        if ( $res ) {
            $row = $this->fetchRow( $res );
            $rows = ( isset( $row['rowcount'] ) ) ? $row['rowcount'] : 0;
        }
 
        return $rows;
    }
 
    static function generalizeSQL( $sql ) {
        # This does the same as the regexp below would do, but in such a way
        # as to avoid crashing php on some large strings.
        # $sql = preg_replace( "/'([^\\\\']|\\\\.)*'|\"([^\\\\\"]|\\\\.)*\"/", "'X'", $sql );
 
        $sql = str_replace( "\\\\", '', $sql );
        $sql = str_replace( "\\'", '', $sql );
        $sql = str_replace( "\\\"", '', $sql );
        $sql = preg_replace( "/'.*'/s", "'X'", $sql );
        $sql = preg_replace( '/".*"/s', "'X'", $sql );
 
        # All newlines, tabs, etc replaced by single space
        $sql = preg_replace( '/\s+/', ' ', $sql );
 
        # All numbers => N
        $sql = preg_replace( '/-?\d+(,-?\d+)+/s', 'N,...,N', $sql );
        $sql = preg_replace( '/-?\d+/s', 'N', $sql );
 
        return $sql;
    }
 
    public function fieldExists( $table, $field, $fname = __METHOD__ ) {
        $info = $this->fieldInfo( $table, $field );
 
        return (bool)$info;
    }
 
    public function indexExists( $table, $index, $fname = __METHOD__ ) {
        if ( !$this->tableExists( $table ) ) {
            return null;
        }
 
        $info = $this->indexInfo( $table, $index, $fname );
        if ( is_null( $info ) ) {
            return null;
        } else {
            return $info !== false;
        }
    }
 
    public function tableExists( $table, $fname = __METHOD__ ) {
        $table = $this->tableName( $table );
        $old = $this->ignoreErrors( true );
        $res = $this->query( "SELECT 1 FROM $table LIMIT 1", $fname );
        $this->ignoreErrors( $old );
 
        return (bool)$res;
    }
 
    public function indexUnique( $table, $index ) {
        $indexInfo = $this->indexInfo( $table, $index );
 
        if ( !$indexInfo ) {
            return null;
        }
 
        return !$indexInfo[0]->Non_unique;
    }
 
    protected function makeInsertOptions( $options ) {
        return implode( ' ', $options );
    }
 
    public function insert( $table, $a, $fname = __METHOD__, $options = array() ) {
        # No rows to insert, easy just return now
        if ( !count( $a ) ) {
            return true;
        }
 
        $table = $this->tableName( $table );
 
        if ( !is_array( $options ) ) {
            $options = array( $options );
        }
 
        $fh = null;
        if ( isset( $options['fileHandle'] ) ) {
            $fh = $options['fileHandle'];
        }
        $options = $this->makeInsertOptions( $options );
 
        if ( isset( $a[0] ) && is_array( $a[0] ) ) {
            $multi = true;
            $keys = array_keys( $a[0] );
        } else {
            $multi = false;
            $keys = array_keys( $a );
        }
 
        $sql = 'INSERT ' . $options .
            " INTO $table (" . implode( ',', $keys ) . ') VALUES ';
 
        if ( $multi ) {
            $first = true;
            foreach ( $a as $row ) {
                if ( $first ) {
                    $first = false;
                } else {
                    $sql .= ',';
                }
                $sql .= '(' . $this->makeList( $row ) . ')';
            }
        } else {
            $sql .= '(' . $this->makeList( $a ) . ')';
        }
 
        if ( $fh !== null && false === fwrite( $fh, $sql ) ) {
            return false;
        } elseif ( $fh !== null ) {
            return true;
        }
 
        return (bool)$this->query( $sql, $fname );
    }
 
    protected function makeUpdateOptionsArray( $options ) {
        if ( !is_array( $options ) ) {
            $options = array( $options );
        }
 
        $opts = array();
 
        if ( in_array( 'LOW_PRIORITY', $options ) ) {
            $opts[] = $this->lowPriorityOption();
        }
 
        if ( in_array( 'IGNORE', $options ) ) {
            $opts[] = 'IGNORE';
        }
 
        return $opts;
    }
 
    protected function makeUpdateOptions( $options ) {
        $opts = $this->makeUpdateOptionsArray( $options );
 
        return implode( ' ', $opts );
    }
 
    function update( $table, $values, $conds, $fname = __METHOD__, $options = array() ) {
        $table = $this->tableName( $table );
        $opts = $this->makeUpdateOptions( $options );
        $sql = "UPDATE $opts $table SET " . $this->makeList( $values, LIST_SET );
 
        if ( $conds !== array() && $conds !== '*' ) {
            $sql .= " WHERE " . $this->makeList( $conds, LIST_AND );
        }
 
        return $this->query( $sql, $fname );
    }
 
    public function makeList( $a, $mode = LIST_COMMA ) {
        if ( !is_array( $a ) ) {
            throw new DBUnexpectedError( $this, 'DatabaseBase::makeList called with incorrect parameters' );
        }
 
        $first = true;
        $list = '';
 
        foreach ( $a as $field => $value ) {
            if ( !$first ) {
                if ( $mode == LIST_AND ) {
                    $list .= ' AND ';
                } elseif ( $mode == LIST_OR ) {
                    $list .= ' OR ';
                } else {
                    $list .= ',';
                }
            } else {
                $first = false;
            }
 
            if ( ( $mode == LIST_AND || $mode == LIST_OR ) && is_numeric( $field ) ) {
                $list .= "($value)";
            } elseif ( ( $mode == LIST_SET ) && is_numeric( $field ) ) {
                $list .= "$value";
            } elseif ( ( $mode == LIST_AND || $mode == LIST_OR ) && is_array( $value ) ) {
                if ( count( $value ) == 0 ) {
                    throw new MWException( __METHOD__ . ": empty input for field $field" );
                } elseif ( count( $value ) == 1 ) {
                    // Special-case single values, as IN isn't terribly efficient
                    // Don't necessarily assume the single key is 0; we don't
                    // enforce linear numeric ordering on other arrays here.
                    $value = array_values( $value );
                    $list .= $field . " = " . $this->addQuotes( $value[0] );
                } else {
                    $list .= $field . " IN (" . $this->makeList( $value ) . ") ";
                }
            } elseif ( $value === null ) {
                if ( $mode == LIST_AND || $mode == LIST_OR ) {
                    $list .= "$field IS ";
                } elseif ( $mode == LIST_SET ) {
                    $list .= "$field = ";
                }
                $list .= 'NULL';
            } else {
                if ( $mode == LIST_AND || $mode == LIST_OR || $mode == LIST_SET ) {
                    $list .= "$field = ";
                }
                $list .= $mode == LIST_NAMES ? $value : $this->addQuotes( $value );
            }
        }
 
        return $list;
    }
 
    public function makeWhereFrom2d( $data, $baseKey, $subKey ) {
        $conds = array();
 
        foreach ( $data as $base => $sub ) {
            if ( count( $sub ) ) {
                $conds[] = $this->makeList(
                    array( $baseKey => $base, $subKey => array_keys( $sub ) ),
                    LIST_AND );
            }
        }
 
        if ( $conds ) {
            return $this->makeList( $conds, LIST_OR );
        } else {
            // Nothing to search for...
            return false;
        }
    }
 
    public function aggregateValue( $valuedata, $valuename = 'value' ) {
        return $valuename;
    }
 
    public function bitNot( $field ) {
        return "(~$field)";
    }
 
    public function bitAnd( $fieldLeft, $fieldRight ) {
        return "($fieldLeft & $fieldRight)";
    }
 
    public function bitOr( $fieldLeft, $fieldRight ) {
        return "($fieldLeft | $fieldRight)";
    }
 
    public function buildConcat( $stringList ) {
        return 'CONCAT(' . implode( ',', $stringList ) . ')';
    }
 
    public function buildGroupConcatField(
        $delim, $table, $field, $conds = '', $join_conds = array()
    ) {
        $fld = "GROUP_CONCAT($field SEPARATOR " . $this->addQuotes( $delim ) . ')';
 
        return '(' . $this->selectSQLText( $table, $fld, $conds, null, array(), $join_conds ) . ')';
    }
 
    public function selectDB( $db ) {
        # Stub. Shouldn't cause serious problems if it's not overridden, but
        # if your database engine supports a concept similar to MySQL's
        # databases you may as well.
        $this->mDBname = $db;
 
        return true;
    }
 
    public function getDBname() {
        return $this->mDBname;
    }
 
    public function getServer() {
        return $this->mServer;
    }
 
    public function tableName( $name, $format = 'quoted' ) {
        global $wgSharedDB, $wgSharedPrefix, $wgSharedTables, $wgSharedSchema;
        # Skip the entire process when we have a string quoted on both ends.
        # Note that we check the end so that we will still quote any use of
        # use of `database`.table. But won't break things if someone wants
        # to query a database table with a dot in the name.
        if ( $this->isQuotedIdentifier( $name ) ) {
            return $name;
        }
 
        # Lets test for any bits of text that should never show up in a table
        # name. Basically anything like JOIN or ON which are actually part of
        # SQL queries, but may end up inside of the table value to combine
        # sql. Such as how the API is doing.
        # Note that we use a whitespace test rather than a \b test to avoid
        # any remote case where a word like on may be inside of a table name
        # surrounded by symbols which may be considered word breaks.
        if ( preg_match( '/(^|\s)(DISTINCT|JOIN|ON|AS)(\s|$)/i', $name ) !== 0 ) {
            return $name;
        }
 
        # Split database and table into proper variables.
        # We reverse the explode so that database.table and table both output
        # the correct table.
        $dbDetails = explode( '.', $name, 2 );
        if ( count( $dbDetails ) == 3 ) {
            list( $database, $schema, $table ) = $dbDetails;
            # We don't want any prefix added in this case
            $prefix = '';
        } elseif ( count( $dbDetails ) == 2 ) {
            list( $database, $table ) = $dbDetails;
            # We don't want any prefix added in this case
            # In dbs that support it, $database may actually be the schema
            # but that doesn't affect any of the functionality here
            $prefix = '';
            $schema = null;
        } else {
            list( $table ) = $dbDetails;
            if ( $wgSharedDB !== null # We have a shared database
                && $this->mForeign == false # We're not working on a foreign database
                && !$this->isQuotedIdentifier( $table ) # Prevent shared tables listing '`table`'
                && in_array( $table, $wgSharedTables ) # A shared table is selected
            ) {
                $database = $wgSharedDB;
                $schema = $wgSharedSchema === null ? $this->mSchema : $wgSharedSchema;
                $prefix = $wgSharedPrefix === null ? $this->mTablePrefix : $wgSharedPrefix;
            } else {
                $database = null;
                $schema = $this->mSchema; # Default schema
                $prefix = $this->mTablePrefix; # Default prefix
            }
        }
 
        # Quote $table and apply the prefix if not quoted.
        # $tableName might be empty if this is called from Database::replaceVars()
        $tableName = "{$prefix}{$table}";
        if ( $format == 'quoted' && !$this->isQuotedIdentifier( $tableName ) && $tableName !== '' ) {
            $tableName = $this->addIdentifierQuotes( $tableName );
        }
 
        # Quote $schema and merge it with the table name if needed
        if ( $schema !== null ) {
            if ( $format == 'quoted' && !$this->isQuotedIdentifier( $schema ) ) {
                $schema = $this->addIdentifierQuotes( $schema );
            }
            $tableName = $schema . '.' . $tableName;
        }
 
        # Quote $database and merge it with the table name if needed
        if ( $database !== null ) {
            if ( $format == 'quoted' && !$this->isQuotedIdentifier( $database ) ) {
                $database = $this->addIdentifierQuotes( $database );
            }
            $tableName = $database . '.' . $tableName;
        }
 
        return $tableName;
    }
 
    public function tableNames() {
        $inArray = func_get_args();
        $retVal = array();
 
        foreach ( $inArray as $name ) {
            $retVal[$name] = $this->tableName( $name );
        }
 
        return $retVal;
    }
 
    public function tableNamesN() {
        $inArray = func_get_args();
        $retVal = array();
 
        foreach ( $inArray as $name ) {
            $retVal[] = $this->tableName( $name );
        }
 
        return $retVal;
    }
 
    public function tableNameWithAlias( $name, $alias = false ) {
        if ( !$alias || $alias == $name ) {
            return $this->tableName( $name );
        } else {
            return $this->tableName( $name ) . ' ' . $this->addIdentifierQuotes( $alias );
        }
    }
 
    public function tableNamesWithAlias( $tables ) {
        $retval = array();
        foreach ( $tables as $alias => $table ) {
            if ( is_numeric( $alias ) ) {
                $alias = $table;
            }
            $retval[] = $this->tableNameWithAlias( $table, $alias );
        }
 
        return $retval;
    }
 
    public function fieldNameWithAlias( $name, $alias = false ) {
        if ( !$alias || (string)$alias === (string)$name ) {
            return $name;
        } else {
            return $name . ' AS ' . $alias; //PostgreSQL needs AS
        }
    }
 
    public function fieldNamesWithAlias( $fields ) {
        $retval = array();
        foreach ( $fields as $alias => $field ) {
            if ( is_numeric( $alias ) ) {
                $alias = $field;
            }
            $retval[] = $this->fieldNameWithAlias( $field, $alias );
        }
 
        return $retval;
    }
 
    protected function tableNamesWithUseIndexOrJOIN(
        $tables, $use_index = array(), $join_conds = array()
    ) {
        $ret = array();
        $retJOIN = array();
        $use_index = (array)$use_index;
        $join_conds = (array)$join_conds;
 
        foreach ( $tables as $alias => $table ) {
            if ( !is_string( $alias ) ) {
                // No alias? Set it equal to the table name
                $alias = $table;
            }
            // Is there a JOIN clause for this table?
            if ( isset( $join_conds[$alias] ) ) {
                list( $joinType, $conds ) = $join_conds[$alias];
                $tableClause = $joinType;
                $tableClause .= ' ' . $this->tableNameWithAlias( $table, $alias );
                if ( isset( $use_index[$alias] ) ) { // has USE INDEX?
                    $use = $this->useIndexClause( implode( ',', (array)$use_index[$alias] ) );
                    if ( $use != '' ) {
                        $tableClause .= ' ' . $use;
                    }
                }
                $on = $this->makeList( (array)$conds, LIST_AND );
                if ( $on != '' ) {
                    $tableClause .= ' ON (' . $on . ')';
                }
 
                $retJOIN[] = $tableClause;
            } elseif ( isset( $use_index[$alias] ) ) {
                // Is there an INDEX clause for this table?
                $tableClause = $this->tableNameWithAlias( $table, $alias );
                $tableClause .= ' ' . $this->useIndexClause(
                    implode( ',', (array)$use_index[$alias] )
                );
 
                $ret[] = $tableClause;
            } else {
                $tableClause = $this->tableNameWithAlias( $table, $alias );
 
                $ret[] = $tableClause;
            }
        }
 
        // We can't separate explicit JOIN clauses with ',', use ' ' for those
        $implicitJoins = !empty( $ret ) ? implode( ',', $ret ) : "";
        $explicitJoins = !empty( $retJOIN ) ? implode( ' ', $retJOIN ) : "";
 
        // Compile our final table clause
        return implode( ' ', array( $implicitJoins, $explicitJoins ) );
    }
 
    protected function indexName( $index ) {
        // Backwards-compatibility hack
        $renamed = array(
            'ar_usertext_timestamp' => 'usertext_timestamp',
            'un_user_id' => 'user_id',
            'un_user_ip' => 'user_ip',
        );
 
        if ( isset( $renamed[$index] ) ) {
            return $renamed[$index];
        } else {
            return $index;
        }
    }
 
    public function addQuotes( $s ) {
        if ( $s === null ) {
            return 'NULL';
        } else {
            # This will also quote numeric values. This should be harmless,
            # and protects against weird problems that occur when they really
            # _are_ strings such as article titles and string->number->string
            # conversion is not 1:1.
            return "'" . $this->strencode( $s ) . "'";
        }
    }
 
    public function addIdentifierQuotes( $s ) {
        return '"' . str_replace( '"', '""', $s ) . '"';
    }
 
    public function isQuotedIdentifier( $name ) {
        return $name[0] == '"' && substr( $name, -1, 1 ) == '"';
    }
 
    protected function escapeLikeInternal( $s ) {
        $s = str_replace( '\\', '\\\\', $s );
        $s = $this->strencode( $s );
        $s = str_replace( array( '%', '_' ), array( '\%', '\_' ), $s );
 
        return $s;
    }
 
    public function buildLike() {
        $params = func_get_args();
 
        if ( count( $params ) > 0 && is_array( $params[0] ) ) {
            $params = $params[0];
        }
 
        $s = '';
 
        foreach ( $params as $value ) {
            if ( $value instanceof LikeMatch ) {
                $s .= $value->toString();
            } else {
                $s .= $this->escapeLikeInternal( $value );
            }
        }
 
        return " LIKE '" . $s . "' ";
    }
 
    public function anyChar() {
        return new LikeMatch( '_' );
    }
 
    public function anyString() {
        return new LikeMatch( '%' );
    }
 
    public function nextSequenceValue( $seqName ) {
        return null;
    }
 
    public function useIndexClause( $index ) {
        return '';
    }
 
    public function replace( $table, $uniqueIndexes, $rows, $fname = __METHOD__ ) {
        $quotedTable = $this->tableName( $table );
 
        if ( count( $rows ) == 0 ) {
            return;
        }
 
        # Single row case
        if ( !is_array( reset( $rows ) ) ) {
            $rows = array( $rows );
        }
 
        foreach ( $rows as $row ) {
            # Delete rows which collide
            if ( $uniqueIndexes ) {
                $sql = "DELETE FROM $quotedTable WHERE ";
                $first = true;
                foreach ( $uniqueIndexes as $index ) {
                    if ( $first ) {
                        $first = false;
                        $sql .= '( ';
                    } else {
                        $sql .= ' ) OR ( ';
                    }
                    if ( is_array( $index ) ) {
                        $first2 = true;
                        foreach ( $index as $col ) {
                            if ( $first2 ) {
                                $first2 = false;
                            } else {
                                $sql .= ' AND ';
                            }
                            $sql .= $col . '=' . $this->addQuotes( $row[$col] );
                        }
                    } else {
                        $sql .= $index . '=' . $this->addQuotes( $row[$index] );
                    }
                }
                $sql .= ' )';
                $this->query( $sql, $fname );
            }
 
            # Now insert the row
            $this->insert( $table, $row, $fname );
        }
    }
 
    protected function nativeReplace( $table, $rows, $fname ) {
        $table = $this->tableName( $table );
 
        # Single row case
        if ( !is_array( reset( $rows ) ) ) {
            $rows = array( $rows );
        }
 
        $sql = "REPLACE INTO $table (" . implode( ',', array_keys( $rows[0] ) ) . ') VALUES ';
        $first = true;
 
        foreach ( $rows as $row ) {
            if ( $first ) {
                $first = false;
            } else {
                $sql .= ',';
            }
 
            $sql .= '(' . $this->makeList( $row ) . ')';
        }
 
        return $this->query( $sql, $fname );
    }
 
    public function upsert( $table, array $rows, array $uniqueIndexes, array $set,
        $fname = __METHOD__
    ) {
        if ( !count( $rows ) ) {
            return true; // nothing to do
        }
 
        if ( !is_array( reset( $rows ) ) ) {
            $rows = array( $rows );
        }
 
        if ( count( $uniqueIndexes ) ) {
            $clauses = array(); // list WHERE clauses that each identify a single row
            foreach ( $rows as $row ) {
                foreach ( $uniqueIndexes as $index ) {
                    $index = is_array( $index ) ? $index : array( $index ); // columns
                    $rowKey = array(); // unique key to this row
                    foreach ( $index as $column ) {
                        $rowKey[$column] = $row[$column];
                    }
                    $clauses[] = $this->makeList( $rowKey, LIST_AND );
                }
            }
            $where = array( $this->makeList( $clauses, LIST_OR ) );
        } else {
            $where = false;
        }
 
        $useTrx = !$this->mTrxLevel;
        if ( $useTrx ) {
            $this->begin( $fname );
        }
        try {
            # Update any existing conflicting row(s)
            if ( $where !== false ) {
                $ok = $this->update( $table, $set, $where, $fname );
            } else {
                $ok = true;
            }
            # Now insert any non-conflicting row(s)
            $ok = $this->insert( $table, $rows, $fname, array( 'IGNORE' ) ) && $ok;
        } catch ( Exception $e ) {
            if ( $useTrx ) {
                $this->rollback( $fname );
            }
            throw $e;
        }
        if ( $useTrx ) {
            $this->commit( $fname );
        }
 
        return $ok;
    }
 
    public function deleteJoin( $delTable, $joinTable, $delVar, $joinVar, $conds,
        $fname = __METHOD__
    ) {
        if ( !$conds ) {
            throw new DBUnexpectedError( $this,
                'DatabaseBase::deleteJoin() called with empty $conds' );
        }
 
        $delTable = $this->tableName( $delTable );
        $joinTable = $this->tableName( $joinTable );
        $sql = "DELETE FROM $delTable WHERE $delVar IN (SELECT $joinVar FROM $joinTable ";
        if ( $conds != '*' ) {
            $sql .= 'WHERE ' . $this->makeList( $conds, LIST_AND );
        }
        $sql .= ')';
 
        $this->query( $sql, $fname );
    }
 
    public function textFieldSize( $table, $field ) {
        $table = $this->tableName( $table );
        $sql = "SHOW COLUMNS FROM $table LIKE \"$field\";";
        $res = $this->query( $sql, 'DatabaseBase::textFieldSize' );
        $row = $this->fetchObject( $res );
 
        $m = array();
 
        if ( preg_match( '/\((.*)\)/', $row->Type, $m ) ) {
            $size = $m[1];
        } else {
            $size = -1;
        }
 
        return $size;
    }
 
    public function lowPriorityOption() {
        return '';
    }
 
    public function delete( $table, $conds, $fname = __METHOD__ ) {
        if ( !$conds ) {
            throw new DBUnexpectedError( $this, 'DatabaseBase::delete() called with no conditions' );
        }
 
        $table = $this->tableName( $table );
        $sql = "DELETE FROM $table";
 
        if ( $conds != '*' ) {
            if ( is_array( $conds ) ) {
                $conds = $this->makeList( $conds, LIST_AND );
            }
            $sql .= ' WHERE ' . $conds;
        }
 
        return $this->query( $sql, $fname );
    }
 
    public function insertSelect( $destTable, $srcTable, $varMap, $conds,
        $fname = __METHOD__,
        $insertOptions = array(), $selectOptions = array()
    ) {
        $destTable = $this->tableName( $destTable );
 
        if ( !is_array( $insertOptions ) ) {
            $insertOptions = array( $insertOptions );
        }
 
        $insertOptions = $this->makeInsertOptions( $insertOptions );
 
        if ( !is_array( $selectOptions ) ) {
            $selectOptions = array( $selectOptions );
        }
 
        list( $startOpts, $useIndex, $tailOpts ) = $this->makeSelectOptions( $selectOptions );
 
        if ( is_array( $srcTable ) ) {
            $srcTable = implode( ',', array_map( array( &$this, 'tableName' ), $srcTable ) );
        } else {
            $srcTable = $this->tableName( $srcTable );
        }
 
        $sql = "INSERT $insertOptions INTO $destTable (" . implode( ',', array_keys( $varMap ) ) . ')' .
            " SELECT $startOpts " . implode( ',', $varMap ) .
            " FROM $srcTable $useIndex ";
 
        if ( $conds != '*' ) {
            if ( is_array( $conds ) ) {
                $conds = $this->makeList( $conds, LIST_AND );
            }
            $sql .= " WHERE $conds";
        }
 
        $sql .= " $tailOpts";
 
        return $this->query( $sql, $fname );
    }
 
    public function limitResult( $sql, $limit, $offset = false ) {
        if ( !is_numeric( $limit ) ) {
            throw new DBUnexpectedError( $this, "Invalid non-numeric limit passed to limitResult()\n" );
        }
 
        return "$sql LIMIT "
            . ( ( is_numeric( $offset ) && $offset != 0 ) ? "{$offset}," : "" )
            . "{$limit} ";
    }
 
    public function unionSupportsOrderAndLimit() {
        return true; // True for almost every DB supported
    }
 
    public function unionQueries( $sqls, $all ) {
        $glue = $all ? ') UNION ALL (' : ') UNION (';
 
        return '(' . implode( $glue, $sqls ) . ')';
    }
 
    public function conditional( $cond, $trueVal, $falseVal ) {
        if ( is_array( $cond ) ) {
            $cond = $this->makeList( $cond, LIST_AND );
        }
 
        return " (CASE WHEN $cond THEN $trueVal ELSE $falseVal END) ";
    }
 
    public function strreplace( $orig, $old, $new ) {
        return "REPLACE({$orig}, {$old}, {$new})";
    }
 
    public function getServerUptime() {
        return 0;
    }
 
    public function wasDeadlock() {
        return false;
    }
 
    public function wasLockTimeout() {
        return false;
    }
 
    public function wasErrorReissuable() {
        return false;
    }
 
    public function wasReadOnlyError() {
        return false;
    }
 
    public function deadlockLoop() {
        $this->begin( __METHOD__ );
        $args = func_get_args();
        $function = array_shift( $args );
        $oldIgnore = $this->ignoreErrors( true );
        $tries = self::DEADLOCK_TRIES;
 
        if ( is_array( $function ) ) {
            $fname = $function[0];
        } else {
            $fname = $function;
        }
 
        do {
            $retVal = call_user_func_array( $function, $args );
            $error = $this->lastError();
            $errno = $this->lastErrno();
            $sql = $this->lastQuery();
 
            if ( $errno ) {
                if ( $this->wasDeadlock() ) {
                    # Retry
                    usleep( mt_rand( self::DEADLOCK_DELAY_MIN, self::DEADLOCK_DELAY_MAX ) );
                } else {
                    $this->reportQueryError( $error, $errno, $sql, $fname );
                }
            }
        } while ( $this->wasDeadlock() && --$tries > 0 );
 
        $this->ignoreErrors( $oldIgnore );
 
        if ( $tries <= 0 ) {
            $this->rollback( __METHOD__ );
            $this->reportQueryError( $error, $errno, $sql, $fname );
 
            return false;
        } else {
            $this->commit( __METHOD__ );
 
            return $retVal;
        }
    }
 
    public function masterPosWait( DBMasterPos $pos, $timeout ) {
        # Real waits are implemented in the subclass.
        return 0;
    }
 
    public function getSlavePos() {
        # Stub
        return false;
    }
 
    public function getMasterPos() {
        # Stub
        return false;
    }
 
    final public function onTransactionIdle( $callback ) {
        $this->mTrxIdleCallbacks[] = array( $callback, wfGetCaller() );
        if ( !$this->mTrxLevel ) {
            $this->runOnTransactionIdleCallbacks();
        }
    }
 
    final public function onTransactionPreCommitOrIdle( $callback ) {
        if ( $this->mTrxLevel ) {
            $this->mTrxPreCommitCallbacks[] = array( $callback, wfGetCaller() );
        } else {
            $this->onTransactionIdle( $callback ); // this will trigger immediately
        }
    }
 
    protected function runOnTransactionIdleCallbacks() {
        $autoTrx = $this->getFlag( DBO_TRX ); // automatic begin() enabled?
 
        $e = null; // last exception
        do { // callbacks may add callbacks :)
            $callbacks = $this->mTrxIdleCallbacks;
            $this->mTrxIdleCallbacks = array(); // recursion guard
            foreach ( $callbacks as $callback ) {
                try {
                    list( $phpCallback ) = $callback;
                    $this->clearFlag( DBO_TRX ); // make each query its own transaction
                    call_user_func( $phpCallback );
                    $this->setFlag( $autoTrx ? DBO_TRX : 0 ); // restore automatic begin()
                } catch ( Exception $e ) {
                }
            }
        } while ( count( $this->mTrxIdleCallbacks ) );
 
        if ( $e instanceof Exception ) {
            throw $e; // re-throw any last exception
        }
    }
 
    protected function runOnTransactionPreCommitCallbacks() {
        $e = null; // last exception
        do { // callbacks may add callbacks :)
            $callbacks = $this->mTrxPreCommitCallbacks;
            $this->mTrxPreCommitCallbacks = array(); // recursion guard
            foreach ( $callbacks as $callback ) {
                try {
                    list( $phpCallback ) = $callback;
                    call_user_func( $phpCallback );
                } catch ( Exception $e ) {
                }
            }
        } while ( count( $this->mTrxPreCommitCallbacks ) );
 
        if ( $e instanceof Exception ) {
            throw $e; // re-throw any last exception
        }
    }
 
    final public function startAtomic( $fname = __METHOD__ ) {
        if ( !$this->mTrxLevel ) {
            $this->begin( $fname );
            $this->mTrxAutomatic = true;
            $this->mTrxAutomaticAtomic = true;
        }
 
        $this->mTrxAtomicLevels->push( $fname );
    }
 
    final public function endAtomic( $fname = __METHOD__ ) {
        if ( !$this->mTrxLevel ) {
            throw new DBUnexpectedError( $this, 'No atomic transaction is open.' );
        }
        if ( $this->mTrxAtomicLevels->isEmpty() ||
            $this->mTrxAtomicLevels->pop() !== $fname
        ) {
            throw new DBUnexpectedError( $this, 'Invalid atomic section ended.' );
        }
 
        if ( $this->mTrxAtomicLevels->isEmpty() && $this->mTrxAutomaticAtomic ) {
            $this->commit( $fname, 'flush' );
        }
    }
 
    final public function begin( $fname = __METHOD__ ) {
        global $wgDebugDBTransactions;
 
        if ( $this->mTrxLevel ) { // implicit commit
            if ( !$this->mTrxAtomicLevels->isEmpty() ) {
                // If the current transaction was an automatic atomic one, then we definitely have
                // a problem. Same if there is any unclosed atomic level.
                throw new DBUnexpectedError( $this,
                    "Attempted to start explicit transaction when atomic levels are still open."
                );
            } elseif ( !$this->mTrxAutomatic ) {
                // We want to warn about inadvertently nested begin/commit pairs, but not about
                // auto-committing implicit transactions that were started by query() via DBO_TRX
                $msg = "$fname: Transaction already in progress (from {$this->mTrxFname}), " .
                    " performing implicit commit!";
                wfWarn( $msg );
                wfLogDBError( $msg );
            } else {
                // if the transaction was automatic and has done write operations,
                // log it if $wgDebugDBTransactions is enabled.
                if ( $this->mTrxDoneWrites && $wgDebugDBTransactions ) {
                    wfDebug( "$fname: Automatic transaction with writes in progress" .
                        " (from {$this->mTrxFname}), performing implicit commit!\n"
                    );
                }
            }
 
            $this->runOnTransactionPreCommitCallbacks();
            $this->doCommit( $fname );
            if ( $this->mTrxDoneWrites ) {
                Profiler::instance()->transactionWritingOut( $this->mServer, $this->mDBname );
            }
            $this->runOnTransactionIdleCallbacks();
        }
 
        $this->doBegin( $fname );
        $this->mTrxFname = $fname;
        $this->mTrxDoneWrites = false;
        $this->mTrxAutomatic = false;
        $this->mTrxAutomaticAtomic = false;
        $this->mTrxAtomicLevels = new SplStack;
        $this->mTrxIdleCallbacks = array();
        $this->mTrxPreCommitCallbacks = array();
    }
 
    protected function doBegin( $fname ) {
        $this->query( 'BEGIN', $fname );
        $this->mTrxLevel = 1;
    }
 
    final public function commit( $fname = __METHOD__, $flush = '' ) {
        if ( !$this->mTrxAtomicLevels->isEmpty() ) {
            // There are still atomic sections open. This cannot be ignored
            throw new DBUnexpectedError(
                $this,
                "Attempted to commit transaction while atomic sections are still open"
            );
        }
 
        if ( $flush !== 'flush' ) {
            if ( !$this->mTrxLevel ) {
                wfWarn( "$fname: No transaction to commit, something got out of sync!" );
            } elseif ( $this->mTrxAutomatic ) {
                wfWarn( "$fname: Explicit commit of implicit transaction. Something may be out of sync!" );
            }
        } else {
            if ( !$this->mTrxLevel ) {
                return; // nothing to do
            } elseif ( !$this->mTrxAutomatic ) {
                wfWarn( "$fname: Flushing an explicit transaction, getting out of sync!" );
            }
        }
 
        $this->runOnTransactionPreCommitCallbacks();
        $this->doCommit( $fname );
        if ( $this->mTrxDoneWrites ) {
            Profiler::instance()->transactionWritingOut( $this->mServer, $this->mDBname );
        }
        $this->runOnTransactionIdleCallbacks();
    }
 
    protected function doCommit( $fname ) {
        if ( $this->mTrxLevel ) {
            $this->query( 'COMMIT', $fname );
            $this->mTrxLevel = 0;
        }
    }
 
    final public function rollback( $fname = __METHOD__, $flush = '' ) {
        if ( $flush !== 'flush' ) {
            if ( !$this->mTrxLevel ) {
                wfWarn( "$fname: No transaction to rollback, something got out of sync!" );
            } elseif ( $this->mTrxAutomatic ) {
                wfWarn( "$fname: Explicit rollback of implicit transaction. Something may be out of sync!" );
            }
        } else {
            if ( !$this->mTrxLevel ) {
                return; // nothing to do
            } elseif ( !$this->mTrxAutomatic ) {
                wfWarn( "$fname: Flushing an explicit transaction, getting out of sync!" );
            }
        }
 
        $this->doRollback( $fname );
        $this->mTrxIdleCallbacks = array(); // cancel
        $this->mTrxPreCommitCallbacks = array(); // cancel
        $this->mTrxAtomicLevels = new SplStack;
        if ( $this->mTrxDoneWrites ) {
            Profiler::instance()->transactionWritingOut( $this->mServer, $this->mDBname );
        }
    }
 
    protected function doRollback( $fname ) {
        if ( $this->mTrxLevel ) {
            $this->query( 'ROLLBACK', $fname, true );
            $this->mTrxLevel = 0;
        }
    }
 
    public function duplicateTableStructure( $oldName, $newName, $temporary = false,
        $fname = __METHOD__
    ) {
        throw new MWException(
            'DatabaseBase::duplicateTableStructure is not implemented in descendant class' );
    }
 
    function listTables( $prefix = null, $fname = __METHOD__ ) {
        throw new MWException( 'DatabaseBase::listTables is not implemented in descendant class' );
    }
 
    final public function clearViewsCache() {
        $this->allViews = null;
    }
 
    public function listViews( $prefix = null, $fname = __METHOD__ ) {
        throw new MWException( 'DatabaseBase::listViews is not implemented in descendant class' );
    }
 
    public function isView( $name ) {
        throw new MWException( 'DatabaseBase::isView is not implemented in descendant class' );
    }
 
    public function timestamp( $ts = 0 ) {
        return wfTimestamp( TS_MW, $ts );
    }
 
    public function timestampOrNull( $ts = null ) {
        if ( is_null( $ts ) ) {
            return null;
        } else {
            return $this->timestamp( $ts );
        }
    }
 
    public function resultObject( $result ) {
        if ( empty( $result ) ) {
            return false;
        } elseif ( $result instanceof ResultWrapper ) {
            return $result;
        } elseif ( $result === true ) {
            // Successful write query
            return $result;
        } else {
            return new ResultWrapper( $this, $result );
        }
    }
 
    public function ping() {
        # Stub. Not essential to override.
        return true;
    }
 
    public function getLag() {
        return 0;
    }
 
    function maxListLen() {
        return 0;
    }
 
    public function encodeBlob( $b ) {
        return $b;
    }
 
    public function decodeBlob( $b ) {
        return $b;
    }
 
    public function setSessionOptions( array $options ) {
    }
 
    public function sourceFile(
        $filename, $lineCallback = false, $resultCallback = false, $fname = false, $inputCallback = false
    ) {
        wfSuppressWarnings();
        $fp = fopen( $filename, 'r' );
        wfRestoreWarnings();
 
        if ( false === $fp ) {
            throw new MWException( "Could not open \"{$filename}\".\n" );
        }
 
        if ( !$fname ) {
            $fname = __METHOD__ . "( $filename )";
        }
 
        try {
            $error = $this->sourceStream( $fp, $lineCallback, $resultCallback, $fname, $inputCallback );
        } catch ( MWException $e ) {
            fclose( $fp );
            throw $e;
        }
 
        fclose( $fp );
 
        return $error;
    }
 
    public function patchPath( $patch ) {
        global $IP;
 
        $dbType = $this->getType();
        if ( file_exists( "$IP/maintenance/$dbType/archives/$patch" ) ) {
            return "$IP/maintenance/$dbType/archives/$patch";
        } else {
            return "$IP/maintenance/archives/$patch";
        }
    }
 
    public function setSchemaVars( $vars ) {
        $this->mSchemaVars = $vars;
    }
 
    public function sourceStream( $fp, $lineCallback = false, $resultCallback = false,
        $fname = __METHOD__, $inputCallback = false
    ) {
        $cmd = '';
 
        while ( !feof( $fp ) ) {
            if ( $lineCallback ) {
                call_user_func( $lineCallback );
            }
 
            $line = trim( fgets( $fp ) );
 
            if ( $line == '' ) {
                continue;
            }
 
            if ( '-' == $line[0] && '-' == $line[1] ) {
                continue;
            }
 
            if ( $cmd != '' ) {
                $cmd .= ' ';
            }
 
            $done = $this->streamStatementEnd( $cmd, $line );
 
            $cmd .= "$line\n";
 
            if ( $done || feof( $fp ) ) {
                $cmd = $this->replaceVars( $cmd );
 
                if ( ( $inputCallback && call_user_func( $inputCallback, $cmd ) ) || !$inputCallback ) {
                    $res = $this->query( $cmd, $fname );
 
                    if ( $resultCallback ) {
                        call_user_func( $resultCallback, $res, $this );
                    }
 
                    if ( false === $res ) {
                        $err = $this->lastError();
 
                        return "Query \"{$cmd}\" failed with error code \"$err\".\n";
                    }
                }
                $cmd = '';
            }
        }
 
        return true;
    }
 
    public function streamStatementEnd( &$sql, &$newLine ) {
        if ( $this->delimiter ) {
            $prev = $newLine;
            $newLine = preg_replace( '/' . preg_quote( $this->delimiter, '/' ) . '$/', '', $newLine );
            if ( $newLine != $prev ) {
                return true;
            }
        }
 
        return false;
    }
 
    protected function replaceSchemaVars( $ins ) {
        $vars = $this->getSchemaVars();
        foreach ( $vars as $var => $value ) {
            // replace '{$var}'
            $ins = str_replace( '\'{$' . $var . '}\'', $this->addQuotes( $value ), $ins );
            // replace `{$var}`
            $ins = str_replace( '`{$' . $var . '}`', $this->addIdentifierQuotes( $value ), $ins );
            // replace /*$var*/
            $ins = str_replace( '/*$' . $var . '*/', $this->strencode( $value ), $ins );
        }
 
        return $ins;
    }
 
    protected function replaceVars( $ins ) {
        $ins = $this->replaceSchemaVars( $ins );
 
        // Table prefixes
        $ins = preg_replace_callback( '!/\*(?:\$wgDBprefix|_)\*/([a-zA-Z_0-9]*)!',
            array( $this, 'tableNameCallback' ), $ins );
 
        // Index names
        $ins = preg_replace_callback( '!/\*i\*/([a-zA-Z_0-9]*)!',
            array( $this, 'indexNameCallback' ), $ins );
 
        return $ins;
    }
 
    protected function getSchemaVars() {
        if ( $this->mSchemaVars ) {
            return $this->mSchemaVars;
        } else {
            return $this->getDefaultSchemaVars();
        }
    }
 
    protected function getDefaultSchemaVars() {
        return array();
    }
 
    protected function tableNameCallback( $matches ) {
        return $this->tableName( $matches[1] );
    }
 
    protected function indexNameCallback( $matches ) {
        return $this->indexName( $matches[1] );
    }
 
    public function lockIsFree( $lockName, $method ) {
        return true;
    }
 
    public function lock( $lockName, $method, $timeout = 5 ) {
        return true;
    }
 
    public function unlock( $lockName, $method ) {
        return true;
    }
 
    public function lockTables( $read, $write, $method, $lowPriority = true ) {
        return true;
    }
 
    public function unlockTables( $method ) {
        return true;
    }
 
    public function dropTable( $tableName, $fName = __METHOD__ ) {
        if ( !$this->tableExists( $tableName, $fName ) ) {
            return false;
        }
        $sql = "DROP TABLE " . $this->tableName( $tableName );
        if ( $this->cascadingDeletes() ) {
            $sql .= " CASCADE";
        }
 
        return $this->query( $sql, $fName );
    }
 
    public function getSearchEngine() {
        return 'SearchEngineDummy';
    }
 
    public function getInfinity() {
        return 'infinity';
    }
 
    public function encodeExpiry( $expiry ) {
        return ( $expiry == '' || $expiry == 'infinity' || $expiry == $this->getInfinity() )
            ? $this->getInfinity()
            : $this->timestamp( $expiry );
    }
 
    public function decodeExpiry( $expiry, $format = TS_MW ) {
        return ( $expiry == '' || $expiry == $this->getInfinity() )
            ? 'infinity'
            : wfTimestamp( $format, $expiry );
    }
 
    public function setBigSelects( $value = true ) {
        // no-op
    }
 
    public function __toString() {
        return (string)$this->mConn;
    }
 
    public function __destruct() {
        if ( $this->mTrxLevel && $this->mTrxDoneWrites ) {
            trigger_error( "Uncommitted DB writes (transaction from {$this->mTrxFname})." );
        }
        if ( count( $this->mTrxIdleCallbacks ) || count( $this->mTrxPreCommitCallbacks ) ) {
            $callers = array();
            foreach ( $this->mTrxIdleCallbacks as $callbackInfo ) {
                $callers[] = $callbackInfo[1];
            }
            $callers = implode( ', ', $callers );
            trigger_error( "DB transaction callbacks still pending (from $callers)." );
        }
    }
}