From: Aaron Schulz <aschulz@wikimedia.org>
Date: Tue, 5 Jan 2016 23:27:44 +0000 (-0800)
Subject: Remove redundant DatabaseBase doc comments
X-Git-Tag: 1.31.0-rc.0~8433^2
X-Git-Url: http://git.cyclocoop.org/%22%20.%20generer_url_aide%28?a=commitdiff_plain;h=75c09d9b31e42b2858183c74f6268bb48544e813;p=lhc%2Fweb%2Fwiklou.git

Remove redundant DatabaseBase doc comments

Change-Id: I7f65d46dd05c6d9f72ec2e11ebba11f0b0854983
---

diff --git a/includes/db/Database.php b/includes/db/Database.php
index 3fec522d66..37c9d6f574 100644
--- a/includes/db/Database.php
+++ b/includes/db/Database.php
@@ -166,13 +166,6 @@ abstract class DatabaseBase implements IDatabase {
 	/** @var TransactionProfiler */
 	protected $trxProfiler;
 
-	/**
-	 * A string describing the current software version, and possibly
-	 * other details in a user-friendly way. Will be listed on Special:Version, etc.
-	 * Use getServerVersion() to get machine-friendly information.
-	 *
-	 * @return string Version information from the database server
-	 */
 	public function getServerInfo() {
 		return $this->getServerVersion();
 	}
@@ -197,27 +190,6 @@ abstract class DatabaseBase implements IDatabase {
 		return wfSetBit( $this->mFlags, DBO_DEBUG, $debug );
 	}
 
-	/**
-	 * 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 null|bool $buffer
-	 * @return null|bool The previous value of the flag
-	 */
 	public function bufferResults( $buffer = null ) {
 		if ( is_null( $buffer ) ) {
 			return !(bool)( $this->mFlags & DBO_NOBUFFER );
@@ -242,45 +214,18 @@ abstract class DatabaseBase implements IDatabase {
 		return wfSetBit( $this->mFlags, DBO_IGNORE, $ignoreErrors );
 	}
 
-	/**
-	 * Gets the current transaction level.
-	 *
-	 * Historically, transactions were allowed to be "nested". This is no
-	 * longer supported, so this function really only returns a boolean.
-	 *
-	 * @return int The previous value
-	 */
 	public function trxLevel() {
 		return $this->mTrxLevel;
 	}
 
-	/**
-	 * Get the UNIX timestamp of the time that the transaction was established
-	 *
-	 * This can be used to reason about the staleness of SELECT data
-	 * in REPEATABLE-READ transaction isolation level.
-	 *
-	 * @return float|null Returns null if there is not active transaction
-	 * @since 1.25
-	 */
 	public function trxTimestamp() {
 		return $this->mTrxLevel ? $this->mTrxTimestamp : null;
 	}
 
-	/**
-	 * Get/set the table prefix.
-	 * @param string $prefix The table prefix to set, or omitted to leave it unchanged.
-	 * @return string The previous table prefix.
-	 */
 	public function tablePrefix( $prefix = null ) {
 		return wfSetVar( $this->mTablePrefix, $prefix );
 	}
 
-	/**
-	 * Get/set the db schema.
-	 * @param string $schema The database schema to set, or omitted to leave it unchanged.
-	 * @return string The previous db schema.
-	 */
 	public function dbSchema( $schema = null ) {
 		return wfSetVar( $this->mSchema, $schema );
 	}
@@ -294,15 +239,6 @@ abstract class DatabaseBase implements IDatabase {
 		$this->fileHandle = $fh;
 	}
 
-	/**
-	 * Get properties passed down from the server info array of the load
-	 * balancer.
-	 *
-	 * @param string $name The entry of the info array to get, or null to get the
-	 *   whole array
-	 *
-	 * @return array|mixed|null
-	 */
 	public function getLBInfo( $name = null ) {
 		if ( is_null( $name ) ) {
 			return $this->mLBInfo;
@@ -315,14 +251,6 @@ abstract class DatabaseBase implements IDatabase {
 		}
 	}
 
-	/**
-	 * 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 string $name
-	 * @param array $value
-	 */
 	public function setLBInfo( $name, $value = null ) {
 		if ( is_null( $value ) ) {
 			$this->mLBInfo = $name;
@@ -396,21 +324,10 @@ abstract class DatabaseBase implements IDatabase {
 		return false;
 	}
 
-	/**
-	 * Returns true if this database does an implicit sort when doing GROUP BY
-	 *
-	 * @return bool
-	 */
 	public function implicitGroupby() {
 		return true;
 	}
 
-	/**
-	 * Returns true if this database does an implicit order by when the column has an index
-	 * For example: SELECT page_title FROM page LIMIT 1
-	 *
-	 * @return bool
-	 */
 	public function implicitOrderby() {
 		return true;
 	}
@@ -434,132 +351,52 @@ abstract class DatabaseBase implements IDatabase {
 		return false;
 	}
 
-	/**
-	 * Return the last query that went through DatabaseBase::query()
-	 * @return string
-	 */
 	public function lastQuery() {
 		return $this->mLastQuery;
 	}
 
-	/**
-	 * Returns true if the connection may have been used for write queries.
-	 * Should return true if unsure.
-	 *
-	 * @return bool
-	 */
 	public function doneWrites() {
 		return (bool)$this->mDoneWrites;
 	}
 
-	/**
-	 * Returns the last time the connection may have been used for write queries.
-	 * Should return a timestamp if unsure.
-	 *
-	 * @return int|float UNIX timestamp or false
-	 * @since 1.24
-	 */
 	public function lastDoneWrites() {
 		return $this->mDoneWrites ?: false;
 	}
 
-	/**
-	 * @return bool Whether there is a transaction open with possible write queries
-	 * @since 1.27
-	 */
 	public function writesPending() {
 		return $this->mTrxLevel && $this->mTrxDoneWrites;
 	}
 
-	/**
-	 * Returns true if there is a transaction open with possible write
-	 * queries or transaction pre-commit/idle callbacks waiting on it to finish.
-	 *
-	 * @return bool
-	 */
 	public function writesOrCallbacksPending() {
 		return $this->mTrxLevel && (
 			$this->mTrxDoneWrites || $this->mTrxIdleCallbacks || $this->mTrxPreCommitCallbacks
 		);
 	}
 
-	/**
-	 * Get the time spend running write queries for this
-	 *
-	 * High times could be due to scanning, updates, locking, and such
-	 *
-	 * @return float|bool Returns false if not transaction is active
-	 * @since 1.26
-	 */
 	public function pendingWriteQueryDuration() {
 		return $this->mTrxLevel ? $this->mTrxWriteDuration : false;
 	}
 
-	/**
-	 * Is a connection to the database open?
-	 * @return bool
-	 */
 	public function isOpen() {
 		return $this->mOpened;
 	}
 
-	/**
-	 * Set a flag for this connection
-	 *
-	 * @param int $flag DBO_* constants from Defines.php:
-	 *   - DBO_DEBUG: output some debug info (same as debug())
-	 *   - DBO_NOBUFFER: don't buffer results (inverse of bufferResults())
-	 *   - DBO_TRX: automatically start transactions
-	 *   - DBO_DEFAULT: automatically sets DBO_TRX if not in command line mode
-	 *       and removes it in command line mode
-	 *   - DBO_PERSISTENT: use persistant database connection
-	 */
 	public function setFlag( $flag ) {
 		$this->mFlags |= $flag;
 	}
 
-	/**
-	 * Clear a flag for this connection
-	 *
-	 * @param int $flag DBO_* constants from Defines.php:
-	 *   - DBO_DEBUG: output some debug info (same as debug())
-	 *   - DBO_NOBUFFER: don't buffer results (inverse of bufferResults())
-	 *   - DBO_TRX: automatically start transactions
-	 *   - DBO_DEFAULT: automatically sets DBO_TRX if not in command line mode
-	 *       and removes it in command line mode
-	 *   - DBO_PERSISTENT: use persistant database connection
-	 */
 	public function clearFlag( $flag ) {
 		$this->mFlags &= ~$flag;
 	}
 
-	/**
-	 * Returns a boolean whether the flag $flag is set for this connection
-	 *
-	 * @param int $flag DBO_* constants from Defines.php:
-	 *   - DBO_DEBUG: output some debug info (same as debug())
-	 *   - DBO_NOBUFFER: don't buffer results (inverse of bufferResults())
-	 *   - DBO_TRX: automatically start transactions
-	 *   - DBO_PERSISTENT: use persistant database connection
-	 * @return bool
-	 */
 	public function getFlag( $flag ) {
 		return !!( $this->mFlags & $flag );
 	}
 
-	/**
-	 * General read-only accessor
-	 *
-	 * @param string $name
-	 * @return string
-	 */
 	public function getProperty( $name ) {
 		return $this->$name;
 	}
 
-	/**
-	 * @return string
-	 */
 	public function getWikiID() {
 		if ( $this->mTablePrefix ) {
 			return "{$this->mDBname}-{$this->mTablePrefix}";
@@ -830,13 +667,6 @@ abstract class DatabaseBase implements IDatabase {
 		);
 	}
 
-	/**
-	 * Closes a database connection.
-	 * if it is open : commits any open transactions
-	 *
-	 * @throws MWException
-	 * @return bool Operation success. true if already closed.
-	 */
 	public function close() {
 		if ( count( $this->mTrxIdleCallbacks ) ) { // sanity
 			throw new MWException( "Transaction idle callbacks still pending." );
@@ -879,10 +709,6 @@ abstract class DatabaseBase implements IDatabase {
 	 */
 	abstract protected function closeConnection();
 
-	/**
-	 * @param string $error Fallback error message, used if none is given by DB
-	 * @throws DBConnectionError
-	 */
 	function reportConnectionError( $error = 'Unknown error' ) {
 		$myError = $this->lastError();
 		if ( $myError ) {
@@ -927,28 +753,6 @@ abstract class DatabaseBase implements IDatabase {
 		return !in_array( $verb, array( 'BEGIN', 'COMMIT', 'ROLLBACK', 'SHOW', 'SET' ) );
 	}
 
-	/**
-	 * 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 string $sql SQL query
-	 * @param string $fname Name of the calling function, for profiling/SHOW PROCESSLIST
-	 *     comment (you can use __METHOD__ or add some extra info)
-	 * @param bool $tempIgnore Whether to avoid throwing an exception on errors...
-	 *     maybe best to catch the exception instead?
-	 * @throws MWException
-	 * @return bool|ResultWrapper True for a successful write query, ResultWrapper object
-	 *     for a successful read query, or false on failure if $tempIgnore set
-	 */
 	public function query( $sql, $fname = __METHOD__, $tempIgnore = false ) {
 		global $wgUser;
 
@@ -1082,17 +886,6 @@ abstract class DatabaseBase implements IDatabase {
 		return $res;
 	}
 
-	/**
-	 * Report a query error. Log the error, and if neither the object ignore
-	 * flag nor the $tempIgnore flag is set, throw a DBQueryError.
-	 *
-	 * @param string $error
-	 * @param int $errno
-	 * @param string $sql
-	 * @param string $fname
-	 * @param bool $tempIgnore
-	 * @throws DBQueryError
-	 */
 	public function reportQueryError( $error, $errno, $sql, $fname, $tempIgnore = false ) {
 		if ( $this->ignoreErrors() || $tempIgnore ) {
 			wfDebug( "SQL ERROR (ignored): $error\n" );
@@ -1217,34 +1010,9 @@ abstract class DatabaseBase implements IDatabase {
 		}
 	}
 
-	/**
-	 * 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 mixed $res A SQL result
-	 */
 	public function freeResult( $res ) {
 	}
 
-	/**
-	 * 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 string|array $table Table name. See DatabaseBase::select() for details.
-	 * @param string $var The field name to select. This must be a valid SQL
-	 *   fragment: do not use unvalidated user input.
-	 * @param string|array $cond The condition array. See DatabaseBase::select() for details.
-	 * @param string $fname The function name of the caller.
-	 * @param string|array $options The query options. See DatabaseBase::select() for details.
-	 *
-	 * @return bool|mixed The value from the field, or false on failure.
-	 * @throws DBUnexpectedError
-	 */
 	public function selectField(
 		$table, $var, $cond = '', $fname = __METHOD__, $options = array()
 	) {
@@ -1272,26 +1040,6 @@ abstract class DatabaseBase implements IDatabase {
 		}
 	}
 
-	/**
-	 * A SELECT wrapper which returns a list of single field values from result rows.
-	 *
-	 * 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 string|array $table Table name. See DatabaseBase::select() for details.
-	 * @param string $var The field name to select. This must be a valid SQL
-	 *   fragment: do not use unvalidated user input.
-	 * @param string|array $cond The condition array. See DatabaseBase::select() for details.
-	 * @param string $fname The function name of the caller.
-	 * @param string|array $options The query options. See DatabaseBase::select() for details.
-	 * @param string|array $join_conds The join conditions. See DatabaseBase::select() for details.
-	 *
-	 * @return bool|array The values from the field, or false on failure
-	 * @throws DBUnexpectedError
-	 * @since 1.25
-	 */
 	public function selectFieldValues(
 		$table, $var, $cond = '', $fname = __METHOD__, $options = array(), $join_conds = array()
 	) {
@@ -1447,147 +1195,6 @@ abstract class DatabaseBase implements IDatabase {
 		return '';
 	}
 
-	/**
-	 * Execute a SELECT query constructed using the various parameters provided.
-	 * See below for full details of the parameters.
-	 *
-	 * @param string|array $table Table name
-	 * @param string|array $vars Field names
-	 * @param string|array $conds Conditions
-	 * @param string $fname Caller function name
-	 * @param array $options Query options
-	 * @param array $join_conds Join conditions
-	 *
-	 *
-	 * @param string|array $table
-	 *
-	 * 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 string|array $vars
-	 *
-	 * May be either a field name or an array of field names. The field names
-	 * can be complete fragments of SQL, for direct inclusion into the SELECT
-	 * query. If an array is given, field aliases can be specified, for example:
-	 *
-	 *   array( 'maxrev' => 'MAX(rev_id)' )
-	 *
-	 * This includes an expression with the alias "maxrev" in the query.
-	 *
-	 * If an expression is given, care must be taken to ensure that it is
-	 * DBMS-independent.
-	 *
-	 *
-	 * @param string|array $conds
-	 *
-	 * 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
-	 *       from its non-null elements, and an IS NULL clause will be added
-	 *       if null is present, such that the field may match any of the
-	 *       elements in the array. The non-null elements 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 string|array $options
-	 *
-	 * 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: May be either an string containing a HAVING clause or an array of
-	 *     conditions building the HAVING clause. If an array is given, the conditions
-	 *     constructed from each element are combined with AND.
-	 *
-	 *   - 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 string|array $join_conds
-	 *
-	 * 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|bool 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.
-	 */
 	public function select( $table, $vars, $conds = '', $fname = __METHOD__,
 		$options = array(), $join_conds = array() ) {
 		$sql = $this->selectSQLText( $table, $vars, $conds, $fname, $options, $join_conds );
@@ -1595,22 +1202,6 @@ abstract class DatabaseBase implements IDatabase {
 		return $this->query( $sql, $fname );
 	}
 
-	/**
-	 * The equivalent of DatabaseBase::select() except that the constructed SQL
-	 * is returned, instead of being immediately executed. This can be useful for
-	 * doing UNION queries, where the SQL text of each query is needed. In general,
-	 * however, callers outside of Database classes should just use select().
-	 *
-	 * @param string|array $table Table name
-	 * @param string|array $vars Field names
-	 * @param string|array $conds Conditions
-	 * @param string $fname Caller function name
-	 * @param string|array $options Query options
-	 * @param string|array $join_conds Join conditions
-	 *
-	 * @return string SQL query string.
-	 * @see DatabaseBase::select()
-	 */
 	public function selectSQLText( $table, $vars, $conds = '', $fname = __METHOD__,
 		$options = array(), $join_conds = array()
 	) {
@@ -1662,20 +1253,6 @@ abstract class DatabaseBase implements IDatabase {
 		return $sql;
 	}
 
-	/**
-	 * 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 string|array $table Table name
-	 * @param string|array $vars Field names
-	 * @param array $conds Conditions
-	 * @param string $fname Caller function name
-	 * @param string|array $options Query options
-	 * @param array|string $join_conds Join conditions
-	 *
-	 * @return stdClass|bool
-	 */
 	public function selectRow( $table, $vars, $conds, $fname = __METHOD__,
 		$options = array(), $join_conds = array()
 	) {
@@ -1696,26 +1273,6 @@ abstract class DatabaseBase implements IDatabase {
 		return $obj;
 	}
 
-	/**
-	 * Estimate the number of 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 string $table Table name
-	 * @param string $vars Unused
-	 * @param array|string $conds Filters on the table
-	 * @param string $fname Function name for profiling
-	 * @param array $options Options for select
-	 * @return int Row count
-	 */
 	public function estimateRowCount(
 		$table, $vars = '*', $conds = '', $fname = __METHOD__, $options = array()
 	) {
@@ -1730,23 +1287,6 @@ abstract class DatabaseBase implements IDatabase {
 		return $rows;
 	}
 
-	/**
-	 * Get the number of rows in dataset
-	 *
-	 * This is useful when trying to do COUNT(*) but with a LIMIT for performance.
-	 *
-	 * Takes the same arguments as DatabaseBase::select().
-	 *
-	 * @since 1.27 Added $join_conds parameter
-	 *
-	 * @param array|string $tables Table names
-	 * @param string $vars Unused
-	 * @param array|string $conds Filters on the table
-	 * @param string $fname Function name for profiling
-	 * @param array $options Options for select
-	 * @param array $join_conds Join conditions (since 1.27)
-	 * @return int Row count
-	 */
 	public function selectRowCount(
 		$tables, $vars = '*', $conds = '', $fname = __METHOD__, $options = array(), $join_conds = array()
 	) {
@@ -1792,30 +1332,12 @@ abstract class DatabaseBase implements IDatabase {
 		return $sql;
 	}
 
-	/**
-	 * Determines whether a field exists in a table
-	 *
-	 * @param string $table Table name
-	 * @param string $field Filed to check on that table
-	 * @param string $fname Calling function name (optional)
-	 * @return bool Whether $table has filed $field
-	 */
 	public function fieldExists( $table, $field, $fname = __METHOD__ ) {
 		$info = $this->fieldInfo( $table, $field );
 
 		return (bool)$info;
 	}
 
-	/**
-	 * Determines whether an index exists
-	 * Usually throws a DBQueryError on failure
-	 * If errors are explicitly ignored, returns NULL on failure
-	 *
-	 * @param string $table
-	 * @param string $index
-	 * @param string $fname
-	 * @return bool|null
-	 */
 	public function indexExists( $table, $index, $fname = __METHOD__ ) {
 		if ( !$this->tableExists( $table ) ) {
 			return null;
@@ -1829,13 +1351,6 @@ abstract class DatabaseBase implements IDatabase {
 		}
 	}
 
-	/**
-	 * Query whether a given table exists
-	 *
-	 * @param string $table
-	 * @param string $fname
-	 * @return bool
-	 */
 	public function tableExists( $table, $fname = __METHOD__ ) {
 		$table = $this->tableName( $table );
 		$old = $this->ignoreErrors( true );
@@ -1845,14 +1360,6 @@ abstract class DatabaseBase implements IDatabase {
 		return (bool)$res;
 	}
 
-	/**
-	 * Determines if a given index is unique
-	 *
-	 * @param string $table
-	 * @param string $index
-	 *
-	 * @return bool
-	 */
 	public function indexUnique( $table, $index ) {
 		$indexInfo = $this->indexInfo( $table, $index );
 
@@ -1873,39 +1380,6 @@ abstract class DatabaseBase implements IDatabase {
 		return implode( ' ', $options );
 	}
 
-	/**
-	 * INSERT wrapper, inserts an array into a table.
-	 *
-	 * $a may be either:
-	 *
-	 *   - 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.
-	 *
-	 * $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 string $table Table name. This will be passed through
-	 *   DatabaseBase::tableName().
-	 * @param array $a Array of rows to insert
-	 * @param string $fname Calling function name (use __METHOD__) for logs/profiling
-	 * @param array $options Array of options
-	 *
-	 * @throws DBQueryError Usually throws a DBQueryError on failure. If errors are explicitly ignored,
-	 * returns success.
-	 *
-	 * @return bool
-	 */
 	public function insert( $table, $a, $fname = __METHOD__, $options = array() ) {
 		# No rows to insert, easy just return now
 		if ( !count( $a ) ) {
@@ -1994,24 +1468,6 @@ abstract class DatabaseBase implements IDatabase {
 		return implode( ' ', $opts );
 	}
 
-	/**
-	 * UPDATE wrapper. Takes a condition array and a SET array.
-	 *
-	 * @param string $table Name of the table to UPDATE. This will be passed through
-	 *   DatabaseBase::tableName().
-	 * @param array $values 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 array $conds An array of conditions (WHERE). See
-	 *   DatabaseBase::select() for the details of the format of condition
-	 *   arrays. Use '*' to update all rows.
-	 * @param string $fname The function name of the caller (from __METHOD__),
-	 *   for logging and profiling.
-	 * @param array $options An array of UPDATE options, can be:
-	 *   - IGNORE: Ignore unique key conflicts
-	 *   - LOW_PRIORITY: MySQL-specific, see MySQL manual.
-	 * @return bool
-	 */
 	function update( $table, $values, $conds, $fname = __METHOD__, $options = array() ) {
 		$table = $this->tableName( $table );
 		$opts = $this->makeUpdateOptions( $options );
@@ -2024,20 +1480,6 @@ abstract class DatabaseBase implements IDatabase {
 		return $this->query( $sql, $fname );
 	}
 
-	/**
-	 * Makes an encoded list of strings from an array
-	 *
-	 * @param array $a Containing the data
-	 * @param int $mode Constant
-	 *    - 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
-	 * @throws MWException|DBUnexpectedError
-	 * @return string
-	 */
 	public function makeList( $a, $mode = LIST_COMMA ) {
 		if ( !is_array( $a ) ) {
 			throw new DBUnexpectedError( $this, 'DatabaseBase::makeList called with incorrect parameters' );
@@ -2113,16 +1555,6 @@ abstract class DatabaseBase implements IDatabase {
 		return $list;
 	}
 
-	/**
-	 * 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 array $data Organized as 2-d
-	 *    array(baseKeyVal => array(subKeyVal => [ignored], ...), ...)
-	 * @param string $baseKey Field name to match the base-level keys to (eg 'pl_namespace')
-	 * @param string $subKey Field name to match the sub-level keys to (eg 'pl_title')
-	 * @return string|bool SQL fragment, or false if no items in array
-	 */
 	public function makeWhereFrom2d( $data, $baseKey, $subKey ) {
 		$conds = array();
 
@@ -2154,58 +1586,22 @@ abstract class DatabaseBase implements IDatabase {
 		return $valuename;
 	}
 
-	/**
-	 * @param string $field
-	 * @return string
-	 */
 	public function bitNot( $field ) {
 		return "(~$field)";
 	}
 
-	/**
-	 * @param string $fieldLeft
-	 * @param string $fieldRight
-	 * @return string
-	 */
 	public function bitAnd( $fieldLeft, $fieldRight ) {
 		return "($fieldLeft & $fieldRight)";
 	}
 
-	/**
-	 * @param string $fieldLeft
-	 * @param string $fieldRight
-	 * @return string
-	 */
 	public function bitOr( $fieldLeft, $fieldRight ) {
 		return "($fieldLeft | $fieldRight)";
 	}
 
-	/**
-	 * Build a concatenation list to feed into a SQL query
-	 * @param array $stringList List of raw SQL expressions; caller is
-	 *   responsible for any quoting
-	 * @return string
-	 */
 	public function buildConcat( $stringList ) {
 		return 'CONCAT(' . implode( ',', $stringList ) . ')';
 	}
 
-	/**
-	 * Build a GROUP_CONCAT or equivalent statement for a query.
-	 *
-	 * This is useful for combining a field for several rows into a single string.
-	 * NULL values will not appear in the output, duplicated values will appear,
-	 * and the resulting delimiter-separated values have no defined sort order.
-	 * Code using the results may need to use the PHP unique() or sort() methods.
-	 *
-	 * @param string $delim Glue to bind the results together
-	 * @param string|array $table Table name
-	 * @param string $field Field name
-	 * @param string|array $conds Conditions
-	 * @param string|array $join_conds Join conditions
-	 * @return string SQL text
-	 * @since 1.23
-	 */
 	public function buildGroupConcatField(
 		$delim, $table, $field, $conds = '', $join_conds = array()
 	) {
@@ -2214,15 +1610,6 @@ abstract class DatabaseBase implements IDatabase {
 		return '(' . $this->selectSQLText( $table, $fld, $conds, null, array(), $join_conds ) . ')';
 	}
 
-	/**
-	 * Change the current database
-	 *
-	 * @todo Explain what exactly will fail if this is not overridden.
-	 *
-	 * @param string $db
-	 *
-	 * @return bool Success or failure
-	 */
 	public function selectDB( $db ) {
 		# Stub. Shouldn't cause serious problems if it's not overridden, but
 		# if your database engine supports a concept similar to MySQL's
@@ -2232,18 +1619,10 @@ abstract class DatabaseBase implements IDatabase {
 		return true;
 	}
 
-	/**
-	 * Get the current DB name
-	 * @return string
-	 */
 	public function getDBname() {
 		return $this->mDBname;
 	}
 
-	/**
-	 * Get the server hostname or IP address
-	 * @return string
-	 */
 	public function getServer() {
 		return $this->mServer;
 	}
@@ -2543,12 +1922,6 @@ abstract class DatabaseBase implements IDatabase {
 		}
 	}
 
-	/**
-	 * Adds quotes and backslashes.
-	 *
-	 * @param string|Blob $s
-	 * @return string
-	 */
 	public function addQuotes( $s ) {
 		if ( $s instanceof Blob ) {
 			$s = $s->fetch();
@@ -2596,22 +1969,6 @@ abstract class DatabaseBase implements IDatabase {
 		return addcslashes( $s, '\%_' );
 	}
 
-	/**
-	 * LIKE statement wrapper, receives a variable-length argument list with
-	 * parts of pattern to match containing either string literals that will be
-	 * escaped or tokens returned by anyChar() or anyString(). Alternatively,
-	 * the function could be provided with an array of aforementioned
-	 * parameters.
-	 *
-	 * Example: $dbr->buildLike( 'My_page_title/', $dbr->anyString() ) returns
-	 * a LIKE clause that searches for subpages of 'My page title'.
-	 * Alternatively:
-	 *   $pattern = array( 'My_page_title/', $dbr->anyString() );
-	 *   $query .= $dbr->buildLike( $pattern );
-	 *
-	 * @since 1.16
-	 * @return string Fully built LIKE statement
-	 */
 	public function buildLike() {
 		$params = func_get_args();
 
@@ -2632,35 +1989,14 @@ abstract class DatabaseBase implements IDatabase {
 		return " LIKE {$this->addQuotes( $s )} ";
 	}
 
-	/**
-	 * Returns a token for buildLike() that denotes a '_' to be used in a LIKE query
-	 *
-	 * @return LikeMatch
-	 */
 	public function anyChar() {
 		return new LikeMatch( '_' );
 	}
 
-	/**
-	 * Returns a token for buildLike() that denotes a '%' to be used in a LIKE query
-	 *
-	 * @return LikeMatch
-	 */
 	public function anyString() {
 		return new LikeMatch( '%' );
 	}
 
-	/**
-	 * Returns an appropriately quoted sequence value for inserting a new row.
-	 * MySQL has autoincrement fields, so this is just NULL. But the PostgreSQL
-	 * subclass will return an integer, and save the value for insertId()
-	 *
-	 * Any implementation of this function should *not* involve reusing
-	 * sequence numbers created for rolled-back transactions.
-	 * See http://bugs.mysql.com/bug.php?id=30767 for details.
-	 * @param string $seqName
-	 * @return null|int
-	 */
 	public function nextSequenceValue( $seqName ) {
 		return null;
 	}
@@ -2679,28 +2015,6 @@ abstract class DatabaseBase implements IDatabase {
 		return '';
 	}
 
-	/**
-	 * REPLACE query wrapper.
-	 *
-	 * 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 string $table The table to replace the row(s) in.
-	 * @param array $uniqueIndexes Is an array of indexes. Each element may be either
-	 *    a field name or an array of field names
-	 * @param array $rows Can be either a single row to insert, or multiple rows,
-	 *    in the same format as for DatabaseBase::insert()
-	 * @param string $fname Calling function name (use __METHOD__) for logs/profiling
-	 */
 	public function replace( $table, $uniqueIndexes, $rows, $fname = __METHOD__ ) {
 		$quotedTable = $this->tableName( $table );
 
@@ -2783,40 +2097,6 @@ abstract class DatabaseBase implements IDatabase {
 		return $this->query( $sql, $fname );
 	}
 
-	/**
-	 * INSERT ON DUPLICATE KEY UPDATE wrapper, upserts an array into a table.
-	 *
-	 * This updates any conflicting rows (according to the unique indexes) using
-	 * the provided SET clause and inserts any remaining (non-conflicted) rows.
-	 *
-	 * $rows may be either:
-	 *   - 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.
-	 *
-	 * 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.
-	 *
-	 * Usually throws a DBQueryError on failure. If errors are explicitly ignored,
-	 * returns success.
-	 *
-	 * @since 1.22
-	 *
-	 * @param string $table Table name. This will be passed through DatabaseBase::tableName().
-	 * @param array $rows A single row or list of rows to insert
-	 * @param array $uniqueIndexes List of single field names or field name tuples
-	 * @param array $set 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 string $fname Calling function name (use __METHOD__) for logs/profiling
-	 * @throws Exception
-	 * @return bool
-	 */
 	public function upsert( $table, array $rows, array $uniqueIndexes, array $set,
 		$fname = __METHOD__
 	) {
@@ -2871,26 +2151,6 @@ abstract class DatabaseBase implements IDatabase {
 		return $ok;
 	}
 
-	/**
-	 * DELETE where the condition is a join.
-	 *
-	 * MySQL overrides this to use a multi-table DELETE syntax, in other databases
-	 * we use sub-selects
-	 *
-	 * For safety, an empty $conds will not delete everything. If you want to
-	 * delete all rows where the join condition matches, set $conds='*'.
-	 *
-	 * DO NOT put the join condition in $conds.
-	 *
-	 * @param string $delTable The table to delete from.
-	 * @param string $joinTable The other table.
-	 * @param string $delVar The variable to join on, in the first table.
-	 * @param string $joinVar The variable to join on, in the second table.
-	 * @param array $conds Condition array of field names mapped to variables,
-	 *   ANDed together in the WHERE clause
-	 * @param string $fname Calling function name (use __METHOD__) for logs/profiling
-	 * @throws DBUnexpectedError
-	 */
 	public function deleteJoin( $delTable, $joinTable, $delVar, $joinVar, $conds,
 		$fname = __METHOD__
 	) {
@@ -2946,16 +2206,6 @@ abstract class DatabaseBase implements IDatabase {
 		return '';
 	}
 
-	/**
-	 * DELETE query wrapper.
-	 *
-	 * @param array $table Table name
-	 * @param string|array $conds Array of conditions. See $conds in DatabaseBase::select()
-	 *   for the format. Use $conds == "*" to delete all rows
-	 * @param string $fname Name of the calling function
-	 * @throws DBUnexpectedError
-	 * @return bool|ResultWrapper
-	 */
 	public function delete( $table, $conds, $fname = __METHOD__ ) {
 		if ( !$conds ) {
 			throw new DBUnexpectedError( $this, 'DatabaseBase::delete() called with no conditions' );
@@ -2974,32 +2224,6 @@ abstract class DatabaseBase implements IDatabase {
 		return $this->query( $sql, $fname );
 	}
 
-	/**
-	 * INSERT SELECT wrapper. Takes data from a SELECT query and inserts it
-	 * into another table.
-	 *
-	 * @param string $destTable The table name to insert into
-	 * @param string|array $srcTable May be either a table name, or an array of table names
-	 *    to include in a join.
-	 *
-	 * @param array $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 array $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 string $fname The function name of the caller, from __METHOD__
-	 *
-	 * @param array $insertOptions Options for the INSERT part of the query, see
-	 *    DatabaseBase::insert() for details.
-	 * @param array $selectOptions Options for the SELECT part of the query, see
-	 *    DatabaseBase::select() for details.
-	 *
-	 * @return ResultWrapper
-	 */
 	public function insertSelect( $destTable, $srcTable, $varMap, $conds,
 		$fname = __METHOD__,
 		$insertOptions = array(), $selectOptions = array()
@@ -3069,38 +2293,16 @@ abstract class DatabaseBase implements IDatabase {
 			. "{$limit} ";
 	}
 
-	/**
-	 * Returns true if current database backend supports ORDER BY or LIMIT for separate subqueries
-	 * within the UNION construct.
-	 * @return bool
-	 */
 	public function unionSupportsOrderAndLimit() {
 		return true; // True for almost every DB supported
 	}
 
-	/**
-	 * Construct a UNION query
-	 * This is used for providing overload point for other DB abstractions
-	 * not compatible with the MySQL syntax.
-	 * @param array $sqls SQL statements to combine
-	 * @param bool $all Use UNION ALL
-	 * @return string SQL fragment
-	 */
 	public function unionQueries( $sqls, $all ) {
 		$glue = $all ? ') UNION ALL (' : ') UNION (';
 
 		return '(' . implode( $glue, $sqls ) . ')';
 	}
 
-	/**
-	 * Returns an SQL expression for a simple conditional. This doesn't need
-	 * to be overridden unless CASE isn't supported in your DBMS.
-	 *
-	 * @param string|array $cond SQL expression which will result in a boolean value
-	 * @param string $trueVal SQL expression to return if true
-	 * @param string $falseVal SQL expression to return if false
-	 * @return string SQL fragment
-	 */
 	public function conditional( $cond, $trueVal, $falseVal ) {
 		if ( is_array( $cond ) ) {
 			$cond = $this->makeList( $cond, LIST_AND );
@@ -3109,67 +2311,26 @@ abstract class DatabaseBase implements IDatabase {
 		return " (CASE WHEN $cond THEN $trueVal ELSE $falseVal END) ";
 	}
 
-	/**
-	 * Returns a comand for str_replace function in SQL query.
-	 * Uses REPLACE() in MySQL
-	 *
-	 * @param string $orig Column to modify
-	 * @param string $old Column to seek
-	 * @param string $new Column to replace with
-	 *
-	 * @return string
-	 */
 	public function strreplace( $orig, $old, $new ) {
 		return "REPLACE({$orig}, {$old}, {$new})";
 	}
 
-	/**
-	 * Determines how long the server has been up
-	 * STUB
-	 *
-	 * @return int
-	 */
 	public function getServerUptime() {
 		return 0;
 	}
 
-	/**
-	 * Determines if the last failure was due to a deadlock
-	 * STUB
-	 *
-	 * @return bool
-	 */
 	public function wasDeadlock() {
 		return false;
 	}
 
-	/**
-	 * Determines if the last failure was due to a lock timeout
-	 * STUB
-	 *
-	 * @return bool
-	 */
 	public function wasLockTimeout() {
 		return false;
 	}
 
-	/**
-	 * Determines if the last query error was something that should be dealt
-	 * with by pinging the connection and reissuing the query.
-	 * STUB
-	 *
-	 * @return bool
-	 */
 	public function wasErrorReissuable() {
 		return false;
 	}
 
-	/**
-	 * Determines if the last failure was due to the database being read-only.
-	 * STUB
-	 *
-	 * @return bool
-	 */
 	public function wasReadOnlyError() {
 		return false;
 	}
@@ -3200,9 +2361,9 @@ abstract class DatabaseBase implements IDatabase {
 	 * Returns whatever the callback function returned on its successful,
 	 * iteration, or false on error, for example if the retry limit was
 	 * reached.
-	 *
 	 * @return mixed
-	 * @throws DBQueryError
+	 * @throws DBUnexpectedError
+	 * @throws Exception
 	 */
 	public function deadlockLoop() {
 		$args = func_get_args();
@@ -3212,6 +2373,7 @@ abstract class DatabaseBase implements IDatabase {
 		$this->begin( __METHOD__ );
 
 		$retVal = null;
+		/** @var Exception $e */
 		$e = null;
 		do {
 			try {
@@ -3239,55 +2401,21 @@ abstract class DatabaseBase implements IDatabase {
 		}
 	}
 
-	/**
-	 * Wait for the slave to catch up to a given master position.
-	 *
-	 * @param DBMasterPos $pos
-	 * @param int $timeout The maximum number of seconds to wait for
-	 *   synchronisation
-	 * @return int 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.
-	 */
 	public function masterPosWait( DBMasterPos $pos, $timeout ) {
 		# Real waits are implemented in the subclass.
 		return 0;
 	}
 
-	/**
-	 * Get the replication position of this slave
-	 *
-	 * @return DBMasterPos|bool False if this is not a slave.
-	 */
 	public function getSlavePos() {
 		# Stub
 		return false;
 	}
 
-	/**
-	 * Get the position of this master
-	 *
-	 * @return DBMasterPos|bool False if this is not a master
-	 */
 	public function getMasterPos() {
 		# Stub
 		return false;
 	}
 
-	/**
-	 * Run an anonymous function as soon as there is no transaction pending.
-	 * If there is a transaction and it is rolled back, then the callback is cancelled.
-	 * Queries in the function will run in AUTO-COMMIT mode unless there are begin() calls.
-	 * Callbacks must commit any transactions that they begin.
-	 *
-	 * This is useful for updates to different systems or when separate transactions are needed.
-	 * For example, one might want to enqueue jobs into a system outside the database, but only
-	 * after the database is updated so that the jobs will see the data when they actually run.
-	 * It can also be used for updates that easily cause deadlocks if locks are held too long.
-	 *
-	 * @param callable $callback
-	 * @since 1.20
-	 */
 	final public function onTransactionIdle( $callback ) {
 		$this->mTrxIdleCallbacks[] = array( $callback, wfGetCaller() );
 		if ( !$this->mTrxLevel ) {
@@ -3295,17 +2423,6 @@ abstract class DatabaseBase implements IDatabase {
 		}
 	}
 
-	/**
-	 * Run an anonymous function before the current transaction commits or now if there is none.
-	 * If there is a transaction and it is rolled back, then the callback is cancelled.
-	 * Callbacks must not start nor commit any transactions.
-	 *
-	 * This is useful for updates that easily cause deadlocks if locks are held too long
-	 * but where atomicity is strongly desired for these updates and some related updates.
-	 *
-	 * @param callable $callback
-	 * @since 1.22
-	 */
 	final public function onTransactionPreCommitOrIdle( $callback ) {
 		if ( $this->mTrxLevel ) {
 			$this->mTrxPreCommitCallbacks[] = array( $callback, wfGetCaller() );
@@ -3383,30 +2500,6 @@ abstract class DatabaseBase implements IDatabase {
 		}
 	}
 
-	/**
-	 * Begin an atomic section of statements
-	 *
-	 * If a transaction has been started already, just keep track of the given
-	 * section name to make sure the transaction is not committed pre-maturely.
-	 * This function can be used in layers (with sub-sections), so use a stack
-	 * to keep track of the different atomic sections. If there is no transaction,
-	 * start one implicitly.
-	 *
-	 * The goal of this function is to create an atomic section of SQL queries
-	 * without having to start a new transaction if it already exists.
-	 *
-	 * Atomic sections are more strict than transactions. With transactions,
-	 * attempting to begin a new transaction when one is already running results
-	 * in MediaWiki issuing a brief warning and doing an implicit commit. All
-	 * atomic levels *must* be explicitly closed using DatabaseBase::endAtomic(),
-	 * and any database transactions cannot be began or committed until all atomic
-	 * levels are closed. There is no such thing as implicitly opening or closing
-	 * an atomic section.
-	 *
-	 * @since 1.23
-	 * @param string $fname
-	 * @throws DBError
-	 */
 	final public function startAtomic( $fname = __METHOD__ ) {
 		if ( !$this->mTrxLevel ) {
 			$this->begin( $fname );
@@ -3421,17 +2514,6 @@ abstract class DatabaseBase implements IDatabase {
 		$this->mTrxAtomicLevels[] = $fname;
 	}
 
-	/**
-	 * Ends an atomic section of SQL statements
-	 *
-	 * Ends the next section of atomic SQL statements and commits the transaction
-	 * if necessary.
-	 *
-	 * @since 1.23
-	 * @see DatabaseBase::startAtomic
-	 * @param string $fname
-	 * @throws DBError
-	 */
 	final public function endAtomic( $fname = __METHOD__ ) {
 		if ( !$this->mTrxLevel ) {
 			throw new DBUnexpectedError( $this, 'No atomic transaction is open.' );
@@ -3462,21 +2544,6 @@ abstract class DatabaseBase implements IDatabase {
 		$this->endAtomic( $fname );
 	}
 
-	/**
-	 * Begin a transaction. If a transaction is already in progress,
-	 * that transaction will be committed before the new transaction is started.
-	 *
-	 * Note that when the DBO_TRX flag is set (which is usually the case for web
-	 * requests, but not for maintenance scripts), any previous database query
-	 * will have started a transaction automatically.
-	 *
-	 * Nesting of transactions is not supported. Attempts to nest transactions
-	 * will cause a warning, unless the current transaction was started
-	 * automatically because of the DBO_TRX flag.
-	 *
-	 * @param string $fname
-	 * @throws DBError
-	 */
 	final public function begin( $fname = __METHOD__ ) {
 		if ( $this->mTrxLevel ) { // implicit commit
 			if ( $this->mTrxAtomicLevels ) {
@@ -3551,20 +2618,6 @@ abstract class DatabaseBase implements IDatabase {
 		$this->mTrxLevel = 1;
 	}
 
-	/**
-	 * Commits a transaction previously started using begin().
-	 * If no transaction is in progress, a warning is issued.
-	 *
-	 * Nesting of transactions is not supported.
-	 *
-	 * @param string $fname
-	 * @param string $flush Flush flag, set to 'flush' to disable warnings about
-	 *   explicitly committing implicit transactions, or calling commit when no
-	 *   transaction is in progress. This will silently break any ongoing
-	 *   explicit transaction. Only set the flush flag if you are sure that it
-	 *   is safe to ignore these warnings in your context.
-	 * @throws DBUnexpectedError
-	 */
 	final public function commit( $fname = __METHOD__, $flush = '' ) {
 		if ( $this->mTrxLevel && $this->mTrxAtomicLevels ) {
 			// There are still atomic sections open. This cannot be ignored
@@ -3617,20 +2670,6 @@ abstract class DatabaseBase implements IDatabase {
 		}
 	}
 
-	/**
-	 * Rollback a transaction previously started using begin().
-	 * If no transaction is in progress, a warning is issued.
-	 *
-	 * No-op on non-transactional databases.
-	 *
-	 * @param string $fname
-	 * @param string $flush Flush flag, set to 'flush' to disable warnings about
-	 *   calling rollback when no transaction is in progress. This will silently
-	 *   break any ongoing explicit transaction. Only set the flush flag if you
-	 *   are sure that it is safe to ignore these warnings in your context.
-	 * @throws DBUnexpectedError
-	 * @since 1.23 Added $flush parameter
-	 */
 	final public function rollback( $fname = __METHOD__, $flush = '' ) {
 		if ( $flush !== 'flush' ) {
 			if ( !$this->mTrxLevel ) {
@@ -3695,14 +2734,6 @@ abstract class DatabaseBase implements IDatabase {
 			'DatabaseBase::duplicateTableStructure is not implemented in descendant class' );
 	}
 
-	/**
-	 * List all tables on the database
-	 *
-	 * @param string $prefix Only show tables with this prefix, e.g. mw_
-	 * @param string $fname Calling function name
-	 * @throws MWException
-	 * @return array
-	 */
 	function listTables( $prefix = null, $fname = __METHOD__ ) {
 		throw new MWException( 'DatabaseBase::listTables is not implemented in descendant class' );
 	}
@@ -3743,34 +2774,10 @@ abstract class DatabaseBase implements IDatabase {
 		throw new MWException( 'DatabaseBase::isView 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.
-	 *
-	 * @param string|int $ts
-	 *
-	 * @return string
-	 */
 	public function timestamp( $ts = 0 ) {
 		return wfTimestamp( TS_MW, $ts );
 	}
 
-	/**
-	 * 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.
-	 *
-	 * @param string|int $ts
-	 *
-	 * @return string
-	 */
 	public function timestampOrNull( $ts = null ) {
 		if ( is_null( $ts ) ) {
 			return null;
@@ -3805,11 +2812,6 @@ abstract class DatabaseBase implements IDatabase {
 		}
 	}
 
-	/**
-	 * Ping the server and try to reconnect if it there is no connection
-	 *
-	 * @return bool Success or failure
-	 */
 	public function ping() {
 		# Stub. Not essential to override.
 		return true;
@@ -3888,36 +2890,14 @@ abstract class DatabaseBase implements IDatabase {
 		return 0;
 	}
 
-	/**
-	 * 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().
-	 *
-	 * @param string $b
-	 * @return string
-	 */
 	public 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.
-	 *
-	 * @param string|Blob $b
-	 * @return string
-	 */
 	public function decodeBlob( $b ) {
 		if ( $b instanceof Blob ) {
 			$b = $b->fetch();
@@ -3925,16 +2905,6 @@ abstract class DatabaseBase implements IDatabase {
 		return $b;
 	}
 
-	/**
-	 * Override database's default behavior. $options include:
-	 *     'connTimeout' : Set the connection timeout value in seconds.
-	 *                     May be useful for very long batch queries such as
-	 *                     full-wiki dumps, where a single query reads out over
-	 *                     hours or days.
-	 *
-	 * @param array $options
-	 * @return void
-	 */
 	public function setSessionOptions( array $options ) {
 	}
 
@@ -4000,13 +2970,6 @@ abstract class DatabaseBase implements IDatabase {
 		}
 	}
 
-	/**
-	 * 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
-	 * all. If it's set to false, $GLOBALS will be used.
-	 *
-	 * @param bool|array $vars Mapping variable name to value.
-	 */
 	public function setSchemaVars( $vars ) {
 		$this->mSchemaVars = $vars;
 	}
@@ -4173,54 +3136,18 @@ abstract class DatabaseBase implements IDatabase {
 		return array();
 	}
 
-	/**
-	 * Check to see if a named lock is available (non-blocking)
-	 *
-	 * @param string $lockName Name of lock to poll
-	 * @param string $method Name of method calling us
-	 * @return bool
-	 * @since 1.20
-	 */
 	public function lockIsFree( $lockName, $method ) {
 		return true;
 	}
 
-	/**
-	 * Acquire a named lock
-	 *
-	 * Named locks are not related to transactions
-	 *
-	 * @param string $lockName Name of lock to aquire
-	 * @param string $method Name of method calling us
-	 * @param int $timeout
-	 * @return bool
-	 */
 	public function lock( $lockName, $method, $timeout = 5 ) {
 		return true;
 	}
 
-	/**
-	 * Release a lock
-	 *
-	 * Named locks are not related to transactions
-	 *
-	 * @param string $lockName Name of lock to release
-	 * @param string $method Name of method calling us
-	 *
-	 * @return int Returns 1 if the lock was released, 0 if the lock was not established
-	 * by this thread (in which case the lock is not released), and NULL if the named
-	 * lock did not exist
-	 */
 	public function unlock( $lockName, $method ) {
 		return true;
 	}
 
-	/**
-	 * Check to see if a named lock used by lock() use blocking queues
-	 *
-	 * @return bool
-	 * @since 1.26
-	 */
 	public function namedLocksEnqueue() {
 		return false;
 	}
@@ -4277,51 +3204,22 @@ abstract class DatabaseBase implements IDatabase {
 		return 'SearchEngineDummy';
 	}
 
-	/**
-	 * 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.
-	 *
-	 * @return string
-	 */
 	public function getInfinity() {
 		return 'infinity';
 	}
 
-	/**
-	 * Encode an expiry time into the DBMS dependent format
-	 *
-	 * @param string $expiry Timestamp for expiry, or the 'infinity' string
-	 * @return string
-	 */
 	public function encodeExpiry( $expiry ) {
 		return ( $expiry == '' || $expiry == 'infinity' || $expiry == $this->getInfinity() )
 			? $this->getInfinity()
 			: $this->timestamp( $expiry );
 	}
 
-	/**
-	 * Decode an expiry time into a DBMS independent format
-	 *
-	 * @param string $expiry DB timestamp field value for expiry
-	 * @param int $format TS_* constant, defaults to TS_MW
-	 * @return string
-	 */
 	public function decodeExpiry( $expiry, $format = TS_MW ) {
 		return ( $expiry == '' || $expiry == 'infinity' || $expiry == $this->getInfinity() )
 			? 'infinity'
 			: wfTimestamp( $format, $expiry );
 	}
 
-	/**
-	 * 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.
-	 *
-	 * @param bool|string $value True for allow, false for deny, or "default" to
-	 *   restore the initial value
-	 */
 	public function setBigSelects( $value = true ) {
 		// no-op
 	}