Update to MediaWiki 1.18.0

* also update ArchLinux skin to chagnes in MonoBook
* Use only css to hide our menu bar when printing

15 files changed, 2846 insertions, 1800 deletions

diff --git a/includes/db/CloneDatabase.php b/includes/db/CloneDatabase.php
new file mode 100644
index 00000000..3357268d
--- /dev/null
+++ b/includes/db/CloneDatabase.php
@@ -0,0 +1,158 @@
+<?php
+/**
+ * Helper class for making a copy of the database, mostly for unit testing.
+ *
+ * Copyright © 2010 Chad Horohoe <chad@anyonecanedit.org>
+ * http://www.mediawiki.org/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ * http://www.gnu.org/copyleft/gpl.html
+ *
+ * @ingroup Database
+ */
+
+class CloneDatabase {
+
+	/**
+	 * Table prefix for cloning
+	 * @var String
+	 */
+	private $newTablePrefix = '';
+
+	/**
+	 * Current table prefix
+	 * @var String
+	 */
+	private $oldTablePrefix = '';
+
+	/**
+	 * List of tables to be cloned
+	 * @var Array
+	 */
+	private $tablesToClone = array();
+
+	/**
+	 * Should we DROP tables containing the new names?
+	 * @var Bool
+	 */
+	private $dropCurrentTables = true;
+
+	/**
+	 * Whether to use temporary tables or not
+	 * @var Bool
+	 */
+	private $useTemporaryTables = true;
+
+	/**
+	 * Constructor
+	 *
+	 * @param $db DatabaseBase A database subclass
+	 * @param $tablesToClone Array An array of tables to clone, unprefixed
+	 * @param $newTablePrefix String Prefix to assign to the tables
+	 * @param $oldTablePrefix String Prefix on current tables, if not $wgDBprefix
+	 * @param $dropCurrentTables bool
+	 */
+	public function __construct( DatabaseBase $db, array $tablesToClone,
+		$newTablePrefix, $oldTablePrefix = '', $dropCurrentTables = true )
+	{
+		$this->db = $db;
+		$this->tablesToClone = $tablesToClone;
+		$this->newTablePrefix = $newTablePrefix;
+		$this->oldTablePrefix = $oldTablePrefix ? $oldTablePrefix : $this->db->tablePrefix();
+		$this->dropCurrentTables = $dropCurrentTables;
+	}
+
+	/**
+	 * Set whether to use temporary tables or not
+	 * @param $u Bool Use temporary tables when cloning the structure
+	 */
+	public function useTemporaryTables( $u = true ) {
+		$this->useTemporaryTables = $u;
+	}
+
+	/**
+	 * Clone the table structure
+	 */
+	public function cloneTableStructure() {
+		
+		foreach( $this->tablesToClone as $tbl ) {
+			# Clean up from previous aborted run.  So that table escaping
+			# works correctly across DB engines, we need to change the pre-
+			# fix back and forth so tableName() works right.
+			
+			self::changePrefix( $this->oldTablePrefix );
+			$oldTableName = $this->db->tableName( $tbl, false );
+			
+			self::changePrefix( $this->newTablePrefix );
+			$newTableName = $this->db->tableName( $tbl, false );
+			
+			if( $this->dropCurrentTables && !in_array( $this->db->getType(), array( 'postgres' ) ) ) {
+				$this->db->dropTable( $tbl, __METHOD__ );
+				wfDebug( __METHOD__." dropping {$newTableName}\n", true);
+				//Dropping the oldTable because the prefix was changed
+			}
+
+			# Create new table
+			wfDebug( __METHOD__." duplicating $oldTableName to $newTableName\n", true );
+			$this->db->duplicateTableStructure( $oldTableName, $newTableName, $this->useTemporaryTables );
+			
+		}
+		
+	}
+
+	/**
+	 * Change the prefix back to the original.
+	 * @param $dropTables bool Optionally drop the tables we created
+	 */
+	public function destroy( $dropTables = false ) {
+		if( $dropTables ) {
+			self::changePrefix( $this->newTablePrefix );
+			foreach( $this->tablesToClone as $tbl ) {
+				$this->db->dropTable( $tbl );
+			}
+		}
+		self::changePrefix( $this->oldTablePrefix );
+	}
+
+	/**
+	 * Change the table prefix on all open DB connections/
+	 *
+	 * @param  $prefix
+	 * @return void
+	 */
+	public static function changePrefix( $prefix ) {
+		global $wgDBprefix;
+		wfGetLBFactory()->forEachLB( array( 'CloneDatabase', 'changeLBPrefix' ), array( $prefix ) );
+		$wgDBprefix = $prefix;
+	}
+
+	/**
+	 * @param  $lb LoadBalancer
+	 * @param  $prefix
+	 * @return void
+	 */
+	public static function changeLBPrefix( $lb, $prefix ) {
+		$lb->forEachOpenConnection( array( 'CloneDatabase', 'changeDBPrefix' ), array( $prefix ) );
+	}
+
+	/**
+	 * @param  $db DatabaseBase
+	 * @param  $prefix
+	 * @return void
+	 */
+	public static function changeDBPrefix( $db, $prefix ) {
+		$db->tablePrefix( $prefix );
+	}
+}
diff --git a/includes/db/Database.php b/includes/db/Database.php
index 5acb67fa..75e6a91d 100644
--- a/includes/db/Database.php
+++ b/includes/db/Database.php
@@ -28,7 +28,7 @@ interface DatabaseType {
 	 *
 	 * @return string
 	 */
-	public function getType();
+	function getType();
 
 	/**
 	 * Open a connection to the database. Usually aborts on failure
@@ -40,38 +40,28 @@ interface DatabaseType {
 	 * @return bool
 	 * @throws DBConnectionError
 	 */
-	public function open( $server, $user, $password, $dbName );
-
-	/**
-	 * The DBMS-dependent part of query()
-	 * @todo Fixme: Make this private someday
-	 *
-	 * @param  $sql String: SQL query.
-	 * @return Result object to feed to fetchObject, fetchRow, ...; or false on failure
-	 * @private
-	 */
-	/*private*/ function doQuery( $sql );
+	function open( $server, $user, $password, $dbName );
 
 	/**
 	 * Fetch the next row from the given result object, in object form.
 	 * Fields can be retrieved with $row->fieldname, with fields acting like
 	 * member variables.
 	 *
-	 * @param $res SQL result object as returned from DatabaseBase::query(), etc.
+	 * @param $res ResultWrapper|object as returned from DatabaseBase::query(), etc.
 	 * @return Row object
 	 * @throws DBUnexpectedError Thrown if the database returns an error
 	 */
-	public function fetchObject( $res );
+	function fetchObject( $res );
 
 	/**
 	 * Fetch the next row from the given result object, in associative array
 	 * form.  Fields are retrieved with $row['fieldname'].
 	 *
-	 * @param $res SQL result object as returned from DatabaseBase::query(), etc.
+	 * @param $res ResultWrapper result object as returned from DatabaseBase::query(), etc.
 	 * @return Row object
 	 * @throws DBUnexpectedError Thrown if the database returns an error
 	 */
-	public function fetchRow( $res );
+	function fetchRow( $res );
 
 	/**
 	 * Get the number of rows in a result object
@@ -79,7 +69,7 @@ interface DatabaseType {
 	 * @param $res Mixed: A SQL result
 	 * @return int
 	 */
-	public function numRows( $res );
+	function numRows( $res );
 
 	/**
 	 * Get the number of fields in a result object
@@ -88,7 +78,7 @@ interface DatabaseType {
 	 * @param $res Mixed: A SQL result
 	 * @return int
 	 */
-	public function numFields( $res );
+	function numFields( $res );
 
 	/**
 	 * Get a field name in a result object
@@ -98,7 +88,7 @@ interface DatabaseType {
 	 * @param $n Integer
 	 * @return string
 	 */
-	public function fieldName( $res, $n );
+	function fieldName( $res, $n );
 
 	/**
 	 * Get the inserted value of an auto-increment row
@@ -112,7 +102,7 @@ interface DatabaseType {
 	 *
 	 * @return int
 	 */
-	public function insertId();
+	function insertId();
 
 	/**
 	 * Change the position of the cursor in a result object
@@ -121,7 +111,7 @@ interface DatabaseType {
 	 * @param $res Mixed: A SQL result
 	 * @param $row Mixed: Either MySQL row or ResultWrapper
 	 */
-	public function dataSeek( $res, $row );
+	function dataSeek( $res, $row );
 
 	/**
 	 * Get the last error number
@@ -129,7 +119,7 @@ interface DatabaseType {
 	 *
 	 * @return int
 	 */
-	public function lastErrno();
+	function lastErrno();
 
 	/**
 	 * Get a description of the last error
@@ -137,7 +127,7 @@ interface DatabaseType {
 	 *
 	 * @return string
 	 */
-	public function lastError();
+	function lastError();
 
 	/**
 	 * mysql_fetch_field() wrapper
@@ -145,8 +135,10 @@ interface DatabaseType {
 	 *
 	 * @param $table string: table name
 	 * @param $field string: field name
+	 *
+	 * @return Field
 	 */
-	public function fieldInfo( $table, $field );
+	function fieldInfo( $table, $field );
 
 	/**
 	 * Get information about an index into an object
@@ -163,7 +155,7 @@ interface DatabaseType {
 	 *
 	 * @return int
 	 */
-	public function affectedRows();
+	function affectedRows();
 
 	/**
 	 * Wrapper for addslashes()
@@ -171,7 +163,7 @@ interface DatabaseType {
 	 * @param $s string: to be slashed.
 	 * @return string: slashed string.
 	 */
-	public function strencode( $s );
+	function strencode( $s );
 
 	/**
 	 * Returns a wikitext link to the DB's website, e.g.,
@@ -181,7 +173,7 @@ interface DatabaseType {
 	 *
 	 * @return string: wikitext of a link to the server software's web site
 	 */
-	public static function getSoftwareLink();
+	static function getSoftwareLink();
 
 	/**
 	 * A string describing the current software version, like from
@@ -189,7 +181,7 @@ interface DatabaseType {
 	 *
 	 * @return string: Version information from the database server.
 	 */
-	public function getServerVersion();
+	function getServerVersion();
 
 	/**
 	 * A string describing the current software version, and possibly
@@ -198,7 +190,7 @@ interface DatabaseType {
 	 *
 	 * @return string: Version information from the database server
 	 */
-	public function getServerInfo();
+	function getServerInfo();
 }
 
 /**
@@ -215,7 +207,12 @@ abstract class DatabaseBase implements DatabaseType {
 	protected $mDoneWrites = false;
 	protected $mPHPError = false;
 
-	protected $mServer, $mUser, $mPassword, $mConn = null, $mDBname;
+	protected $mServer, $mUser, $mPassword, $mDBname;
+
+	/**
+	 * @var DatabaseBase
+	 */
+	protected $mConn = null;
 	protected $mOpened = false;
 
 	protected $mTablePrefix;
@@ -244,15 +241,39 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * Boolean, controls output of large amounts of debug information
+	 * Boolean, controls output of large amounts of debug information.
+	 * @param $debug:
+	 *   - true to enable debugging
+	 *   - false to disable debugging
+	 *   - omitted or null to do nothing
+	 *
+	 * @return The previous value of the flag
 	 */
 	function debug( $debug = null ) {
 		return wfSetBit( $this->mFlags, DBO_DEBUG, $debug );
 	}
 
 	/**
-	 * Turns buffering of SQL result sets on (true) or off (false).
-	 * Default is "on" and it should not be changed without good reasons.
+	 * Turns buffering of SQL result sets on (true) or off (false). Default is
+	 * "on".
+	 *
+	 * Unbuffered queries are very troublesome in MySQL:
+	 *
+	 *   - If another query is executed while the first query is being read
+	 *     out, the first query is killed. This means you can't call normal
+	 *     MediaWiki functions while you are reading an unbuffered query result
+	 *     from a normal wfGetDB() connection.
+	 *
+	 *   - Unbuffered queries cause the MySQL server to use large amounts of
+	 *     memory and to hold broad locks which block other queries.
+	 *
+	 * If you want to limit client-side memory, it's almost always better to
+	 * split up queries into batches using a LIMIT clause than to switch off
+	 * buffering.
+	 *
+	 * @param $buffer null|bool
+	 *
+	 * @return The previous value of the flag
 	 */
 	function bufferResults( $buffer = null ) {
 		if ( is_null( $buffer ) ) {
@@ -268,32 +289,50 @@ abstract class DatabaseBase implements DatabaseType {
 	 * database errors. Default is on (false). When turned off, the
 	 * code should use lastErrno() and lastError() to handle the
 	 * situation as appropriate.
+	 *
+	 * @return The previous value of the flag.
 	 */
 	function ignoreErrors( $ignoreErrors = null ) {
 		return wfSetBit( $this->mFlags, DBO_IGNORE, $ignoreErrors );
 	}
 
 	/**
-	 * The current depth of nested transactions
-	 * @param $level Integer: , default NULL.
+	 * Gets or sets the current transaction level.
+	 *
+	 * Historically, transactions were allowed to be "nested". This is no
+	 * longer supported, so this function really only returns a boolean.
+	 *
+	 * @param $level An integer (0 or 1), or omitted to leave it unchanged.
+	 * @return The previous value
 	 */
 	function trxLevel( $level = null ) {
 		return wfSetVar( $this->mTrxLevel, $level );
 	}
 
 	/**
-	 * Number of errors logged, only useful when errors are ignored
+	 * Get/set the number of errors logged. Only useful when errors are ignored
+	 * @param $count The count to set, or omitted to leave it unchanged.
+	 * @return The error count
 	 */
 	function errorCount( $count = null ) {
 		return wfSetVar( $this->mErrorCount, $count );
 	}
 
+	/**
+	 * Get/set the table prefix.
+	 * @param $prefix The table prefix to set, or omitted to leave it unchanged.
+	 * @return The previous table prefix.
+	 */
 	function tablePrefix( $prefix = null ) {
-		return wfSetVar( $this->mTablePrefix, $prefix );
+		return wfSetVar( $this->mTablePrefix, $prefix, true );
 	}
 
 	/**
-	 * Properties passed down from the server info array of the load balancer
+	 * Get properties passed down from the server info array of the load
+	 * balancer.
+	 *
+	 * @param $name The entry of the info array to get, or null to get the
+	 *   whole array
 	 */
 	function getLBInfo( $name = null ) {
 		if ( is_null( $name ) ) {
@@ -307,6 +346,15 @@ abstract class DatabaseBase implements DatabaseType {
 		}
 	}
 
+	/**
+	 * Set the LB info array, or a member of it. If called with one parameter,
+	 * the LB info array is set to that parameter. If it is called with two
+	 * parameters, the member with the given name is set to the given value.
+	 *
+	 * @param $name
+	 * @param $value
+	 * @return void
+	 */
 	function setLBInfo( $name, $value = null ) {
 		if ( is_null( $value ) ) {
 			$this->mLBInfo = $name;
@@ -400,20 +448,28 @@ abstract class DatabaseBase implements DatabaseType {
 	 * Return the last query that went through DatabaseBase::query()
 	 * @return String
 	 */
-	function lastQuery() { return $this->mLastQuery; }
+	function lastQuery() {
+		return $this->mLastQuery;
+	}
 
 
 	/**
 	 * Returns true if the connection may have been used for write queries.
 	 * Should return true if unsure.
+	 *
+	 * @return bool
 	 */
-	function doneWrites() { return $this->mDoneWrites; }
+	function doneWrites() {
+		return $this->mDoneWrites;
+	}
 
 	/**
 	 * Is a connection to the database open?
 	 * @return Boolean
 	 */
-	function isOpen() { return $this->mOpened; }
+	function isOpen() {
+		return $this->mOpened;
+	}
 
 	/**
 	 * Set a flag for this connection
@@ -457,6 +513,9 @@ abstract class DatabaseBase implements DatabaseType {
 		return $this->$name;
 	}
 
+	/**
+	 * @return string
+	 */
 	function getWikiID() {
 		if ( $this->mTablePrefix ) {
 			return "{$this->mDBname}-{$this->mTablePrefix}";
@@ -466,9 +525,11 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * Return a path to the DBMS-specific schema, otherwise default to tables.sql
+	 * Return a path to the DBMS-specific schema file, otherwise default to tables.sql
+	 *
+	 * @return string
 	 */
-	public function getSchema() {
+	public function getSchemaPath() {
 		global $IP;
 		if ( file_exists( "$IP/maintenance/" . $this->getType() . "/tables.sql" ) ) {
 			return "$IP/maintenance/" . $this->getType() . "/tables.sql";
@@ -493,12 +554,8 @@ abstract class DatabaseBase implements DatabaseType {
 	function __construct( $server = false, $user = false, $password = false, $dbName = false,
 		$flags = 0, $tablePrefix = 'get from global'
 	) {
-		global $wgOut, $wgDBprefix, $wgCommandLineMode;
+		global $wgDBprefix, $wgCommandLineMode;
 
-		# Can't get a reference if it hasn't been set yet
-		if ( !isset( $wgOut ) ) {
-			$wgOut = null;
-		}
 		$this->mFlags = $flags;
 
 		if ( $this->mFlags & DBO_DEFAULT ) {
@@ -509,13 +566,6 @@ abstract class DatabaseBase implements DatabaseType {
 			}
 		}
 
-		/*
-		// Faster read-only access
-		if ( wfReadOnly() ) {
-			$this->mFlags |= DBO_PERSISTENT;
-			$this->mFlags &= ~DBO_TRX;
-		}*/
-
 		/** Get the default table prefix*/
 		if ( $tablePrefix == 'get from global' ) {
 			$this->mTablePrefix = $wgDBprefix;
@@ -523,14 +573,16 @@ abstract class DatabaseBase implements DatabaseType {
 			$this->mTablePrefix = $tablePrefix;
 		}
 
-		if ( $server ) {
+		if ( $user ) {
 			$this->open( $server, $user, $password, $dbName );
 		}
 	}
 
 	/**
 	 * Same as new DatabaseMysql( ... ), kept for backward compatibility
-	 * @deprecated
+	 * @deprecated since 1.17
+	 *
+	 * @return DatabaseMysql
 	 */
 	static function newFromParams( $server, $user, $password, $dbName, $flags = 0 ) {
 		wfDeprecated( __METHOD__ );
@@ -554,10 +606,10 @@ abstract class DatabaseBase implements DatabaseType {
 	 *
 	 * @param $dbType String A possible DB type
 	 * @param $p Array An array of options to pass to the constructor.
-	 *    Valid options are: host, user, password, dbname, flags, tableprefix
+	 *    Valid options are: host, user, password, dbname, flags, tablePrefix
 	 * @return DatabaseBase subclass or null
 	 */
-	public final static function newFromType( $dbType, $p = array() ) {
+	public final static function factory( $dbType, $p = array() ) {
 		$canonicalDBTypes = array(
 			'mysql', 'postgres', 'sqlite', 'oracle', 'mssql', 'ibm_db2'
 		);
@@ -571,7 +623,7 @@ abstract class DatabaseBase implements DatabaseType {
 				isset( $p['password'] ) ? $p['password'] : false,
 				isset( $p['dbname'] ) ? $p['dbname'] : false,
 				isset( $p['flags'] ) ? $p['flags'] : 0,
-				isset( $p['tableprefix'] ) ? $p['tableprefix'] : 'get from global'
+				isset( $p['tablePrefix'] ) ? $p['tablePrefix'] : 'get from global'
 			);
 		} else {
 			return null;
@@ -627,36 +679,51 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
+	 * The DBMS-dependent part of query()
+	 *
+	 * @param  $sql String: SQL query.
+	 * @return Result object to feed to fetchObject, fetchRow, ...; or false on failure
+	 */
+	protected abstract function doQuery( $sql );
+
+	/**
 	 * Determine whether a query writes to the DB.
 	 * Should return true if unsure.
+	 *
+	 * @return bool
 	 */
 	function isWriteQuery( $sql ) {
 		return !preg_match( '/^(?:SELECT|BEGIN|COMMIT|SET|SHOW|\(SELECT)\b/i', $sql );
 	}
 
 	/**
-	 * Usually aborts on failure.  If errors are explicitly ignored, returns success.
+	 * Run an SQL query and return the result. Normally throws a DBQueryError
+	 * on failure. If errors are ignored, returns false instead.
+	 *
+	 * In new code, the query wrappers select(), insert(), update(), delete(),
+	 * etc. should be used where possible, since they give much better DBMS
+	 * independence and automatically quote or validate user input in a variety
+	 * of contexts. This function is generally only useful for queries which are
+	 * explicitly DBMS-dependent and are unsupported by the query wrappers, such
+	 * as CREATE TABLE.
+	 *
+	 * However, the query wrappers themselves should call this function.
 	 *
 	 * @param  $sql        String: SQL query
 	 * @param  $fname      String: Name of the calling function, for profiling/SHOW PROCESSLIST
 	 *     comment (you can use __METHOD__ or add some extra info)
 	 * @param  $tempIgnore Boolean:   Whether to avoid throwing an exception on errors...
 	 *     maybe best to catch the exception instead?
-	 * @return boolean or ResultWrapper. true for a successful write query, ResultWrapper object for a successful read query,
-	 *     or false on failure if $tempIgnore set
+	 * @return boolean|ResultWrapper. true for a successful write query, ResultWrapper object
+	 *     for a successful read query, or false on failure if $tempIgnore set
 	 * @throws DBQueryError Thrown when the database returns an error of any kind
 	 */
 	public function query( $sql, $fname = '', $tempIgnore = false ) {
-		global $wgProfiler;
-
 		$isMaster = !is_null( $this->getLBInfo( 'master' ) );
-		if ( isset( $wgProfiler ) ) {
+		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.
 
-			# Who's been wasting my precious column space? -- TS
-			# $profName = 'query: ' . $fname . ' ' . substr( DatabaseBase::generalizeSQL( $sql ), 0, 255 );
-
 			if ( $isMaster ) {
 				$queryProf = 'query-m: ' . substr( DatabaseBase::generalizeSQL( $sql ), 0, 255 );
 				$totalProf = 'DatabaseBase::query-master';
@@ -671,34 +738,30 @@ abstract class DatabaseBase implements DatabaseType {
 
 		$this->mLastQuery = $sql;
 		if ( !$this->mDoneWrites && $this->isWriteQuery( $sql ) ) {
-			// Set a flag indicating that writes have been done
+			# 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 ( $fname ) {
-			global $wgUser;
-			if ( is_object( $wgUser ) && $wgUser->mDataLoaded ) {
-				$userName = $wgUser->getName();
-				if ( mb_strlen( $userName ) > 15 ) {
-					$userName = mb_substr( $userName, 0, 15 ) . '...';
-				}
-				$userName = str_replace( '/', '', $userName );
-			} else {
-				$userName = '';
+		global $wgUser;
+		if ( is_object( $wgUser ) && $wgUser->isItemLoaded( 'name' ) ) {
+			$userName = $wgUser->getName();
+			if ( mb_strlen( $userName ) > 15 ) {
+				$userName = mb_substr( $userName, 0, 15 ) . '...';
 			}
-			$commentedSql = preg_replace( '/\s/', " /* $fname $userName */ ", $sql, 1 );
-		# } else {
-		#	$commentedSql = $sql;
-		# }
+			$userName = str_replace( '/', '', $userName );
+		} else {
+			$userName = '';
+		}
+		$commentedSql = preg_replace( '/\s/', " /* $fname $userName */ ", $sql, 1 );
 
 		# If DBO_TRX is set, start a transaction
 		if ( ( $this->mFlags & DBO_TRX ) && !$this->trxLevel() &&
 			$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
+			# 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 and strpos( $sqlstart, "SET " ) !== 0 )
 				$this->begin();
@@ -751,7 +814,7 @@ abstract class DatabaseBase implements DatabaseType {
 			$this->reportQueryError( $this->lastError(), $this->lastErrno(), $sql, $fname, $tempIgnore );
 		}
 
-		if ( isset( $wgProfiler ) ) {
+		if ( !Profiler::instance()->isStub() ) {
 			wfProfileOut( $queryProf );
 			wfProfileOut( $totalProf );
 		}
@@ -760,6 +823,9 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
+	 * Report a query error. Log the error, and if neither the object ignore
+	 * flag nor the $tempIgnore flag is set, throw a DBQueryError.
+	 *
 	 * @param $error String
 	 * @param $errno Integer
 	 * @param $sql String
@@ -782,7 +848,6 @@ abstract class DatabaseBase implements DatabaseType {
 		}
 	}
 
-
 	/**
 	 * Intended to be compatible with the PEAR::DB wrapper functions.
 	 * http://pear.php.net/manual/en/package.database.db.intro-execute.php
@@ -791,6 +856,12 @@ abstract class DatabaseBase implements DatabaseType {
 	 * ! = raw SQL bit (a function for instance)
 	 * & = filename; reads the file and inserts as a blob
 	 *     (we don't use this though...)
+	 *
+	 * This function should not be used directly by new code outside of the
+	 * database classes. The query wrapper functions (select() etc.) should be
+	 * used instead.
+	 *
+	 * @return array
 	 */
 	function prepare( $sql, $func = 'DatabaseBase::prepare' ) {
 		/* MySQL doesn't support prepared statements (yet), so just
@@ -799,6 +870,9 @@ abstract class DatabaseBase implements DatabaseType {
 		return array( 'query' => $sql, 'func' => $func );
 	}
 
+	/**
+	 * Free a prepared query, generated by prepare().
+	 */
 	function freePrepared( $prepared ) {
 		/* No-op by default */
 	}
@@ -807,6 +881,8 @@ abstract class DatabaseBase implements DatabaseType {
 	 * Execute a prepared query with the various arguments
 	 * @param $prepared String: the prepared sql
 	 * @param $args Mixed: Either an array here, or put scalars as varargs
+	 *
+	 * @return ResultWrapper
 	 */
 	function execute( $prepared, $args = null ) {
 		if ( !is_array( $args ) ) {
@@ -823,8 +899,15 @@ abstract class DatabaseBase implements DatabaseType {
 	/**
 	 * Prepare & execute an SQL statement, quoting and inserting arguments
 	 * in the appropriate places.
+	 *
+	 * This function should not be used directly by new code outside of the
+	 * database classes. The query wrapper functions (select() etc.) should be
+	 * used instead.
+	 *
 	 * @param $query String
 	 * @param $args ...
+	 *
+	 * @return ResultWrapper
 	 */
 	function safeQuery( $query, $args = null ) {
 		$prepared = $this->prepare( $query, 'DatabaseBase::safeQuery' );
@@ -886,21 +969,24 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * Free a result object
+	 * Free a result object returned by query() or select(). It's usually not
+	 * necessary to call this, just use unset() or let the variable holding
+	 * the result object go out of scope.
+	 *
 	 * @param $res Mixed: A SQL result
 	 */
 	function freeResult( $res ) {
-		# Stub.  Might not really need to be overridden, since results should
-		# be freed by PHP when the variable goes out of scope anyway.
 	}
 
 	/**
-	 * Simple UPDATE wrapper
-	 * Usually aborts on failure
+	 * Simple UPDATE wrapper.
+	 * Usually throws a DBQueryError on failure.
 	 * If errors are explicitly ignored, returns success
 	 *
 	 * This function exists for historical reasons, DatabaseBase::update() has a more standard
 	 * calling convention and feature set
+	 *
+	 * @return bool
 	 */
 	function set( $table, $var, $value, $cond, $fname = 'DatabaseBase::set' ) {
 		$table = $this->tableName( $table );
@@ -911,11 +997,25 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * Simple SELECT wrapper, returns a single field, input must be encoded
-	 * Usually aborts on failure
-	 * If errors are explicitly ignored, returns FALSE on failure
+	 * A SELECT wrapper which returns a single field from a single result row.
+	 *
+	 * Usually throws a DBQueryError on failure. If errors are explicitly
+	 * ignored, returns false on failure.
+	 *
+	 * If no result rows are returned from the query, false is returned.
+	 *
+	 * @param $table string|array Table name. See DatabaseBase::select() for details.
+	 * @param $var string The field name to select. This must be a valid SQL
+	 *   fragment: do not use unvalidated user input.
+	 * @param $cond string|array The condition array. See DatabaseBase::select() for details.
+	 * @param $fname string The function name of the caller.
+	 * @param $options string|array The query options. See DatabaseBase::select() for details.
+	 *
+	 * @return false|mixed The value from the field, or false on failure.
 	 */
-	function selectField( $table, $var, $cond = '', $fname = 'DatabaseBase::selectField', $options = array() ) {
+	function selectField( $table, $var, $cond = '', $fname = 'DatabaseBase::selectField',
+		$options = array() )
+	{
 		if ( !is_array( $options ) ) {
 			$options = array( $options );
 		}
@@ -939,13 +1039,12 @@ abstract class DatabaseBase implements DatabaseType {
 
 	/**
 	 * Returns an optional USE INDEX clause to go after the table, and a
-	 * string to go at the end of the query
-	 *
-	 * @private
+	 * string to go at the end of the query.
 	 *
 	 * @param $options Array: associative array of options to be turned into
 	 *              an SQL query, valid keys are listed in the function.
 	 * @return Array
+	 * @see DatabaseBase::select()
 	 */
 	function makeSelectOptions( $options ) {
 		$preLimitTail = $postLimitTail = '';
@@ -960,7 +1059,10 @@ abstract class DatabaseBase implements DatabaseType {
 		}
 
 		if ( isset( $options['GROUP BY'] ) ) {
-			$preLimitTail .= " GROUP BY {$options['GROUP BY']}";
+			$gb = is_array( $options['GROUP BY'] )
+				? implode( ',', $options['GROUP BY'] )
+				: $options['GROUP BY'];
+			$preLimitTail .= " GROUP BY {$gb}";
 		}
 
 		if ( isset( $options['HAVING'] ) ) {
@@ -968,7 +1070,10 @@ abstract class DatabaseBase implements DatabaseType {
 		}
 
 		if ( isset( $options['ORDER BY'] ) ) {
-			$preLimitTail .= " ORDER BY {$options['ORDER BY']}";
+			$ob = is_array( $options['ORDER BY'] )
+				? implode( ',', $options['ORDER BY'] )
+				: $options['ORDER BY'];
+			$preLimitTail .= " ORDER BY {$ob}";
 		}
 
 		// if (isset($options['LIMIT'])) {
@@ -1032,49 +1137,176 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * SELECT wrapper
+	 * Execute a SELECT query constructed using the various parameters provided.
+	 * See below for full details of the parameters.
+	 *
+	 * @param $table String|Array Table name
+	 * @param $vars String|Array Field names
+	 * @param $conds String|Array Conditions
+	 * @param $fname String Caller function name
+	 * @param $options Array Query options
+	 * @param $join_conds Array Join conditions
+	 *
+	 *
+	 * @param $table string|array
+	 *
+	 * May be either an array of table names, or a single string holding a table
+	 * name. If an array is given, table aliases can be specified, for example:
+	 *
+	 *    array( 'a' => 'user' )
+	 *
+	 * This includes the user table in the query, with the alias "a" available
+	 * for use in field names (e.g. a.user_name).
+	 *
+	 * All of the table names given here are automatically run through
+	 * DatabaseBase::tableName(), which causes the table prefix (if any) to be
+	 * added, and various other table name mappings to be performed.
+	 *
+	 *
+	 * @param $vars string|array
+	 *
+	 * May be either a field name or an array of field names. The field names
+	 * here are complete fragments of SQL, for direct inclusion into the SELECT
+	 * query. Expressions and aliases may be specified as in SQL, for example:
+	 *
+	 *   array( 'MAX(rev_id) AS maxrev' )
+	 *
+	 * If an expression is given, care must be taken to ensure that it is
+	 * DBMS-independent.
+	 *
+	 *
+	 * @param $conds string|array
+	 *
+	 * May be either a string containing a single condition, or an array of
+	 * conditions. If an array is given, the conditions constructed from each
+	 * element are combined with AND.
+	 *
+	 * Array elements may take one of two forms:
+	 *
+	 *   - Elements with a numeric key are interpreted as raw SQL fragments.
+	 *   - Elements with a string key are interpreted as equality conditions,
+	 *     where the key is the field name.
+	 *     - If the value of such an array element is a scalar (such as a
+	 *       string), it will be treated as data and thus quoted appropriately.
+	 *       If it is null, an IS NULL clause will be added.
+	 *     - If the value is an array, an IN(...) clause will be constructed,
+	 *       such that the field name may match any of the elements in the
+	 *       array. The elements of the array will be quoted.
+	 *
+	 * Note that expressions are often DBMS-dependent in their syntax.
+	 * DBMS-independent wrappers are provided for constructing several types of
+	 * expression commonly used in condition queries. See:
+	 *    - DatabaseBase::buildLike()
+	 *    - DatabaseBase::conditional()
+	 *
+	 *
+	 * @param $options string|array
+	 *
+	 * Optional: Array of query options. Boolean options are specified by
+	 * including them in the array as a string value with a numeric key, for
+	 * example:
+	 *
+	 *    array( 'FOR UPDATE' )
+	 *
+	 * The supported options are:
+	 *
+	 *   - OFFSET: Skip this many rows at the start of the result set. OFFSET
+	 *     with LIMIT can theoretically be used for paging through a result set,
+	 *     but this is discouraged in MediaWiki for performance reasons.
+	 *
+	 *   - LIMIT: Integer: return at most this many rows. The rows are sorted
+	 *     and then the first rows are taken until the limit is reached. LIMIT
+	 *     is applied to a result set after OFFSET.
+	 *
+	 *   - FOR UPDATE: Boolean: lock the returned rows so that they can't be
+	 *     changed until the next COMMIT.
+	 *
+	 *   - DISTINCT: Boolean: return only unique result rows.
+	 *
+	 *   - GROUP BY: May be either an SQL fragment string naming a field or
+	 *     expression to group by, or an array of such SQL fragments.
+	 *
+	 *   - HAVING: A string containing a HAVING clause.
+	 *
+	 *   - ORDER BY: May be either an SQL fragment giving a field name or
+	 *     expression to order by, or an array of such SQL fragments.
+	 *
+	 *   - USE INDEX: This may be either a string giving the index name to use
+	 *     for the query, or an array. If it is an associative array, each key
+	 *     gives the table name (or alias), each value gives the index name to
+	 *     use for that table. All strings are SQL fragments and so should be
+	 *     validated by the caller.
+	 *
+	 *   - EXPLAIN: In MySQL, this causes an EXPLAIN SELECT query to be run,
+	 *     instead of SELECT.
+	 *
+	 * And also the following boolean MySQL extensions, see the MySQL manual
+	 * for documentation:
+	 *
+	 *    - LOCK IN SHARE MODE
+	 *    - STRAIGHT_JOIN
+	 *    - HIGH_PRIORITY
+	 *    - SQL_BIG_RESULT
+	 *    - SQL_BUFFER_RESULT
+	 *    - SQL_SMALL_RESULT
+	 *    - SQL_CALC_FOUND_ROWS
+	 *    - SQL_CACHE
+	 *    - SQL_NO_CACHE
+	 *
 	 *
-	 * @param $table   Mixed:  Array or string, table name(s) (prefix auto-added)
-	 * @param $vars    Mixed:  Array or string, field name(s) to be retrieved
-	 * @param $conds   Mixed:  Array or string, condition(s) for WHERE
-	 * @param $fname   String: Calling function name (use __METHOD__) for logs/profiling
-	 * @param $options Array:  Associative array of options (e.g. array('GROUP BY' => 'page_title')),
-	 *                         see DatabaseBase::makeSelectOptions code for list of supported stuff
-	 * @param $join_conds Array: Associative array of table join conditions (optional)
-	 *                           (e.g. array( 'page' => array('LEFT JOIN','page_latest=rev_id') )
-	 * @return mixed Database result resource (feed to DatabaseBase::fetchObject or whatever), or false on failure
+	 * @param $join_conds string|array
+	 *
+	 * Optional associative array of table-specific join conditions. In the
+	 * most common case, this is unnecessary, since the join condition can be
+	 * in $conds. However, it is useful for doing a LEFT JOIN.
+	 *
+	 * The key of the array contains the table name or alias. The value is an
+	 * array with two elements, numbered 0 and 1. The first gives the type of
+	 * join, the second is an SQL fragment giving the join condition for that
+	 * table. For example:
+	 *
+	 *    array( 'page' => array('LEFT JOIN','page_latest=rev_id') )
+	 *
+	 * @return ResultWrapper. If the query returned no rows, a ResultWrapper
+	 *   with no rows in it will be returned. If there was a query error, a
+	 *   DBQueryError exception will be thrown, except if the "ignore errors"
+	 *   option was set, in which case false will be returned.
 	 */
-	function select( $table, $vars, $conds = '', $fname = 'DatabaseBase::select', $options = array(), $join_conds = array() ) {
+	function select( $table, $vars, $conds = '', $fname = 'DatabaseBase::select',
+		$options = array(), $join_conds = array() ) {
 		$sql = $this->selectSQLText( $table, $vars, $conds, $fname, $options, $join_conds );
 
 		return $this->query( $sql, $fname );
 	}
 
 	/**
-	 * SELECT wrapper
+	 * The equivalent of DatabaseBase::select() except that the constructed SQL
+	 * is returned, instead of being immediately executed.
+	 *
+	 * @param $table string|array Table name
+	 * @param $vars string|array Field names
+	 * @param $conds string|array Conditions
+	 * @param $fname string Caller function name
+	 * @param $options string|array Query options
+	 * @param $join_conds string|array Join conditions
 	 *
-	 * @param $table   Mixed:  Array or string, table name(s) (prefix auto-added). Array keys are table aliases (optional)
-	 * @param $vars    Mixed:  Array or string, field name(s) to be retrieved
-	 * @param $conds   Mixed:  Array or string, condition(s) for WHERE
-	 * @param $fname   String: Calling function name (use __METHOD__) for logs/profiling
-	 * @param $options Array:  Associative array of options (e.g. array('GROUP BY' => 'page_title')),
-	 *                         see DatabaseBase::makeSelectOptions code for list of supported stuff
-	 * @param $join_conds Array: Associative array of table join conditions (optional)
-	 *                           (e.g. array( 'page' => array('LEFT JOIN','page_latest=rev_id') )
-	 * @return string, the SQL text
+	 * @return SQL query string.
+	 * @see DatabaseBase::select()
 	 */
 	function selectSQLText( $table, $vars, $conds = '', $fname = 'DatabaseBase::select', $options = array(), $join_conds = array() ) {
 		if ( is_array( $vars ) ) {
 			$vars = implode( ',', $vars );
 		}
 
-		if ( !is_array( $options ) ) {
-			$options = array( $options );
-		}
+		$options = (array)$options;
 
 		if ( is_array( $table ) ) {
-			if ( !empty( $join_conds ) || ( isset( $options['USE INDEX'] ) && is_array( @$options['USE INDEX'] ) ) ) {
-				$from = ' FROM ' . $this->tableNamesWithUseIndexOrJOIN( $table, @$options['USE INDEX'], $join_conds );
+			$useIndex = ( isset( $options['USE INDEX'] ) && is_array( $options['USE INDEX'] ) )
+				? $options['USE INDEX']
+				: array();
+			if ( count( $join_conds ) || count( $useIndex ) ) {
+				$from = ' FROM ' .
+					$this->tableNamesWithUseIndexOrJOIN( $table, $useIndex, $join_conds );
 			} else {
 				$from = ' FROM ' . implode( ',', $this->tableNamesWithAlias( $table ) );
 			}
@@ -1099,9 +1331,10 @@ abstract class DatabaseBase implements DatabaseType {
 			$sql = "SELECT $startOpts $vars $from $useIndex $preLimitTail";
 		}
 
-		if ( isset( $options['LIMIT'] ) )
+		if ( isset( $options['LIMIT'] ) ) {
 			$sql = $this->limitResult( $sql, $options['LIMIT'],
 				isset( $options['OFFSET'] ) ? $options['OFFSET'] : false );
+		}
 		$sql = "$sql $postLimitTail";
 
 		if ( isset( $options['EXPLAIN'] ) ) {
@@ -1112,24 +1345,22 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * Single row SELECT wrapper
-	 * Aborts or returns FALSE on error
+	 * Single row SELECT wrapper. Equivalent to DatabaseBase::select(), except
+	 * that a single row object is returned. If the query returns no rows,
+	 * false is returned.
 	 *
-	 * @param $table String: table name
-	 * @param $vars String: the selected variables
-	 * @param $conds Array: a condition map, terms are ANDed together.
-	 *   Items with numeric keys are taken to be literal conditions
-	 * Takes an array of selected variables, and a condition map, which is ANDed
-	 * e.g: selectRow( "page", array( "page_id" ), array( "page_namespace" =>
-	 * NS_MAIN, "page_title" => "Astronomy" ) )   would return an object where
-	 * $obj- >page_id is the ID of the Astronomy article
-	 * @param $fname String: Calling function name
-	 * @param $options Array
-	 * @param $join_conds Array
+	 * @param $table string|array Table name
+	 * @param $vars string|array Field names
+	 * @param $conds|array Conditions
+	 * @param $fname string Caller function name
+	 * @param $options string|array Query options
+	 * @param $join_conds array|string Join conditions
 	 *
-	 * @todo migrate documentation to phpdocumentor format
+	 * @return ResultWrapper|bool
 	 */
-	function selectRow( $table, $vars, $conds, $fname = 'DatabaseBase::selectRow', $options = array(), $join_conds = array() ) {
+	function selectRow( $table, $vars, $conds, $fname = 'DatabaseBase::selectRow',
+		$options = array(), $join_conds = array() )
+	{
 		$options['LIMIT'] = 1;
 		$res = $this->select( $table, $vars, $conds, $fname, $options, $join_conds );
 
@@ -1147,10 +1378,17 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * Estimate rows in dataset
-	 * Returns estimated count - not necessarily an accurate estimate across different databases,
-	 * so use sparingly
-	 * Takes same arguments as DatabaseBase::select()
+	 * Estimate rows in dataset.
+	 *
+	 * MySQL allows you to estimate the number of rows that would be returned
+	 * by a SELECT query, using EXPLAIN SELECT. The estimate is provided using
+	 * index cardinality statistics, and is notoriously inaccurate, especially
+	 * when large numbers of rows have recently been added or deleted.
+	 *
+	 * For DBMSs that don't support fast result size estimation, this function
+	 * will actually perform the SELECT COUNT(*).
+	 *
+	 * Takes the same arguments as DatabaseBase::select().
 	 *
 	 * @param $table String: table name
 	 * @param $vars Array: unused
@@ -1159,7 +1397,9 @@ abstract class DatabaseBase implements DatabaseType {
 	 * @param $options Array: options for select
 	 * @return Integer: row count
 	 */
-	public function estimateRowCount( $table, $vars = '*', $conds = '', $fname = 'DatabaseBase::estimateRowCount', $options = array() ) {
+	public function estimateRowCount( $table, $vars = '*', $conds = '',
+		$fname = 'DatabaseBase::estimateRowCount', $options = array() )
+	{
 		$rows = 0;
 		$res = $this->select ( $table, 'COUNT(*) AS rowcount', $conds, $fname, $options );
 
@@ -1213,8 +1453,10 @@ abstract class DatabaseBase implements DatabaseType {
 
 	/**
 	 * Determines whether an index exists
-	 * Usually aborts on failure
+	 * Usually throws a DBQueryError on failure
 	 * If errors are explicitly ignored, returns NULL on failure
+	 *
+	 * @return bool|null
 	 */
 	function indexExists( $table, $index, $fname = 'DatabaseBase::indexExists' ) {
 		$info = $this->indexInfo( $table, $index, $fname );
@@ -1227,6 +1469,10 @@ abstract class DatabaseBase implements DatabaseType {
 
 	/**
 	 * Query whether a given table exists
+	 *
+	 * @string table
+	 *
+	 * @return bool
 	 */
 	function tableExists( $table ) {
 		$table = $this->tableName( $table );
@@ -1250,6 +1496,11 @@ abstract class DatabaseBase implements DatabaseType {
 
 	/**
 	 * Determines if a given index is unique
+	 *
+	 * @param $table string
+	 * @param $index string
+	 *
+	 * @return bool
 	 */
 	function indexUnique( $table, $index ) {
 		$indexInfo = $this->indexInfo( $table, $index );
@@ -1262,18 +1513,45 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * INSERT wrapper, inserts an array into a table
+	 * Helper for DatabaseBase::insert().
+	 *
+	 * @param $options array
+	 * @return string
+	 */
+	function makeInsertOptions( $options ) {
+		return implode( ' ', $options );
+	}
+
+	/**
+	 * INSERT wrapper, inserts an array into a table.
 	 *
-	 * $a may be a single associative array, or an array of these with numeric keys, for
-	 * multi-row insert.
+	 * $a may be either:
 	 *
-	 * Usually aborts on failure
-	 * If errors are explicitly ignored, returns success
+	 *   - A single associative array. The array keys are the field names, and
+	 *     the values are the values to insert. The values are treated as data
+	 *     and will be quoted appropriately. If NULL is inserted, this will be
+	 *     converted to a database NULL.
+	 *   - An array with numeric keys, holding a list of associative arrays.
+	 *     This causes a multi-row INSERT on DBMSs that support it. The keys in
+	 *     each subarray must be identical to each other, and in the same order.
+	 *
+	 * Usually throws a DBQueryError on failure. If errors are explicitly ignored,
+	 * returns success.
+	 *
+	 * $options is an array of options, with boolean options encoded as values
+	 * with numeric keys, in the same style as $options in
+	 * DatabaseBase::select(). Supported options are:
+	 *
+	 *   - IGNORE: Boolean: if present, duplicate key errors are ignored, and
+	 *     any rows which cause duplicate key errors are not inserted. It's
+	 *     possible to determine how many rows were successfully inserted using
+	 *     DatabaseBase::affectedRows().
 	 *
-	 * @param $table   String: table name (prefix auto-added)
-	 * @param $a	   Array: Array of rows to insert
-	 * @param $fname   String: Calling function name (use __METHOD__) for logs/profiling
-	 * @param $options Mixed: Associative array of options
+	 * @param $table   String Table name. This will be passed through
+	 *                 DatabaseBase::tableName().
+	 * @param $a	   Array of rows to insert
+	 * @param $fname   String Calling function name (use __METHOD__) for logs/profiling
+	 * @param $options Array of options
 	 *
 	 * @return bool
 	 */
@@ -1289,6 +1567,8 @@ abstract class DatabaseBase implements DatabaseType {
 			$options = array( $options );
 		}
 
+		$options = $this->makeInsertOptions( $options );
+
 		if ( isset( $a[0] ) && is_array( $a[0] ) ) {
 			$multi = true;
 			$keys = array_keys( $a[0] );
@@ -1297,7 +1577,7 @@ abstract class DatabaseBase implements DatabaseType {
 			$keys = array_keys( $a );
 		}
 
-		$sql = 'INSERT ' . implode( ' ', $options ) .
+		$sql = 'INSERT ' . $options .
 			" INTO $table (" . implode( ',', $keys ) . ') VALUES ';
 
 		if ( $multi ) {
@@ -1320,7 +1600,6 @@ abstract class DatabaseBase implements DatabaseType {
 	/**
 	 * Make UPDATE options for the DatabaseBase::update function
 	 *
-	 * @private
 	 * @param $options Array: The options passed to DatabaseBase::update
 	 * @return string
 	 */
@@ -1343,15 +1622,26 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * UPDATE wrapper, takes a condition array and a SET array
+	 * UPDATE wrapper. Takes a condition array and a SET array.
+	 *
+	 * @param $table  String name of the table to UPDATE. This will be passed through
+	 *                DatabaseBase::tableName().
+	 *
+	 * @param $values Array:  An array of values to SET. For each array element,
+	 *                the key gives the field name, and the value gives the data
+	 *                to set that field to. The data will be quoted by
+	 *                DatabaseBase::addQuotes().
 	 *
-	 * @param $table  String: The table to UPDATE
-	 * @param $values Array:  An array of values to SET
-	 * @param $conds  Array:  An array of conditions (WHERE). Use '*' to update all rows.
-	 * @param $fname  String: The Class::Function calling this function
-	 *                        (for the log)
-	 * @param $options Array: An array of UPDATE options, can be one or
-	 *                        more of IGNORE, LOW_PRIORITY
+	 * @param $conds  Array:  An array of conditions (WHERE). See
+	 *                DatabaseBase::select() for the details of the format of
+	 *                condition arrays. Use '*' to update all rows.
+	 *
+	 * @param $fname  String: The function name of the caller (from __METHOD__),
+	 *                for logging and profiling.
+	 *
+	 * @param $options Array: An array of UPDATE options, can be:
+	 *                   - IGNORE: Ignore unique key conflicts
+	 *                   - LOW_PRIORITY: MySQL-specific, see MySQL manual.
 	 * @return Boolean
 	 */
 	function update( $table, $values, $conds, $fname = 'DatabaseBase::update', $options = array() ) {
@@ -1368,12 +1658,16 @@ abstract class DatabaseBase implements DatabaseType {
 
 	/**
 	 * Makes an encoded list of strings from an array
-	 * $mode:
-	 *        LIST_COMMA         - comma separated, no field names
-	 *        LIST_AND           - ANDed WHERE clause (without the WHERE)
-	 *        LIST_OR            - ORed WHERE clause (without the WHERE)
-	 *        LIST_SET           - comma separated with field names, like a SET clause
-	 *        LIST_NAMES         - comma separated field names
+	 * @param $a Array containing the data
+	 * @param $mode:
+	 *      - LIST_COMMA:          comma separated, no field names
+	 *      - LIST_AND:            ANDed WHERE clause (without the WHERE). See
+	 *        the documentation for $conds in DatabaseBase::select().
+	 *      - LIST_OR:             ORed WHERE clause (without the WHERE)
+	 *      - LIST_SET:            comma separated with field names, like a SET clause
+	 *      - LIST_NAMES:          comma separated field names
+	 *
+	 * @return string
 	 */
 	function makeList( $a, $mode = LIST_COMMA ) {
 		if ( !is_array( $a ) ) {
@@ -1434,7 +1728,8 @@ abstract class DatabaseBase implements DatabaseType {
 	 * Build a partial where clause from a 2-d array such as used for LinkBatch.
 	 * The keys on each level may be either integers or strings.
 	 *
-	 * @param $data Array: organized as 2-d array(baseKeyVal => array(subKeyVal => <ignored>, ...), ...)
+	 * @param $data Array: organized as 2-d
+	 *              array(baseKeyVal => array(subKeyVal => <ignored>, ...), ...)
 	 * @param $baseKey String: field name to match the base-level keys to (eg 'pl_namespace')
 	 * @param $subKey String: field name to match the sub-level keys to (eg 'pl_title')
 	 * @return Mixed: string SQL fragment, or false if no items in array.
@@ -1462,14 +1757,28 @@ abstract class DatabaseBase implements DatabaseType {
 	 * Bitwise operations
 	 */
 
+	/**
+	 * @param $field
+	 * @return string
+	 */
 	function bitNot( $field ) {
 		return "(~$field)";
 	}
 
+	/**
+	 * @param $fieldLeft
+	 * @param $fieldRight
+	 * @return string
+	 */
 	function bitAnd( $fieldLeft, $fieldRight ) {
 		return "($fieldLeft & $fieldRight)";
 	}
 
+	/**
+	 * @param  $fieldLeft
+	 * @param  $fieldRight
+	 * @return string
+	 */
 	function bitOr( $fieldLeft, $fieldRight ) {
 		return "($fieldLeft | $fieldRight)";
 	}
@@ -1484,6 +1793,7 @@ abstract class DatabaseBase implements DatabaseType {
 		# 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;
 	}
 
@@ -1512,15 +1822,17 @@ abstract class DatabaseBase implements DatabaseType {
 	 * when calling query() directly.
 	 *
 	 * @param $name String: database table name
+	 * @param $quoted Boolean: Automatically pass the table name through
+	 *          addIdentifierQuotes() so that it can be used in a query.
 	 * @return String: full database name
 	 */
-	function tableName( $name ) {
+	function tableName( $name, $quoted = true ) {
 		global $wgSharedDB, $wgSharedPrefix, $wgSharedTables;
 		# 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 ( $name[0] == '`' && substr( $name, -1, 1 ) == '`' ) {
+		if ( $this->isQuotedIdentifier( $name ) ) {
 			return $name;
 		}
 
@@ -1540,23 +1852,23 @@ abstract class DatabaseBase implements DatabaseType {
 		# the correct table.
 		$dbDetails = array_reverse( explode( '.', $name, 2 ) );
 		if ( isset( $dbDetails[1] ) ) {
-			@list( $table, $database ) = $dbDetails;
+			list( $table, $database ) = $dbDetails;
 		} else {
-			@list( $table ) = $dbDetails;
+			list( $table ) = $dbDetails;
 		}
 		$prefix = $this->mTablePrefix; # Default prefix
 
-		# A database name has been specified in input. Quote the table name
-		# because we don't want any prefixes added.
+		# A database name has been specified in input. We don't want any 
+		# prefixes added.
 		if ( isset( $database ) ) {
-			$table = ( $table[0] == '`' ? $table : "`{$table}`" );
+			$prefix = '';
 		}
 
 		# Note that we use the long format because php will complain in in_array if
 		# the input is not an array, and will complain in is_array if it is not set.
 		if ( !isset( $database ) # Don't use shared database if pre selected.
 		 && isset( $wgSharedDB ) # We have a shared database
-		 && $table[0] != '`' # Paranoia check to prevent shared tables listing '`table`'
+		 && !$this->isQuotedIdentifier( $table ) # Paranoia check to prevent shared tables listing '`table`'
 		 && isset( $wgSharedTables )
 		 && is_array( $wgSharedTables )
 		 && in_array( $table, $wgSharedTables ) ) { # A shared table is selected
@@ -1566,9 +1878,13 @@ abstract class DatabaseBase implements DatabaseType {
 
 		# Quote the $database and $table and apply the prefix if not quoted.
 		if ( isset( $database ) ) {
-			$database = ( $database[0] == '`' ? $database : "`{$database}`" );
+			$database = ( !$quoted || $this->isQuotedIdentifier( $database ) ? $database : $this->addIdentifierQuotes( $database ) );
+		}
+
+		$table = "{$prefix}{$table}";
+		if ( $quoted && !$this->isQuotedIdentifier( $table ) ) {
+			$table = $this->addIdentifierQuotes( "{$table}" );
 		}
-		$table = ( $table[0] == '`' ? $table : "`{$prefix}{$table}`" );
 
 		# Merge our database and table into our final table name.
 		$tableName = ( isset( $database ) ? "{$database}.{$table}" : "{$table}" );
@@ -1650,45 +1966,54 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * @private
+	 * Get the aliased table name clause for a FROM clause
+	 * which might have a JOIN and/or USE INDEX clause
+	 *
+	 * @param $tables array( [alias] => table )
+	 * @param $use_index array() Same as for select()
+	 * @param $join_conds array() Same as for select()
+	 * @return string
 	 */
-	function tableNamesWithUseIndexOrJOIN( $tables, $use_index = array(), $join_conds = array() ) {
+	protected function tableNamesWithUseIndexOrJOIN(
+		$tables, $use_index = array(), $join_conds = array()
+	) {
 		$ret = array();
 		$retJOIN = array();
-		$use_index_safe = is_array( $use_index ) ? $use_index : array();
-		$join_conds_safe = is_array( $join_conds ) ? $join_conds : 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 and INDEX clause for this table?
-			if ( isset( $join_conds_safe[$alias] ) && isset( $use_index_safe[$alias] ) ) {
-				$tableClause = $join_conds_safe[$alias][0] . ' ' . $this->tableNameWithAlias( $table, $alias );
-				$tableClause .= ' ' . $this->useIndexClause( implode( ',', (array)$use_index_safe[$alias] ) );
-				$on = $this->makeList( (array)$join_conds_safe[$alias][1], LIST_AND );
+			// 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;
-			// Is there an INDEX clause?
-			} else if ( isset( $use_index_safe[$alias] ) ) {
+			// Is there an INDEX clause for this table?
+			} elseif ( isset( $use_index[$alias] ) ) {
 				$tableClause = $this->tableNameWithAlias( $table, $alias );
-				$tableClause .= ' ' . $this->useIndexClause( implode( ',', (array)$use_index_safe[$alias] ) );
-				$ret[] = $tableClause;
-			// Is there a JOIN clause?
-			} else if ( isset( $join_conds_safe[$alias] ) ) {
-				$tableClause = $join_conds_safe[$alias][0] . ' ' . $this->tableNameWithAlias( $table, $alias );
-				$on = $this->makeList( (array)$join_conds_safe[$alias][1], LIST_AND );
-				if ( $on != '' ) {
-					$tableClause .= ' ON (' . $on . ')';
-				}
+				$tableClause .= ' ' . $this->useIndexClause(
+					implode( ',', (array)$use_index[$alias] ) );
 
-				$retJOIN[] = $tableClause;
+				$ret[] = $tableClause;
 			} else {
 				$tableClause = $this->tableNameWithAlias( $table, $alias );
+
 				$ret[] = $tableClause;
 			}
 		}
@@ -1703,6 +2028,10 @@ abstract class DatabaseBase implements DatabaseType {
 
 	/**
 	 * Get the name of an index in a given table
+	 *
+	 * @param $index
+	 *
+	 * @return string
 	 */
 	function indexName( $index ) {
 		// Backwards-compatibility hack
@@ -1722,6 +2051,10 @@ abstract class DatabaseBase implements DatabaseType {
 	/**
 	 * If it's a string, adds quotes and backslashes
 	 * Otherwise returns as-is
+	 *
+	 * @param $s string
+	 *
+	 * @return string
 	 */
 	function addQuotes( $s ) {
 		if ( $s === null ) {
@@ -1740,16 +2073,32 @@ abstract class DatabaseBase implements DatabaseType {
 	 * MySQL uses `backticks` while basically everything else uses double quotes.
 	 * Since MySQL is the odd one out here the double quotes are our generic
 	 * and we implement backticks in DatabaseMysql.
-	 */ 	 
+	 *
+	 * @return string
+	 */
 	public function addIdentifierQuotes( $s ) {
 		return '"' . str_replace( '"', '""', $s ) . '"';
 	}
 
 	/**
+	 * Returns if the given identifier looks quoted or not according to
+	 * the database convention for quoting identifiers .
+	 *
+	 * @param $name string
+	 *
+	 * @return boolean
+	 */
+	public function isQuotedIdentifier( $name ) {
+		return $name[0] == '"' && substr( $name, -1, 1 ) == '"';
+	}
+
+	/**
 	 * Backwards compatibility, identifier quoting originated in DatabasePostgres
 	 * which used quote_ident which does not follow our naming conventions
 	 * was renamed to addIdentifierQuotes.
-	 * @deprecated use addIdentifierQuotes
+	 * @deprecated since 1.18 use addIdentifierQuotes
+	 *
+	 * @return string
 	 */
 	function quote_ident( $s ) {
 		wfDeprecated( __METHOD__ );
@@ -1760,7 +2109,7 @@ abstract class DatabaseBase implements DatabaseType {
 	 * Escape string for safe LIKE usage.
 	 * WARNING: you should almost never use this function directly,
 	 * instead use buildLike() that escapes everything automatically
-	 * Deprecated in 1.17, warnings in 1.17, removed in ???
+	 * @deprecated since 1.17, warnings in 1.17, removed in ???
 	 */
 	public function escapeLike( $s ) {
 		wfDeprecated( __METHOD__ );
@@ -1809,6 +2158,8 @@ abstract class DatabaseBase implements DatabaseType {
 
 	/**
 	 * Returns a token for buildLike() that denotes a '_' to be used in a LIKE query
+	 *
+	 * @return LikeMatch
 	 */
 	function anyChar() {
 		return new LikeMatch( '_' );
@@ -1816,6 +2167,8 @@ abstract class DatabaseBase implements DatabaseType {
 
 	/**
 	 * Returns a token for buildLike() that denotes a '%' to be used in a LIKE query
+	 *
+	 * @rerturn LikeMatch
 	 */
 	function anyString() {
 		return new LikeMatch( '%' );
@@ -1843,15 +2196,24 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * REPLACE query wrapper
-	 * PostgreSQL simulates this with a DELETE followed by INSERT
-	 * $row is the row to insert, an associative array
-	 * $uniqueIndexes is an array of indexes. Each element may be either a
-	 * field name or an array of field names
+	 * REPLACE query wrapper.
 	 *
-	 * It may be more efficient to leave off unique indexes which are unlikely to collide.
-	 * However if you do this, you run the risk of encountering errors which wouldn't have
-	 * occurred in MySQL
+	 * REPLACE is a very handy MySQL extension, which functions like an INSERT
+	 * except that when there is a duplicate key error, the old row is deleted
+	 * and the new row is inserted in its place.
+	 *
+	 * We simulate this with standard SQL with a DELETE followed by INSERT. To
+	 * perform the delete, we need to know what the unique indexes are so that
+	 * we know how to find the conflicting rows.
+	 *
+	 * It may be more efficient to leave off unique indexes which are unlikely
+	 * to collide. However if you do this, you run the risk of encountering
+	 * errors which wouldn't have occurred in MySQL.
+	 *
+	 * @param $rows Can be either a single row to insert, or multiple rows,
+	 *    in the same format as for DatabaseBase::insert()
+	 * @param $uniqueIndexes is an array of indexes. Each element may be either
+	 *    a field name or an array of field names
 	 *
 	 * @param $table String: The table to replace the row(s) in.
 	 * @param $uniqueIndexes Array: An associative array of indexes
@@ -1859,6 +2221,61 @@ abstract class DatabaseBase implements DatabaseType {
 	 * @param $fname String: Calling function name (use __METHOD__) for logs/profiling
 	 */
 	function replace( $table, $uniqueIndexes, $rows, $fname = 'DatabaseBase::replace' ) {
+		$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 );
+		}
+	}
+
+	/**
+	 * REPLACE query wrapper for MySQL and SQLite, which have a native REPLACE
+	 * statement.
+	 *
+	 * @param $table Table name
+	 * @param $rows Rows to insert
+	 * @param $fname Caller function name
+	 */
+	protected function nativeReplace( $table, $rows, $fname ) {
 		$table = $this->tableName( $table );
 
 		# Single row case
@@ -1883,35 +2300,42 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * DELETE where the condition is a join
-	 * MySQL does this with a multi-table DELETE syntax, PostgreSQL does it with sub-selects
+	 * DELETE where the condition is a join.
 	 *
-	 * For safety, an empty $conds will not delete everything. If you want to delete all rows where the
-	 * join condition matches, set $conds='*'
+	 * MySQL overrides this to use a multi-table DELETE syntax, in other databases
+	 * we use sub-selects
 	 *
-	 * DO NOT put the join condition in $conds
+	 * For safety, an empty $conds will not delete everything. If you want to
+	 * delete all rows where the join condition matches, set $conds='*'.
 	 *
-	 * @param $delTable String: The table to delete from.
-	 * @param $joinTable String: The other table.
-	 * @param $delVar String: The variable to join on, in the first table.
-	 * @param $joinVar String: The variable to join on, in the second table.
-	 * @param $conds Array: Condition array of field names mapped to variables, ANDed together in the WHERE clause
-	 * @param $fname String: Calling function name (use __METHOD__) for logs/profiling
+	 * DO NOT put the join condition in $conds.
+	 *
+	 * @param $delTable   String: The table to delete from.
+	 * @param $joinTable  String: The other table.
+	 * @param $delVar     String: The variable to join on, in the first table.
+	 * @param $joinVar    String: The variable to join on, in the second table.
+	 * @param $conds      Array: Condition array of field names mapped to variables,
+	 *                    ANDed together in the WHERE clause
+	 * @param $fname      String: Calling function name (use __METHOD__) for
+	 *                    logs/profiling
 	 */
-	function deleteJoin( $delTable, $joinTable, $delVar, $joinVar, $conds, $fname = 'DatabaseBase::deleteJoin' ) {
+	function deleteJoin( $delTable, $joinTable, $delVar, $joinVar, $conds,
+		$fname = 'DatabaseBase::deleteJoin' )
+	{
 		if ( !$conds ) {
-			throw new DBUnexpectedError( $this, 'DatabaseBase::deleteJoin() called with empty $conds' );
+			throw new DBUnexpectedError( $this,
+				'DatabaseBase::deleteJoin() called with empty $conds' );
 		}
 
 		$delTable = $this->tableName( $delTable );
 		$joinTable = $this->tableName( $joinTable );
-		$sql = "DELETE $delTable FROM $delTable, $joinTable WHERE $delVar=$joinVar ";
-
+		$sql = "DELETE FROM $delTable WHERE $delVar IN (SELECT $joinVar FROM $joinTable ";
 		if ( $conds != '*' ) {
-			$sql .= ' AND ' . $this->makeList( $conds, LIST_AND );
+			$sql .= 'WHERE ' . $this->makeList( $conds, LIST_AND );
 		}
+		$sql .= ')';
 
-		return $this->query( $sql, $fname );
+		$this->query( $sql, $fname );
 	}
 
 	/**
@@ -1939,16 +2363,22 @@ abstract class DatabaseBase implements DatabaseType {
 	 * MySQL's LOW_PRIORITY.  If no such feature exists, return an empty
 	 * string and nothing bad should happen.
 	 *
-	 * @return string Returns the text of the low priority option if it is supported, or a blank string otherwise
+	 * @return string Returns the text of the low priority option if it is
+	 *   supported, or a blank string otherwise
 	 */
 	function lowPriorityOption() {
 		return '';
 	}
 
 	/**
-	 * DELETE query wrapper
+	 * DELETE query wrapper.
 	 *
-	 * Use $conds == "*" to delete all rows
+	 * @param $table Array Table name
+	 * @param $conds String|Array of conditions. See $conds in DatabaseBase::select() for
+	 *               the format. Use $conds == "*" to delete all rows
+	 * @param $fname String name of the calling function
+	 *
+	 * @return bool
 	 */
 	function delete( $table, $conds, $fname = 'DatabaseBase::delete' ) {
 		if ( !$conds ) {
@@ -1966,13 +2396,33 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * INSERT SELECT wrapper
-	 * $varMap must be an associative array of the form array( 'dest1' => 'source1', ...)
-	 * Source items may be literals rather than field names, but strings should be quoted with DatabaseBase::addQuotes()
-	 * $conds may be "*" to copy the whole table
-	 * srcTable may be an array of tables.
+	 * INSERT SELECT wrapper. Takes data from a SELECT query and inserts it
+	 * into another table.
+	 *
+	 * @param $destTable The table name to insert into
+	 * @param $srcTable May be either a table name, or an array of table names
+	 *    to include in a join.
+	 *
+	 * @param $varMap must be an associative array of the form
+	 *    array( 'dest1' => 'source1', ...). Source items may be literals
+	 *    rather than field names, but strings should be quoted with
+	 *    DatabaseBase::addQuotes()
+	 *
+	 * @param $conds Condition array. See $conds in DatabaseBase::select() for
+	 *    the details of the format of condition arrays. May be "*" to copy the
+	 *    whole table.
+	 *
+	 * @param $fname The function name of the caller, from __METHOD__
+	 *
+	 * @param $insertOptions Options for the INSERT part of the query, see
+	 *    DatabaseBase::insert() for details.
+	 * @param $selectOptions Options for the SELECT part of the query, see
+	 *    DatabaseBase::select() for details.
+	 *
+	 * @return ResultWrapper
 	 */
-	function insertSelect( $destTable, $srcTable, $varMap, $conds, $fname = 'DatabaseBase::insertSelect',
+	function insertSelect( $destTable, $srcTable, $varMap, $conds,
+		$fname = 'DatabaseBase::insertSelect',
 		$insertOptions = array(), $selectOptions = array() )
 	{
 		$destTable = $this->tableName( $destTable );
@@ -2023,6 +2473,8 @@ abstract class DatabaseBase implements DatabaseType {
 	 * @param $sql String: SQL query we will append the limit too
 	 * @param $limit Integer: the SQL limit
 	 * @param $offset Integer the SQL offset (default false)
+	 *
+	 * @return string
 	 */
 	function limitResult( $sql, $limit, $offset = false ) {
 		if ( !is_numeric( $limit ) ) {
@@ -2080,24 +2532,18 @@ abstract class DatabaseBase implements DatabaseType {
 	 * @param $orig String: column to modify
 	 * @param $old String: column to seek
 	 * @param $new String: column to replace with
+	 *
+	 * @return string
 	 */
 	function strreplace( $orig, $old, $new ) {
 		return "REPLACE({$orig}, {$old}, {$new})";
 	}
 
 	/**
-	 * Convert a field to an unix timestamp
-	 *
-	 * @param $field String: field name
-	 * @return String: SQL statement
-	 */
-	public function unixTimestamp( $field ) {
-		return "EXTRACT(epoch FROM $field)";
-	}
-
-	/**
 	 * Determines if the last failure was due to a deadlock
 	 * STUB
+	 *
+	 * @return bool
 	 */
 	function wasDeadlock() {
 		return false;
@@ -2107,6 +2553,8 @@ abstract class DatabaseBase implements DatabaseType {
 	 * Determines if the last query error was something that should be dealt
 	 * with by pinging the connection and reissuing the query.
 	 * STUB
+	 *
+	 * @return bool
 	 */
 	function wasErrorReissuable() {
 		return false;
@@ -2115,6 +2563,8 @@ abstract class DatabaseBase implements DatabaseType {
 	/**
 	 * Determines if the last failure was due to the database being read-only.
 	 * STUB
+	 *
+	 * @return bool
 	 */
 	function wasReadOnlyError() {
 		return false;
@@ -2180,20 +2630,20 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * Do a SELECT MASTER_POS_WAIT()
+	 * Wait for the slave to catch up to a given master position.
+	 *
+	 * @param $pos DBMasterPos object
+	 * @param $timeout Integer: the maximum number of seconds to wait for
+	 *   synchronisation
 	 *
-	 * @param $pos MySQLMasterPos object
-	 * @param $timeout Integer: the maximum number of seconds to wait for synchronisation
+	 * @return An integer: zero if the slave was past that position already,
+	 *   greater than zero if we waited for some period of time, less than
+	 *   zero if we timed out.
 	 */
-	function masterPosWait( MySQLMasterPos $pos, $timeout ) {
+	function masterPosWait( DBMasterPos $pos, $timeout ) {
 		$fname = 'DatabaseBase::masterPosWait';
 		wfProfileIn( $fname );
 
-		# Commit any open transactions
-		if ( $this->mTrxLevel ) {
-			$this->commit();
-		}
-
 		if ( !is_null( $this->mFakeSlaveLag ) ) {
 			$wait = intval( ( $pos->pos - microtime( true ) + $this->mFakeSlaveLag ) * 1e6 );
 
@@ -2213,55 +2663,36 @@ abstract class DatabaseBase implements DatabaseType {
 			}
 		}
 
-		# Call doQuery() directly, to avoid opening a transaction if DBO_TRX is set
-		$encFile = $this->addQuotes( $pos->file );
-		$encPos = intval( $pos->pos );
-		$sql = "SELECT MASTER_POS_WAIT($encFile, $encPos, $timeout)";
-		$res = $this->doQuery( $sql );
+		wfProfileOut( $fname );
 
-		if ( $res && $row = $this->fetchRow( $res ) ) {
-			wfProfileOut( $fname );
-			return $row[0];
-		} else {
-			wfProfileOut( $fname );
-			return false;
-		}
+		# Real waits are implemented in the subclass.
+		return 0;
 	}
 
 	/**
-	 * Get the position of the master from SHOW SLAVE STATUS
+	 * Get the replication position of this slave
+	 *
+	 * @return DBMasterPos, or false if this is not a slave.
 	 */
 	function getSlavePos() {
 		if ( !is_null( $this->mFakeSlaveLag ) ) {
 			$pos = new MySQLMasterPos( 'fake', microtime( true ) - $this->mFakeSlaveLag );
 			wfDebug( __METHOD__ . ": fake slave pos = $pos\n" );
 			return $pos;
-		}
-
-		$res = $this->query( 'SHOW SLAVE STATUS', 'DatabaseBase::getSlavePos' );
-		$row = $this->fetchObject( $res );
-
-		if ( $row ) {
-			$pos = isset( $row->Exec_master_log_pos ) ? $row->Exec_master_log_pos : $row->Exec_Master_Log_Pos;
-			return new MySQLMasterPos( $row->Relay_Master_Log_File, $pos );
 		} else {
+			# Stub
 			return false;
 		}
 	}
 
 	/**
-	 * Get the position of the master from SHOW MASTER STATUS
+	 * Get the position of this master
+	 *
+	 * @return DBMasterPos, or false if this is not a master
 	 */
 	function getMasterPos() {
 		if ( $this->mFakeMaster ) {
 			return new MySQLMasterPos( 'fake', microtime( true ) );
-		}
-
-		$res = $this->query( 'SHOW MASTER STATUS', 'DatabaseBase::getMasterPos' );
-		$row = $this->fetchObject( $res );
-
-		if ( $row ) {
-			return new MySQLMasterPos( $row->File, $row->Position );
 		} else {
 			return false;
 		}
@@ -2297,28 +2728,12 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * Begin a transaction, committing any previously open transaction
-	 * @deprecated use begin()
-	 */
-	function immediateBegin( $fname = 'DatabaseBase::immediateBegin' ) {
-		wfDeprecated( __METHOD__ );
-		$this->begin();
-	}
-
-	/**
-	 * Commit transaction, if one is open
-	 * @deprecated use commit()
-	 */
-	function immediateCommit( $fname = 'DatabaseBase::immediateCommit' ) {
-		wfDeprecated( __METHOD__ );
-		$this->commit();
-	}
-
-	/**
 	 * Creates a new table with structure copied from existing table
 	 * Note that unlike most database abstraction functions, this function does not
 	 * automatically append database prefix, because it works at a lower
 	 * abstraction level.
+	 * The table names passed to this function shall not be quoted (this
+	 * function calls addIdentifierQuotes when needed).
 	 *
 	 * @param $oldName String: name of table whose structure should be copied
 	 * @param $newName String: name of table to be created
@@ -2326,19 +2741,46 @@ abstract class DatabaseBase implements DatabaseType {
 	 * @param $fname String: calling function name
 	 * @return Boolean: true if operation was successful
 	 */
-	function duplicateTableStructure( $oldName, $newName, $temporary = false, $fname = 'DatabaseBase::duplicateTableStructure' ) {
-		throw new MWException( 'DatabaseBase::duplicateTableStructure is not implemented in descendant class' );
+	function duplicateTableStructure( $oldName, $newName, $temporary = false,
+		$fname = 'DatabaseBase::duplicateTableStructure' )
+	{
+		throw new MWException(
+			'DatabaseBase::duplicateTableStructure is not implemented in descendant class' );
 	}
 
 	/**
-	 * Return MW-style timestamp used for MySQL schema
+	 * List all tables on the database
+	 *
+	 * @param $prefix Only show tables with this prefix, e.g. mw_
+	 * @param $fname String: calling function name
+	 */
+	function listTables( $prefix = null, $fname = 'DatabaseBase::listTables' ) {
+		throw new MWException( 'DatabaseBase::listTables is not implemented in descendant class' );
+	}
+
+	/**
+	 * Convert a timestamp in one of the formats accepted by wfTimestamp()
+	 * to the format used for inserting into timestamp fields in this DBMS.
+	 *
+	 * The result is unquoted, and needs to be passed through addQuotes()
+	 * before it can be included in raw SQL.
+	 *
+	 * @return string
 	 */
 	function timestamp( $ts = 0 ) {
 		return wfTimestamp( TS_MW, $ts );
 	}
 
 	/**
-	 * Local database timestamp format or null
+	 * Convert a timestamp in one of the formats accepted by wfTimestamp()
+	 * to the format used for inserting into timestamp fields in this DBMS. If
+	 * NULL is input, it is passed through, allowing NULL values to be inserted
+	 * into timestamp fields.
+	 *
+	 * The result is unquoted, and needs to be passed through addQuotes()
+	 * before it can be included in raw SQL.
+	 *
+	 * @return string
 	 */
 	function timestampOrNull( $ts = null ) {
 		if ( is_null( $ts ) ) {
@@ -2349,7 +2791,15 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * @todo document
+	 * Take the result from a query, and wrap it in a ResultWrapper if
+	 * necessary. Boolean values are passed through as is, to indicate success
+	 * of write queries or failure.
+	 *
+	 * Once upon a time, DatabaseBase::query() returned a bare MySQL result
+	 * resource, and it was necessary to call this function to convert it to
+	 * a wrapper. Nowadays, raw database objects are never exposed to external
+	 * callers, so this is unnecessary in external code. For compatibility with
+	 * old code, ResultWrapper objects are passed through unaltered.
 	 */
 	function resultObject( $result ) {
 		if ( empty( $result ) ) {
@@ -2382,8 +2832,12 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * Get slave lag.
-	 * Currently supported only by MySQL
+	 * Get slave lag. Currently supported only by MySQL.
+	 *
+	 * Note that this function will generate a fatal error on many
+	 * installations. Most callers should use LoadBalancer::safeGetLag()
+	 * instead.
+	 *
 	 * @return Database replication lag in seconds
 	 */
 	function getLag() {
@@ -2391,30 +2845,29 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * Get status information from SHOW STATUS in an associative array
-	 */
-	function getStatus( $which = "%" ) {
-		$res = $this->query( "SHOW STATUS LIKE '{$which}'" );
-		$status = array();
-
-		foreach ( $res as $row ) {
-			$status[$row->Variable_name] = $row->Value;
-		}
-
-		return $status;
-	}
-
-	/**
 	 * Return the maximum number of items allowed in a list, or 0 for unlimited.
+	 *
+	 * return int
 	 */
 	function maxListLen() {
 		return 0;
 	}
 
+	/**
+	 * Some DBMSs have a special format for inserting into blob fields, they
+	 * don't allow simple quoted strings to be inserted. To insert into such
+	 * a field, pass the data through this function before passing it to
+	 * DatabaseBase::insert().
+	 */
 	function encodeBlob( $b ) {
 		return $b;
 	}
 
+	/**
+	 * Some DBMSs return a special placeholder object representing blob fields
+	 * in result objects. Pass the object through this function to return the
+	 * original string.
+	 */
 	function decodeBlob( $b ) {
 		return $b;
 	}
@@ -2431,21 +2884,23 @@ abstract class DatabaseBase implements DatabaseType {
 
 	/**
 	 * Read and execute SQL commands from a file.
-	 * Returns true on success, error string or exception on failure (depending on object's error ignore settings)
+	 *
+	 * Returns true on success, error string or exception on failure (depending
+	 * on object's error ignore settings).
+	 *
 	 * @param $filename String: File name to open
 	 * @param $lineCallback Callback: Optional function called before reading each line
 	 * @param $resultCallback Callback: Optional function called for each MySQL result
-	 * @param $fname String: Calling function name or false if name should be generated dynamically
-	 * 		using $filename
+	 * @param $fname String: Calling function name or false if name should be
+	 *      generated dynamically using $filename
 	 */
 	function sourceFile( $filename, $lineCallback = false, $resultCallback = false, $fname = false ) {
+		wfSuppressWarnings();
 		$fp = fopen( $filename, 'r' );
+		wfRestoreWarnings();
 
 		if ( false === $fp ) {
-			if ( !defined( "MEDIAWIKI_INSTALL" ) )
-				throw new MWException( "Could not open \"{$filename}\".\n" );
-			else
-				return "Could not open \"{$filename}\".\n";
+			throw new MWException( "Could not open \"{$filename}\".\n" );
 		}
 
 		if ( !$fname ) {
@@ -2456,12 +2911,8 @@ abstract class DatabaseBase implements DatabaseType {
 			$error = $this->sourceStream( $fp, $lineCallback, $resultCallback, $fname );
 		}
 		catch ( MWException $e ) {
-			if ( defined( "MEDIAWIKI_INSTALL" ) ) {
-				$error = $e->getMessage();
-			} else {
-				fclose( $fp );
-				throw $e;
-			}
+			fclose( $fp );
+			throw $e;
 		}
 
 		fclose( $fp );
@@ -2490,7 +2941,7 @@ abstract class DatabaseBase implements DatabaseType {
 
 	/**
 	 * Set variables to be used in sourceFile/sourceStream, in preference to the
-	 * ones in $GLOBALS. If an array is set here, $GLOBALS will not be used at 
+	 * ones in $GLOBALS. If an array is set here, $GLOBALS will not be used at
 	 * all. If it's set to false, $GLOBALS will be used.
 	 *
 	 * @param $vars False, or array mapping variable name to value.
@@ -2500,14 +2951,19 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * Read and execute commands from an open file handle
-	 * Returns true on success, error string or exception on failure (depending on object's error ignore settings)
-	 * @param $fp String: File handle
+	 * Read and execute commands from an open file handle.
+	 *
+	 * Returns true on success, error string or exception on failure (depending
+	 * on object's error ignore settings).
+	 *
+	 * @param $fp Resource: File handle
 	 * @param $lineCallback Callback: Optional function called before reading each line
 	 * @param $resultCallback Callback: Optional function called for each MySQL result
 	 * @param $fname String: Calling function name
 	 */
-	function sourceStream( $fp, $lineCallback = false, $resultCallback = false, $fname = 'DatabaseBase::sourceStream' ) {
+	function sourceStream( $fp, $lineCallback = false, $resultCallback = false,
+		$fname = 'DatabaseBase::sourceStream' )
+	{
 		$cmd = "";
 		$done = false;
 		$dollarquote = false;
@@ -2517,7 +2973,7 @@ abstract class DatabaseBase implements DatabaseType {
 				call_user_func( $lineCallback );
 			}
 
-			$line = trim( fgets( $fp, 1024 ) );
+			$line = trim( fgets( $fp ) );
 			$sl = strlen( $line ) - 1;
 
 			if ( $sl < 0 ) {
@@ -2538,7 +2994,7 @@ abstract class DatabaseBase implements DatabaseType {
 					$dollarquote = true;
 				}
 			}
-			else if ( !$dollarquote ) {
+			elseif ( !$dollarquote ) {
 				if ( ';' == $line { $sl } && ( $sl < 2 || ';' != $line { $sl - 1 } ) ) {
 					$done = true;
 					$line = substr( $line, 0, $sl );
@@ -2574,16 +3030,19 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * Database independent variable replacement, replaces a set of variables
-	 * in a sql statement with their contents as given by $this->getSchemaVars().
-	 * Supports '{$var}' `{$var}` and / *$var* / (without the spaces) style variables
-	 * 
-	 * '{$var}' should be used for text and is passed through the database's addQuotes method
-	 * `{$var}` should be used for identifiers (eg: table and database names), it is passed through
-	 *          the database's addIdentifierQuotes method which can be overridden if the database
-	 *          uses something other than backticks.
-	 * / *$var* / is just encoded, besides traditional dbprefix and tableoptions it's use should be avoided
-	 * 
+	 * Database independent variable replacement. Replaces a set of variables
+	 * in an SQL statement with their contents as given by $this->getSchemaVars().
+	 *
+	 * Supports '{$var}' `{$var}` and / *$var* / (without the spaces) style variables.
+	 *
+	 * - '{$var}' should be used for text and is passed through the database's
+	 *   addQuotes method.
+	 * - `{$var}` should be used for identifiers (eg: table and database names),
+	 *   it is passed through the database's addIdentifierQuotes method which
+	 *   can be overridden if the database uses something other than backticks.
+	 * - / *$var* / is just encoded, besides traditional table prefix and
+	 *   table options its use should be avoided.
+	 *
 	 * @param $ins String: SQL statement to replace variables in
 	 * @return String The new SQL statement with variables replaced
 	 */
@@ -2602,6 +3061,10 @@ abstract class DatabaseBase implements DatabaseType {
 
 	/**
 	 * Replace variables in sourced SQL
+	 *
+	 * @param $ins string
+	 *
+	 * @return string
 	 */
 	protected function replaceVars( $ins ) {
 		$ins = $this->replaceSchemaVars( $ins );
@@ -2631,8 +3094,11 @@ abstract class DatabaseBase implements DatabaseType {
 
 	/**
 	 * Get schema variables to use if none have been set via setSchemaVars().
-	 * Override this in derived classes to provide variables for tables.sql 
-	 * and SQL patch files. 
+	 *
+	 * Override this in derived classes to provide variables for tables.sql
+	 * and SQL patch files.
+	 *
+	 * @return array
 	 */
 	protected function getDefaultSchemaVars() {
 		return array();
@@ -2640,7 +3106,10 @@ abstract class DatabaseBase implements DatabaseType {
 
 	/**
 	 * Table name callback
-	 * @private
+	 *
+	 * @param $matches array
+	 *
+	 * @return string
 	 */
 	protected function tableNameCallback( $matches ) {
 		return $this->tableName( $matches[1] );
@@ -2648,6 +3117,10 @@ abstract class DatabaseBase implements DatabaseType {
 
 	/**
 	 * Index name callback
+	 *
+	 * @param $matches array
+	 *
+	 * @return string
 	 */
 	protected function indexNameCallback( $matches ) {
 		return $this->indexName( $matches[1] );
@@ -2698,6 +3171,8 @@ abstract class DatabaseBase implements DatabaseType {
 	 * @param $write Array of tables to lock for write access
 	 * @param $method String name of caller
 	 * @param $lowPriority bool Whether to indicate writes to be LOW PRIORITY
+	 *
+	 * @return bool
 	 */
 	public function lockTables( $read, $write, $method, $lowPriority = true ) {
 		return true;
@@ -2707,12 +3182,31 @@ abstract class DatabaseBase implements DatabaseType {
 	 * Unlock specific tables
 	 *
 	 * @param $method String the caller
+	 *
+	 * @return bool
 	 */
 	public function unlockTables( $method ) {
 		return true;
 	}
 
 	/**
+	 * Delete a table
+	 * @param $tableName string
+	 * @param $fName string
+	 * @return bool|ResultWrapper
+	 */
+	public function dropTable( $tableName, $fName = 'DatabaseBase::dropTable' ) {
+		if( !$this->tableExists( $tableName ) ) {
+			return false;
+		}
+		$sql = "DROP TABLE " . $this->tableName( $tableName );
+		if( $this->cascadingDeletes() ) {
+			$sql .= " CASCADE";
+		}
+		return $this->query( $sql, $fName );
+	}
+
+	/**
 	 * Get search engine class. All subclasses of this need to implement this
 	 * if they wish to use searching.
 	 *
@@ -2723,537 +3217,40 @@ abstract class DatabaseBase implements DatabaseType {
 	}
 
 	/**
-	 * Allow or deny "big selects" for this session only. This is done by setting
-	 * the sql_big_selects session variable.
-	 *
-	 * This is a MySQL-specific feature.
+	 * Find out when 'infinity' is. Most DBMSes support this. This is a special
+	 * keyword for timestamps in PostgreSQL, and works with CHAR(14) as well
+	 * because "i" sorts after all numbers.
 	 *
-	 * @param $value Mixed: true for allow, false for deny, or "default" to restore the initial value
-	 */
-	public function setBigSelects( $value = true ) {
-		// no-op
-	}
-}
-
-/******************************************************************************
- * Utility classes
- *****************************************************************************/
-
-/**
- * Utility class.
- * @ingroup Database
- */
-class DBObject {
-	public $mData;
-
-	function __construct( $data ) {
-		$this->mData = $data;
-	}
-
-	function isLOB() {
-		return false;
-	}
-
-	function data() {
-		return $this->mData;
-	}
-}
-
-/**
- * Utility class
- * @ingroup Database
- *
- * This allows us to distinguish a blob from a normal string and an array of strings
- */
-class Blob {
-	private $mData;
-
-	function __construct( $data ) {
-		$this->mData = $data;
-	}
-
-	function fetch() {
-		return $this->mData;
-	}
-}
-
-/**
- * Base for all database-specific classes representing information about database fields
- * @ingroup Database
- */
-interface Field {
-	/**
-	 * Field name
-	 * @return string
-	 */
-	function name();
-
-	/**
-	 * Name of table this field belongs to
-	 * @return string
-	 */
-	function tableName();
-
-	/**
-	 * Database type
-	 * @return string
-	 */
-	function type();
-
-	/**
-	 * Whether this field can store NULL values
-	 * @return bool
-	 */
-	function isNullable();
-}
-
-/******************************************************************************
- * Error classes
- *****************************************************************************/
-
-/**
- * Database error base class
- * @ingroup Database
- */
-class DBError extends MWException {
-	public $db;
-
-	/**
-	 * Construct a database error
-	 * @param $db Database object which threw the error
-	 * @param $error A simple error message to be used for debugging
+	 * @return String
 	 */
-	function __construct( DatabaseBase &$db, $error ) {
-		$this->db =& $db;
-		parent::__construct( $error );
-	}
-
-	function getText() {
-		global $wgShowDBErrorBacktrace;
-
-		$s = $this->getMessage() . "\n";
-
-		if ( $wgShowDBErrorBacktrace ) {
-			$s .= "Backtrace:\n" . $this->getTraceAsString() . "\n";
-		}
-
-		return $s;
-	}
-}
-
-/**
- * @ingroup Database
- */
-class DBConnectionError extends DBError {
-	public $error;
-
-	function __construct( DatabaseBase &$db, $error = 'unknown error' ) {
-		$msg = 'DB connection error';
-
-		if ( trim( $error ) != '' ) {
-			$msg .= ": $error";
-		}
-
-		$this->error = $error;
-
-		parent::__construct( $db, $msg );
-	}
-
-	function useOutputPage() {
-		// Not likely to work
-		return false;
-	}
-
-	function useMessageCache() {
-		// Not likely to work
-		return false;
-	}
-
-	function getLogMessage() {
-		# Don't send to the exception log
-		return false;
-	}
-
-	function getPageTitle() {
-		global $wgSitename, $wgLang;
-
-		$header = "$wgSitename has a problem";
-
-		if ( $wgLang instanceof Language ) {
-			$header = htmlspecialchars( $wgLang->getMessage( 'dberr-header' ) );
-		}
-
-		return $header;
-	}
-
-	function getHTML() {
-		global $wgLang, $wgMessageCache, $wgUseFileCache, $wgShowDBErrorBacktrace;
-
-		$sorry = 'Sorry! This site is experiencing technical difficulties.';
-		$again = 'Try waiting a few minutes and reloading.';
-		$info  = '(Can\'t contact the database server: $1)';
-
-		if ( $wgLang instanceof Language ) {
-			$sorry = htmlspecialchars( $wgLang->getMessage( 'dberr-problems' ) );
-			$again = htmlspecialchars( $wgLang->getMessage( 'dberr-again' ) );
-			$info  = htmlspecialchars( $wgLang->getMessage( 'dberr-info' ) );
-		}
-
-		# No database access
-		if ( is_object( $wgMessageCache ) ) {
-			$wgMessageCache->disable();
-		}
-
-		if ( trim( $this->error ) == '' ) {
-			$this->error = $this->db->getProperty( 'mServer' );
-		}
-
-		$noconnect = "<p><strong>$sorry</strong><br />$again</p><p><small>$info</small></p>";
-		$text = str_replace( '$1', $this->error, $noconnect );
-
-		if ( $wgShowDBErrorBacktrace ) {
-			$text .= '<p>Backtrace:</p><p>' . nl2br( htmlspecialchars( $this->getTraceAsString() ) );
-		}
-
-		$extra = $this->searchForm();
-
-		if ( $wgUseFileCache ) {
-			try {
-				$cache = $this->fileCachedPage();
-				# Cached version on file system?
-				if ( $cache !== null ) {
-					# Hack: extend the body for error messages
-					$cache = str_replace( array( '</html>', '</body>' ), '', $cache );
-					# Add cache notice...
-					$cachederror = "This is a cached copy of the requested page, and may not be up to date. ";
-
-					# Localize it if possible...
-					if ( $wgLang instanceof Language ) {
-						$cachederror = htmlspecialchars( $wgLang->getMessage( 'dberr-cachederror' ) );
-					}
-
-					$warning = "<div style='color:red;font-size:150%;font-weight:bold;'>$cachederror</div>";
-
-					# Output cached page with notices on bottom and re-close body
-					return "{$cache}{$warning}<hr />$text<hr />$extra</body></html>";
-				}
-			} catch ( MWException $e ) {
-				// Do nothing, just use the default page
-			}
-		}
-
-		# Headers needed here - output is just the error message
-		return $this->htmlHeader() . "$text<hr />$extra" . $this->htmlFooter();
-	}
-
-	function searchForm() {
-		global $wgSitename, $wgServer, $wgLang;
-
-		$usegoogle = "You can try searching via Google in the meantime.";
-		$outofdate = "Note that their indexes of our content may be out of date.";
-		$googlesearch = "Search";
-
-		if ( $wgLang instanceof Language ) {
-			$usegoogle = htmlspecialchars( $wgLang->getMessage( 'dberr-usegoogle' ) );
-			$outofdate = htmlspecialchars( $wgLang->getMessage( 'dberr-outofdate' ) );
-			$googlesearch  = htmlspecialchars( $wgLang->getMessage( 'searchbutton' ) );
-		}
-
-		$search = htmlspecialchars( @$_REQUEST['search'] );
-
-		$server = htmlspecialchars( $wgServer );
-		$sitename = htmlspecialchars( $wgSitename );
-
-		$trygoogle = <<<EOT
-<div style="margin: 1.5em">$usegoogle<br />
-<small>$outofdate</small></div>
-<!-- SiteSearch Google -->
-<form method="get" action="http://www.google.com/search" id="googlesearch">
-	<input type="hidden" name="domains" value="$server" />
-	<input type="hidden" name="num" value="50" />
-	<input type="hidden" name="ie" value="UTF-8" />
-	<input type="hidden" name="oe" value="UTF-8" />
-
-	<input type="text" name="q" size="31" maxlength="255" value="$search" />
-	<input type="submit" name="btnG" value="$googlesearch" />
-  <div>
-	<input type="radio" name="sitesearch" id="gwiki" value="$server" checked="checked" /><label for="gwiki">$sitename</label>
-	<input type="radio" name="sitesearch" id="gWWW" value="" /><label for="gWWW">WWW</label>
-  </div>
-</form>
-<!-- SiteSearch Google -->
-EOT;
-		return $trygoogle;
-	}
-
-	function fileCachedPage() {
-		global $wgTitle, $wgLang, $wgOut;
-
-		if ( $wgOut->isDisabled() ) {
-			return; // Done already?
-		}
-
-		$mainpage = 'Main Page';
-
-		if ( $wgLang instanceof Language ) {
-			$mainpage    = htmlspecialchars( $wgLang->getMessage( 'mainpage' ) );
-		}
-
-		if ( $wgTitle ) {
-			$t =& $wgTitle;
-		} else {
-			$t = Title::newFromText( $mainpage );
-		}
-
-		$cache = new HTMLFileCache( $t );
-		if ( $cache->isFileCached() ) {
-			return $cache->fetchPageText();
-		} else {
-			return '';
-		}
+	public function getInfinity() {
+		return 'infinity';
 	}
 
-	function htmlBodyOnly() {
-		return true;
-	}
-}
-
-/**
- * @ingroup Database
- */
-class DBQueryError extends DBError {
-	public $error, $errno, $sql, $fname;
-
-	function __construct( DatabaseBase &$db, $error, $errno, $sql, $fname ) {
-		$message = "A database error has occurred.  Did you forget to run maintenance/update.php after upgrading?  See: http://www.mediawiki.org/wiki/Manual:Upgrading#Run_the_update_script\n" .
-		  "Query: $sql\n" .
-		  "Function: $fname\n" .
-		  "Error: $errno $error\n";
-
-		parent::__construct( $db, $message );
-
-		$this->error = $error;
-		$this->errno = $errno;
-		$this->sql = $sql;
-		$this->fname = $fname;
-	}
-
-	function getText() {
-		global $wgShowDBErrorBacktrace;
-
-		if ( $this->useMessageCache() ) {
-			$s = wfMsg( 'dberrortextcl', htmlspecialchars( $this->getSQL() ),
-				htmlspecialchars( $this->fname ), $this->errno, htmlspecialchars( $this->error ) ) . "\n";
-
-			if ( $wgShowDBErrorBacktrace ) {
-				$s .= "Backtrace:\n" . $this->getTraceAsString() . "\n";
-			}
-
-			return $s;
-		} else {
-			return parent::getText();
-		}
-	}
-
-	function getSQL() {
-		global $wgShowSQLErrors;
-
-		if ( !$wgShowSQLErrors ) {
-			return $this->msg( 'sqlhidden', 'SQL hidden' );
-		} else {
-			return $this->sql;
-		}
-	}
-
-	function getLogMessage() {
-		# Don't send to the exception log
-		return false;
-	}
-
-	function getPageTitle() {
-		return $this->msg( 'databaseerror', 'Database error' );
-	}
-
-	function getHTML() {
-		global $wgShowDBErrorBacktrace;
-
-		if ( $this->useMessageCache() ) {
-			$s = wfMsgNoDB( 'dberrortext', htmlspecialchars( $this->getSQL() ),
-			  htmlspecialchars( $this->fname ), $this->errno, htmlspecialchars( $this->error ) );
-		} else {
-			$s = nl2br( htmlspecialchars( $this->getMessage() ) );
-		}
-
-		if ( $wgShowDBErrorBacktrace ) {
-			$s .= '<p>Backtrace:</p><p>' . nl2br( htmlspecialchars( $this->getTraceAsString() ) );
-		}
-
-		return $s;
-	}
-}
-
-/**
- * @ingroup Database
- */
-class DBUnexpectedError extends DBError {}
-
-
-/**
- * Result wrapper for grabbing data queried by someone else
- * @ingroup Database
- */
-class ResultWrapper implements Iterator {
-	var $db, $result, $pos = 0, $currentRow = null;
-
 	/**
-	 * Create a new result object from a result resource and a Database object
+	 * Encode an expiry time
+	 *
+	 * @param $expiry String: timestamp for expiry, or the 'infinity' string
+	 * @return String
 	 */
-	function __construct( $database, $result ) {
-		$this->db = $database;
-
-		if ( $result instanceof ResultWrapper ) {
-			$this->result = $result->result;
+	public function encodeExpiry( $expiry ) {
+		if ( $expiry == '' || $expiry == $this->getInfinity() ) {
+			return $this->getInfinity();
 		} else {
-			$this->result = $result;
+			return $this->timestamp( $expiry );
 		}
 	}
 
 	/**
-	 * Get the number of rows in a result object
-	 */
-	function numRows() {
-		return $this->db->numRows( $this );
-	}
-
-	/**
-	 * Fetch the next row from the given result object, in object form.
-	 * Fields can be retrieved with $row->fieldname, with fields acting like
-	 * member variables.
+	 * Allow or deny "big selects" for this session only. This is done by setting
+	 * the sql_big_selects session variable.
 	 *
-	 * @return MySQL row object
-	 * @throws DBUnexpectedError Thrown if the database returns an error
-	 */
-	function fetchObject() {
-		return $this->db->fetchObject( $this );
-	}
-
-	/**
-	 * Fetch the next row from the given result object, in associative array
-	 * form.  Fields are retrieved with $row['fieldname'].
+	 * This is a MySQL-specific feature.
 	 *
-	 * @return MySQL row object
-	 * @throws DBUnexpectedError Thrown if the database returns an error
-	 */
-	function fetchRow() {
-		return $this->db->fetchRow( $this );
-	}
-
-	/**
-	 * Free a result object
+	 * @param $value Mixed: true for allow, false for deny, or "default" to
+	 *   restore the initial value
 	 */
-	function free() {
-		$this->db->freeResult( $this );
-		unset( $this->result );
-		unset( $this->db );
-	}
-
-	/**
-	 * Change the position of the cursor in a result object
-	 * See mysql_data_seek()
-	 */
-	function seek( $row ) {
-		$this->db->dataSeek( $this, $row );
-	}
-
-	/*********************
-	 * Iterator functions
-	 * Note that using these in combination with the non-iterator functions
-	 * above may cause rows to be skipped or repeated.
-	 */
-
-	function rewind() {
-		if ( $this->numRows() ) {
-			$this->db->dataSeek( $this, 0 );
-		}
-		$this->pos = 0;
-		$this->currentRow = null;
-	}
-
-	function current() {
-		if ( is_null( $this->currentRow ) ) {
-			$this->next();
-		}
-		return $this->currentRow;
-	}
-
-	function key() {
-		return $this->pos;
-	}
-
-	function next() {
-		$this->pos++;
-		$this->currentRow = $this->fetchObject();
-		return $this->currentRow;
-	}
-
-	function valid() {
-		return $this->current() !== false;
-	}
-}
-
-/**
- * Overloads the relevant methods of the real ResultsWrapper so it
- * doesn't go anywhere near an actual database.
- */
-class FakeResultWrapper extends ResultWrapper {
-	var $result     = array();
-	var $db         = null;	// And it's going to stay that way :D
-	var $pos        = 0;
-	var $currentRow = null;
-
-	function __construct( $array ) {
-		$this->result = $array;
-	}
-
-	function numRows() {
-		return count( $this->result );
-	}
-
-	function fetchRow() {
-		$this->currentRow = $this->result[$this->pos++];
-		return $this->currentRow;
-	}
-
-	function seek( $row ) {
-		$this->pos = $row;
-	}
-
-	function free() {}
-
-	// Callers want to be able to access fields with $this->fieldName
-	function fetchObject() {
-		$this->currentRow = $this->result[$this->pos++];
-		return (object)$this->currentRow;
-	}
-
-	function rewind() {
-		$this->pos = 0;
-		$this->currentRow = null;
-	}
-}
-
-/**
- * Used by DatabaseBase::buildLike() to represent characters that have special meaning in SQL LIKE clauses
- * and thus need no escaping. Don't instantiate it manually, use DatabaseBase::anyChar() and anyString() instead.
- */
-class LikeMatch {
-	private $str;
-
-	public function __construct( $s ) {
-		$this->str = $s;
-	}
-
-	public function toString() {
-		return $this->str;
+	public function setBigSelects( $value = true ) {
+		// no-op
 	}
 }
diff --git a/includes/db/DatabaseError.php b/includes/db/DatabaseError.php
new file mode 100644
index 00000000..b7fb1b22
--- /dev/null
+++ b/includes/db/DatabaseError.php
@@ -0,0 +1,314 @@
+<?php
+
+/**
+ * Database error base class
+ * @ingroup Database
+ */
+class DBError extends MWException {
+
+	/**
+	 * @var DatabaseBase
+	 */
+	public $db;
+
+	/**
+	 * Construct a database error
+	 * @param $db DatabaseBase object which threw the error
+	 * @param $error String A simple error message to be used for debugging
+	 */
+	function __construct( DatabaseBase &$db, $error ) {
+		$this->db = $db;
+		parent::__construct( $error );
+	}
+
+	/**
+	 * @param $html string
+	 * @return string
+	 */
+	protected function getContentMessage( $html ) {
+		if ( $html ) {
+			return nl2br( htmlspecialchars( $this->getMessage() ) );
+		} else {
+			return $this->getMessage();
+		}
+	}
+
+	/**
+	 * @return string
+	 */
+	function getText() {
+		global $wgShowDBErrorBacktrace;
+
+		$s = $this->getContentMessage( false ) . "\n";
+
+		if ( $wgShowDBErrorBacktrace ) {
+			$s .= "Backtrace:\n" . $this->getTraceAsString() . "\n";
+		}
+
+		return $s;
+	}
+
+	/**
+	 * @return string
+	 */
+	function getHTML() {
+		global $wgShowDBErrorBacktrace;
+
+		$s = $this->getContentMessage( true );
+
+		if ( $wgShowDBErrorBacktrace ) {
+			$s .= '<p>Backtrace:</p><p>' . nl2br( htmlspecialchars( $this->getTraceAsString() ) );
+		}
+
+		return $s;
+	}
+}
+
+/**
+ * @ingroup Database
+ */
+class DBConnectionError extends DBError {
+	public $error;
+
+	function __construct( DatabaseBase &$db, $error = 'unknown error' ) {
+		$msg = 'DB connection error';
+
+		if ( trim( $error ) != '' ) {
+			$msg .= ": $error";
+		}
+
+		$this->error = $error;
+
+		parent::__construct( $db, $msg );
+	}
+
+	function useOutputPage() {
+		// Not likely to work
+		return false;
+	}
+
+	function msg( $key, $fallback /*[, params...] */ ) {
+		global $wgLang;
+
+		$args = array_slice( func_get_args(), 2 );
+
+		if ( $this->useMessageCache() ) {
+			$message = $wgLang->getMessage( $key );
+		} else {
+			$message = $fallback;
+		}
+		return wfMsgReplaceArgs( $message, $args );
+	}
+
+	function getLogMessage() {
+		# Don't send to the exception log
+		return false;
+	}
+
+	/**
+	 * @return string
+	 */
+	function getPageTitle() {
+		global $wgSitename;
+		return htmlspecialchars( $this->msg( 'dberr-header', "$wgSitename has a problem" ) );
+	}
+
+	/**
+	 * @return string
+	 */
+	function getHTML() {
+		global $wgShowDBErrorBacktrace;
+
+		$sorry = htmlspecialchars( $this->msg( 'dberr-problems', 'Sorry! This site is experiencing technical difficulties.' ) );
+		$again = htmlspecialchars( $this->msg( 'dberr-again', 'Try waiting a few minutes and reloading.' ) );
+		$info  = htmlspecialchars( $this->msg( 'dberr-info', '(Can\'t contact the database server: $1)' ) );
+
+		# No database access
+		MessageCache::singleton()->disable();
+
+		if ( trim( $this->error ) == '' ) {
+			$this->error = $this->db->getProperty( 'mServer' );
+		}
+
+		$this->error = Html::element( 'span', array( 'dir' => 'ltr' ), $this->error );
+
+		$noconnect = "<h1>$sorry</h1><p>$again</p><p><small>$info</small></p>";
+		$text = str_replace( '$1', $this->error, $noconnect );
+
+		if ( $wgShowDBErrorBacktrace ) {
+			$text .= '<p>Backtrace:</p><p>' . nl2br( htmlspecialchars( $this->getTraceAsString() ) );
+		}
+
+		$extra = $this->searchForm();
+
+		return "$text<hr />$extra";
+	}
+
+	public function reportHTML(){
+		global $wgUseFileCache;
+
+		# Check whether we can serve a file-cached copy of the page with the error underneath
+		if ( $wgUseFileCache ) {
+			try {
+				$cache = $this->fileCachedPage();
+				# Cached version on file system?
+				if ( $cache !== null ) {
+					# Hack: extend the body for error messages
+					$cache = str_replace( array( '</html>', '</body>' ), '', $cache );
+					# Add cache notice...
+					$cache .= '<div style="color:red;font-size:150%;font-weight:bold;">'.
+						htmlspecialchars( $this->msg( 'dberr-cachederror',
+							'This is a cached copy of the requested page, and may not be up to date. ' ) ) .
+						'</div>';
+
+					# Output cached page with notices on bottom and re-close body
+					echo "{$cache}<hr />{$this->getHTML()}</body></html>";
+					return;
+				}
+			} catch ( MWException $e ) {
+				// Do nothing, just use the default page
+			}
+		}
+
+		# We can't, cough and die in the usual fashion
+		return parent::reportHTML();
+	}
+
+	/**
+	 * @return string
+	 */
+	function searchForm() {
+		global $wgSitename, $wgServer, $wgRequest;
+
+		$usegoogle = htmlspecialchars( $this->msg( 'dberr-usegoogle', 'You can try searching via Google in the meantime.' ) );
+		$outofdate = htmlspecialchars( $this->msg( 'dberr-outofdate', 'Note that their indexes of our content may be out of date.' ) );
+		$googlesearch = htmlspecialchars( $this->msg( 'searchbutton', 'Search' ) );
+
+		$search = htmlspecialchars( $wgRequest->getVal( 'search' ) );
+
+		$server = htmlspecialchars( $wgServer );
+		$sitename = htmlspecialchars( $wgSitename );
+
+		$trygoogle = <<<EOT
+<div style="margin: 1.5em">$usegoogle<br />
+<small>$outofdate</small></div>
+<!-- SiteSearch Google -->
+<form method="get" action="http://www.google.com/search" id="googlesearch">
+	<input type="hidden" name="domains" value="$server" />
+	<input type="hidden" name="num" value="50" />
+	<input type="hidden" name="ie" value="UTF-8" />
+	<input type="hidden" name="oe" value="UTF-8" />
+
+	<input type="text" name="q" size="31" maxlength="255" value="$search" />
+	<input type="submit" name="btnG" value="$googlesearch" />
+  <div>
+	<input type="radio" name="sitesearch" id="gwiki" value="$server" checked="checked" /><label for="gwiki">$sitename</label>
+	<input type="radio" name="sitesearch" id="gWWW" value="" /><label for="gWWW">WWW</label>
+  </div>
+</form>
+<!-- SiteSearch Google -->
+EOT;
+		return $trygoogle;
+	}
+
+	/**
+	 * @return string
+	 */
+	private function fileCachedPage() {
+		global $wgTitle, $wgOut;
+
+		if ( $wgOut->isDisabled() ) {
+			return; // Done already?
+		}
+
+		if ( $wgTitle ) {
+			$t =& $wgTitle;
+		} else {
+			$t = Title::newFromText( $this->msg( 'mainpage', 'Main Page' ) );
+		}
+
+		$cache = new HTMLFileCache( $t );
+		if ( $cache->isFileCached() ) {
+			return $cache->fetchPageText();
+		} else {
+			return '';
+		}
+	}
+}
+
+/**
+ * @ingroup Database
+ */
+class DBQueryError extends DBError {
+	public $error, $errno, $sql, $fname;
+
+	function __construct( DatabaseBase &$db, $error, $errno, $sql, $fname ) {
+		$message = "A database error has occurred.  Did you forget to run maintenance/update.php after upgrading?  See: http://www.mediawiki.org/wiki/Manual:Upgrading#Run_the_update_script\n" .
+		  "Query: $sql\n" .
+		  "Function: $fname\n" .
+		  "Error: $errno $error\n";
+		global $wgShowDBErrorBacktrace;
+		if( $wgShowDBErrorBacktrace ) {
+			$message .= $this->getTraceAsString();
+		}
+		parent::__construct( $db, $message );
+
+		$this->error = $error;
+		$this->errno = $errno;
+		$this->sql = $sql;
+		$this->fname = $fname;
+	}
+
+	/**
+	 * @param $html string
+	 * @return string
+	 */
+	function getContentMessage( $html ) {
+		if ( $this->useMessageCache() ) {
+			if ( $html ) {
+				$msg = 'dberrortext';
+				$sql = htmlspecialchars( $this->getSQL() );
+				$fname = htmlspecialchars( $this->fname );
+				$error = htmlspecialchars( $this->error );
+			} else {
+				$msg = 'dberrortextcl';
+				$sql = $this->getSQL();
+				$fname = $this->fname;
+				$error = $this->error;
+			}
+			return wfMsg( $msg, $sql, $fname, $this->errno, $error );
+		} else {
+			return parent::getContentMessage( $html );
+		}
+	}
+
+	/**
+	 * @return String
+	 */
+	function getSQL() {
+		global $wgShowSQLErrors;
+
+		if ( !$wgShowSQLErrors ) {
+			return $this->msg( 'sqlhidden', 'SQL hidden' );
+		} else {
+			return $this->sql;
+		}
+	}
+
+	function getLogMessage() {
+		# Don't send to the exception log
+		return false;
+	}
+
+	/**
+	 * @return String
+	 */
+	function getPageTitle() {
+		return $this->msg( 'databaseerror', 'Database error' );
+	}
+}
+
+/**
+ * @ingroup Database
+ */
+class DBUnexpectedError extends DBError {}
diff --git a/includes/db/DatabaseIbm_db2.php b/includes/db/DatabaseIbm_db2.php
index becca11e..147b9d59 100644
--- a/includes/db/DatabaseIbm_db2.php
+++ b/includes/db/DatabaseIbm_db2.php
@@ -114,7 +114,7 @@ class DatabaseIbm_db2 extends DatabaseBase {
 	protected $mPHPError = false;
 
 	protected $mServer, $mUser, $mPassword, $mConn = null, $mDBname;
-	protected $mOut, $mOpened = false;
+	protected $mOpened = false;
 
 	protected $mTablePrefix;
 	protected $mFlags;
@@ -144,7 +144,7 @@ class DatabaseIbm_db2 extends DatabaseBase {
 	public $mStmtOptions = array();
 
 	/** Default schema */
-	const USE_GLOBAL = 'mediawiki';
+	const USE_GLOBAL = 'get from global';
 
 	/** Option that applies to nothing */
 	const NONE_OPTION = 0x00;
@@ -268,6 +268,10 @@ class DatabaseIbm_db2 extends DatabaseBase {
 		}
 
 		// configure the connection and statement objects
+		/*
+		$this->setDB2Option( 'cursor', 'DB2_SCROLLABLE',
+			self::CONN_OPTION | self::STMT_OPTION );
+		*/
 		$this->setDB2Option( 'db2_attr_case', 'DB2_CASE_LOWER',
 			self::CONN_OPTION | self::STMT_OPTION );
 		$this->setDB2Option( 'deferred_prepare', 'DB2_DEFERRED_PREPARE_ON',
@@ -321,27 +325,17 @@ class DatabaseIbm_db2 extends DatabaseBase {
 	 * @return a fresh connection
 	 */
 	public function open( $server, $user, $password, $dbName ) {
-		// Load the port number
-		global $wgDBport;
 		wfProfileIn( __METHOD__ );
 
-		// Load IBM DB2 driver if missing
+		# Load IBM DB2 driver if missing
 		wfDl( 'ibm_db2' );
 
-		// Test for IBM DB2 support, to avoid suppressed fatal error
+		# Test for IBM DB2 support, to avoid suppressed fatal error
 		if ( !function_exists( 'db2_connect' ) ) {
-			$error = <<<ERROR
-DB2 functions missing, have you enabled the ibm_db2 extension for PHP?
-
-ERROR;
-			$this->installPrint( $error );
-			$this->reportConnectionError( $error );
+			throw new DBConnectionError( $this, "DB2 functions missing, have you enabled the ibm_db2 extension for PHP?" );
 		}
 
-		if ( strlen( $user ) < 1 ) {
-			wfProfileOut( __METHOD__ );
-			return null;
-		}
+		global $wgDBport;
 
 		// Close existing connection
 		$this->close();
@@ -354,24 +348,26 @@ ERROR;
 
 		$this->openUncataloged( $dbName, $user, $password, $server, $port );
 
-		// Apply connection config
-		db2_set_option( $this->mConn, $this->mConnOptions, 1 );
-		// Some MediaWiki code is still transaction-less (?).
-		// The strategy is to keep AutoCommit on for that code
-		//  but switch it off whenever a transaction is begun.
-		db2_autocommit( $this->mConn, DB2_AUTOCOMMIT_ON );
-
 		if ( !$this->mConn ) {
 			$this->installPrint( "DB connection error\n" );
 			$this->installPrint(
 				"Server: $server, Database: $dbName, User: $user, Password: "
 				. substr( $password, 0, 3 ) . "...\n" );
 			$this->installPrint( $this->lastError() . "\n" );
-
 			wfProfileOut( __METHOD__ );
-			return null;
+			wfDebug( "DB connection error\n" );
+			wfDebug( "Server: $server, Database: $dbName, User: $user, Password: " . substr( $password, 0, 3 ) . "...\n" );
+			wfDebug( $this->lastError() . "\n" );
+			throw new DBConnectionError( $this, $this->lastError() );
 		}
 
+		// Apply connection config
+		db2_set_option( $this->mConn, $this->mConnOptions, 1 );
+		// Some MediaWiki code is still transaction-less (?).
+		// The strategy is to keep AutoCommit on for that code
+		//  but switch it off whenever a transaction is begun.
+		db2_autocommit( $this->mConn, DB2_AUTOCOMMIT_ON );
+
 		$this->mOpened = true;
 		$this->applySchema();
 
@@ -383,7 +379,9 @@ ERROR;
 	 * Opens a cataloged database connection, sets mConn
 	 */
 	protected function openCataloged( $dbName, $user, $password ) {
-		@$this->mConn = db2_pconnect( $dbName, $user, $password );
+		wfSuppressWarnings();
+		$this->mConn = db2_pconnect( $dbName, $user, $password );
+		wfRestoreWarnings();
 	}
 
 	/**
@@ -391,16 +389,10 @@ ERROR;
 	 */
 	protected function openUncataloged( $dbName, $user, $password, $server, $port )
 	{
-		$str = "DRIVER={IBM DB2 ODBC DRIVER};";
-		$str .= "DATABASE=$dbName;";
-		$str .= "HOSTNAME=$server;";
-		// port was formerly validated to not be 0
-		$str .= "PORT=$port;";
-		$str .= "PROTOCOL=TCPIP;";
-		$str .= "UID=$user;";
-		$str .= "PWD=$password;";
-
-		@$this->mConn = db2_pconnect( $str, $user, $password );
+		$dsn = "DRIVER={IBM DB2 ODBC DRIVER};DATABASE=$dbName;CHARSET=UTF-8;HOSTNAME=$server;PORT=$port;PROTOCOL=TCPIP;UID=$user;PWD=$password;";
+		wfSuppressWarnings();
+		$this->mConn = db2_pconnect($dsn, "", "", array());
+		wfRestoreWarnings();
 	}
 
 	/**
@@ -420,23 +412,6 @@ ERROR;
 	}
 
 	/**
-	 * Returns a fresh instance of this class
-	 *
-	 * @param $server String: hostname of database server
-	 * @param $user String: username
-	 * @param $password String
-	 * @param $dbName String: database name on the server
-	 * @param $flags Integer: database behaviour flags (optional, unused)
-	 * @return DatabaseIbm_db2 object
-	 */
-	static function newFromParams( $server, $user, $password, $dbName,
-		$flags = 0 )
-	{
-		return new DatabaseIbm_db2( $server, $user, $password, $dbName,
-			$flags );
-	}
-
-	/**
 	 * Retrieves the most current database error
 	 * Forces a database rollback
 	 */
@@ -482,15 +457,19 @@ ERROR;
 	 * The DBMS-dependent part of query()
 	 * @param  $sql String: SQL query.
 	 * @return object Result object for fetch functions or false on failure
-	 * @access private
 	 */
-	/*private*/
-	public function doQuery( $sql ) {
+	protected function doQuery( $sql ) {
 		$this->applySchema();
-
+		
+		// Needed to handle any UTF-8 encoding issues in the raw sql
+		// Note that we fully support prepared statements for DB2
+		// prepare() and execute() should be used instead of doQuery() whenever possible
+		$sql = utf8_decode($sql);
+		
 		$ret = db2_exec( $this->mConn, $sql, $this->mStmtOptions );
 		if( $ret == false ) {
 			$error = db2_stmt_errormsg();
+			
 			$this->installPrint( "<pre>$sql</pre>" );
 			$this->installPrint( $error );
 			throw new DBUnexpectedError( $this, 'SQL error: '
@@ -515,17 +494,18 @@ ERROR;
 	 */
 	public function tableExists( $table ) {
 		$schema = $this->mSchema;
-		$sql = <<< EOF
-SELECT COUNT( * ) FROM SYSIBM.SYSTABLES ST
-WHERE ST.NAME = '$table' AND ST.CREATOR = '$schema'
-EOF;
+		
+		$sql = "SELECT COUNT( * ) FROM SYSIBM.SYSTABLES ST WHERE ST.NAME = '" . 
+			strtoupper( $table ) .
+			"' AND ST.CREATOR = '" .
+			strtoupper( $schema ) . "'";
 		$res = $this->query( $sql );
 		if ( !$res ) {
 			return false;
 		}
 
 		// If the table exists, there should be one of it
-		@$row = $this->fetchRow( $res );
+		$row = $this->fetchRow( $res );
 		$count = $row[0];
 		if ( $count == '1' || $count == 1 ) {
 			return true;
@@ -547,7 +527,9 @@ EOF;
 		if ( $res instanceof ResultWrapper ) {
 			$res = $res->result;
 		}
-		@$row = db2_fetch_object( $res );
+		wfSuppressWarnings();
+		$row = db2_fetch_object( $res );
+		wfRestoreWarnings();
 		if( $this->lastErrno() ) {
 			throw new DBUnexpectedError( $this, 'Error in fetchObject(): '
 				. htmlspecialchars( $this->lastError() ) );
@@ -567,51 +549,17 @@ EOF;
 		if ( $res instanceof ResultWrapper ) {
 			$res = $res->result;
 		}
-		@$row = db2_fetch_array( $res );
-		if ( $this->lastErrno() ) {
-			throw new DBUnexpectedError( $this, 'Error in fetchRow(): '
-				. htmlspecialchars( $this->lastError() ) );
-		}
-		return $row;
-	}
-
-	/**
-	 * Create tables, stored procedures, and so on
-	 */
-	public function setup_database() {
-		try {
-			// TODO: switch to root login if available
-
-			// Switch into the correct namespace
-			$this->applySchema();
-			$this->begin();
-
-			$res = $this->sourceFile( "../maintenance/ibm_db2/tables.sql" );
-			if ( $res !== true ) {
-				print ' <b>FAILED</b>: ' . htmlspecialchars( $res ) . '</li>';
-			} else {
-				print ' done</li>';
-			}
-			$res = $this->sourceFile( "../maintenance/ibm_db2/foreignkeys.sql" );
-			if ( $res !== true ) {
-				print ' <b>FAILED</b>: ' . htmlspecialchars( $res ) . '</li>';
-			} else {
-				print '<li>Foreign keys done</li>';
-			}
-
-			// TODO: populate interwiki links
-
-			if ( $this->lastError() ) {
-				$this->installPrint(
-					'Errors encountered during table creation -- rolled back' );
-				$this->installPrint( 'Please install again' );
-				$this->rollback();
-			} else {
-				$this->commit();
+		if ( db2_num_rows( $res ) > 0) {
+			wfSuppressWarnings();
+			$row = db2_fetch_array( $res );
+			wfRestoreWarnings();
+			if ( $this->lastErrno() ) {
+				throw new DBUnexpectedError( $this, 'Error in fetchRow(): '
+					. htmlspecialchars( $this->lastError() ) );
 			}
-		} catch ( MWException $mwe ) {
-			print "<br><pre>$mwe</pre><br>";
+			return $row;
 		}
+		return false;
 	}
 
 	/**
@@ -797,9 +745,10 @@ EOF;
 	 * Handle reserved keyword replacement in table names
 	 *
 	 * @param $name Object
+	 * @param $name Boolean
 	 * @return String
 	 */
-	public function tableName( $name ) {
+	public function tableName( $name, $quoted = true ) {
 		// we want maximum compatibility with MySQL schema
 		return $name;
 	}
@@ -915,9 +864,9 @@ EOF;
 		} else {
 			$sql .= '( ?' . str_repeat( ',?', $key_count-1 ) . ' )';
 		}
-		//$this->installPrint( "Preparing the following SQL:" );
-		//$this->installPrint( "$sql" );
-		//$this->installPrint( print_r( $args, true ));
+		$this->installPrint( "Preparing the following SQL:" );
+		$this->installPrint( "$sql" );
+		$this->installPrint( print_r( $args, true ));
 		$stmt = $this->prepare( $sql );
 
 		// start a transaction/enter transaction mode
@@ -990,18 +939,22 @@ EOF;
 	 */
 	private function removeNullPrimaryKeys( $table, $args ) {
 		$schema = $this->mSchema;
+		
 		// find out the primary keys
-		$keyres = db2_primary_keys( $this->mConn, null, strtoupper( $schema ),
-			strtoupper( $table )
-		);
+		$keyres = $this->doQuery( "SELECT NAME FROM SYSIBM.SYSCOLUMNS WHERE TBNAME = '" 
+		  . strtoupper( $table ) 
+		  . "' AND TBCREATOR = '" 
+		  . strtoupper( $schema ) 
+		  . "' AND KEYSEQ > 0" );
+		
 		$keys = array();
 		for (
-			$row = $this->fetchObject( $keyres );
+			$row = $this->fetchRow( $keyres );
 			$row != null;
-			$row = $this->fetchObject( $keyres )
+			$row = $this->fetchRow( $keyres )
 		)
 		{
-			$keys[] = strtolower( $row->column_name );
+			$keys[] = strtolower( $row[0] );
 		}
 		// remove primary keys
 		foreach ( $args as $ai => $row ) {
@@ -1084,66 +1037,6 @@ EOF;
 	}
 
 	/**
-	 * Simulates REPLACE with a DELETE followed by INSERT
-	 * @param $table Object
-	 * @param $uniqueIndexes Array consisting of indexes and arrays of indexes
-	 * @param $rows Array: rows to insert
-	 * @param $fname String: name of the function for profiling
-	 * @return nothing
-	 */
-	function replace( $table, $uniqueIndexes, $rows,
-		$fname = 'DatabaseIbm_db2::replace' )
-	{
-		$table = $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 $table 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
-			$sql = "INSERT INTO $table ( "
-				. $this->makeList( array_keys( $row ), LIST_NAMES )
-				.' ) VALUES ( ' . $this->makeList( $row, LIST_COMMA ) . ' )';
-			$this->query( $sql, $fname );
-		}
-	}
-
-	/**
 	 * Returns the number of rows in the result set
 	 * Has to be called right after the corresponding select query
 	 * @param $res Object result set
@@ -1153,6 +1046,7 @@ EOF;
 		if ( $res instanceof ResultWrapper ) {
 			$res = $res->result;
 		}
+		
 		if ( $this->mNumRows ) {
 			return $this->mNumRows;
 		} else {
@@ -1186,7 +1080,10 @@ EOF;
 		if ( $res instanceof ResultWrapper ) {
 			$res = $res->result;
 		}
-		if ( !@db2_free_result( $res ) ) {
+		wfSuppressWarnings();
+		$ok = db2_free_result( $res );
+		wfRestoreWarnings();
+		if ( !$ok ) {
 			throw new DBUnexpectedError( $this, "Unable to free DB2 result\n" );
 		}
 	}
@@ -1365,14 +1262,6 @@ EOF;
 	######################################
 	/**
 	 * Not implemented
-	 * @return string ''
-	 */
-	public function getStatus( $which = '%' ) {
-		$this->installPrint( 'Not implemented for DB2: getStatus()' );
-		return '';
-	}
-	/**
-	 * Not implemented
 	 * @return string $sql
 	 */
 	public function limitResultForUpdate( $sql, $num ) {
@@ -1496,39 +1385,6 @@ SQL;
 	}
 
 	/**
-	 * DELETE where the condition is a join
-	 * @param $delTable String: deleting from this table
-	 * @param $joinTable String: using data from this table
-	 * @param $delVar String: variable in deleteable table
-	 * @param $joinVar String: variable in data table
-	 * @param $conds Array: conditionals for join table
-	 * @param $fname String: function name for profiling
-	 */
-	public function deleteJoin( $delTable, $joinTable, $delVar, $joinVar,
-		$conds, $fname = "DatabaseIbm_db2::deleteJoin" )
-	{
-		if ( !$conds ) {
-			throw new DBUnexpectedError( $this,
-				'DatabaseIbm_db2::deleteJoin() called with empty $conds' );
-		}
-
-		$delTable = $this->tableName( $delTable );
-		$joinTable = $this->tableName( $joinTable );
-		$sql = <<<SQL
-DELETE FROM $delTable
-WHERE $delVar IN (
-  SELECT $joinVar FROM $joinTable
-
-SQL;
-		if ( $conds != '*' ) {
-			$sql .= 'WHERE ' . $this->makeList( $conds, LIST_AND );
-		}
-		$sql .= ' )';
-
-		$this->query( $sql, $fname );
-	}
-
-	/**
 	 * Description is left as an exercise for the reader
 	 * @param $b Mixed: data to be encoded
 	 * @return IBM_DB2Blob
diff --git a/includes/db/DatabaseMssql.php b/includes/db/DatabaseMssql.php
index 41ba2d08..cbdf89ca 100644
--- a/includes/db/DatabaseMssql.php
+++ b/includes/db/DatabaseMssql.php
@@ -17,6 +17,8 @@ class DatabaseMssql extends DatabaseBase {
 	var $mLastResult = NULL;
 	var $mAffectedRows = NULL;
 
+	var $mPort;
+
 	function cascadingDeletes() {
 		return true;
 	}
@@ -42,10 +44,6 @@ class DatabaseMssql extends DatabaseBase {
 		return false;
 	}
 
-	static function newFromParams( $server, $user, $password, $dbName, $flags = 0 ) {
-		return new DatabaseMssql( $server, $user, $password, $dbName, $flags );
-	}
-
 	/**
 	 * Usually aborts on failure
 	 */
@@ -83,7 +81,7 @@ class DatabaseMssql extends DatabaseBase {
 		$ntAuthPassTest = strtolower( $password );
 
 		// Decide which auth scenerio to use
-		if( ( $ntAuthPassTest == 'ntauth' && $ntAuthUserTest == 'ntauth' ) ){
+		if( $ntAuthPassTest == 'ntauth' && $ntAuthUserTest == 'ntauth' ){
 			// Don't add credentials to $connectionInfo
 		} else {
 			$connectionInfo['UID'] = $user;
@@ -91,7 +89,9 @@ class DatabaseMssql extends DatabaseBase {
 		}
 		// End NT Auth Hack
 
-		$this->mConn = @sqlsrv_connect( $server, $connectionInfo );
+		wfSuppressWarnings();
+		$this->mConn = sqlsrv_connect( $server, $connectionInfo );
+		wfRestoreWarnings();
 
 		if ( $this->mConn === false ) {
 			wfDebug( "DB connection error\n" );
@@ -117,7 +117,7 @@ class DatabaseMssql extends DatabaseBase {
 		}
 	}
 
-	function doQuery( $sql ) {
+	protected function doQuery( $sql ) {
 		wfDebug( "SQL: [$sql]\n" );
 		$this->offset = 0;
 
@@ -241,16 +241,18 @@ class DatabaseMssql extends DatabaseBase {
 	function lastError() {
 		if ( $this->mConn ) {
 			return $this->getErrors();
-		}
-		else {
+		} else {
 			return "No database connection";
 		}
 	}
 
 	function lastErrno() {
 		$err = sqlsrv_errors( SQLSRV_ERR_ALL );
-		if ( $err[0] ) return $err[0]['code'];
-		else return 0;
+		if ( $err[0] ) {
+			return $err[0]['code'];
+		} else {
+			return 0;
+		}
 	}
 
 	function affectedRows() {
@@ -321,7 +323,6 @@ class DatabaseMssql extends DatabaseBase {
 		return $rows;
 	}
 
-
 	/**
 	 * Returns information about an index
 	 * If errors are explicitly ignored, returns NULL on failure
@@ -344,7 +345,7 @@ class DatabaseMssql extends DatabaseBase {
 					$row->Column_name = trim( $col );
 					$result[] = clone $row;
 				}
-			} else if ( $index == 'PRIMARY' && stristr( $row->index_description, 'PRIMARY' ) ) {
+			} elseif ( $index == 'PRIMARY' && stristr( $row->index_description, 'PRIMARY' ) ) {
 				$row->Non_unique = 0;
 				$cols = explode( ", ", $row->index_keys );
 				foreach ( $cols as $col ) {
@@ -383,7 +384,6 @@ class DatabaseMssql extends DatabaseBase {
 
 		$allOk = true;
 
-
 		// We know the table we're inserting into, get its identity column
 		$identity = null;
 		$tableRaw = preg_replace( '#\[([^\]]*)\]#', '$1', $table ); // strip matching square brackets from table name
@@ -421,7 +421,6 @@ class DatabaseMssql extends DatabaseBase {
 
 			$keys = array_keys( $a );
 
-
 			// INSERT IGNORE is not supported by SQL Server
 			// remove IGNORE from options list and set ignore flag to true
 			$ignoreClause = false;
@@ -436,7 +435,7 @@ class DatabaseMssql extends DatabaseBase {
 			// example:
 			// MySQL: INSERT IGNORE INTO user_groups (ug_user,ug_group) VALUES ('1','sysop')
 			// MSSQL: IF NOT EXISTS (SELECT * FROM user_groups WHERE ug_user = '1') INSERT INTO user_groups (ug_user,ug_group) VALUES ('1','sysop')
-			if ( $ignoreClause == true ) {
+			if ( $ignoreClause ) {
 				$prival = $a[$keys[0]];
 				$sqlPre .= "IF NOT EXISTS (SELECT * FROM $table WHERE $keys[0] = '$prival')";
 			}
@@ -453,14 +452,14 @@ class DatabaseMssql extends DatabaseBase {
 					$sql .= ',';
 				}
 				if ( is_string( $value ) ) {
-					$sql .= $this->addIdentifierQuotes( $value );
+					$sql .= $this->addQuotes( $value );
 				} elseif ( is_null( $value ) ) {
 					$sql .= 'null';
 				} elseif ( is_array( $value ) || is_object( $value ) ) {
 					if ( is_object( $value ) && strtolower( get_class( $value ) ) == 'blob' ) {
-						$sql .= $this->addIdentifierQuotes( $value->fetch() );
+						$sql .= $this->addQuotes( $value );
 					}  else {
-						$sql .= $this->addIdentifierQuotes( serialize( $value ) );
+						$sql .= $this->addQuotes( serialize( $value ) );
 					}
 				} else {
 					$sql .= $value;
@@ -497,12 +496,11 @@ class DatabaseMssql extends DatabaseBase {
 	 * srcTable may be an array of tables.
 	 */
 	function insertSelect( $destTable, $srcTable, $varMap, $conds, $fname = 'DatabaseMssql::insertSelect',
-		$insertOptions = array(), $selectOptions = array() )
-	{
+		$insertOptions = array(), $selectOptions = array() ) {
 		$ret = parent::insertSelect( $destTable, $srcTable, $varMap, $conds, $fname, $insertOptions, $selectOptions );
 
 		if ( $ret === false ) {
-			throw new DBQueryError( $this, $this->getErrors(), $this->lastErrno(), $sql, $fname );
+			throw new DBQueryError( $this, $this->getErrors(), $this->lastErrno(), /*$sql*/ '', $fname );
 		} elseif ( $ret != NULL ) {
 			// remember number of rows affected
 			$this->mAffectedRows = sqlsrv_rows_affected( $ret );
@@ -512,35 +510,6 @@ class DatabaseMssql extends DatabaseBase {
 	}
 
 	/**
-	 * Format a table name ready for use in constructing an SQL query
-	 *
-	 * This does two important things: it brackets table names which as necessary,
-	 * and it adds a table prefix if there is one.
-	 *
-	 * All functions of this object which require a table name call this function
-	 * themselves. Pass the canonical name to such functions. This is only needed
-	 * when calling query() directly.
-	 *
-	 * @param $name String: database table name
-	 */
-	function tableName( $name ) {
-		global $wgSharedDB;
-		# Skip quoted literals
-		if ( $name != '' && $name { 0 } != '[' ) {
-			if ( $this->mTablePrefix !== '' &&  strpos( '.', $name ) === false ) {
-				$name = "{$this->mTablePrefix}$name";
-			}
-			if ( isset( $wgSharedDB ) && "{$this->mTablePrefix}user" == $name ) {
-				$name = "[$wgSharedDB].[$name]";
-			} else {
-				# Standard quoting
-				if ( $name != '' ) $name = "[$name]";
-			}
-		}
-		return $name;
-	}
-
-	/**
 	 * Return the next in a sequence, save the value for retrieval via insertId()
 	 */
 	function nextSequenceValue( $seqName ) {
@@ -570,82 +539,6 @@ class DatabaseMssql extends DatabaseBase {
 		}
 	}
 
-
-	# REPLACE query wrapper
-	# MSSQL simulates this with a DELETE followed by INSERT
-	# $row is the row to insert, an associative array
-	# $uniqueIndexes is an array of indexes. Each element may be either a
-	# field name or an array of field names
-	#
-	# It may be more efficient to leave off unique indexes which are unlikely to collide.
-	# However if you do this, you run the risk of encountering errors which wouldn't have
-	# occurred in MySQL
-	function replace( $table, $uniqueIndexes, $rows, $fname = 'DatabaseMssql::replace' ) {
-		$table = $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 $table 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
-			$sql = "INSERT INTO $table (" . $this->makeList( array_keys( $row ), LIST_NAMES ) . ') VALUES (' .
-				$this->makeList( $row, LIST_COMMA ) . ')';
-			$this->query( $sql, $fname );
-		}
-	}
-
-	# DELETE where the condition is a join
-	function deleteJoin( $delTable, $joinTable, $delVar, $joinVar, $conds, $fname = "DatabaseMssql::deleteJoin" ) {
-		if ( !$conds ) {
-			throw new DBUnexpectedError( $this, 'DatabaseMssql::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 );
-	}
-
 	# Returns the size of a text field, or -1 for "unlimited"
 	function textFieldSize( $table, $field ) {
 		$table = $this->tableName( $table );
@@ -654,7 +547,9 @@ class DatabaseMssql extends DatabaseBase {
 		$res = $this->query( $sql );
 		$row = $this->fetchRow( $res );
 		$size = -1;
-		if ( strtolower( $row['DATA_TYPE'] ) != 'text' ) $size = $row['CHARACTER_MAXIMUM_LENGTH'];
+		if ( strtolower( $row['DATA_TYPE'] ) != 'text' ) {
+			$size = $row['CHARACTER_MAXIMUM_LENGTH'];
+		}
 		return $size;
 	}
 
@@ -713,7 +608,6 @@ class DatabaseMssql extends DatabaseBase {
 		return $sql;
 	}
 
-
 	function timestamp( $ts = 0 ) {
 		return wfTimestamp( TS_ISO_8601, $ts );
 	}
@@ -731,7 +625,9 @@ class DatabaseMssql extends DatabaseBase {
 	function getServerVersion() {
 		$server_info = sqlsrv_server_info( $this->mConn );
 		$version = 'Error';
-		if ( isset( $server_info['SQLServerVersion'] ) ) $version = $server_info['SQLServerVersion'];
+		if ( isset( $server_info['SQLServerVersion'] ) ) {
+			$version = $server_info['SQLServerVersion'];
+		}
 		return $version;
 	}
 
@@ -742,10 +638,11 @@ class DatabaseMssql extends DatabaseBase {
 			print( "Error in tableExists query: " . $this->getErrors() );
 			return false;
 		}
-		if ( sqlsrv_fetch( $res ) )
+		if ( sqlsrv_fetch( $res ) ) {
 			return true;
-		else
+		} else {
 			return false;
+		}
 	}
 
 	/**
@@ -759,10 +656,11 @@ class DatabaseMssql extends DatabaseBase {
 			print( "Error in fieldExists query: " . $this->getErrors() );
 			return false;
 		}
-		if ( sqlsrv_fetch( $res ) )
+		if ( sqlsrv_fetch( $res ) ) {
 			return true;
-		else
+		} else {
 			return false;
+		}
 	}
 
 	function fieldInfo( $table, $field ) {
@@ -780,10 +678,6 @@ class DatabaseMssql extends DatabaseBase {
 		return false;
 	}
 
-	public function unixTimestamp( $field ) {
-		return "DATEDIFF(s,CONVERT(datetime,'1/1/1970'),$field)";
-	}
-
 	/**
 	 * Begin a transaction, committing any previously open transaction
 	 */
@@ -809,48 +703,6 @@ class DatabaseMssql extends DatabaseBase {
 		$this->mTrxLevel = 0;
 	}
 
-	function setup_database() {
-		global $wgDBuser;
-
-		// Make sure that we can write to the correct schema
-		$ctest = "mediawiki_test_table";
-		if ( $this->tableExists( $ctest ) ) {
-			$this->doQuery( "DROP TABLE $ctest" );
-		}
-		$SQL = "CREATE TABLE $ctest (a int)";
-		$res = $this->doQuery( $SQL );
-		if ( !$res ) {
-			print "<b>FAILED</b>. Make sure that the user " . htmlspecialchars( $wgDBuser ) . " can write to the database</li>\n";
-			dieout( );
-		}
-		$this->doQuery( "DROP TABLE $ctest" );
-
-		$res = $this->sourceFile( "../maintenance/mssql/tables.sql" );
-		if ( $res !== true ) {
-			echo " <b>FAILED</b></li>";
-			dieout( htmlspecialchars( $res ) );
-		}
-
-		# Avoid the non-standard "REPLACE INTO" syntax
-		$f = fopen( "../maintenance/interwiki.sql", 'r' );
-		if ( $f == false ) {
-			dieout( "<li>Could not find the interwiki.sql file" );
-		}
-		# We simply assume it is already empty as we have just created it
-		$SQL = "INSERT INTO interwiki(iw_prefix,iw_url,iw_local) VALUES ";
-		while ( ! feof( $f ) ) {
-			$line = fgets( $f, 1024 );
-			$matches = array();
-			if ( !preg_match( '/^\s*(\(.+?),(\d)\)/', $line, $matches ) ) {
-				continue;
-			}
-			$this->query( "$SQL $matches[1],$matches[2])" );
-		}
-		print " (table interwiki successfully populated)...\n";
-
-		$this->commit();
-	}
-
 	/**
 	 * Escapes a identifier for use inm SQL.
 	 * Throws an exception if it is invalid.
@@ -957,12 +809,12 @@ class DatabaseMssql extends DatabaseBase {
 				$tableClause .= ' ON (' . $this->makeList( (array)$join_conds_safe[$table][1], LIST_AND ) . ')';
 				$retJOIN[] = $tableClause;
 			// Is there an INDEX clause?
-			} else if ( isset( $use_index_safe[$table] ) ) {
+			} elseif ( isset( $use_index_safe[$table] ) ) {
 				$tableClause = $this->tableName( $table );
 				$tableClause .= ' ' . $this->useIndexClause( implode( ',', (array)$use_index_safe[$table] ) );
 				$ret[] = $tableClause;
 			// Is there a JOIN clause?
-			} else if ( isset( $join_conds_safe[$table] ) ) {
+			} elseif ( isset( $join_conds_safe[$table] ) ) {
 				$tableClause = $join_conds_safe[$table][0] . ' ' . $this->tableName( $table );
 				$tableClause .= ' ON (' . $this->makeList( (array)$join_conds_safe[$table][1], LIST_AND ) . ')';
 				$retJOIN[] = $tableClause;
@@ -990,6 +842,15 @@ class DatabaseMssql extends DatabaseBase {
 		}
 	}
 
+	public function addIdentifierQuotes( $s ) {
+		// http://msdn.microsoft.com/en-us/library/aa223962.aspx
+		return '[' . $s . ']';
+	}
+
+	public function isQuotedIdentifier( $name ) {
+		return $name[0] == '[' && substr( $name, -1, 1 ) == ']';
+	}
+
 	function selectDB( $db ) {
 		return ( $this->query( "SET DATABASE $db" ) !== false );
 	}
@@ -1012,11 +873,19 @@ class DatabaseMssql extends DatabaseBase {
 			}
 		}
 
-		if ( isset( $options['GROUP BY'] ) ) $tailOpts .= " GROUP BY {$options['GROUP BY']}";
-		if ( isset( $options['HAVING'] ) )   $tailOpts .= " HAVING {$options['GROUP BY']}";
-		if ( isset( $options['ORDER BY'] ) ) $tailOpts .= " ORDER BY {$options['ORDER BY']}";
+		if ( isset( $options['GROUP BY'] ) ) {
+			$tailOpts .= " GROUP BY {$options['GROUP BY']}";
+		}
+		if ( isset( $options['HAVING'] ) ) {
+			$tailOpts .= " HAVING {$options['GROUP BY']}";
+		}
+		if ( isset( $options['ORDER BY'] ) ) {
+			$tailOpts .= " ORDER BY {$options['ORDER BY']}";
+		}
 
-		if ( isset( $noKeyOptions['DISTINCT'] ) && isset( $noKeyOptions['DISTINCTROW'] ) ) $startOpts .= 'DISTINCT';
+		if ( isset( $noKeyOptions['DISTINCT'] ) && isset( $noKeyOptions['DISTINCTROW'] ) ) {
+			$startOpts .= 'DISTINCT';
+		}
 
 		// we want this to be compatible with the output of parent::makeSelectOptions()
 		return array( $startOpts, '' , $tailOpts, '' );
@@ -1037,6 +906,14 @@ class DatabaseMssql extends DatabaseBase {
 		return "SearchMssql";
 	}
 
+	/**
+	 * Since MSSQL doesn't recognize the infinity keyword, set date manually.
+	 * @todo Remove magic date
+	 */
+	public function getInfinity() {
+		return '3000-01-31 00:00:00.000';
+	}
+
 } // end DatabaseMssql class
 
 /**
@@ -1051,9 +928,10 @@ class MssqlField implements Field {
 		$this->tablename = $info['TABLE_NAME'];
 		$this->default = $info['COLUMN_DEFAULT'];
 		$this->max_length = $info['CHARACTER_MAXIMUM_LENGTH'];
-		$this->nullable = ( strtolower( $info['IS_NULLABLE'] ) == 'no' ) ? false:true;
+		$this->nullable = !( strtolower( $info['IS_NULLABLE'] ) == 'no' );
 		$this->type = $info['DATA_TYPE'];
 	}
+
 	function name() {
 		return $this->name;
 	}
@@ -1087,26 +965,29 @@ class MssqlField implements Field {
  */
 class MssqlResult {
 
-  public function __construct( $queryresult = false ) {
-	$this->mCursor = 0;
-	$this->mRows = array();
-	$this->mNumFields = sqlsrv_num_fields( $queryresult );
-	$this->mFieldMeta = sqlsrv_field_metadata( $queryresult );
-	while ( $row = sqlsrv_fetch_array( $queryresult, SQLSRV_FETCH_ASSOC ) ) {
-		if ( $row !== null ) {
-			foreach ( $row as $k => $v ) {
-				if ( is_object( $v ) && method_exists( $v, 'format' ) ) {// DateTime Object
-					$row[$k] = $v->format( "Y-m-d\TH:i:s\Z" );
+	public function __construct( $queryresult = false ) {
+		$this->mCursor = 0;
+		$this->mRows = array();
+		$this->mNumFields = sqlsrv_num_fields( $queryresult );
+		$this->mFieldMeta = sqlsrv_field_metadata( $queryresult );
+
+		$rows = sqlsrv_fetch_array( $queryresult, SQLSRV_FETCH_ASSOC );
+
+		foreach( $rows as $row ) {
+			if ( $row !== null ) {
+				foreach ( $row as $k => $v ) {
+					if ( is_object( $v ) && method_exists( $v, 'format' ) ) {// DateTime Object
+						$row[$k] = $v->format( "Y-m-d\TH:i:s\Z" );
+					}
 				}
+				$this->mRows[] = $row;// read results into memory, cursors are not supported
 			}
-			$this->mRows[] = $row;// read results into memory, cursors are not supported
 		}
+		$this->mRowCount = count( $this->mRows );
+		sqlsrv_free_stmt( $queryresult );
 	}
-	$this->mRowCount = count( $this->mRows );
-	sqlsrv_free_stmt( $queryresult );
-  }
 
-  private function array_to_obj( $array, &$obj ) {
+	private function array_to_obj( $array, &$obj ) {
 		foreach ( $array as $key => $value ) {
 			if ( is_array( $value ) ) {
 				$obj->$key = new stdClass();
@@ -1118,109 +999,108 @@ class MssqlResult {
 			}
 		}
 		return $obj;
-  }
-
-  public function fetch( $mode = SQLSRV_FETCH_BOTH, $object_class = 'stdClass' ) {
-	if ( $this->mCursor >= $this->mRowCount || $this->mRowCount == 0 ) {
-		return false;
 	}
-	$arrNum = array();
-	if ( $mode == SQLSRV_FETCH_NUMERIC || $mode == SQLSRV_FETCH_BOTH ) {
-		foreach ( $this->mRows[$this->mCursor] as $value ) {
-			$arrNum[] = $value;
+
+	public function fetch( $mode = SQLSRV_FETCH_BOTH, $object_class = 'stdClass' ) {
+		if ( $this->mCursor >= $this->mRowCount || $this->mRowCount == 0 ) {
+			return false;
 		}
+		$arrNum = array();
+		if ( $mode == SQLSRV_FETCH_NUMERIC || $mode == SQLSRV_FETCH_BOTH ) {
+			foreach ( $this->mRows[$this->mCursor] as $value ) {
+				$arrNum[] = $value;
+			}
+		}
+		switch( $mode ) {
+			case SQLSRV_FETCH_ASSOC:
+				$ret = $this->mRows[$this->mCursor];
+				break;
+			case SQLSRV_FETCH_NUMERIC:
+				$ret = $arrNum;
+				break;
+			case 'OBJECT':
+				$o = new $object_class;
+				$ret = $this->array_to_obj( $this->mRows[$this->mCursor], $o );
+				break;
+			case SQLSRV_FETCH_BOTH:
+			default:
+				$ret = $this->mRows[$this->mCursor] + $arrNum;
+				break;
+		}
+
+		$this->mCursor++;
+		return $ret;
+	}
+
+	public function get( $pos, $fld ) {
+		return $this->mRows[$pos][$fld];
 	}
-	switch( $mode ) {
-		case SQLSRV_FETCH_ASSOC:
-			$ret = $this->mRows[$this->mCursor];
-			break;
-		case SQLSRV_FETCH_NUMERIC:
-			$ret = $arrNum;
-			break;
-		case 'OBJECT':
-			$o = new $object_class;
-			$ret = $this->array_to_obj( $this->mRows[$this->mCursor], $o );
-			break;
-		case SQLSRV_FETCH_BOTH:
-		default:
-			$ret = $this->mRows[$this->mCursor] + $arrNum;
-			break;
-	}
-
-	$this->mCursor++;
-	return $ret;
-  }
-
-  public function get( $pos, $fld ) {
-	return $this->mRows[$pos][$fld];
-  }
-
-  public function numrows() {
-	return $this->mRowCount;
-  }
-
-  public function seek( $iRow ) {
-	$this->mCursor = min( $iRow, $this->mRowCount );
-  }
-
-  public function numfields() {
-	return $this->mNumFields;
-  }
-
-  public function fieldname( $nr ) {
-	$arrKeys = array_keys( $this->mRows[0] );
-	return $arrKeys[$nr];
-  }
-
-  public function fieldtype( $nr ) {
-	$i = 0;
-	$intType = -1;
-	foreach ( $this->mFieldMeta as $meta ) {
-		if ( $nr == $i ) {
-			$intType = $meta['Type'];
-			break;
+
+	public function numrows() {
+		return $this->mRowCount;
+	}
+
+	public function seek( $iRow ) {
+		$this->mCursor = min( $iRow, $this->mRowCount );
+	}
+
+	public function numfields() {
+		return $this->mNumFields;
+	}
+
+	public function fieldname( $nr ) {
+		$arrKeys = array_keys( $this->mRows[0] );
+		return $arrKeys[$nr];
+	}
+
+	public function fieldtype( $nr ) {
+		$i = 0;
+		$intType = -1;
+		foreach ( $this->mFieldMeta as $meta ) {
+			if ( $nr == $i ) {
+				$intType = $meta['Type'];
+				break;
+			}
+			$i++;
 		}
-		$i++;
-	}
-	// http://msdn.microsoft.com/en-us/library/cc296183.aspx contains type table
-	switch( $intType ) {
-		case SQLSRV_SQLTYPE_BIGINT: 		$strType = 'bigint'; break;
-		case SQLSRV_SQLTYPE_BINARY: 		$strType = 'binary'; break;
-		case SQLSRV_SQLTYPE_BIT: 			$strType = 'bit'; break;
-		case SQLSRV_SQLTYPE_CHAR: 			$strType = 'char'; break;
-		case SQLSRV_SQLTYPE_DATETIME: 		$strType = 'datetime'; break;
-		case SQLSRV_SQLTYPE_DECIMAL/*($precision, $scale)*/: $strType = 'decimal'; break;
-		case SQLSRV_SQLTYPE_FLOAT: 			$strType = 'float'; break;
-		case SQLSRV_SQLTYPE_IMAGE: 			$strType = 'image'; break;
-		case SQLSRV_SQLTYPE_INT: 			$strType = 'int'; break;
-		case SQLSRV_SQLTYPE_MONEY: 			$strType = 'money'; break;
-		case SQLSRV_SQLTYPE_NCHAR/*($charCount)*/: $strType = 'nchar'; break;
-		case SQLSRV_SQLTYPE_NUMERIC/*($precision, $scale)*/: $strType = 'numeric'; break;
-		case SQLSRV_SQLTYPE_NVARCHAR/*($charCount)*/: $strType = 'nvarchar'; break;
-		// case SQLSRV_SQLTYPE_NVARCHAR('max'): $strType = 'nvarchar(MAX)'; break;
-		case SQLSRV_SQLTYPE_NTEXT: 			$strType = 'ntext'; break;
-		case SQLSRV_SQLTYPE_REAL: 			$strType = 'real'; break;
-		case SQLSRV_SQLTYPE_SMALLDATETIME: 	$strType = 'smalldatetime'; break;
-		case SQLSRV_SQLTYPE_SMALLINT: 		$strType = 'smallint'; break;
-		case SQLSRV_SQLTYPE_SMALLMONEY: 	$strType = 'smallmoney'; break;
-		case SQLSRV_SQLTYPE_TEXT: 			$strType = 'text'; break;
-		case SQLSRV_SQLTYPE_TIMESTAMP: 		$strType = 'timestamp'; break;
-		case SQLSRV_SQLTYPE_TINYINT: 		$strType = 'tinyint'; break;
-		case SQLSRV_SQLTYPE_UNIQUEIDENTIFIER: $strType = 'uniqueidentifier'; break;
-		case SQLSRV_SQLTYPE_UDT: 			$strType = 'UDT'; break;
-		case SQLSRV_SQLTYPE_VARBINARY/*($byteCount)*/: $strType = 'varbinary'; break;
-		// case SQLSRV_SQLTYPE_VARBINARY('max'): $strType = 'varbinary(MAX)'; break;
-		case SQLSRV_SQLTYPE_VARCHAR/*($charCount)*/: $strType = 'varchar'; break;
-		// case SQLSRV_SQLTYPE_VARCHAR('max'): $strType = 'varchar(MAX)'; break;
-		case SQLSRV_SQLTYPE_XML: 			$strType = 'xml'; break;
-		default: $strType = $intType;
-	}
-	return $strType;
-  }
-
-  public function free() {
-	unset( $this->mRows );
-	return;
-  }
+		// http://msdn.microsoft.com/en-us/library/cc296183.aspx contains type table
+		switch( $intType ) {
+			case SQLSRV_SQLTYPE_BIGINT: 		$strType = 'bigint'; break;
+			case SQLSRV_SQLTYPE_BINARY: 		$strType = 'binary'; break;
+			case SQLSRV_SQLTYPE_BIT: 			$strType = 'bit'; break;
+			case SQLSRV_SQLTYPE_CHAR: 			$strType = 'char'; break;
+			case SQLSRV_SQLTYPE_DATETIME: 		$strType = 'datetime'; break;
+			case SQLSRV_SQLTYPE_DECIMAL/*($precision, $scale)*/: $strType = 'decimal'; break;
+			case SQLSRV_SQLTYPE_FLOAT: 			$strType = 'float'; break;
+			case SQLSRV_SQLTYPE_IMAGE: 			$strType = 'image'; break;
+			case SQLSRV_SQLTYPE_INT: 			$strType = 'int'; break;
+			case SQLSRV_SQLTYPE_MONEY: 			$strType = 'money'; break;
+			case SQLSRV_SQLTYPE_NCHAR/*($charCount)*/: $strType = 'nchar'; break;
+			case SQLSRV_SQLTYPE_NUMERIC/*($precision, $scale)*/: $strType = 'numeric'; break;
+			case SQLSRV_SQLTYPE_NVARCHAR/*($charCount)*/: $strType = 'nvarchar'; break;
+			// case SQLSRV_SQLTYPE_NVARCHAR('max'): $strType = 'nvarchar(MAX)'; break;
+			case SQLSRV_SQLTYPE_NTEXT: 			$strType = 'ntext'; break;
+			case SQLSRV_SQLTYPE_REAL: 			$strType = 'real'; break;
+			case SQLSRV_SQLTYPE_SMALLDATETIME: 	$strType = 'smalldatetime'; break;
+			case SQLSRV_SQLTYPE_SMALLINT: 		$strType = 'smallint'; break;
+			case SQLSRV_SQLTYPE_SMALLMONEY: 	$strType = 'smallmoney'; break;
+			case SQLSRV_SQLTYPE_TEXT: 			$strType = 'text'; break;
+			case SQLSRV_SQLTYPE_TIMESTAMP: 		$strType = 'timestamp'; break;
+			case SQLSRV_SQLTYPE_TINYINT: 		$strType = 'tinyint'; break;
+			case SQLSRV_SQLTYPE_UNIQUEIDENTIFIER: $strType = 'uniqueidentifier'; break;
+			case SQLSRV_SQLTYPE_UDT: 			$strType = 'UDT'; break;
+			case SQLSRV_SQLTYPE_VARBINARY/*($byteCount)*/: $strType = 'varbinary'; break;
+			// case SQLSRV_SQLTYPE_VARBINARY('max'): $strType = 'varbinary(MAX)'; break;
+			case SQLSRV_SQLTYPE_VARCHAR/*($charCount)*/: $strType = 'varchar'; break;
+			// case SQLSRV_SQLTYPE_VARCHAR('max'): $strType = 'varchar(MAX)'; break;
+			case SQLSRV_SQLTYPE_XML: 			$strType = 'xml'; break;
+			default: $strType = $intType;
+		}
+		return $strType;
+	}
 
+	public function free() {
+		unset( $this->mRows );
+		return;
+	}
 }
diff --git a/includes/db/DatabaseMysql.php b/includes/db/DatabaseMysql.php
index ed276ec5..9cbd455e 100644
--- a/includes/db/DatabaseMysql.php
+++ b/includes/db/DatabaseMysql.php
@@ -18,7 +18,7 @@ class DatabaseMysql extends DatabaseBase {
 		return 'mysql';
 	}
 
-	/*private*/ function doQuery( $sql ) {
+	protected function doQuery( $sql ) {
 		if( $this->bufferResults() ) {
 			$ret = mysql_query( $sql, $this->mConn );
 		} else {
@@ -95,7 +95,9 @@ class DatabaseMysql extends DatabaseBase {
 		wfProfileOut("dbconnect-$server");
 
 		if ( $dbName != '' && $this->mConn !== false ) {
-			$success = @/**/mysql_select_db( $dbName, $this->mConn );
+			wfSuppressWarnings();
+			$success = mysql_select_db( $dbName, $this->mConn );
+			wfRestoreWarnings();
 			if ( !$success ) {
 				$error = "Error selecting database $dbName on server {$this->mServer} " .
 					"from client host " . wfHostname() . "\n";
@@ -152,7 +154,10 @@ class DatabaseMysql extends DatabaseBase {
 		if ( $res instanceof ResultWrapper ) {
 			$res = $res->result;
 		}
-		if ( !@/**/mysql_free_result( $res ) ) {
+		wfSuppressWarnings();
+		$ok = mysql_free_result( $res );
+		wfRestoreWarnings();
+		if ( !$ok ) {
 			throw new DBUnexpectedError( $this, "Unable to free MySQL result" );
 		}
 	}
@@ -161,7 +166,9 @@ class DatabaseMysql extends DatabaseBase {
 		if ( $res instanceof ResultWrapper ) {
 			$res = $res->result;
 		}
-		@/**/$row = mysql_fetch_object( $res );
+		wfSuppressWarnings();
+		$row = mysql_fetch_object( $res );
+		wfRestoreWarnings();
 		if( $this->lastErrno() ) {
 			throw new DBUnexpectedError( $this, 'Error in fetchObject(): ' . htmlspecialchars( $this->lastError() ) );
 		}
@@ -172,7 +179,9 @@ class DatabaseMysql extends DatabaseBase {
 		if ( $res instanceof ResultWrapper ) {
 			$res = $res->result;
 		}
-		@/**/$row = mysql_fetch_array( $res );
+		wfSuppressWarnings();
+		$row = mysql_fetch_array( $res );
+		wfRestoreWarnings();
 		if ( $this->lastErrno() ) {
 			throw new DBUnexpectedError( $this, 'Error in fetchRow(): ' . htmlspecialchars( $this->lastError() ) );
 		}
@@ -183,7 +192,9 @@ class DatabaseMysql extends DatabaseBase {
 		if ( $res instanceof ResultWrapper ) {
 			$res = $res->result;
 		}
-		@/**/$n = mysql_num_rows( $res );
+		wfSuppressWarnings();
+		$n = mysql_num_rows( $res );
+		wfRestoreWarnings();
 		if( $this->lastErrno() ) {
 			throw new DBUnexpectedError( $this, 'Error in numRows(): ' . htmlspecialchars( $this->lastError() ) );
 		}
@@ -241,6 +252,10 @@ class DatabaseMysql extends DatabaseBase {
 
 	function affectedRows() { return mysql_affected_rows( $this->mConn ); }
 
+	function replace( $table, $uniqueIndexes, $rows, $fname = 'DatabaseMysql::replace' ) {
+		return $this->nativeReplace( $table, $rows, $fname );
+	}
+
 	/**
 	 * Estimate rows in dataset
 	 * Returns estimated count, based on EXPLAIN output
@@ -329,6 +344,10 @@ class DatabaseMysql extends DatabaseBase {
 		return "`" . $this->strencode( $s ) . "`";
 	}
 
+	public function isQuotedIdentifier( $name ) {
+		return strlen($name) && $name[0] == '`' && substr( $name, -1, 1 ) == '`';
+	}
+
 	function ping() {
 		$ping = mysql_ping( $this->mConn );
 		if ( $ping ) {
@@ -344,7 +363,11 @@ class DatabaseMysql extends DatabaseBase {
 
 	/**
 	 * Returns slave lag.
-	 * At the moment, this will only work if the DB user has the PROCESS privilege
+	 *
+	 * On MySQL 4.1.9 and later, this will do a SHOW SLAVE STATUS. On earlier
+	 * versions of MySQL, it uses SHOW PROCESSLIST, which requires the PROCESS
+	 * privilege.
+	 *
 	 * @result int
 	 */
 	function getLag() {
@@ -352,6 +375,31 @@ class DatabaseMysql extends DatabaseBase {
 			wfDebug( "getLag: fake slave lagged {$this->mFakeSlaveLag} seconds\n" );
 			return $this->mFakeSlaveLag;
 		}
+
+		if ( version_compare( $this->getServerVersion(), '4.1.9', '>=' ) ) {
+			return $this->getLagFromSlaveStatus();
+		} else {
+			return $this->getLagFromProcesslist();
+		}
+	}
+
+	function getLagFromSlaveStatus() {
+		$res = $this->query( 'SHOW SLAVE STATUS', __METHOD__ );
+		if ( !$res ) {
+			return false;
+		}
+		$row = $res->fetchObject();
+		if ( !$row ) {
+			return false;
+		}
+		if ( strval( $row->Seconds_Behind_Master ) === '' ) {
+			return false;
+		} else {
+			return intval( $row->Seconds_Behind_Master );
+		}
+	}
+
+	function getLagFromProcesslist() {
 		$res = $this->query( 'SHOW PROCESSLIST', __METHOD__ );
 		if( !$res ) {
 			return false;
@@ -384,6 +432,83 @@ class DatabaseMysql extends DatabaseBase {
 		}
 		return false;
 	}
+	
+	/**
+	 * Wait for the slave to catch up to a given master position.
+	 *
+	 * @param $pos DBMasterPos object
+	 * @param $timeout Integer: the maximum number of seconds to wait for synchronisation
+	 */
+	function masterPosWait( DBMasterPos $pos, $timeout ) {
+		$fname = 'DatabaseBase::masterPosWait';
+		wfProfileIn( $fname );
+
+		# Commit any open transactions
+		if ( $this->mTrxLevel ) {
+			$this->commit();
+		}
+
+		if ( !is_null( $this->mFakeSlaveLag ) ) {
+			$status = parent::masterPosWait( $pos, $timeout );
+			wfProfileOut( $fname );
+			return $status;
+		}
+
+		# Call doQuery() directly, to avoid opening a transaction if DBO_TRX is set
+		$encFile = $this->addQuotes( $pos->file );
+		$encPos = intval( $pos->pos );
+		$sql = "SELECT MASTER_POS_WAIT($encFile, $encPos, $timeout)";
+		$res = $this->doQuery( $sql );
+
+		if ( $res && $row = $this->fetchRow( $res ) ) {
+			wfProfileOut( $fname );
+			return $row[0];
+		} else {
+			wfProfileOut( $fname );
+			return false;
+		}
+	}
+
+	/**
+	 * Get the position of the master from SHOW SLAVE STATUS
+	 *
+	 * @return MySQLMasterPos|false
+	 */
+	function getSlavePos() {
+		if ( !is_null( $this->mFakeSlaveLag ) ) {
+			return parent::getSlavePos();
+		}
+
+		$res = $this->query( 'SHOW SLAVE STATUS', 'DatabaseBase::getSlavePos' );
+		$row = $this->fetchObject( $res );
+
+		if ( $row ) {
+			$pos = isset( $row->Exec_master_log_pos ) ? $row->Exec_master_log_pos : $row->Exec_Master_Log_Pos;
+			return new MySQLMasterPos( $row->Relay_Master_Log_File, $pos );
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * Get the position of the master from SHOW MASTER STATUS
+	 *
+	 * @return MySQLMasterPos|false
+	 */
+	function getMasterPos() {
+		if ( $this->mFakeMaster ) {
+			return parent::getMasterPos();
+		}
+
+		$res = $this->query( 'SHOW MASTER STATUS', 'DatabaseBase::getMasterPos' );
+		$row = $this->fetchObject( $res );
+
+		if ( $row ) {
+			return new MySQLMasterPos( $row->File, $row->Position );
+		} else {
+			return false;
+		}
+	}
 
 	function getServerVersion() {
 		return mysql_get_server_info( $this->mConn );
@@ -478,8 +603,23 @@ class DatabaseMysql extends DatabaseBase {
 		$this->query( "SET sql_big_selects=$encValue", __METHOD__ );
 	}
 
-	public function unixTimestamp( $field ) {
-		return "UNIX_TIMESTAMP($field)";
+	/**
+	 * DELETE where the condition is a join. MySql uses multi-table deletes.
+	 */
+	function deleteJoin( $delTable, $joinTable, $delVar, $joinVar, $conds, $fname = 'DatabaseBase::deleteJoin' ) {
+		if ( !$conds ) {
+			throw new DBUnexpectedError( $this, 'DatabaseBase::deleteJoin() called with empty $conds' );
+		}
+
+		$delTable = $this->tableName( $delTable );
+		$joinTable = $this->tableName( $joinTable );
+		$sql = "DELETE $delTable FROM $delTable, $joinTable WHERE $delVar=$joinVar ";
+
+		if ( $conds != '*' ) {
+			$sql .= ' AND ' . $this->makeList( $conds, LIST_AND );
+		}
+
+		return $this->query( $sql, $fname );
 	}
 
 	/**
@@ -516,26 +656,79 @@ class DatabaseMysql extends DatabaseBase {
 			# Note that we don't bother changing around the prefixes here be-
 			# cause we know we're using MySQL anyway.
 
-			$res = $this->query( "SHOW CREATE TABLE $oldName" );
+			$res = $this->query( 'SHOW CREATE TABLE ' . $this->addIdentifierQuotes( $oldName ) );
 			$row = $this->fetchRow( $res );
 			$oldQuery = $row[1];
 			$query = preg_replace( '/CREATE TABLE `(.*?)`/',
-				"CREATE $tmp TABLE `$newName`", $oldQuery );
+				"CREATE $tmp TABLE " . $this->addIdentifierQuotes( $newName ), $oldQuery );
 			if ($oldQuery === $query) {
 				# Couldn't do replacement
 				throw new MWException( "could not create temporary table $newName" );
 			}
 		} else {
+			$newName = $this->addIdentifierQuotes( $newName );
+			$oldName = $this->addIdentifierQuotes( $oldName );
 			$query = "CREATE $tmp TABLE $newName (LIKE $oldName)";
 		}
 		$this->query( $query, $fname );
 	}
+	
+	/**
+	 * List all tables on the database
+	 *
+	 * @param $prefix Only show tables with this prefix, e.g. mw_
+	 * @param $fname String: calling function name
+	 */
+	function listTables( $prefix = null, $fname = 'DatabaseMysql::listTables' ) {
+		$result = $this->query( "SHOW TABLES", $fname);
+
+		$endArray = array();
+
+		foreach( $result as $table ) {
+			$vars = get_object_vars($table);
+			$table = array_pop( $vars );
+
+			if( !$prefix || strpos( $table, $prefix ) === 0 ) {
+				$endArray[] = $table;
+			}
+		}
+		
+		return $endArray;
+	}
+
+	public function dropTable( $tableName, $fName = 'DatabaseMysql::dropTable' ) {
+		if( !$this->tableExists( $tableName ) ) {
+			return false;
+		}
+		return $this->query( "DROP TABLE IF EXISTS " . $this->tableName( $tableName ), $fName );
+	}
 
+	/**
+	 * @return array
+	 */
 	protected function getDefaultSchemaVars() {
 		$vars = parent::getDefaultSchemaVars();
-		$vars['wgDBTableOptions'] = $GLOBALS['wgDBTableOptions'];
+		$vars['wgDBTableOptions'] = str_replace( 'TYPE', 'ENGINE', $GLOBALS['wgDBTableOptions'] );
+		$vars['wgDBTableOptions'] = str_replace( 'CHARSET=mysql4', 'CHARSET=binary', $GLOBALS['wgDBTableOptions'] );
 		return $vars;
 	}
+
+	/**
+	 * Get status information from SHOW STATUS in an associative array
+	 *
+	 * @return array
+	 */
+	function getMysqlStatus( $which = "%" ) {
+		$res = $this->query( "SHOW STATUS LIKE '{$which}'" );
+		$status = array();
+
+		foreach ( $res as $row ) {
+			$status[$row->Variable_name] = $row->Value;
+		}
+
+		return $status;
+	}
+
 }
 
 /**
@@ -593,7 +786,7 @@ class MySQLField implements Field {
 	}
 }
 
-class MySQLMasterPos {
+class MySQLMasterPos implements DBMasterPos {
 	var $file, $pos;
 
 	function __construct( $file, $pos ) {
diff --git a/includes/db/DatabaseOracle.php b/includes/db/DatabaseOracle.php
index 3c4d00ac..b64e66c2 100644
--- a/includes/db/DatabaseOracle.php
+++ b/includes/db/DatabaseOracle.php
@@ -16,7 +16,7 @@ class ORAResult {
 	private $rows;
 	private $cursor;
 	private $nrows;
-	
+
 	private $columns = array();
 
 	private function array_unique_md( $array_in ) {
@@ -34,6 +34,11 @@ class ORAResult {
 		return $array_out;
 	}
 
+	/**
+	 * @param $db DatabaseBase
+	 * @param $stmt
+	 * @param bool $unique
+	 */
 	function __construct( &$db, $stmt, $unique = false ) {
 		$this->db =& $db;
 
@@ -165,7 +170,6 @@ class ORAField implements Field {
 class DatabaseOracle extends DatabaseBase {
 	var $mInsertId = null;
 	var $mLastResult = null;
-	var $numeric_version = null;
 	var $lastResult = null;
 	var $cursor = 0;
 	var $mAffectedRows;
@@ -180,7 +184,8 @@ class DatabaseOracle extends DatabaseBase {
 	function __construct( $server = false, $user = false, $password = false, $dbName = false,
 		$flags = 0, $tablePrefix = 'get from global' )
 	{
-		$tablePrefix = $tablePrefix == 'get from global' ? $tablePrefix : strtoupper( $tablePrefix );
+		global $wgDBprefix;
+		$tablePrefix = $tablePrefix == 'get from global' ? strtoupper( $wgDBprefix ) : strtoupper( $tablePrefix );
 		parent::__construct( $server, $user, $password, $dbName, $flags, $tablePrefix );
 		wfRunHooks( 'DatabaseOraclePostInit', array( $this ) );
 	}
@@ -219,11 +224,6 @@ class DatabaseOracle extends DatabaseBase {
 		return true;
 	}
 
-	static function newFromParams( $server, $user, $password, $dbName, $flags = 0 )
-	{
-		return new DatabaseOracle( $server, $user, $password, $dbName, $flags );
-	}
-
 	/**
 	 * Usually aborts on failure
 	 */
@@ -232,6 +232,7 @@ class DatabaseOracle extends DatabaseBase {
 			throw new DBConnectionError( $this, "Oracle functions missing, have you compiled PHP with the --with-oci8 option?\n (Note: if you recently installed PHP, you may need to restart your webserver and database)\n" );
 		}
 
+		$this->close();
 		$this->mUser = $user;
 		$this->mPassword = $password;
 		// changed internal variables functions
@@ -245,7 +246,7 @@ class DatabaseOracle extends DatabaseBase {
 			$this->mServer = $server;
 			if ( !$dbName ) {
 				$this->mDBname = $user;
-			} else {	
+			} else {
 				$this->mDBname = $dbName;
 			}
 		}
@@ -255,11 +256,13 @@ class DatabaseOracle extends DatabaseBase {
 		}
 
 		$session_mode = $this->mFlags & DBO_SYSDBA ? OCI_SYSDBA : OCI_DEFAULT;
+		wfSuppressWarnings();
 		if ( $this->mFlags & DBO_DEFAULT ) {
 			$this->mConn = oci_new_connect( $this->mUser, $this->mPassword, $this->mServer, $this->defaultCharset, $session_mode );
 		} else {
 			$this->mConn = oci_connect( $this->mUser, $this->mPassword, $this->mServer, $this->defaultCharset, $session_mode );
 		}
+		wfRestoreWarnings();
 
 		if ( $this->mUser != $this->mDBname ) {
 			//change current schema in session
@@ -276,7 +279,6 @@ class DatabaseOracle extends DatabaseBase {
 		$this->doQuery( 'ALTER SESSION SET NLS_TIMESTAMP_FORMAT=\'DD-MM-YYYY HH24:MI:SS.FF6\'' );
 		$this->doQuery( 'ALTER SESSION SET NLS_TIMESTAMP_TZ_FORMAT=\'DD-MM-YYYY HH24:MI:SS.FF6\'' );
 		$this->doQuery( 'ALTER SESSION SET NLS_NUMERIC_CHARACTERS=\'.,\'' );
-		
 		return $this->mConn;
 	}
 
@@ -297,10 +299,10 @@ class DatabaseOracle extends DatabaseBase {
 	}
 
 	function execFlags() {
-		return $this->mTrxLevel ? OCI_DEFAULT : OCI_COMMIT_ON_SUCCESS;
+		return $this->mTrxLevel ? OCI_NO_AUTO_COMMIT : OCI_COMMIT_ON_SUCCESS;
 	}
 
-	function doQuery( $sql ) {
+	protected function doQuery( $sql ) {
 		wfDebug( "SQL: [$sql]\n" );
 		if ( !mb_check_encoding( $sql ) ) {
 			throw new MWException( "SQL encoding is invalid\n$sql" );
@@ -357,7 +359,7 @@ class DatabaseOracle extends DatabaseBase {
 		if ( $res instanceof ResultWrapper ) {
 			$res = $res->result;
 		}
-		
+
 		$res->free();
 	}
 
@@ -365,7 +367,7 @@ class DatabaseOracle extends DatabaseBase {
 		if ( $res instanceof ResultWrapper ) {
 			$res = $res->result;
 		}
-		
+
 		return $res->fetchObject();
 	}
 
@@ -478,16 +480,16 @@ class DatabaseOracle extends DatabaseBase {
 	private function fieldBindStatement ( $table, $col, &$val, $includeCol = false ) {
 		$col_info = $this->fieldInfoMulti( $table, $col );
 		$col_type = $col_info != false ? $col_info->type() : 'CONSTANT';
-		
+
 		$bind = '';
 		if ( is_numeric( $col ) ) {
 			$bind = $val;
 			$val = null;
-			return $bind; 
-		} else if ( $includeCol ) {
+			return $bind;
+		} elseif ( $includeCol ) {
 			$bind = "$col = ";
 		}
-		
+
 		if ( $val == '' && $val !== 0 && $col_type != 'BLOB' && $col_type != 'CLOB' ) {
 			$val = null;
 		}
@@ -505,7 +507,7 @@ class DatabaseOracle extends DatabaseBase {
 		} else {
 			$bind .= ':' . $col;
 		}
-		
+
 		return $bind;
 	}
 
@@ -525,7 +527,7 @@ class DatabaseOracle extends DatabaseBase {
 			} else {
 				$first = false;
 			}
-			
+
 			$sql .= $this->fieldBindStatement( $table, $col, $val );
 		}
 		$sql .= ')';
@@ -551,7 +553,7 @@ class DatabaseOracle extends DatabaseBase {
 				}
 
 				$val = ( $wgContLang != null ) ? $wgContLang->checkTitleEncoding( $val ) : $val;
-				if ( oci_bind_by_name( $stmt, ":$col", $val ) === false ) {
+				if ( oci_bind_by_name( $stmt, ":$col", $val, -1, SQLT_CHR ) === false ) {
 					$e = oci_error( $stmt );
 					$this->reportQueryError( $e['message'], $e['code'], $sql, __METHOD__ );
 					return false;
@@ -652,8 +654,7 @@ class DatabaseOracle extends DatabaseBase {
 		return $retval;
 	}
 
-	function tableName( $name ) {
-		global $wgSharedDB, $wgSharedPrefix, $wgSharedTables;
+	function tableName( $name, $quoted = true ) {
 		/*
 		Replace reserved words with better ones
 		Using uppercase because that's the only way Oracle can handle
@@ -668,53 +669,13 @@ class DatabaseOracle extends DatabaseBase {
 				break;
 		}
 
-		/*
-			The rest of procedure is equal to generic Databse class
-			except for the quoting style
-		*/
-		if ( $name[0] == '"' && substr( $name, - 1, 1 ) == '"' ) {
-			return $name;
-		}
-		if ( preg_match( '/(^|\s)(DISTINCT|JOIN|ON|AS)(\s|$)/i', $name ) !== 0 ) {
-			return $name;
-		}
-		$dbDetails = array_reverse( explode( '.', $name, 2 ) );
-		if ( isset( $dbDetails[1] ) ) {
-			@list( $table, $database ) = $dbDetails;
-		} else {
-			@list( $table ) = $dbDetails;
-		}
-
-		$prefix = $this->mTablePrefix;
-
-		if ( isset( $database ) ) {
-			$table = ( $table[0] == '`' ? $table : "`{$table}`" );
-		}
-
-		if ( !isset( $database ) && isset( $wgSharedDB ) && $table[0] != '"'
-			&& isset( $wgSharedTables )
-			&& is_array( $wgSharedTables )
-			&& in_array( $table, $wgSharedTables )
-		) {
-			$database = $wgSharedDB;
-			$prefix   = isset( $wgSharedPrefix ) ? $wgSharedPrefix : $prefix;
-		}
-
-		if ( isset( $database ) ) {
-			$database = ( $database[0] == '"' ? $database : "\"{$database}\"" );
-		}
-		$table = ( $table[0] == '"') ? $table : "\"{$prefix}{$table}\"" ;
-
-		$tableName = ( isset( $database ) ? "{$database}.{$table}" : "{$table}" );
-
-		return strtoupper( $tableName );
+		return parent::tableName( strtoupper( $name ), $quoted );
 	}
 
 	function tableNameInternal( $name ) {
 		$name = $this->tableName( $name );
-		return preg_replace( '/.*\."(.*)"/', '$1', $name);
+		return preg_replace( '/.*\.(.*)/', '$1', $name);
 	}
-
 	/**
 	 * Return the next in a sequence, save the value for retrieval via insertId()
 	 */
@@ -730,96 +691,26 @@ class DatabaseOracle extends DatabaseBase {
 	 */
 	private function getSequenceData( $table ) {
 		if ( $this->sequenceData == null ) {
-			$result = $this->doQuery( 'SELECT lower(us.sequence_name), lower(utc.table_name), lower(utc.column_name) from user_sequences us, user_tab_columns utc where us.sequence_name = utc.table_name||\'_\'||utc.column_name||\'_SEQ\'' );
+			$result = $this->doQuery( "SELECT lower(asq.sequence_name),
+				   lower(atc.table_name),
+				   lower(atc.column_name)
+			  FROM all_sequences asq, all_tab_columns atc
+			 WHERE decode(atc.table_name, '{$this->mTablePrefix}MWUSER', '{$this->mTablePrefix}USER', atc.table_name) || '_' ||
+				   atc.column_name || '_SEQ' = '{$this->mTablePrefix}' || asq.sequence_name
+			   AND asq.sequence_owner = upper('{$this->mDBname}')
+			   AND atc.owner = upper('{$this->mDBname}')" );
 
 			while ( ( $row = $result->fetchRow() ) !== false ) {
-				$this->sequenceData[$this->tableName( $row[1] )] = array(
+				$this->sequenceData[$row[1]] = array(
 					'sequence' => $row[0],
 					'column' => $row[2]
 				);
 			}
 		}
-
+		$table = strtolower( $this->removeIdentifierQuotes( $this->tableName( $table ) ) );
 		return ( isset( $this->sequenceData[$table] ) ) ? $this->sequenceData[$table] : false;
 	}
 
-	/**
-	 * REPLACE query wrapper
-	 * Oracle simulates this with a DELETE followed by INSERT
-	 * $row is the row to insert, an associative array
-	 * $uniqueIndexes is an array of indexes. Each element may be either a
-	 * field name or an array of field names
-	 *
-	 * It may be more efficient to leave off unique indexes which are unlikely to collide.
-	 * However if you do this, you run the risk of encountering errors which wouldn't have
-	 * occurred in MySQL.
-	 *
-	 * @param $table String: table name
-	 * @param $uniqueIndexes Array: array of indexes. Each element may be
-	 *                       either a field name or an array of field names
-	 * @param $rows Array: rows to insert to $table
-	 * @param $fname String: function name, you can use __METHOD__ here
-	 */
-	function replace( $table, $uniqueIndexes, $rows, $fname = 'DatabaseOracle::replace' ) {
-		$table = $this->tableName( $table );
-
-		if ( count( $rows ) == 0 ) {
-			return;
-		}
-
-		# Single row case
-		if ( !is_array( reset( $rows ) ) ) {
-			$rows = array( $rows );
-		}
-
-		$sequenceData = $this->getSequenceData( $table );
-
-		foreach ( $rows as $row ) {
-			# Delete rows which collide
-			if ( $uniqueIndexes ) {
-				$deleteConds = array();
-				foreach ( $uniqueIndexes as $key=>$index ) {
-					if ( is_array( $index ) ) {
-						$deleteConds2 = array();
-						foreach ( $index as $col ) {
-							$deleteConds2[$col] = $row[$col];
-						}
-						$deleteConds[$key] = $this->makeList( $deleteConds2, LIST_AND );
-					} else {
-						$deleteConds[$index] = $row[$index];
-					}
-				}
-				$deleteConds = array( $this->makeList( $deleteConds, LIST_OR ) );
-				$this->delete( $table, $deleteConds, $fname );
-			}
-
-			
-			if ( $sequenceData !== false && !isset( $row[$sequenceData['column']] ) ) {
-				$row[$sequenceData['column']] = $this->nextSequenceValue( $sequenceData['sequence'] );
-			}
-
-			# Now insert the row
-			$this->insert( $table, $row, $fname );
-		}
-	}
-
-	# DELETE where the condition is a join
-	function deleteJoin( $delTable, $joinTable, $delVar, $joinVar, $conds, $fname = 'DatabaseOracle::deleteJoin' ) {
-		if ( !$conds ) {
-			throw new DBUnexpectedError( $this, 'DatabaseOracle::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 );
-	}
-
 	# Returns the size of a text field, or -1 for "unlimited"
 	function textFieldSize( $table, $field ) {
 		$fieldInfoData = $this->fieldInfo( $table, $field );
@@ -849,26 +740,21 @@ class DatabaseOracle extends DatabaseBase {
 		return 'SELECT * ' . ( $all ? '':'/* UNION_UNIQUE */ ' ) . 'FROM (' . implode( $glue, $sqls ) . ')' ;
 	}
 
-	public function unixTimestamp( $field ) {
-		return "((trunc($field) - to_date('19700101','YYYYMMDD')) * 86400)";
-	}
-
 	function wasDeadlock() {
 		return $this->lastErrno() == 'OCI-00060';
 	}
 
 	function duplicateTableStructure( $oldName, $newName, $temporary = false, $fname = 'DatabaseOracle::duplicateTableStructure' ) {
-		global $wgDBprefix;
-		
 		$temporary = $temporary ? 'TRUE' : 'FALSE';
 
-		$newName = trim( strtoupper( $newName ), '"');
-		$oldName = trim( strtoupper( $oldName ), '"');
+		$newName = strtoupper( $newName );
+		$oldName = strtoupper( $oldName );
 
-		$tabName = substr( $newName, strlen( $wgDBprefix ) );
+		$tabName = substr( $newName, strlen( $this->mTablePrefix ) );
 		$oldPrefix = substr( $oldName, 0, strlen( $oldName ) - strlen( $tabName ) );
+		$newPrefix = strtoupper( $this->mTablePrefix );
 
-		return $this->doQuery( 'BEGIN DUPLICATE_TABLE(\'' . $tabName . '\', \'' . $oldPrefix . '\', \'' . strtoupper( $wgDBprefix ) . '\', ' . $temporary . '); END;' );
+		return $this->doQuery( "BEGIN DUPLICATE_TABLE( '$tabName', '$oldPrefix', '$newPrefix', $temporary ); END;" );
 	}
 
 	function listTables( $prefix = null, $fname = 'DatabaseOracle::listTables' ) {
@@ -876,8 +762,9 @@ class DatabaseOracle extends DatabaseBase {
 		if (!empty($prefix)) {
 			$listWhere = ' AND table_name LIKE \''.strtoupper($prefix).'%\'';
 		}
-		
-		$result = $this->doQuery( "SELECT table_name FROM user_tables WHERE table_name NOT LIKE '%!_IDX$_' ESCAPE '!' $listWhere" );
+
+		$owner = strtoupper( $this->mDBname );
+		$result = $this->doQuery( "SELECT table_name FROM all_tables WHERE owner='$owner' AND table_name NOT LIKE '%!_IDX\$_' ESCAPE '!' $listWhere" );
 
 		// dirty code ... i know
 		$endArray = array();
@@ -898,7 +785,7 @@ class DatabaseOracle extends DatabaseBase {
 		if( !$this->tableExists( $tableName ) ) {
 			return false;
 		}
-		
+
 		return $this->doQuery( "DROP TABLE $tableName CASCADE CONSTRAINTS PURGE" );
 	}
 
@@ -942,15 +829,35 @@ class DatabaseOracle extends DatabaseBase {
 		$rset = $this->doQuery( 'SELECT version FROM product_component_version WHERE UPPER(product) LIKE \'ORACLE DATABASE%\'' );
 		if ( !( $row =  $rset->fetchRow() ) ) {
 			return oci_server_version( $this->mConn );
-		} 
+		}
 		return $row['version'];
 	}
 
 	/**
+	 * Query whether a given index exists
+	 */
+	function indexExists( $table, $index, $fname = 'DatabaseOracle::indexExists' ) {
+		$table = $this->tableName( $table );
+		$table = strtoupper( $this->removeIdentifierQuotes( $table ) );
+		$index = strtoupper( $index );
+		$owner = strtoupper( $this->mDBname );
+		$SQL = "SELECT 1 FROM all_indexes WHERE owner='$owner' AND index_name='{$table}_{$index}'";
+		$res = $this->doQuery( $SQL );
+		if ( $res ) {
+			$count = $res->numRows();
+			$res->free();
+		} else {
+			$count = 0;
+		}
+		return $count != 0;
+	}
+
+	/**
 	 * Query whether a given table exists (in the given schema, or the default mw one if not given)
 	 */
 	function tableExists( $table ) {
-		$table = $this->addQuotes( trim( $this->tableName($table), '"' ) );
+		$table = $this->tableName( $table );
+		$table = $this->addQuotes( strtoupper( $this->removeIdentifierQuotes( $table ) ) );
 		$owner = $this->addQuotes( strtoupper( $this->mDBname ) );
 		$SQL = "SELECT 1 FROM all_tables WHERE owner=$owner AND table_name=$table";
 		$res = $this->doQuery( $SQL );
@@ -960,7 +867,7 @@ class DatabaseOracle extends DatabaseBase {
 		} else {
 			$count = 0;
 		}
-		return $count!=0;
+		return $count;
 	}
 
 	/**
@@ -971,6 +878,7 @@ class DatabaseOracle extends DatabaseBase {
 	 *
 	 * @param $table Array
 	 * @param $field String
+	 * @return ORAField|ORAResult
 	 */
 	private function fieldInfoMulti( $table, $field ) {
 		$field = strtoupper( $field );
@@ -978,7 +886,7 @@ class DatabaseOracle extends DatabaseBase {
 			$table = array_map( array( &$this, 'tableNameInternal' ), $table );
 			$tableWhere = 'IN (';
 			foreach( $table as &$singleTable ) {
-				$singleTable = strtoupper( trim( $singleTable, '"' ) );
+				$singleTable = $this->removeIdentifierQuotes($singleTable);
 				if ( isset( $this->mFieldInfoCache["$singleTable.$field"] ) ) {
 					return $this->mFieldInfoCache["$singleTable.$field"];
 				}
@@ -986,7 +894,7 @@ class DatabaseOracle extends DatabaseBase {
 			}
 			$tableWhere = rtrim( $tableWhere, ',' ) . ')';
 		} else {
-			$table = strtoupper( trim( $this->tableNameInternal( $table ), '"' ) );
+			$table = $this->removeIdentifierQuotes(  $this->tableNameInternal( $table ) );
 			if ( isset( $this->mFieldInfoCache["$table.$field"] ) ) {
 				return $this->mFieldInfoCache["$table.$field"];
 			}
@@ -1018,6 +926,12 @@ class DatabaseOracle extends DatabaseBase {
 		return $fieldInfoTemp;
 	}
 
+	/**
+	 * @throws DBUnexpectedError
+	 * @param  $table
+	 * @param  $field
+	 * @return ORAField
+	 */
 	function fieldInfo( $table, $field ) {
 		if ( is_array( $table ) ) {
 			throw new DBUnexpectedError( $this, 'DatabaseOracle::fieldInfo called with table array!' );
@@ -1027,12 +941,17 @@ class DatabaseOracle extends DatabaseBase {
 
 	function begin( $fname = 'DatabaseOracle::begin' ) {
 		$this->mTrxLevel = 1;
+		$this->doQuery( 'SET CONSTRAINTS ALL DEFERRED' );
 	}
 
 	function commit( $fname = 'DatabaseOracle::commit' ) {
 		if ( $this->mTrxLevel ) {
-			oci_commit( $this->mConn );
+			$ret = oci_commit( $this->mConn );
+			if ( !$ret ) {
+				throw new DBUnexpectedError( $this, $this->lastError() );
+			}
 			$this->mTrxLevel = 0;
+			$this->doQuery( 'SET CONSTRAINTS ALL IMMEDIATE' );
 		}
 	}
 
@@ -1040,6 +959,7 @@ class DatabaseOracle extends DatabaseBase {
 		if ( $this->mTrxLevel ) {
 			oci_rollback( $this->mConn );
 			$this->mTrxLevel = 0;
+			$this->doQuery( 'SET CONSTRAINTS ALL IMMEDIATE' );
 		}
 	}
 
@@ -1154,15 +1074,23 @@ class DatabaseOracle extends DatabaseBase {
 	}
 
 	public function addIdentifierQuotes( $s ) {
-		if ( !$this->mFlags & DBO_DDLMODE ) {
-			$s = '"' . str_replace( '"', '""', $s ) . '"';
+		if ( !$this->getFlag( DBO_DDLMODE ) ) {
+			$s = '/*Q*/' . $s;
 		}
 		return $s;
 	}
 
+	public function removeIdentifierQuotes( $s ) {
+		return strpos($s, '/*Q*/') === FALSE ? $s : substr($s, 5);
+	}
+
+	public function isQuotedIdentifier( $s ) {
+		return strpos($s, '/*Q*/') !== FALSE;
+	}
+
 	private function wrapFieldForWhere( $table, &$col, &$val ) {
 		global $wgContLang;
-		
+
 		$col_info = $this->fieldInfoMulti( $table, $col );
 		$col_type = $col_info != false ? $col_info->type() : 'CONSTANT';
 		if ( $col_type == 'CLOB' ) {
@@ -1244,20 +1172,38 @@ class DatabaseOracle extends DatabaseBase {
 		if ( is_array($conds) ) {
 			$conds = $this->wrapConditionsForWhere( $table, $conds );
 		}
+		// a hack for deleting pages, users and images (which have non-nullable FKs)
+		// all deletions on these tables have transactions so final failure rollbacks these updates
+		$table = $this->tableName( $table );
+		if ( $table == $this->tableName( 'page' ) ) {
+				$this->update( 'recentchanges', array( 'rc_cur_id' => 0 ), array( 'rc_cur_id' => $conds['page_id'] ), $fname );
+		} elseif ( $table == $this->tableName( 'user' )  ) {
+				$this->update( 'archive', array( 'ar_user' => 0 ), array( 'ar_user' => $conds['user_id'] ), $fname );
+				$this->update( 'ipblocks', array( 'ipb_user' => 0 ), array( 'ipb_user' => $conds['user_id'] ), $fname );
+				$this->update( 'image', array( 'img_user' => 0 ), array( 'img_user' => $conds['user_id'] ), $fname );
+				$this->update( 'oldimage', array( 'oi_user' => 0 ), array( 'oi_user' => $conds['user_id'] ), $fname );
+				$this->update( 'filearchive', array( 'fa_deleted_user' => 0 ), array( 'fa_deleted_user' => $conds['user_id'] ), $fname );
+				$this->update( 'filearchive', array( 'fa_user' => 0 ), array( 'fa_user' => $conds['user_id'] ), $fname );
+				$this->update( 'uploadstash', array( 'us_user' => 0 ), array( 'us_user' => $conds['user_id'] ), $fname );
+				$this->update( 'recentchanges', array( 'rc_user' => 0 ), array( 'rc_user' => $conds['user_id'] ), $fname );
+				$this->update( 'logging', array( 'log_user' => 0 ), array( 'log_user' => $conds['user_id'] ), $fname );
+		} elseif ( $table == $this->tableName( 'image' )  ) {
+				$this->update( 'oldimage', array( 'oi_name' => 0 ), array( 'oi_name' => $conds['img_name'] ), $fname );
+		}
 		return parent::delete( $table, $conds, $fname );
 	}
 
 	function update( $table, $values, $conds, $fname = 'DatabaseOracle::update', $options = array() ) {
 		global $wgContLang;
-		
+
 		$table = $this->tableName( $table );
 		$opts = $this->makeUpdateOptions( $options );
 		$sql = "UPDATE $opts $table SET ";
-		
+
 		$first = true;
 		foreach ( $values as $col => &$val ) {
 			$sqlSet = $this->fieldBindStatement( $table, $col, $val, true );
-			
+
 			if ( !$first ) {
 				$sqlSet = ', ' . $sqlSet;
 			} else {
@@ -1303,8 +1249,8 @@ class DatabaseOracle extends DatabaseBase {
 					throw new DBUnexpectedError( $this, "Cannot create LOB descriptor: " . $e['message'] );
 				}
 
-				if ( $col_type == 'BLOB' ) { 
-					$lob[$col]->writeTemporary( $val ); 
+				if ( $col_type == 'BLOB' ) {
+					$lob[$col]->writeTemporary( $val );
 					oci_bind_by_name( $stmt, ":$col", $lob[$col], - 1, SQLT_BLOB );
 				} else {
 					$lob[$col]->writeTemporary( $val );
diff --git a/includes/db/DatabasePostgres.php b/includes/db/DatabasePostgres.php
index bc71a9a5..742a8b51 100644
--- a/includes/db/DatabasePostgres.php
+++ b/includes/db/DatabasePostgres.php
@@ -9,8 +9,14 @@
 class PostgresField implements Field {
 	private $name, $tablename, $type, $nullable, $max_length, $deferred, $deferrable, $conname;
 
-	static function fromText($db, $table, $field) {
-	global $wgDBmwschema;
+	/**
+	 * @param $db DatabaseBase
+	 * @param  $table
+	 * @param  $field
+	 * @return null|PostgresField
+	 */
+	static function fromText( $db, $table, $field ) {
+		global $wgDBmwschema;
 
 		$q = <<<SQL
 SELECT
@@ -33,7 +39,7 @@ AND relname=%s
 AND attname=%s;
 SQL;
 
-		$table = $db->tableName( $table );
+		$table = $db->tableName( $table, false );
 		$res = $db->query(
 			sprintf( $q,
 				$db->addQuotes( $wgDBmwschema ),
@@ -137,10 +143,6 @@ class DatabasePostgres extends DatabaseBase {
 		return $this->numRows( $res );
 	}
 
-	static function newFromParams( $server, $user, $password, $dbName, $flags = 0 ) {
-		return new DatabasePostgres( $server, $user, $password, $dbName, $flags );
-	}
-
 	/**
 	 * Usually aborts on failure
 	 */
@@ -155,9 +157,10 @@ class DatabasePostgres extends DatabaseBase {
 		if ( !strlen( $user ) ) { # e.g. the class is being loaded
 			return;
 		}
+
 		$this->close();
 		$this->mServer = $server;
-		$this->mPort = $port = $wgDBport;
+		$port = $wgDBport;
 		$this->mUser = $user;
 		$this->mPassword = $password;
 		$this->mDBname = $dbName;
@@ -194,21 +197,34 @@ class DatabasePostgres extends DatabaseBase {
 			$this->doQuery( "SET client_min_messages = 'ERROR'" );
 		}
 
-		$this->doQuery( "SET client_encoding='UTF8'" );
+		$this->query( "SET client_encoding='UTF8'", __METHOD__ );
+		$this->query( "SET datestyle = 'ISO, YMD'", __METHOD__ );
+		$this->query( "SET timezone = 'GMT'", __METHOD__ );
 
-		global $wgDBmwschema, $wgDBts2schema;
-		if ( isset( $wgDBmwschema ) && isset( $wgDBts2schema )
-			&& $wgDBmwschema !== 'mediawiki'
-			&& preg_match( '/^\w+$/', $wgDBmwschema )
-			&& preg_match( '/^\w+$/', $wgDBts2schema )
-		) {
+		global $wgDBmwschema;
+		if ( $this->schemaExists( $wgDBmwschema ) ) {
 			$safeschema = $this->addIdentifierQuotes( $wgDBmwschema );
-			$this->doQuery( "SET search_path = $safeschema, $wgDBts2schema, public" );
+			$this->doQuery( "SET search_path = $safeschema" );
+		} else {
+			$this->doQuery( "SET search_path = public" );
 		}
 
 		return $this->mConn;
 	}
 
+	/**
+	 * Postgres doesn't support selectDB in the same way MySQL does. So if the
+	 * DB name doesn't match the open connection, open a new one
+	 * @return
+	 */
+	function selectDB( $db ) {
+		if ( $this->mDBname !== $db ) {
+			return (bool)$this->open( $this->mServer, $this->mUser, $this->mPassword, $db );
+		} else {
+			return true;
+		}
+	}
+
 	function makeConnectionString( $vars ) {
 		$s = '';
 		foreach ( $vars as $name => $value ) {
@@ -230,7 +246,7 @@ class DatabasePostgres extends DatabaseBase {
 		}
 	}
 
-	function doQuery( $sql ) {
+	protected function doQuery( $sql ) {
 		if ( function_exists( 'mb_convert_encoding' ) ) {
 			$sql = mb_convert_encoding( $sql, 'UTF-8' );
 		}
@@ -247,7 +263,10 @@ class DatabasePostgres extends DatabaseBase {
 		if ( $res instanceof ResultWrapper ) {
 			$res = $res->result;
 		}
-		if ( !@pg_free_result( $res ) ) {
+		wfSuppressWarnings();
+		$ok = pg_free_result( $res );
+		wfRestoreWarnings();
+		if ( !$ok ) {
 			throw new DBUnexpectedError( $this, "Unable to free Postgres result\n" );
 		}
 	}
@@ -256,11 +275,12 @@ class DatabasePostgres extends DatabaseBase {
 		if ( $res instanceof ResultWrapper ) {
 			$res = $res->result;
 		}
-		@$row = pg_fetch_object( $res );
-		# FIXME: HACK HACK HACK HACK debug
+		wfSuppressWarnings();
+		$row = pg_fetch_object( $res );
+		wfRestoreWarnings();
+		# @todo FIXME: HACK HACK HACK HACK debug
 
-		# TODO:
-		# hashar : not sure if the following test really trigger if the object
+		# @todo hashar: not sure if the following test really trigger if the object
 		#          fetching failed.
 		if( pg_last_error( $this->mConn ) ) {
 			throw new DBUnexpectedError( $this, 'SQL error: ' . htmlspecialchars( pg_last_error( $this->mConn ) ) );
@@ -272,7 +292,9 @@ class DatabasePostgres extends DatabaseBase {
 		if ( $res instanceof ResultWrapper ) {
 			$res = $res->result;
 		}
-		@$row = pg_fetch_array( $res );
+		wfSuppressWarnings();
+		$row = pg_fetch_array( $res );
+		wfRestoreWarnings();
 		if( pg_last_error( $this->mConn ) ) {
 			throw new DBUnexpectedError( $this, 'SQL error: ' . htmlspecialchars( pg_last_error( $this->mConn ) ) );
 		}
@@ -283,7 +305,9 @@ class DatabasePostgres extends DatabaseBase {
 		if ( $res instanceof ResultWrapper ) {
 			$res = $res->result;
 		}
-		@$n = pg_num_rows( $res );
+		wfSuppressWarnings();
+		$n = pg_num_rows( $res );
+		wfRestoreWarnings();
 		if( pg_last_error( $this->mConn ) ) {
 			throw new DBUnexpectedError( $this, 'SQL error: ' . htmlspecialchars( pg_last_error( $this->mConn ) ) );
 		}
@@ -529,7 +553,7 @@ class DatabasePostgres extends DatabaseBase {
 	 * Source items may be literals rather then field names, but strings should be quoted with Database::addQuotes()
 	 * $conds may be "*" to copy the whole table
 	 * srcTable may be an array of tables.
-	 * @todo FIXME: implement this a little better (seperate select/insert)?
+	 * @todo FIXME: Implement this a little better (seperate select/insert)?
 	 */
 	function insertSelect( $destTable, $srcTable, $varMap, $conds, $fname = 'DatabasePostgres::insertSelect',
 		$insertOptions = array(), $selectOptions = array() )
@@ -598,7 +622,7 @@ class DatabasePostgres extends DatabaseBase {
 		return $res;
 	}
 
-	function tableName( $name ) {
+	function tableName( $name, $quoted = true ) {
 		# Replace reserved words with better ones
 		switch( $name ) {
 			case 'user':
@@ -606,7 +630,7 @@ class DatabasePostgres extends DatabaseBase {
 			case 'text':
 				return 'pagecontent';
 			default:
-				return $name;
+				return parent::tableName( $name, $quoted );
 		}
 	}
 
@@ -632,83 +656,6 @@ class DatabasePostgres extends DatabaseBase {
 		return $currval;
 	}
 
-	/**
-	 * REPLACE query wrapper
-	 * Postgres simulates this with a DELETE followed by INSERT
-	 * $row is the row to insert, an associative array
-	 * $uniqueIndexes is an array of indexes. Each element may be either a
-	 * field name or an array of field names
-	 *
-	 * It may be more efficient to leave off unique indexes which are unlikely to collide.
-	 * However if you do this, you run the risk of encountering errors which wouldn't have
-	 * occurred in MySQL
-	 */
-	function replace( $table, $uniqueIndexes, $rows, $fname = 'DatabasePostgres::replace' ) {
-		$table = $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 $table 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
-			$sql = "INSERT INTO $table (" . $this->makeList( array_keys( $row ), LIST_NAMES ) .') VALUES (' .
-				$this->makeList( $row, LIST_COMMA ) . ')';
-			$this->query( $sql, $fname );
-		}
-	}
-
-	# DELETE where the condition is a join
-	function deleteJoin( $delTable, $joinTable, $delVar, $joinVar, $conds, $fname = 'DatabasePostgres::deleteJoin' ) {
-		if ( !$conds ) {
-			throw new DBUnexpectedError( $this, 'DatabasePostgres::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 );
-	}
-
 	# Returns the size of a text field, or -1 for "unlimited"
 	function textFieldSize( $table, $field ) {
 		$table = $this->tableName( $table );
@@ -735,6 +682,8 @@ class DatabasePostgres extends DatabaseBase {
 	}
 
 	function duplicateTableStructure( $oldName, $newName, $temporary = false, $fname = 'DatabasePostgres::duplicateTableStructure' ) {
+		$newName = $this->addIdentifierQuotes( $newName );
+		$oldName = $this->addIdentifierQuotes( $oldName );
 		return $this->query( 'CREATE ' . ( $temporary ? 'TEMPORARY ' : '' ) . " TABLE $newName (LIKE $oldName INCLUDING DEFAULTS)", $fname );
 	}
 
@@ -788,6 +737,7 @@ class DatabasePostgres extends DatabaseBase {
 		if ( !$schema ) {
 			$schema = $wgDBmwschema;
 		}
+		$table = $this->tableName( $table, false );
 		$etable = $this->addQuotes( $table );
 		$eschema = $this->addQuotes( $schema );
 		$SQL = "SELECT 1 FROM pg_catalog.pg_class c, pg_catalog.pg_namespace n "
@@ -899,6 +849,10 @@ SQL;
 		return $sql;
 	}
 
+	/**
+	 * @param $b
+	 * @return Blob
+	 */
 	function encodeBlob( $b ) {
 		return new Blob( pg_escape_bytea( $this->mConn, $b ) );
 	}
@@ -914,6 +868,10 @@ SQL;
 		return pg_escape_string( $this->mConn, $s );
 	}
 
+	/**
+	 * @param $s null|bool|Blob
+	 * @return int|string
+	 */
 	function addQuotes( $s ) {
 		if ( is_null( $s ) ) {
 			return 'NULL';
@@ -971,13 +929,21 @@ SQL;
 		}
 
 		if ( isset( $options['GROUP BY'] ) ) {
-			$preLimitTail .= ' GROUP BY ' . $options['GROUP BY'];
+			$gb = is_array( $options['GROUP BY'] )
+				? implode( ',', $options['GROUP BY'] )
+				: $options['GROUP BY'];
+			$preLimitTail .= " GROUP BY {$gb}";
 		}
+
 		if ( isset( $options['HAVING'] ) ) {
 			$preLimitTail .= " HAVING {$options['HAVING']}";
 		}
+
 		if ( isset( $options['ORDER BY'] ) ) {
-			$preLimitTail .= ' ORDER BY ' . $options['ORDER BY'];
+			$ob = is_array( $options['ORDER BY'] )
+				? implode( ',', $options['ORDER BY'] )
+				: $options['ORDER BY'];
+			$preLimitTail .= " ORDER BY {$ob}";
 		}
 
 		//if ( isset( $options['LIMIT'] ) ) {
diff --git a/includes/db/DatabaseSqlite.php b/includes/db/DatabaseSqlite.php
index 503ebdf6..e298175d 100644
--- a/includes/db/DatabaseSqlite.php
+++ b/includes/db/DatabaseSqlite.php
@@ -20,8 +20,18 @@ class DatabaseSqlite extends DatabaseBase {
 	var $mName;
 
 	/**
+	 * @var PDO
+	 */
+	protected $mConn;
+
+	/**
 	 * Constructor.
 	 * Parameters $server, $user and $password are not used.
+	 * @param $server string
+	 * @param $user string
+	 * @param $password string
+	 * @param $dbName string
+	 * @param $flags int
 	 */
 	function __construct( $server = false, $user = false, $password = false, $dbName = false, $flags = 0 ) {
 		$this->mName = $dbName;
@@ -35,21 +45,31 @@ class DatabaseSqlite extends DatabaseBase {
 		}
 	}
 
+	/**
+	 * @return string
+	 */
 	function getType() {
 		return 'sqlite';
 	}
 
 	/**
 	 * @todo: check if it should be true like parent class
+	 *
+	 * @return bool
 	 */
-	function implicitGroupby()   { return false; }
-
-	static function newFromParams( $server, $user, $password, $dbName, $flags = 0 ) {
-		return new DatabaseSqlite( $server, $user, $password, $dbName, $flags );
+	function implicitGroupby() {
+		return false;
 	}
 
 	/** Open an SQLite database and return a resource handle to it
 	 *  NOTE: only $dbName is used, the other parameters are irrelevant for SQLite databases
+	 *
+	 * @param $server
+	 * @param $user
+	 * @param $pass
+	 * @param $dbName
+	 *
+	 * @return PDO
 	 */
 	function open( $server, $user, $pass, $dbName ) {
 		global $wgSQLiteDataDir;
@@ -65,7 +85,10 @@ class DatabaseSqlite extends DatabaseBase {
 
 	/**
 	 * Opens a database file
-	 * @return SQL connection or false if failed
+	 *
+	 * @param $fileName string
+	 *
+	 * @return PDO|false SQL connection or false if failed
 	 */
 	function openFile( $fileName ) {
 		$this->mDatabaseFile = $fileName;
@@ -93,6 +116,8 @@ class DatabaseSqlite extends DatabaseBase {
 
 	/**
 	 * Close an SQLite database
+	 *
+	 * @return bool
 	 */
 	function close() {
 		$this->mOpened = false;
@@ -115,7 +140,7 @@ class DatabaseSqlite extends DatabaseBase {
 
 	/**
 	 * Check if the searchindext table is FTS enabled.
-	 * @returns false if not enabled.
+	 * @return false if not enabled.
 	 */
 	function checkForEnabledSearch() {
 		if ( self::$fulltextEnabled === null ) {
@@ -154,9 +179,12 @@ class DatabaseSqlite extends DatabaseBase {
 	/**
 	 * Attaches external database to our connection, see http://sqlite.org/lang_attach.html
 	 * for details.
+	 *
 	 * @param $name String: database name to be used in queries like SELECT foo FROM dbname.table
 	 * @param $file String: database file name. If omitted, will be generated using $name and $wgSQLiteDataDir
 	 * @param $fname String: calling function name
+	 *
+	 * @return ResultWrapper
 	 */
 	function attachDatabase( $name, $file = false, $fname = 'DatabaseSqlite::attachDatabase' ) {
 		global $wgSQLiteDataDir;
@@ -169,6 +197,10 @@ class DatabaseSqlite extends DatabaseBase {
 
 	/**
 	 * @see DatabaseBase::isWriteQuery()
+	 *
+	 * @param $sql string
+	 *
+	 * @return bool
 	 */
 	function isWriteQuery( $sql ) {
 		return parent::isWriteQuery( $sql ) && !preg_match( '/^ATTACH\b/i', $sql );
@@ -176,8 +208,12 @@ class DatabaseSqlite extends DatabaseBase {
 
 	/**
 	 * SQLite doesn't allow buffered results or data seeking etc, so we'll use fetchAll as the result
+	 *
+	 * @param $sql string
+	 *
+	 * @return ResultWrapper
 	 */
-	function doQuery( $sql ) {
+	protected function doQuery( $sql ) {
 		$res = $this->mConn->query( $sql );
 		if ( $res === false ) {
 			return false;
@@ -189,6 +225,9 @@ class DatabaseSqlite extends DatabaseBase {
 		return $res;
 	}
 
+	/**
+	 * @param $res ResultWrapper
+	 */
 	function freeResult( $res ) {
 		if ( $res instanceof ResultWrapper ) {
 			$res->result = null;
@@ -197,6 +236,10 @@ class DatabaseSqlite extends DatabaseBase {
 		}
 	}
 
+	/**
+	 * @param $res ResultWrapper
+	 * @return
+	 */
 	function fetchObject( $res ) {
 		if ( $res instanceof ResultWrapper ) {
 			$r =& $res->result;
@@ -219,6 +262,10 @@ class DatabaseSqlite extends DatabaseBase {
 		return false;
 	}
 
+	/**
+	 * @param $res ResultWrapper
+	 * @return bool|mixed
+	 */
 	function fetchRow( $res ) {
 		if ( $res instanceof ResultWrapper ) {
 			$r =& $res->result;
@@ -235,37 +282,60 @@ class DatabaseSqlite extends DatabaseBase {
 
 	/**
 	 * The PDO::Statement class implements the array interface so count() will work
+	 *
+	 * @param $res ResultWrapper
+	 *
+	 * @return int
 	 */
 	function numRows( $res ) {
 		$r = $res instanceof ResultWrapper ? $res->result : $res;
 		return count( $r );
 	}
 
+	/**
+	 * @param $res ResultWrapper
+	 * @return int
+	 */
 	function numFields( $res ) {
 		$r = $res instanceof ResultWrapper ? $res->result : $res;
 		return is_array( $r ) ? count( $r[0] ) : 0;
 	}
 
+	/**
+	 * @param $res ResultWrapper
+	 * @param $n 
+	 * @return bool
+	 */
 	function fieldName( $res, $n ) {
 		$r = $res instanceof ResultWrapper ? $res->result : $res;
 		if ( is_array( $r ) ) {
 			$keys = array_keys( $r[0] );
 			return $keys[$n];
 		}
-		return  false;
+		return false;
 	}
 
 	/**
 	 * Use MySQL's naming (accounts for prefix etc) but remove surrounding backticks
+	 *
+	 * @param $name
+	 * @param bool $quoted
+	 * @return string
 	 */
-	function tableName( $name ) {
+	function tableName( $name, $quoted = true ) {
 		// table names starting with sqlite_ are reserved
-		if ( strpos( $name, 'sqlite_' ) === 0 ) return $name;
-		return str_replace( '`', '', parent::tableName( $name ) );
+		if ( strpos( $name, 'sqlite_' ) === 0 ) {
+			return $name;
+		}
+		return str_replace( '"', '', parent::tableName( $name, $quoted ) );
 	}
 
 	/**
 	 * Index names have DB scope
+	 *
+	 * @param $index string
+	 *
+	 * @return string
 	 */
 	function indexName( $index ) {
 		return $index;
@@ -273,11 +343,17 @@ class DatabaseSqlite extends DatabaseBase {
 
 	/**
 	 * This must be called after nextSequenceVal
+	 *
+	 * @return int
 	 */
 	function insertId() {
 		return $this->mConn->lastInsertId();
 	}
 
+	/**
+	 * @param $res ResultWrapper
+	 * @param $row
+	 */
 	function dataSeek( $res, $row ) {
 		if ( $res instanceof ResultWrapper ) {
 			$r =& $res->result;
@@ -292,6 +368,9 @@ class DatabaseSqlite extends DatabaseBase {
 		}
 	}
 
+	/**
+	 * @return string
+	 */
 	function lastError() {
 		if ( !is_object( $this->mConn ) ) {
 			return "Cannot return last error, no db connection";
@@ -300,6 +379,9 @@ class DatabaseSqlite extends DatabaseBase {
 		return isset( $e[2] ) ? $e[2] : '';
 	}
 
+	/**
+	 * @return string
+	 */
 	function lastErrno() {
 		if ( !is_object( $this->mConn ) ) {
 			return "Cannot return last error, no db connection";
@@ -309,6 +391,9 @@ class DatabaseSqlite extends DatabaseBase {
 		}
 	}
 
+	/**
+	 * @return int
+	 */
 	function affectedRows() {
 		return $this->mAffectedRows;
 	}
@@ -317,6 +402,8 @@ class DatabaseSqlite extends DatabaseBase {
 	 * Returns information about an index
 	 * Returns false if the index does not exist
 	 * - if errors are explicitly ignored, returns NULL on failure
+	 *
+	 * @return array
 	 */
 	function indexInfo( $table, $index, $fname = 'DatabaseSqlite::indexExists' ) {
 		$sql = 'PRAGMA index_info(' . $this->addQuotes( $this->indexName( $index ) ) . ')';
@@ -334,6 +421,12 @@ class DatabaseSqlite extends DatabaseBase {
 		return $info;
 	}
 
+	/**
+	 * @param $table
+	 * @param $index
+	 * @param $fname string
+	 * @return bool|null
+	 */
 	function indexUnique( $table, $index, $fname = 'DatabaseSqlite::indexUnique' ) {
 		$row = $this->selectRow( 'sqlite_master', '*',
 			array(
@@ -356,6 +449,10 @@ class DatabaseSqlite extends DatabaseBase {
 
 	/**
 	 * Filter the options used in SELECT statements
+	 *
+	 * @param $options array
+	 *
+	 * @return array
 	 */
 	function makeSelectOptions( $options ) {
 		foreach ( $options as $k => $v ) {
@@ -367,22 +464,44 @@ class DatabaseSqlite extends DatabaseBase {
 	}
 
 	/**
-	 * Based on generic method (parent) with some prior SQLite-sepcific adjustments
+	 * @param $options array
+	 * @return string
 	 */
-	function insert( $table, $a, $fname = 'DatabaseSqlite::insert', $options = array() ) {
-		if ( !count( $a ) ) {
-			return true;
-		}
-		if ( !is_array( $options ) ) {
-			$options = array( $options );
-		}
+	function makeUpdateOptions( $options ) {
+		$options = self::fixIgnore( $options );
+		return parent::makeUpdateOptions( $options );
+	}
 
+	/**
+	 * @param $options array
+	 * @return array
+	 */
+	static function fixIgnore( $options ) {
 		# SQLite uses OR IGNORE not just IGNORE
 		foreach ( $options as $k => $v ) {
 			if ( $v == 'IGNORE' ) {
 				$options[$k] = 'OR IGNORE';
 			}
 		}
+		return $options;
+	}
+
+	/**
+	 * @param $options array
+	 * @return string
+	 */
+	function makeInsertOptions( $options ) {
+		$options = self::fixIgnore( $options );
+		return parent::makeInsertOptions( $options );
+	}
+
+	/**
+	 * Based on generic method (parent) with some prior SQLite-sepcific adjustments
+	 */
+	function insert( $table, $a, $fname = 'DatabaseSqlite::insert', $options = array() ) {
+		if ( !count( $a ) ) {
+			return true;
+		}
 
 		# SQLite can't handle multi-row inserts, so divide up into multiple single-row inserts
 		if ( isset( $a[0] ) && is_array( $a[0] ) ) {
@@ -399,6 +518,13 @@ class DatabaseSqlite extends DatabaseBase {
 		return $ret;
 	}
 
+	/**
+	 * @param $table
+	 * @param $uniqueIndexes
+	 * @param $rows
+	 * @param $fname string
+	 * @return bool|ResultWrapper
+	 */
 	function replace( $table, $uniqueIndexes, $rows, $fname = 'DatabaseSqlite::replace' ) {
 		if ( !count( $rows ) ) return true;
 
@@ -406,12 +532,12 @@ class DatabaseSqlite extends DatabaseBase {
 		if ( isset( $rows[0] ) && is_array( $rows[0] ) ) {
 			$ret = true;
 			foreach ( $rows as $v ) {
-				if ( !parent::replace( $table, $uniqueIndexes, $v, "$fname/multi-row" ) ) {
+				if ( !$this->nativeReplace( $table, $v, "$fname/multi-row" ) ) {
 					$ret = false;
 				}
 			}
 		} else {
-			$ret = parent::replace( $table, $uniqueIndexes, $rows, "$fname/single-row" );
+			$ret = $this->nativeReplace( $table, $rows, "$fname/single-row" );
 		}
 
 		return $ret;
@@ -420,32 +546,47 @@ class DatabaseSqlite extends DatabaseBase {
 	/**
 	 * Returns the size of a text field, or -1 for "unlimited"
 	 * In SQLite this is SQLITE_MAX_LENGTH, by default 1GB. No way to query it though.
+	 *
+	 * @return int
 	 */
 	function textFieldSize( $table, $field ) {
-		return - 1;
+		return -1;
 	}
 
+	/**
+	 * @return bool
+	 */
 	function unionSupportsOrderAndLimit() {
 		return false;
 	}
 
+	/**
+	 * @param $sqls
+	 * @param $all
+	 * @return string
+	 */
 	function unionQueries( $sqls, $all ) {
 		$glue = $all ? ' UNION ALL ' : ' UNION ';
 		return implode( $glue, $sqls );
 	}
 
-	public function unixTimestamp( $field ) {
-		return $field;
-	}
-
+	/**
+	 * @return bool
+	 */
 	function wasDeadlock() {
 		return $this->lastErrno() == 5; // SQLITE_BUSY
 	}
 
+	/**
+	 * @return bool
+	 */
 	function wasErrorReissuable() {
 		return $this->lastErrno() ==  17; // SQLITE_SCHEMA;
 	}
 
+	/**
+	 * @return bool
+	 */
 	function wasReadOnlyError() {
 		return $this->lastErrno() == 8; // SQLITE_READONLY;
 	}
@@ -475,6 +616,8 @@ class DatabaseSqlite extends DatabaseBase {
 	/**
 	 * Get information about a given field
 	 * Returns false if the field does not exist.
+	 *
+	 * @return SQLiteField|false
 	 */
 	function fieldInfo( $table, $field ) {
 		$tableName = $this->tableName( $table );
@@ -489,35 +632,58 @@ class DatabaseSqlite extends DatabaseBase {
 	}
 
 	function begin( $fname = '' ) {
-		if ( $this->mTrxLevel == 1 ) $this->commit();
+		if ( $this->mTrxLevel == 1 ) {
+			$this->commit();
+		}
 		$this->mConn->beginTransaction();
 		$this->mTrxLevel = 1;
 	}
 
 	function commit( $fname = '' ) {
-		if ( $this->mTrxLevel == 0 ) return;
+		if ( $this->mTrxLevel == 0 ) {
+			return;
+		}
 		$this->mConn->commit();
 		$this->mTrxLevel = 0;
 	}
 
 	function rollback( $fname = '' ) {
-		if ( $this->mTrxLevel == 0 ) return;
+		if ( $this->mTrxLevel == 0 ) {
+			return;
+		}
 		$this->mConn->rollBack();
 		$this->mTrxLevel = 0;
 	}
 
+	/**
+	 * @param  $sql
+	 * @param  $num
+	 * @return string
+	 */
 	function limitResultForUpdate( $sql, $num ) {
 		return $this->limitResult( $sql, $num );
 	}
 
+	/**
+	 * @param $s string
+	 * @return string
+	 */
 	function strencode( $s ) {
 		return substr( $this->addQuotes( $s ), 1, - 1 );
 	}
 
+	/**
+	 * @param $b
+	 * @return Blob
+	 */
 	function encodeBlob( $b ) {
 		return new Blob( $b );
 	}
 
+	/**
+	 * @param $b Blob|string
+	 * @return string
+	 */
 	function decodeBlob( $b ) {
 		if ( $b instanceof Blob ) {
 			$b = $b->fetch();
@@ -525,6 +691,10 @@ class DatabaseSqlite extends DatabaseBase {
 		return $b;
 	}
 
+	/**
+	 * @param $s Blob|string
+	 * @return string
+	 */
 	function addQuotes( $s ) {
 		if ( $s instanceof Blob ) {
 			return "x'" . bin2hex( $s->fetch() ) . "'";
@@ -533,6 +703,9 @@ class DatabaseSqlite extends DatabaseBase {
 		}
 	}
 
+	/**
+	 * @return string
+	 */
 	function buildLike() {
 		$params = func_get_args();
 		if ( count( $params ) > 0 && is_array( $params[0] ) ) {
@@ -541,6 +714,9 @@ class DatabaseSqlite extends DatabaseBase {
 		return parent::buildLike( $params ) . "ESCAPE '\' ";
 	}
 
+	/**
+	 * @return string
+	 */
 	public function getSearchEngine() {
 		return "SearchSqlite";
 	}
@@ -554,6 +730,10 @@ class DatabaseSqlite extends DatabaseBase {
 		return call_user_func_array( $function, $args );
 	}
 
+	/**
+	 * @param $s string
+	 * @return string
+	 */
 	protected function replaceVars( $s ) {
 		$s = parent::replaceVars( $s );
 		if ( preg_match( '/^\s*(CREATE|ALTER) TABLE/i', $s ) ) {
@@ -596,23 +776,75 @@ class DatabaseSqlite extends DatabaseBase {
 		return $s;
 	}
 
-	/*
+	/**
 	 * Build a concatenation list to feed into a SQL query
+	 *
+	 * @param $stringList array
+	 *
+	 * @return string
 	 */
 	function buildConcat( $stringList ) {
 		return '(' . implode( ') || (', $stringList ) . ')';
 	}
 
+	/**
+	 * @throws MWException
+	 * @param $oldName
+	 * @param $newName
+	 * @param $temporary bool
+	 * @param $fname string
+	 * @return bool|ResultWrapper
+	 */
 	function duplicateTableStructure( $oldName, $newName, $temporary = false, $fname = 'DatabaseSqlite::duplicateTableStructure' ) {
-		$res = $this->query( "SELECT sql FROM sqlite_master WHERE tbl_name='$oldName' AND type='table'", $fname );
+		$res = $this->query( "SELECT sql FROM sqlite_master WHERE tbl_name=" . $this->addQuotes( $oldName ) . " AND type='table'", $fname );
 		$obj = $this->fetchObject( $res );
 		if ( !$obj ) {
 			throw new MWException( "Couldn't retrieve structure for table $oldName" );
 		}
 		$sql = $obj->sql;
-		$sql = preg_replace( '/\b' . preg_quote( $oldName ) . '\b/', $newName, $sql, 1 );
+		$sql = preg_replace( '/(?<=\W)"?' . preg_quote( trim( $this->addIdentifierQuotes( $oldName ), '"' ) ) . '"?(?=\W)/', $this->addIdentifierQuotes( $newName ), $sql, 1 );
+		if ( $temporary ) {
+			if ( preg_match( '/^\\s*CREATE\\s+VIRTUAL\\s+TABLE\b/i', $sql ) ) {
+				wfDebug( "Table $oldName is virtual, can't create a temporary duplicate.\n" );
+			} else {
+				$sql = str_replace( 'CREATE TABLE', 'CREATE TEMPORARY TABLE', $sql );
+			}
+		}
 		return $this->query( $sql, $fname );
 	}
+	
+	
+	/**
+	 * List all tables on the database
+	 *
+	 * @param $prefix Only show tables with this prefix, e.g. mw_
+	 * @param $fname String: calling function name
+	 *
+	 * @return array
+	 */
+	function listTables( $prefix = null, $fname = 'DatabaseSqlite::listTables' ) {
+		$result = $this->select(
+			'sqlite_master',
+			'name',
+			"type='table'"
+		);
+		
+		$endArray = array();
+		
+		foreach( $result as $table ) {	
+			$vars = get_object_vars($table);
+			$table = array_pop( $vars );
+			
+			if( !$prefix || strpos( $table, $prefix ) === 0 ) {
+				if ( strpos( $table, 'sqlite_' ) !== 0 ) {
+					$endArray[] = $table;
+				}
+				
+			}
+		}
+		
+		return $endArray;
+	}
 
 } // end DatabaseSqlite class
 
@@ -656,6 +888,9 @@ class SQLiteField implements Field {
 		return $this->info->dflt_value;
 	}
 
+	/**
+	 * @return bool
+	 */
 	function isNullable() {
 		return !$this->info->notnull;
 	}
diff --git a/includes/db/DatabaseUtility.php b/includes/db/DatabaseUtility.php
new file mode 100644
index 00000000..d1bced6b
--- /dev/null
+++ b/includes/db/DatabaseUtility.php
@@ -0,0 +1,268 @@
+<?php
+/**
+ * Utility class.
+ * @ingroup Database
+ */
+class DBObject {
+	public $mData;
+
+	function __construct( $data ) {
+		$this->mData = $data;
+	}
+
+	function isLOB() {
+		return false;
+	}
+
+	function data() {
+		return $this->mData;
+	}
+}
+
+/**
+ * Utility class
+ * @ingroup Database
+ *
+ * This allows us to distinguish a blob from a normal string and an array of strings
+ */
+class Blob {
+	private $mData;
+
+	function __construct( $data ) {
+		$this->mData = $data;
+	}
+
+	function fetch() {
+		return $this->mData;
+	}
+}
+
+/**
+ * Base for all database-specific classes representing information about database fields
+ * @ingroup Database
+ */
+interface Field {
+	/**
+	 * Field name
+	 * @return string
+	 */
+	function name();
+
+	/**
+	 * Name of table this field belongs to
+	 * @return string
+	 */
+	function tableName();
+
+	/**
+	 * Database type
+	 * @return string
+	 */
+	function type();
+
+	/**
+	 * Whether this field can store NULL values
+	 * @return bool
+	 */
+	function isNullable();
+}
+
+/**
+ * Result wrapper for grabbing data queried by someone else
+ * @ingroup Database
+ */
+class ResultWrapper implements Iterator {
+	var $db, $result, $pos = 0, $currentRow = null;
+
+	/**
+	 * Create a new result object from a result resource and a Database object
+	 *
+	 * @param DatabaseBase $database
+	 * @param resource $result
+	 */
+	function __construct( $database, $result ) {
+		$this->db = $database;
+
+		if ( $result instanceof ResultWrapper ) {
+			$this->result = $result->result;
+		} else {
+			$this->result = $result;
+		}
+	}
+
+	/**
+	 * Get the number of rows in a result object
+	 *
+	 * @return integer
+	 */
+	function numRows() {
+		return $this->db->numRows( $this );
+	}
+
+	/**
+	 * Fetch the next row from the given result object, in object form.
+	 * Fields can be retrieved with $row->fieldname, with fields acting like
+	 * member variables.
+	 *
+	 * @return object
+	 * @throws DBUnexpectedError Thrown if the database returns an error
+	 */
+	function fetchObject() {
+		return $this->db->fetchObject( $this );
+	}
+
+	/**
+	 * Fetch the next row from the given result object, in associative array
+	 * form.  Fields are retrieved with $row['fieldname'].
+	 *
+	 * @return Array
+	 * @throws DBUnexpectedError Thrown if the database returns an error
+	 */
+	function fetchRow() {
+		return $this->db->fetchRow( $this );
+	}
+
+	/**
+	 * Free a result object
+	 */
+	function free() {
+		$this->db->freeResult( $this );
+		unset( $this->result );
+		unset( $this->db );
+	}
+
+	/**
+	 * Change the position of the cursor in a result object.
+	 * See mysql_data_seek()
+	 *
+	 * @param $row integer
+	 */
+	function seek( $row ) {
+		$this->db->dataSeek( $this, $row );
+	}
+
+	/*********************
+	 * Iterator functions
+	 * Note that using these in combination with the non-iterator functions
+	 * above may cause rows to be skipped or repeated.
+	 */
+
+	function rewind() {
+		if ( $this->numRows() ) {
+			$this->db->dataSeek( $this, 0 );
+		}
+		$this->pos = 0;
+		$this->currentRow = null;
+	}
+
+	function current() {
+		if ( is_null( $this->currentRow ) ) {
+			$this->next();
+		}
+		return $this->currentRow;
+	}
+
+	function key() {
+		return $this->pos;
+	}
+
+	function next() {
+		$this->pos++;
+		$this->currentRow = $this->fetchObject();
+		return $this->currentRow;
+	}
+
+	function valid() {
+		return $this->current() !== false;
+	}
+}
+
+/**
+ * Overloads the relevant methods of the real ResultsWrapper so it
+ * doesn't go anywhere near an actual database.
+ */
+class FakeResultWrapper extends ResultWrapper {
+	var $result     = array();
+	var $db         = null;	// And it's going to stay that way :D
+	var $pos        = 0;
+	var $currentRow = null;
+
+	function __construct( $array ) {
+		$this->result = $array;
+	}
+
+	/**
+	 * @return int
+	 */
+	function numRows() {
+		return count( $this->result );
+	}
+
+	function fetchRow() {
+		if ( $this->pos < count( $this->result ) ) {
+			$this->currentRow = $this->result[$this->pos];
+		} else {
+			$this->currentRow = false;
+		}
+		$this->pos++;
+		return $this->currentRow;
+	}
+
+	function seek( $row ) {
+		$this->pos = $row;
+	}
+
+	function free() {}
+
+	// Callers want to be able to access fields with $this->fieldName
+	function fetchObject() {
+		$this->fetchRow();
+		if ( $this->currentRow ) {
+			return (object)$this->currentRow;
+		} else {
+			return false;
+		}
+	}
+
+	function rewind() {
+		$this->pos = 0;
+		$this->currentRow = null;
+	}
+
+	function next() {
+		return $this->fetchObject();
+	}
+}
+
+/**
+ * Used by DatabaseBase::buildLike() to represent characters that have special meaning in SQL LIKE clauses
+ * and thus need no escaping. Don't instantiate it manually, use DatabaseBase::anyChar() and anyString() instead.
+ */
+class LikeMatch {
+	private $str;
+
+	/**
+	 * Store a string into a LikeMatch marker object.
+	 *
+	 * @param String $s
+	 */
+	public function __construct( $s ) {
+		$this->str = $s;
+	}
+
+	/**
+	 * Return the original stored string.
+	 *
+	 * @return String
+	 */
+	public function toString() {
+		return $this->str;
+	}
+}
+
+/**
+ * An object representing a master or slave position in a replicated setup.
+ */
+interface DBMasterPos {
+}
+
diff --git a/includes/db/LBFactory.php b/includes/db/LBFactory.php
index f84a70e5..22a84960 100644
--- a/includes/db/LBFactory.php
+++ b/includes/db/LBFactory.php
@@ -11,6 +11,10 @@
  * @ingroup Database
  */
 abstract class LBFactory {
+
+	/**
+	 * @var LBFactory
+	 */
 	static $instance;
 
 	/**
@@ -23,15 +27,9 @@ abstract class LBFactory {
 	}
 
 	/**
-	 * Resets the singleton for use if it's been disabled. Does nothing otherwise
-	 */
-	public static function enableBackend() {
-		if( self::$instance instanceof LBFactory_Fake )
-			self::$instance = null;
-	}
-
-	/**
 	 * Get an LBFactory instance
+	 *
+	 * @return LBFactory
 	 */
 	static function &singleton() {
 		if ( is_null( self::$instance ) ) {
@@ -56,6 +54,8 @@ abstract class LBFactory {
 
 	/**
 	 * Set the instance to be the given object
+	 *
+	 * @param $instance LBFactory
 	 */
 	static function setInstance( $instance ) {
 		self::destroyInstance();
@@ -84,21 +84,25 @@ abstract class LBFactory {
 	 */
 	abstract function getMainLB( $wiki = false );
 
-	/*
+	/**
 	 * Create a new load balancer for external storage. The resulting object will be
 	 * untracked, not chronology-protected, and the caller is responsible for
 	 * cleaning it up.
 	 *
 	 * @param $cluster String: external storage cluster, or false for core
 	 * @param $wiki String: wiki ID, or false for the current wiki
+	 *
+	 * @return LoadBalancer
 	 */
 	abstract function newExternalLB( $cluster, $wiki = false );
 
-	/*
+	/**
 	 * Get a cached (tracked) load balancer for external storage
 	 *
 	 * @param $cluster String: external storage cluster, or false for core
 	 * @param $wiki String: wiki ID, or false for the current wiki
+	 *
+	 * @return LoadBalancer
 	 */
 	abstract function &getExternalLB( $cluster, $wiki = false );
 
@@ -141,6 +145,10 @@ abstract class LBFactory {
  * A simple single-master LBFactory that gets its configuration from the b/c globals
  */
 class LBFactory_Simple extends LBFactory {
+
+	/**
+	 * @var LoadBalancer
+	 */
 	var $mainLB;
 	var $extLBs = array();
 
@@ -151,6 +159,10 @@ class LBFactory_Simple extends LBFactory {
 		$this->chronProt = new ChronologyProtector;
 	}
 
+	/**
+	 * @param $wiki
+	 * @return LoadBalancer
+	 */
 	function newMainLB( $wiki = false ) {
 		global $wgDBservers, $wgMasterWaitTimeout;
 		if ( $wgDBservers ) {
@@ -174,6 +186,10 @@ class LBFactory_Simple extends LBFactory {
 		));
 	}
 
+	/**
+	 * @param $wiki
+	 * @return LoadBalancer
+	 */
 	function getMainLB( $wiki = false ) {
 		if ( !isset( $this->mainLB ) ) {
 			$this->mainLB = $this->newMainLB( $wiki );
@@ -183,6 +199,12 @@ class LBFactory_Simple extends LBFactory {
 		return $this->mainLB;
 	}
 
+	/**
+	 * @throws MWException
+	 * @param $cluster
+	 * @param $wiki
+	 * @return LoadBalancer
+	 */
 	function newExternalLB( $cluster, $wiki = false ) {
 		global $wgExternalServers;
 		if ( !isset( $wgExternalServers[$cluster] ) ) {
@@ -193,6 +215,11 @@ class LBFactory_Simple extends LBFactory {
 		));
 	}
 
+	/**
+	 * @param $cluster
+	 * @param $wiki
+	 * @return array
+	 */
 	function &getExternalLB( $cluster, $wiki = false ) {
 		if ( !isset( $this->extLBs[$cluster] ) ) {
 			$this->extLBs[$cluster] = $this->newExternalLB( $cluster, $wiki );
diff --git a/includes/db/LBFactory_Multi.php b/includes/db/LBFactory_Multi.php
index 0d411ec6..61e56e78 100644
--- a/includes/db/LBFactory_Multi.php
+++ b/includes/db/LBFactory_Multi.php
@@ -98,6 +98,10 @@ class LBFactory_Multi extends LBFactory {
 		return $section;
 	}
 
+	/**
+	 * @param $wiki string
+	 * @return LoadBalancer
+	 */
 	function newMainLB( $wiki = false ) {
 		list( $dbName, ) = $this->getDBNameAndPrefix( $wiki );
 		$section = $this->getSectionForWiki( $wiki );
@@ -111,6 +115,10 @@ class LBFactory_Multi extends LBFactory {
 		return $this->newLoadBalancer( $this->serverTemplate, $this->sectionLoads[$section], $groupLoads );
 	}
 
+	/**
+	 * @param $wiki
+	 * @return LoadBalancer
+	 */
 	function getMainLB( $wiki = false ) {
 		$section = $this->getSectionForWiki( $wiki );
 		if ( !isset( $this->mainLBs[$section] ) ) {
@@ -122,6 +130,11 @@ class LBFactory_Multi extends LBFactory {
 		return $this->mainLBs[$section];
 	}
 
+	/**
+	 * @param $cluster
+	 * @param $wiki
+	 * @return LoadBalancer
+	 */
 	function newExternalLB( $cluster, $wiki = false ) {
 		if ( !isset( $this->externalLoads[$cluster] ) ) {
 			throw new MWException( __METHOD__.": Unknown cluster \"$cluster\"" );
@@ -136,6 +149,11 @@ class LBFactory_Multi extends LBFactory {
 		return $this->newLoadBalancer( $template, $this->externalLoads[$cluster], array() );
 	}
 
+	/**
+	 * @param $cluster
+	 * @param $wiki
+	 * @return LoadBalancer
+	 */
 	function &getExternalLB( $cluster, $wiki = false ) {
 		if ( !isset( $this->extLBs[$cluster] ) ) {
 			$this->extLBs[$cluster] = $this->newExternalLB( $cluster, $wiki );
@@ -146,6 +164,8 @@ class LBFactory_Multi extends LBFactory {
 
 	/**
 	 * Make a new load balancer object based on template and load array
+	 *
+	 * @return LoadBalancer
 	 */
 	function newLoadBalancer( $template, $loads, $groupLoads ) {
 		global $wgMasterWaitTimeout;
@@ -159,6 +179,8 @@ class LBFactory_Multi extends LBFactory {
 
 	/**
 	 * Make a server array as expected by LoadBalancer::__construct, using a template and load array
+	 *
+	 * @return array
 	 */
 	function makeServerArray( $template, $loads, $groupLoads ) {
 		$servers = array();
diff --git a/includes/db/LBFactory_Single.php b/includes/db/LBFactory_Single.php
index 25acdc5b..89b41321 100644
--- a/includes/db/LBFactory_Single.php
+++ b/includes/db/LBFactory_Single.php
@@ -7,29 +7,55 @@ class LBFactory_Single extends LBFactory {
 	protected $lb;
 
 	/**
-	 * @param $conf An associative array with one member:
+	 * @param $conf array An associative array with one member:
 	 *  - connection: The DatabaseBase connection object
 	 */
 	function __construct( $conf ) {
 		$this->lb = new LoadBalancer_Single( $conf );
 	}
 
+	/**
+	 * @param $wiki
+	 *
+	 * @return LoadBalancer_Single
+	 */
 	function newMainLB( $wiki = false ) {
 		return $this->lb;
 	}
 
+	/**
+	 * @param $wiki
+	 *
+	 * @return LoadBalancer_Single
+	 */
 	function getMainLB( $wiki = false ) {
 		return $this->lb;
 	}
 
+	/**
+	 * @param $cluster
+	 * @param $wiki
+	 *
+	 * @return LoadBalancer_Single
+	 */
 	function newExternalLB( $cluster, $wiki = false ) {
 		return $this->lb;
 	}
 
+	/**
+	 * @param $cluster
+	 * @param $wiki
+	 *
+	 * @return LoadBalancer_Single
+	 */
 	function &getExternalLB( $cluster, $wiki = false ) {
 		return $this->lb;
 	}
 
+	/**
+	 * @param $callback string|array
+	 * @param $params array
+	 */
 	function forEachLB( $callback, $params = array() ) {
 		call_user_func_array( $callback, array_merge( array( $this->lb ), $params ) );
 	}
@@ -39,8 +65,15 @@ class LBFactory_Single extends LBFactory {
  * Helper class for LBFactory_Single.
  */
 class LoadBalancer_Single extends LoadBalancer {
+
+	/**
+	 * @var DatabaseBase
+	 */
 	var $db;
 
+	/**
+	 * @param $params array
+	 */
 	function __construct( $params ) {
 		$this->db = $params['connection'];
 		parent::__construct( array( 'servers' => array( array(
@@ -51,6 +84,13 @@ class LoadBalancer_Single extends LoadBalancer {
 		) ) ) );
 	}
 
+	/**
+	 *
+	 * @param $server string
+	 * @param $dbNameOverride bool
+	 *
+	 * @return DatabaseBase
+	 */
 	function reallyOpenConnection( $server, $dbNameOverride = false ) {
 		return $this->db;
 	}
diff --git a/includes/db/LoadBalancer.php b/includes/db/LoadBalancer.php
index d899ce07..c7210c4c 100644
--- a/includes/db/LoadBalancer.php
+++ b/includes/db/LoadBalancer.php
@@ -13,13 +13,13 @@
  * @ingroup Database
  */
 class LoadBalancer {
-	/* private */ var $mServers, $mConns, $mLoads, $mGroupLoads;
-	/* private */ var $mErrorConnection;
-	/* private */ var $mReadIndex, $mAllowLagged;
-	/* private */ var $mWaitForPos, $mWaitTimeout;
-	/* private */ var $mLaggedSlaveMode, $mLastError = 'Unknown error';
-	/* private */ var $mParentInfo, $mLagTimes;
-	/* private */ var $mLoadMonitorClass, $mLoadMonitor;
+	private $mServers, $mConns, $mLoads, $mGroupLoads;
+	private $mErrorConnection;
+	private $mReadIndex, $mAllowLagged;
+	private $mWaitForPos, $mWaitTimeout;
+	private $mLaggedSlaveMode, $mLastError = 'Unknown error';
+	private $mParentInfo, $mLagTimes;
+	private $mLoadMonitorClass, $mLoadMonitor;
 
 	/**
 	 * @param $params Array with keys:
@@ -27,8 +27,7 @@ class LoadBalancer {
 	 *    masterWaitTimeout Replication lag wait timeout
 	 *    loadMonitor       Name of a class used to fetch server lag and load.
 	 */
-	function __construct( $params )
-	{
+	function __construct( $params ) {
 		if ( !isset( $params['servers'] ) ) {
 			throw new MWException( __CLASS__.': missing servers parameter' );
 		}
@@ -51,8 +50,17 @@ class LoadBalancer {
 		$this->mLaggedSlaveMode = false;
 		$this->mErrorConnection = false;
 		$this->mAllowLagged = false;
-		$this->mLoadMonitorClass = isset( $params['loadMonitor'] ) 
-			? $params['loadMonitor'] : 'LoadMonitor_MySQL';
+
+		if ( isset( $params['loadMonitor'] ) ) {
+			$this->mLoadMonitorClass = $params['loadMonitor'];
+		} else {
+			$master = reset( $params['servers'] );
+			if ( isset( $master['type'] ) && $master['type'] === 'mysql' ) {
+				$this->mLoadMonitorClass = 'LoadMonitor_MySQL';
+			} else {
+				$this->mLoadMonitorClass = 'LoadMonitor_Null';
+			}
+		}
 
 		foreach( $params['servers'] as $i => $server ) {
 			$this->mLoads[$i] = $server['load'];
@@ -69,6 +77,8 @@ class LoadBalancer {
 
 	/**
 	 * Get a LoadMonitor instance
+	 *
+	 * @return LoadMonitor
 	 */
 	function getLoadMonitor() {
 		if ( !isset( $this->mLoadMonitor ) ) {
@@ -88,9 +98,12 @@ class LoadBalancer {
 	/**
 	 * Given an array of non-normalised probabilities, this function will select
 	 * an element and return the appropriate key
+	 *
+	 * @param $weights
+	 *
+	 * @return int
 	 */
-	function pickRandom( $weights )
-	{
+	function pickRandom( $weights ) {
 		if ( !is_array( $weights ) || count( $weights ) == 0 ) {
 			return false;
 		}
@@ -116,6 +129,11 @@ class LoadBalancer {
 		return $i;
 	}
 
+	/**
+	 * @param $loads
+	 * @param $wiki bool
+	 * @return bool|int|string
+	 */
 	function getRandomNonLagged( $loads, $wiki = false ) {
 		# Unset excessively lagged servers
 		$lags = $this->getLagTimes( $wiki );
@@ -160,11 +178,14 @@ class LoadBalancer {
 	 * always return a consistent index during a given invocation
 	 *
 	 * Side effect: opens connections to databases
+	 * @param $group bool
+	 * @param $wiki bool
+	 * @return bool|int|string
 	 */
 	function getReaderIndex( $group = false, $wiki = false ) {
 		global $wgReadOnly, $wgDBClusterTimeout, $wgDBAvgStatusPoll, $wgDBtype;
 
-		# FIXME: For now, only go through all this for mysql databases
+		# @todo FIXME: For now, only go through all this for mysql databases
 		if ($wgDBtype != 'mysql') {
 			return $this->getWriterIndex();
 		}
@@ -220,7 +241,7 @@ class LoadBalancer {
 					$i = $this->getRandomNonLagged( $currentLoads, $wiki );
 					if ( $i === false && count( $currentLoads ) != 0 )  {
 						# All slaves lagged. Switch to read-only mode
-						$wgReadOnly = 'The database has been automatically locked ' . 
+						$wgReadOnly = 'The database has been automatically locked ' .
 							'while the slave database servers catch up to the master';
 						$i = $this->pickRandom( $currentLoads );
 						$laggedSlaveMode = true;
@@ -229,7 +250,7 @@ class LoadBalancer {
 
 				if ( $i === false ) {
 					# pickRandom() returned false
-					# This is permanent and means the configuration or the load monitor 
+					# This is permanent and means the configuration or the load monitor
 					# wants us to return false.
 					wfDebugLog( 'connect', __METHOD__.": pickRandom() returned false\n" );
 					wfProfileOut( __METHOD__ );
@@ -247,7 +268,7 @@ class LoadBalancer {
 				}
 
 				// Perform post-connection backoff
-				$threshold = isset( $this->mServers[$i]['max threads'] ) 
+				$threshold = isset( $this->mServers[$i]['max threads'] )
 					? $this->mServers[$i]['max threads'] : false;
 				$backoff = $this->getLoadMonitor()->postConnectionBackoff( $conn, $threshold );
 
@@ -256,7 +277,7 @@ class LoadBalancer {
 				if ( $wiki !== false ) {
 					$this->reuseConnection( $conn );
 				}
-				
+
 				if ( $backoff ) {
 					# Post-connection overload, don't use this server for now
 					$totalThreadsConnected += $backoff;
@@ -339,7 +360,7 @@ class LoadBalancer {
 		}
 		wfProfileOut( __METHOD__ );
 	}
-	
+
 	/**
 	 * Set the master wait position and wait for ALL slaves to catch up to it
 	 */
@@ -347,7 +368,7 @@ class LoadBalancer {
 		wfProfileIn( __METHOD__ );
 		$this->mWaitForPos = $pos;
 		for ( $i = 1; $i < count( $this->mServers ); $i++ ) {
-			$this->doWait( $i );
+			$this->doWait( $i , true );
 		}
 		wfProfileOut( __METHOD__ );
 	}
@@ -355,6 +376,8 @@ class LoadBalancer {
 	/**
 	 * Get any open connection to a given server index, local or foreign
 	 * Returns false if there is no connection open
+	 *
+	 * @return DatabaseBase
 	 */
 	function getAnyOpenConnection( $i ) {
 		foreach ( $this->mConns as $conns ) {
@@ -368,12 +391,20 @@ class LoadBalancer {
 	/**
 	 * Wait for a given slave to catch up to the master pos stored in $this
 	 */
-	function doWait( $index ) {
+	function doWait( $index, $open = false ) {
 		# Find a connection to wait on
 		$conn = $this->getAnyOpenConnection( $index );
 		if ( !$conn ) {
-			wfDebug( __METHOD__ . ": no connection open\n" );
-			return false;
+			if ( !$open ) {
+				wfDebug( __METHOD__ . ": no connection open\n" );
+				return false;
+			} else {
+				$conn = $this->openConnection( $index );
+				if ( !$conn ) {
+					wfDebug( __METHOD__ . ": failed to open connection\n" );
+					return false;
+				}
+			}
 		}
 
 		wfDebug( __METHOD__.": Waiting for slave #$index to catch up...\n" );
@@ -392,11 +423,11 @@ class LoadBalancer {
 	/**
 	 * Get a connection by index
 	 * This is the main entry point for this class.
-	 * 
+	 *
 	 * @param $i Integer: server index
 	 * @param $groups Array: query groups
 	 * @param $wiki String: wiki ID
-	 * 
+	 *
 	 * @return DatabaseBase
 	 */
 	public function &getConnection( $i, $groups = array(), $wiki = false ) {
@@ -460,6 +491,8 @@ class LoadBalancer {
 	 * Mark a foreign connection as being available for reuse under a different
 	 * DB name or prefix. This mechanism is reference-counted, and must be called
 	 * the same number of times as getConnection() to work.
+	 *
+	 * @param DatabaseBase $conn
 	 */
 	public function reuseConnection( $conn ) {
 		$serverIndex = $conn->getLBInfo('serverIndex');
@@ -506,8 +539,8 @@ class LoadBalancer {
 	 * On error, returns false, and the connection which caused the
 	 * error will be available via $this->mErrorConnection.
 	 *
-	 * @param $i Integer: server index
-	 * @param $wiki String: wiki ID to open
+	 * @param $i Integer server index
+	 * @param $wiki String wiki ID to open
 	 * @return DatabaseBase
 	 *
 	 * @access private
@@ -615,6 +648,7 @@ class LoadBalancer {
 	 *
 	 * @param $index Integer: server index
 	 * @access private
+	 * @return bool
 	 */
 	function isOpen( $index ) {
 		if( !is_integer( $index ) ) {
@@ -627,10 +661,13 @@ class LoadBalancer {
 	 * Really opens a connection. Uncached.
 	 * Returns a Database object whether or not the connection was successful.
 	 * @access private
+	 *
+	 * @return DatabaseBase
 	 */
 	function reallyOpenConnection( $server, $dbNameOverride = false ) {
 		if( !is_array( $server ) ) {
-			throw new MWException( 'You must update your load-balancing configuration. See DefaultSettings.php entry for $wgDBservers.' );
+			throw new MWException( 'You must update your load-balancing configuration. ' .
+			                       'See DefaultSettings.php entry for $wgDBservers.' );
 		}
 
 		$host = $server['host'];
@@ -643,12 +680,13 @@ class LoadBalancer {
 		# Create object
 		wfDebug( "Connecting to $host $dbname...\n" );
 		try {
-			$db = DatabaseBase::newFromType( $server['type'], $server );
+			$db = DatabaseBase::factory( $server['type'], $server );
 		} catch ( DBConnectionError $e ) {
-			// FIXME: This is probably the ugliest thing I have ever done to 
+			// FIXME: This is probably the ugliest thing I have ever done to
 			// PHP. I'm half-expecting it to segfault, just out of disgust. -- TS
 			$db = $e->db;
 		}
+
 		if ( $db->isOpen() ) {
 			wfDebug( "Connected to $host $dbname.\n" );
 		} else {
@@ -669,7 +707,7 @@ class LoadBalancer {
 
 		if ( !is_object( $conn ) ) {
 			// No last connection, probably due to all servers being too busy
-			wfLogDBError( "LB failure with no last connection\n" );
+			wfLogDBError( "LB failure with no last connection. Connection error: {$this->mLastError}\n" );
 			$conn = new Database;
 			// If all servers were busy, mLastError will contain something sensible
 			throw new DBConnectionError( $conn, $this->mLastError );
@@ -687,6 +725,8 @@ class LoadBalancer {
 
 	/**
 	 * Returns true if the specified index is a valid server index
+	 *
+	 * @return bool
 	 */
 	function haveIndex( $i ) {
 		return array_key_exists( $i, $this->mServers );
@@ -694,6 +734,8 @@ class LoadBalancer {
 
 	/**
 	 * Returns true if the specified index is valid and has non-zero load
+	 *
+	 * @return bool
 	 */
 	function isNonZeroLoad( $i ) {
 		return array_key_exists( $i, $this->mServers ) && $this->mLoads[$i] != 0;
@@ -701,6 +743,8 @@ class LoadBalancer {
 
 	/**
 	 * Get the number of defined servers (not the number of open connections)
+	 *
+	 * @return int
 	 */
 	function getServerCount() {
 		return count( $this->mServers );
@@ -732,6 +776,13 @@ class LoadBalancer {
 	}
 
 	/**
+	 * Sets the server info structure for the given index. Entry at index $i is created if it doesn't exist
+	 */
+	function setServerInfo( $i, $serverInfo ) {
+		$this->mServers[$i] = $serverInfo;
+	}
+
+	/**
 	 * Get the current master position for chronology control purposes
 	 * @return mixed
 	 */
@@ -774,6 +825,8 @@ class LoadBalancer {
 
 	/**
 	 * Deprecated function, typo in function name
+	 *
+	 * @deprecated in 1.18
 	 */
 	function closeConnecton( $conn ) {
 		$this->closeConnection( $conn );
@@ -783,7 +836,7 @@ class LoadBalancer {
 	 * Close a connection
 	 * Using this function makes sure the LoadBalancer knows the connection is closed.
 	 * If you use $conn->close() directly, the load balancer won't update its state.
-	 * @param  $conn
+	 * @param $conn
 	 * @return void
 	 */
 	function closeConnection( $conn ) {
@@ -818,7 +871,9 @@ class LoadBalancer {
 		}
 	}
 
-	/* Issue COMMIT only on master, only if queries were done on connection */
+	/**
+	 *  Issue COMMIT only on master, only if queries were done on connection
+	 */
 	function commitMasterChanges() {
 		// Always 0, but who knows.. :)
 		$masterIndex = $this->getWriterIndex();
@@ -843,10 +898,11 @@ class LoadBalancer {
 	}
 
 	/* Disables/enables lag checks */
-	function allowLagged($mode=null) {
-		if ($mode===null)
+	function allowLagged( $mode = null ) {
+		if ( $mode === null) {
 			return $this->mAllowLagged;
-		$this->mAllowLagged=$mode;
+		}
+		$this->mAllowLagged = $mode;
 	}
 
 	function pingAll() {
@@ -880,47 +936,84 @@ class LoadBalancer {
 	/**
 	 * Get the hostname and lag time of the most-lagged slave.
 	 * This is useful for maintenance scripts that need to throttle their updates.
-	 * May attempt to open connections to slaves on the default DB.
+	 * May attempt to open connections to slaves on the default DB. If there is 
+	 * no lag, the maximum lag will be reported as -1.
+	 *
 	 * @param $wiki string Wiki ID, or false for the default database
+	 *
+	 * @return array ( host, max lag, index of max lagged host )
 	 */
 	function getMaxLag( $wiki = false ) {
 		$maxLag = -1;
 		$host = '';
-		foreach ( $this->mServers as $i => $conn ) {
-			$conn = false;
-			if ( $wiki === false ) {
-				$conn = $this->getAnyOpenConnection( $i );
-			}
-			if ( !$conn ) {
-				$conn = $this->openConnection( $i, $wiki );
-			}
-			if ( !$conn ) {
-				continue;
-			}
-			$lag = $conn->getLag();
-			if ( $lag > $maxLag ) {
-				$maxLag = $lag;
-				$host = $this->mServers[$i]['host'];
+		$maxIndex = 0;
+		if ( $this->getServerCount() > 1 ) { // no replication = no lag
+			foreach ( $this->mServers as $i => $conn ) {
+				$conn = false;
+				if ( $wiki === false ) {
+					$conn = $this->getAnyOpenConnection( $i );
+				}
+				if ( !$conn ) {
+					$conn = $this->openConnection( $i, $wiki );
+				}
+				if ( !$conn ) {
+					continue;
+				}
+				$lag = $conn->getLag();
+				if ( $lag > $maxLag ) {
+					$maxLag = $lag;
+					$host = $this->mServers[$i]['host'];
+					$maxIndex = $i;
+				}
 			}
 		}
-		return array( $host, $maxLag );
+		return array( $host, $maxLag, $maxIndex );
 	}
 
 	/**
 	 * Get lag time for each server
 	 * Results are cached for a short time in memcached, and indefinitely in the process cache
+	 *
+	 * @param $wiki
+	 *
+	 * @return array
 	 */
 	function getLagTimes( $wiki = false ) {
 		# Try process cache
 		if ( isset( $this->mLagTimes ) ) {
 			return $this->mLagTimes;
 		}
-		# No, send the request to the load monitor
-		$this->mLagTimes = $this->getLoadMonitor()->getLagTimes( array_keys( $this->mServers ), $wiki );
+		if ( $this->getServerCount() == 1 ) {
+			# No replication
+			$this->mLagTimes = array( 0 => 0 );
+		} else {
+			# Send the request to the load monitor
+			$this->mLagTimes = $this->getLoadMonitor()->getLagTimes( 
+				array_keys( $this->mServers ), $wiki );
+		}
 		return $this->mLagTimes;
 	}
 
 	/**
+	 * Get the lag in seconds for a given connection, or zero if this load 
+	 * balancer does not have replication enabled. 
+	 *
+	 * This should be used in preference to Database::getLag() in cases where 
+	 * replication may not be in use, since there is no way to determine if 
+	 * replication is in use at the connection level without running 
+	 * potentially restricted queries such as SHOW SLAVE STATUS. Using this
+	 * function instead of Database::getLag() avoids a fatal error in this
+	 * case on many installations.
+	 */
+	function safeGetLag( $conn ) {
+		if ( $this->getServerCount() == 1 ) {
+			return 0;
+		} else {
+			return $conn->getLag();
+		}
+	}
+
+	/**
 	 * Clear the cache for getLagTimes
 	 */
 	function clearLagTimeCache() {
diff --git a/includes/db/LoadMonitor.php b/includes/db/LoadMonitor.php
index 9b959728..a6370c9e 100644
--- a/includes/db/LoadMonitor.php
+++ b/includes/db/LoadMonitor.php
@@ -14,12 +14,14 @@
 interface LoadMonitor {
 	/**
 	 * Construct a new LoadMonitor with a given LoadBalancer parent
+	 *
+	 * @param LoadBalancer $parent
 	 */
 	function __construct( $parent );
-	
+
 	/**
 	 * Perform pre-connection load ratio adjustment.
-	 * @param $loads Array
+	 * @param $loads array
 	 * @param $group String: the selected query group
 	 * @param $wiki String
 	 */
@@ -28,13 +30,13 @@ interface LoadMonitor {
 	/**
 	 * Perform post-connection backoff.
 	 *
-	 * If the connection is in overload, this should return a backoff factor 
-	 * which will be used to control polling time. The number of threads 
+	 * If the connection is in overload, this should return a backoff factor
+	 * which will be used to control polling time. The number of threads
 	 * connected is a good measure.
 	 *
 	 * If there is no overload, zero can be returned.
 	 *
-	 * A threshold thread count is given, the concrete class may compare this 
+	 * A threshold thread count is given, the concrete class may compare this
 	 * to the running thread count. The threshold may be false, which indicates
 	 * that the sysadmin has not configured this feature.
 	 *
@@ -45,10 +47,30 @@ interface LoadMonitor {
 
 	/**
 	 * Return an estimate of replication lag for each server
+	 *
+	 * @param $serverIndexes
+	 * @param $wiki
+	 *
+	 * @return array
 	 */
 	function getLagTimes( $serverIndexes, $wiki );
 }
 
+class LoadMonitor_Null implements LoadMonitor {
+	function __construct( $parent ) {
+	}
+
+	function scaleLoads( &$loads, $group = false, $wiki = false ) {
+	}
+
+	function postConnectionBackoff( $conn, $threshold ) {
+	}
+
+	function getLagTimes( $serverIndexes, $wiki ) {
+		return array_fill_keys( $serverIndexes, 0 );
+	}
+}
+
 
 /**
  * Basic MySQL load monitor with no external dependencies
@@ -57,16 +79,38 @@ interface LoadMonitor {
  * @ingroup Database
  */
 class LoadMonitor_MySQL implements LoadMonitor {
-	var $parent; // LoadBalancer
 
+	/**
+	 * @var LoadBalancer
+	 */
+	var $parent;
+
+	/**
+	 * @param LoadBalancer $parent
+	 */
 	function __construct( $parent ) {
 		$this->parent = $parent;
 	}
 
+	/**
+	 * @param $loads
+	 * @param $group bool
+	 * @param $wiki bool
+	 */
 	function scaleLoads( &$loads, $group = false, $wiki = false ) {
 	}
 
+	/**
+	 * @param $serverIndexes
+	 * @param $wiki
+	 * @return array
+	 */
 	function getLagTimes( $serverIndexes, $wiki ) {
+		if ( count( $serverIndexes ) == 1 && reset( $serverIndexes ) == 0 ) {
+			// Single server only, just return zero without caching
+			return array( 0 => 0 );
+		}
+
 		wfProfileIn( __METHOD__ );
 		$expiry = 5;
 		$requestRate = 10;
@@ -74,7 +118,7 @@ class LoadMonitor_MySQL implements LoadMonitor {
 		global $wgMemc;
 		if ( empty( $wgMemc ) )
 			$wgMemc = wfGetMainCache();
-		
+
 		$masterName = $this->parent->getServerName( 0 );
 		$memcKey = wfMemcKey( 'lag_times', $masterName );
 		$times = $wgMemc->get( $memcKey );
@@ -117,12 +161,19 @@ class LoadMonitor_MySQL implements LoadMonitor {
 		return $lagTimes;
 	}
 
+	/**
+	 * @param $conn DatabaseBase
+	 * @param $threshold
+	 * @return int
+	 */
 	function postConnectionBackoff( $conn, $threshold ) {
 		if ( !$threshold ) {
 			return 0;
 		}
-		$status = $conn->getStatus("Thread%");
+		$status = $conn->getMysqlStatus("Thread%");
 		if ( $status['Threads_running'] > $threshold ) {
+			$server = $conn->getProperty( 'mServer' );
+			wfLogDBError( "LB backoff from $server - Threads_running = {$status['Threads_running']}\n" );
 			return $status['Threads_connected'];
 		} else {
 			return 0;