<?php
+/**
+ * Representation of a page version.
+ *
+ * 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
+ *
+ * @file
+ */
+
+use Wikimedia\Rdbms\Database;
+use Wikimedia\Rdbms\IDatabase;
+use MediaWiki\Linker\LinkTarget;
+use MediaWiki\MediaWikiServices;
+use Wikimedia\Rdbms\ResultWrapper;
+use Wikimedia\Rdbms\FakeResultWrapper;
/**
* @todo document
*/
-class Revision {
+class Revision implements IDBAccessObject {
+ /** @var int|null */
+ protected $mId;
+ /** @var int|null */
+ protected $mPage;
+ /** @var string */
+ protected $mUserText;
+ /** @var string */
+ protected $mOrigUserText;
+ /** @var int */
+ protected $mUser;
+ /** @var bool */
+ protected $mMinorEdit;
+ /** @var string */
+ protected $mTimestamp;
+ /** @var int */
+ protected $mDeleted;
+ /** @var int */
+ protected $mSize;
+ /** @var string */
+ protected $mSha1;
+ /** @var int */
+ protected $mParentId;
+ /** @var string */
+ protected $mComment;
+ /** @var string */
+ protected $mText;
+ /** @var int */
+ protected $mTextId;
+ /** @var int */
+ protected $mUnpatrolled;
+
+ /** @var stdClass|null */
+ protected $mTextRow;
+
+ /** @var null|Title */
+ protected $mTitle;
+ /** @var bool */
+ protected $mCurrent;
+ /** @var string */
+ protected $mContentModel;
+ /** @var string */
+ protected $mContentFormat;
+
+ /** @var Content|null|bool */
+ protected $mContent;
+ /** @var null|ContentHandler */
+ protected $mContentHandler;
+
+ /** @var int */
+ protected $mQueryFlags = 0;
+ /** @var bool Used for cached values to reload user text and rev_deleted */
+ protected $mRefreshMutableFields = false;
+ /** @var string Wiki ID; false means the current wiki */
+ protected $mWiki = false;
+
+ // Revision deletion constants
const DELETED_TEXT = 1;
const DELETED_COMMENT = 2;
const DELETED_USER = 4;
const DELETED_RESTRICTED = 8;
- // Convenience field
- const SUPPRESSED_USER = 12;
- // Audience options for Revision::getText()
+ const SUPPRESSED_USER = 12; // convenience
+ const SUPPRESSED_ALL = 15; // convenience
+
+ // Audience options for accessors
const FOR_PUBLIC = 1;
const FOR_THIS_USER = 2;
const RAW = 3;
+ const TEXT_CACHE_GROUP = 'revisiontext:10'; // process cache name and max key count
+
/**
* Load a page revision from a given revision ID number.
* Returns null if no such revision can be found.
*
- * @param $id Integer
- * @return Revision or null
+ * $flags include:
+ * Revision::READ_LATEST : Select the data from the master
+ * Revision::READ_LOCKING : Select & lock the data from the master
+ *
+ * @param int $id
+ * @param int $flags (optional)
+ * @return Revision|null
*/
- public static function newFromId( $id ) {
- return Revision::newFromConds(
- array( 'page_id=rev_page',
- 'rev_id' => intval( $id ) ) );
+ public static function newFromId( $id, $flags = 0 ) {
+ return self::newFromConds( [ 'rev_id' => intval( $id ) ], $flags );
}
/**
* Load either the current, or a specified, revision
- * that's attached to a given title. If not attached
- * to that title, will return null.
+ * that's attached to a given link target. If not attached
+ * to that link target, will return null.
+ *
+ * $flags include:
+ * Revision::READ_LATEST : Select the data from the master
+ * Revision::READ_LOCKING : Select & lock the data from the master
*
- * @param $title Title
- * @param $id Integer
- * @return Revision or null
+ * @param LinkTarget $linkTarget
+ * @param int $id (optional)
+ * @param int $flags Bitfield (optional)
+ * @return Revision|null
*/
- public static function newFromTitle( $title, $id = 0 ) {
- $conds = array(
- 'page_namespace' => $title->getNamespace(),
- 'page_title' => $title->getDBkey()
- );
+ public static function newFromTitle( LinkTarget $linkTarget, $id = 0, $flags = 0 ) {
+ $conds = [
+ 'page_namespace' => $linkTarget->getNamespace(),
+ 'page_title' => $linkTarget->getDBkey()
+ ];
if ( $id ) {
// Use the specified ID
$conds['rev_id'] = $id;
- } elseif ( wfGetLB()->getServerCount() > 1 ) {
- // Get the latest revision ID from the master
- $dbw = wfGetDB( DB_MASTER );
- $latest = $dbw->selectField( 'page', 'page_latest', $conds, __METHOD__ );
- if ( $latest === false ) {
- // Page does not exist
- return null;
- }
- $conds['rev_id'] = $latest;
+ return self::newFromConds( $conds, $flags );
} else {
// Use a join to get the latest revision
$conds[] = 'rev_id=page_latest';
+ $db = wfGetDB( ( $flags & self::READ_LATEST ) ? DB_MASTER : DB_REPLICA );
+ return self::loadFromConds( $db, $conds, $flags );
+ }
+ }
+
+ /**
+ * Load either the current, or a specified, revision
+ * that's attached to a given page ID.
+ * Returns null if no such revision can be found.
+ *
+ * $flags include:
+ * Revision::READ_LATEST : Select the data from the master (since 1.20)
+ * Revision::READ_LOCKING : Select & lock the data from the master
+ *
+ * @param int $pageId
+ * @param int $revId (optional)
+ * @param int $flags Bitfield (optional)
+ * @return Revision|null
+ */
+ public static function newFromPageId( $pageId, $revId = 0, $flags = 0 ) {
+ $conds = [ 'page_id' => $pageId ];
+ if ( $revId ) {
+ $conds['rev_id'] = $revId;
+ return self::newFromConds( $conds, $flags );
+ } else {
+ // Use a join to get the latest revision
+ $conds[] = 'rev_id = page_latest';
+ $db = wfGetDB( ( $flags & self::READ_LATEST ) ? DB_MASTER : DB_REPLICA );
+ return self::loadFromConds( $db, $conds, $flags );
}
- $conds[] = 'page_id=rev_page';
- return Revision::newFromConds( $conds );
}
/**
* Make a fake revision object from an archive table row. This is queried
* for permissions or even inserted (as in Special:Undelete)
- * @todo Fixme: should be a subclass for RevisionDelete. [TS]
+ * @todo FIXME: Should be a subclass for RevisionDelete. [TS]
+ *
+ * @param object $row
+ * @param array $overrides
+ *
+ * @throws MWException
+ * @return Revision
*/
- public static function newFromArchiveRow( $row, $overrides = array() ) {
- $attribs = $overrides + array(
- 'page' => isset( $row->page_id ) ? $row->page_id : null,
+ public static function newFromArchiveRow( $row, $overrides = [] ) {
+ global $wgContentHandlerUseDB;
+
+ $attribs = $overrides + [
+ 'page' => isset( $row->ar_page_id ) ? $row->ar_page_id : null,
'id' => isset( $row->ar_rev_id ) ? $row->ar_rev_id : null,
- 'comment' => $row->ar_comment,
+ 'comment' => CommentStore::newKey( 'ar_comment' )
+ // Legacy because $row probably came from self::selectArchiveFields()
+ ->getCommentLegacy( wfGetDB( DB_REPLICA ), $row, true )->text,
'user' => $row->ar_user,
'user_text' => $row->ar_user_text,
'timestamp' => $row->ar_timestamp,
'minor_edit' => $row->ar_minor_edit,
'text_id' => isset( $row->ar_text_id ) ? $row->ar_text_id : null,
'deleted' => $row->ar_deleted,
- 'len' => $row->ar_len);
+ 'len' => $row->ar_len,
+ 'sha1' => isset( $row->ar_sha1 ) ? $row->ar_sha1 : null,
+ 'content_model' => isset( $row->ar_content_model ) ? $row->ar_content_model : null,
+ 'content_format' => isset( $row->ar_content_format ) ? $row->ar_content_format : null,
+ ];
+
+ if ( !$wgContentHandlerUseDB ) {
+ unset( $attribs['content_model'] );
+ unset( $attribs['content_format'] );
+ }
+
+ if ( !isset( $attribs['title'] )
+ && isset( $row->ar_namespace )
+ && isset( $row->ar_title )
+ ) {
+ $attribs['title'] = Title::makeTitle( $row->ar_namespace, $row->ar_title );
+ }
+
if ( isset( $row->ar_text ) && !$row->ar_text_id ) {
// Pre-1.5 ar_text row
$attribs['text'] = self::getRevisionText( $row, 'ar_' );
if ( $attribs['text'] === false ) {
- throw new MWException( 'Unable to load text from archive row (possibly bug 22624)' );
+ throw new MWException( 'Unable to load text from archive row (possibly T24624)' );
}
}
return new self( $attribs );
}
+ /**
+ * @since 1.19
+ *
+ * @param object $row
+ * @return Revision
+ */
+ public static function newFromRow( $row ) {
+ return new self( $row );
+ }
+
/**
* Load a page revision from a given revision ID number.
* Returns null if no such revision can be found.
*
- * @param $db DatabaseBase
- * @param $id Integer
- * @return Revision or null
+ * @param IDatabase $db
+ * @param int $id
+ * @return Revision|null
*/
public static function loadFromId( $db, $id ) {
- return Revision::loadFromConds( $db,
- array( 'page_id=rev_page',
- 'rev_id' => intval( $id ) ) );
+ return self::loadFromConds( $db, [ 'rev_id' => intval( $id ) ] );
}
/**
* that's attached to a given page. If not attached
* to that page, will return null.
*
- * @param $db DatabaseBase
- * @param $pageid Integer
- * @param $id Integer
- * @return Revision or null
+ * @param IDatabase $db
+ * @param int $pageid
+ * @param int $id
+ * @return Revision|null
*/
public static function loadFromPageId( $db, $pageid, $id = 0 ) {
- $conds = array( 'page_id=rev_page','rev_page' => intval( $pageid ), 'page_id'=>intval( $pageid ) );
- if( $id ) {
+ $conds = [ 'rev_page' => intval( $pageid ), 'page_id' => intval( $pageid ) ];
+ if ( $id ) {
$conds['rev_id'] = intval( $id );
} else {
$conds[] = 'rev_id=page_latest';
}
- return Revision::loadFromConds( $db, $conds );
+ return self::loadFromConds( $db, $conds );
}
/**
* that's attached to a given page. If not attached
* to that page, will return null.
*
- * @param $db DatabaseBase
- * @param $title Title
- * @param $id Integer
- * @return Revision or null
+ * @param IDatabase $db
+ * @param Title $title
+ * @param int $id
+ * @return Revision|null
*/
public static function loadFromTitle( $db, $title, $id = 0 ) {
- if( $id ) {
+ if ( $id ) {
$matchId = intval( $id );
} else {
$matchId = 'page_latest';
}
- return Revision::loadFromConds(
- $db,
- array( "rev_id=$matchId",
- 'page_id=rev_page',
- 'page_namespace' => $title->getNamespace(),
- 'page_title' => $title->getDBkey() ) );
+ return self::loadFromConds( $db,
+ [
+ "rev_id=$matchId",
+ 'page_namespace' => $title->getNamespace(),
+ 'page_title' => $title->getDBkey()
+ ]
+ );
}
/**
* WARNING: Timestamps may in some circumstances not be unique,
* so this isn't the best key to use.
*
- * @param $db Database
- * @param $title Title
- * @param $timestamp String
- * @return Revision or null
+ * @param IDatabase $db
+ * @param Title $title
+ * @param string $timestamp
+ * @return Revision|null
*/
public static function loadFromTimestamp( $db, $title, $timestamp ) {
- return Revision::loadFromConds(
- $db,
- array( 'rev_timestamp' => $db->timestamp( $timestamp ),
- 'page_id=rev_page',
- 'page_namespace' => $title->getNamespace(),
- 'page_title' => $title->getDBkey() ) );
+ return self::loadFromConds( $db,
+ [
+ 'rev_timestamp' => $db->timestamp( $timestamp ),
+ 'page_namespace' => $title->getNamespace(),
+ 'page_title' => $title->getDBkey()
+ ]
+ );
}
/**
- * Given a set of conditions, fetch a revision.
+ * Given a set of conditions, fetch a revision
+ *
+ * This method is used then a revision ID is qualified and
+ * will incorporate some basic replica DB/master fallback logic
*
- * @param $conditions Array
- * @return Revision or null
+ * @param array $conditions
+ * @param int $flags (optional)
+ * @return Revision|null
*/
- public static function newFromConds( $conditions ) {
- $db = wfGetDB( DB_SLAVE );
- $row = Revision::loadFromConds( $db, $conditions );
- if( is_null( $row ) && wfGetLB()->getServerCount() > 1 ) {
- $dbw = wfGetDB( DB_MASTER );
- $row = Revision::loadFromConds( $dbw, $conditions );
+ private static function newFromConds( $conditions, $flags = 0 ) {
+ $db = wfGetDB( ( $flags & self::READ_LATEST ) ? DB_MASTER : DB_REPLICA );
+
+ $rev = self::loadFromConds( $db, $conditions, $flags );
+ // Make sure new pending/committed revision are visibile later on
+ // within web requests to certain avoid bugs like T93866 and T94407.
+ if ( !$rev
+ && !( $flags & self::READ_LATEST )
+ && wfGetLB()->getServerCount() > 1
+ && wfGetLB()->hasOrMadeRecentMasterChanges()
+ ) {
+ $flags = self::READ_LATEST;
+ $db = wfGetDB( DB_MASTER );
+ $rev = self::loadFromConds( $db, $conditions, $flags );
}
- return $row;
+
+ if ( $rev ) {
+ $rev->mQueryFlags = $flags;
+ }
+
+ return $rev;
}
/**
* Given a set of conditions, fetch a revision from
* the given database connection.
*
- * @param $db Database
- * @param $conditions Array
- * @return Revision or null
- */
- private static function loadFromConds( $db, $conditions ) {
- $res = Revision::fetchFromConds( $db, $conditions );
- if( $res ) {
- $row = $res->fetchObject();
- $res->free();
- if( $row ) {
- $ret = new Revision( $row );
- return $ret;
- }
+ * @param IDatabase $db
+ * @param array $conditions
+ * @param int $flags (optional)
+ * @return Revision|null
+ */
+ private static function loadFromConds( $db, $conditions, $flags = 0 ) {
+ $row = self::fetchFromConds( $db, $conditions, $flags );
+ if ( $row ) {
+ $rev = new Revision( $row );
+ $rev->mWiki = $db->getDomainID();
+
+ return $rev;
}
- $ret = null;
- return $ret;
+
+ return null;
}
/**
* fetch all of a given page's revisions in turn.
* Each row can be fed to the constructor to get objects.
*
- * @param $title Title
+ * @param LinkTarget $title
* @return ResultWrapper
+ * @deprecated Since 1.28
*/
- public static function fetchRevision( $title ) {
- return Revision::fetchFromConds(
- wfGetDB( DB_SLAVE ),
- array( 'rev_id=page_latest',
- 'page_namespace' => $title->getNamespace(),
- 'page_title' => $title->getDBkey(),
- 'page_id=rev_page' ) );
+ public static function fetchRevision( LinkTarget $title ) {
+ $row = self::fetchFromConds(
+ wfGetDB( DB_REPLICA ),
+ [
+ 'rev_id=page_latest',
+ 'page_namespace' => $title->getNamespace(),
+ 'page_title' => $title->getDBkey()
+ ]
+ );
+
+ return new FakeResultWrapper( $row ? [ $row ] : [] );
}
/**
* which will return matching database rows with the
* fields necessary to build Revision objects.
*
- * @param $db Database
- * @param $conditions Array
- * @return ResultWrapper
+ * @param IDatabase $db
+ * @param array $conditions
+ * @param int $flags (optional)
+ * @return stdClass
*/
- private static function fetchFromConds( $db, $conditions ) {
- $fields = self::selectFields();
- $fields[] = 'page_namespace';
- $fields[] = 'page_title';
- $fields[] = 'page_latest';
- $res = $db->select(
- array( 'page', 'revision' ),
+ private static function fetchFromConds( $db, $conditions, $flags = 0 ) {
+ $fields = array_merge(
+ self::selectFields(),
+ self::selectPageFields(),
+ self::selectUserFields()
+ );
+ $options = [];
+ if ( ( $flags & self::READ_LOCKING ) == self::READ_LOCKING ) {
+ $options[] = 'FOR UPDATE';
+ }
+ return $db->selectRow(
+ [ 'revision', 'page', 'user' ],
$fields,
$conditions,
__METHOD__,
- array( 'LIMIT' => 1 ) );
- $ret = $db->resultObject( $res );
- return $ret;
+ $options,
+ [ 'page' => self::pageJoinCond(), 'user' => self::userJoinCond() ]
+ );
+ }
+
+ /**
+ * Return the value of a select() JOIN conds array for the user table.
+ * This will get user table rows for logged-in users.
+ * @since 1.19
+ * @return array
+ */
+ public static function userJoinCond() {
+ return [ 'LEFT JOIN', [ 'rev_user != 0', 'user_id = rev_user' ] ];
+ }
+
+ /**
+ * Return the value of a select() page conds array for the page table.
+ * This will assure that the revision(s) are not orphaned from live pages.
+ * @since 1.19
+ * @return array
+ */
+ public static function pageJoinCond() {
+ return [ 'INNER JOIN', [ 'page_id = rev_page' ] ];
}
/**
* Return the list of revision fields that should be selected to create
* a new revision.
+ * @todo Deprecate this in favor of a method that returns tables and joins
+ * as well, and use CommentStore::getJoin().
+ * @return array
*/
- static function selectFields() {
- return array(
+ public static function selectFields() {
+ global $wgContentHandlerUseDB;
+
+ $fields = [
'rev_id',
'rev_page',
'rev_text_id',
'rev_timestamp',
- 'rev_comment',
- 'rev_user_text,'.
+ 'rev_user_text',
'rev_user',
'rev_minor_edit',
'rev_deleted',
'rev_len',
- 'rev_parent_id'
- );
+ 'rev_parent_id',
+ 'rev_sha1',
+ ];
+
+ $fields += CommentStore::newKey( 'rev_comment' )->getFields();
+
+ if ( $wgContentHandlerUseDB ) {
+ $fields[] = 'rev_content_format';
+ $fields[] = 'rev_content_model';
+ }
+
+ return $fields;
+ }
+
+ /**
+ * Return the list of revision fields that should be selected to create
+ * a new revision from an archive row.
+ * @todo Deprecate this in favor of a method that returns tables and joins
+ * as well, and use CommentStore::getJoin().
+ * @return array
+ */
+ public static function selectArchiveFields() {
+ global $wgContentHandlerUseDB;
+ $fields = [
+ 'ar_id',
+ 'ar_page_id',
+ 'ar_rev_id',
+ 'ar_text',
+ 'ar_text_id',
+ 'ar_timestamp',
+ 'ar_user_text',
+ 'ar_user',
+ 'ar_minor_edit',
+ 'ar_deleted',
+ 'ar_len',
+ 'ar_parent_id',
+ 'ar_sha1',
+ ];
+
+ $fields += CommentStore::newKey( 'ar_comment' )->getFields();
+
+ if ( $wgContentHandlerUseDB ) {
+ $fields[] = 'ar_content_format';
+ $fields[] = 'ar_content_model';
+ }
+ return $fields;
}
-
+
/**
- * Return the list of text fields that should be selected to read the
+ * Return the list of text fields that should be selected to read the
* revision text
+ * @return array
*/
- static function selectTextFields() {
- return array(
+ public static function selectTextFields() {
+ return [
'old_text',
'old_flags'
- );
+ ];
}
/**
* Return the list of page fields that should be selected from page table
+ * @return array
*/
- static function selectPageFields() {
- return array(
+ public static function selectPageFields() {
+ return [
'page_namespace',
'page_title',
- 'page_latest'
- );
+ 'page_id',
+ 'page_latest',
+ 'page_is_redirect',
+ 'page_len',
+ ];
}
/**
- * Constructor
- *
- * @param $row Mixed: either a database row or an array
+ * Return the list of user fields that should be selected from user table
+ * @return array
+ */
+ public static function selectUserFields() {
+ return [ 'user_name' ];
+ }
+
+ /**
+ * Do a batched query to get the parent revision lengths
+ * @param IDatabase $db
+ * @param array $revIds
+ * @return array
+ */
+ public static function getParentLengths( $db, array $revIds ) {
+ $revLens = [];
+ if ( !$revIds ) {
+ return $revLens; // empty
+ }
+ $res = $db->select( 'revision',
+ [ 'rev_id', 'rev_len' ],
+ [ 'rev_id' => $revIds ],
+ __METHOD__ );
+ foreach ( $res as $row ) {
+ $revLens[$row->rev_id] = $row->rev_len;
+ }
+ return $revLens;
+ }
+
+ /**
+ * @param object|array $row Either a database row or an array
+ * @throws MWException
* @access private
*/
function __construct( $row ) {
- if( is_object( $row ) ) {
- $this->mId = intval( $row->rev_id );
- $this->mPage = intval( $row->rev_page );
- $this->mTextId = intval( $row->rev_text_id );
- $this->mComment = $row->rev_comment;
- $this->mUserText = $row->rev_user_text;
- $this->mUser = intval( $row->rev_user );
+ if ( is_object( $row ) ) {
+ $this->mId = intval( $row->rev_id );
+ $this->mPage = intval( $row->rev_page );
+ $this->mTextId = intval( $row->rev_text_id );
+ $this->mComment = CommentStore::newKey( 'rev_comment' )
+ // Legacy because $row probably came from self::selectFields()
+ ->getCommentLegacy( wfGetDB( DB_REPLICA ), $row, true )->text;
+ $this->mUser = intval( $row->rev_user );
$this->mMinorEdit = intval( $row->rev_minor_edit );
- $this->mTimestamp = $row->rev_timestamp;
- $this->mDeleted = intval( $row->rev_deleted );
+ $this->mTimestamp = $row->rev_timestamp;
+ $this->mDeleted = intval( $row->rev_deleted );
- if( !isset( $row->rev_parent_id ) )
- $this->mParentId = is_null($row->rev_parent_id) ? null : 0;
- else
- $this->mParentId = intval( $row->rev_parent_id );
+ if ( !isset( $row->rev_parent_id ) ) {
+ $this->mParentId = null;
+ } else {
+ $this->mParentId = intval( $row->rev_parent_id );
+ }
- if( !isset( $row->rev_len ) || is_null( $row->rev_len ) )
+ if ( !isset( $row->rev_len ) ) {
$this->mSize = null;
- else
+ } else {
$this->mSize = intval( $row->rev_len );
+ }
+
+ if ( !isset( $row->rev_sha1 ) ) {
+ $this->mSha1 = null;
+ } else {
+ $this->mSha1 = $row->rev_sha1;
+ }
- if( isset( $row->page_latest ) ) {
+ if ( isset( $row->page_latest ) ) {
$this->mCurrent = ( $row->rev_id == $row->page_latest );
$this->mTitle = Title::newFromRow( $row );
} else {
$this->mTitle = null;
}
+ if ( !isset( $row->rev_content_model ) ) {
+ $this->mContentModel = null; # determine on demand if needed
+ } else {
+ $this->mContentModel = strval( $row->rev_content_model );
+ }
+
+ if ( !isset( $row->rev_content_format ) ) {
+ $this->mContentFormat = null; # determine on demand if needed
+ } else {
+ $this->mContentFormat = strval( $row->rev_content_format );
+ }
+
// Lazy extraction...
- $this->mText = null;
- if( isset( $row->old_text ) ) {
+ $this->mText = null;
+ if ( isset( $row->old_text ) ) {
$this->mTextRow = $row;
} else {
// 'text' table row entry will be lazy-loaded
$this->mTextRow = null;
}
- } elseif( is_array( $row ) ) {
+
+ // Use user_name for users and rev_user_text for IPs...
+ $this->mUserText = null; // lazy load if left null
+ if ( $this->mUser == 0 ) {
+ $this->mUserText = $row->rev_user_text; // IP user
+ } elseif ( isset( $row->user_name ) ) {
+ $this->mUserText = $row->user_name; // logged-in user
+ }
+ $this->mOrigUserText = $row->rev_user_text;
+ } elseif ( is_array( $row ) ) {
// Build a new revision to be saved...
- global $wgUser;
+ global $wgUser; // ugh
+
+ # if we have a content object, use it to set the model and type
+ if ( !empty( $row['content'] ) ) {
+ // @todo when is that set? test with external store setup! check out insertOn() [dk]
+ if ( !empty( $row['text_id'] ) ) {
+ throw new MWException( "Text already stored in external store (id {$row['text_id']}), " .
+ "can't serialize content object" );
+ }
- $this->mId = isset( $row['id'] ) ? intval( $row['id'] ) : null;
- $this->mPage = isset( $row['page'] ) ? intval( $row['page'] ) : null;
- $this->mTextId = isset( $row['text_id'] ) ? intval( $row['text_id'] ) : null;
- $this->mUserText = isset( $row['user_text'] ) ? strval( $row['user_text'] ) : $wgUser->getName();
- $this->mUser = isset( $row['user'] ) ? intval( $row['user'] ) : $wgUser->getId();
+ $row['content_model'] = $row['content']->getModel();
+ # note: mContentFormat is initializes later accordingly
+ # note: content is serialized later in this method!
+ # also set text to null?
+ }
+
+ $this->mId = isset( $row['id'] ) ? intval( $row['id'] ) : null;
+ $this->mPage = isset( $row['page'] ) ? intval( $row['page'] ) : null;
+ $this->mTextId = isset( $row['text_id'] ) ? intval( $row['text_id'] ) : null;
+ $this->mUserText = isset( $row['user_text'] )
+ ? strval( $row['user_text'] ) : $wgUser->getName();
+ $this->mUser = isset( $row['user'] ) ? intval( $row['user'] ) : $wgUser->getId();
$this->mMinorEdit = isset( $row['minor_edit'] ) ? intval( $row['minor_edit'] ) : 0;
- $this->mTimestamp = isset( $row['timestamp'] ) ? strval( $row['timestamp'] ) : wfTimestamp( TS_MW );
- $this->mDeleted = isset( $row['deleted'] ) ? intval( $row['deleted'] ) : 0;
- $this->mSize = isset( $row['len'] ) ? intval( $row['len'] ) : null;
- $this->mParentId = isset( $row['parent_id'] ) ? intval( $row['parent_id'] ) : null;
+ $this->mTimestamp = isset( $row['timestamp'] )
+ ? strval( $row['timestamp'] ) : wfTimestampNow();
+ $this->mDeleted = isset( $row['deleted'] ) ? intval( $row['deleted'] ) : 0;
+ $this->mSize = isset( $row['len'] ) ? intval( $row['len'] ) : null;
+ $this->mParentId = isset( $row['parent_id'] ) ? intval( $row['parent_id'] ) : null;
+ $this->mSha1 = isset( $row['sha1'] ) ? strval( $row['sha1'] ) : null;
+
+ $this->mContentModel = isset( $row['content_model'] )
+ ? strval( $row['content_model'] ) : null;
+ $this->mContentFormat = isset( $row['content_format'] )
+ ? strval( $row['content_format'] ) : null;
// Enforce spacing trimming on supplied text
- $this->mComment = isset( $row['comment'] ) ? trim( strval( $row['comment'] ) ) : null;
- $this->mText = isset( $row['text'] ) ? rtrim( strval( $row['text'] ) ) : null;
- $this->mTextRow = null;
-
- $this->mTitle = null; # Load on demand if needed
- $this->mCurrent = false;
- # If we still have no len_size, see it we have the text to figure it out
- if ( !$this->mSize )
- $this->mSize = is_null( $this->mText ) ? null : strlen( $this->mText );
+ $this->mComment = isset( $row['comment'] ) ? trim( strval( $row['comment'] ) ) : null;
+ $this->mText = isset( $row['text'] ) ? rtrim( strval( $row['text'] ) ) : null;
+ $this->mTextRow = null;
+
+ $this->mTitle = isset( $row['title'] ) ? $row['title'] : null;
+
+ // if we have a Content object, override mText and mContentModel
+ if ( !empty( $row['content'] ) ) {
+ if ( !( $row['content'] instanceof Content ) ) {
+ throw new MWException( '`content` field must contain a Content object.' );
+ }
+
+ $handler = $this->getContentHandler();
+ $this->mContent = $row['content'];
+
+ $this->mContentModel = $this->mContent->getModel();
+ $this->mContentHandler = null;
+
+ $this->mText = $handler->serializeContent( $row['content'], $this->getContentFormat() );
+ } elseif ( $this->mText !== null ) {
+ $handler = $this->getContentHandler();
+ $this->mContent = $handler->unserializeContent( $this->mText );
+ }
+
+ // If we have a Title object, make sure it is consistent with mPage.
+ if ( $this->mTitle && $this->mTitle->exists() ) {
+ if ( $this->mPage === null ) {
+ // if the page ID wasn't known, set it now
+ $this->mPage = $this->mTitle->getArticleID();
+ } elseif ( $this->mTitle->getArticleID() !== $this->mPage ) {
+ // Got different page IDs. This may be legit (e.g. during undeletion),
+ // but it seems worth mentioning it in the log.
+ wfDebug( "Page ID " . $this->mPage . " mismatches the ID " .
+ $this->mTitle->getArticleID() . " provided by the Title object." );
+ }
+ }
+
+ $this->mCurrent = false;
+
+ // If we still have no length, see it we have the text to figure it out
+ if ( !$this->mSize && $this->mContent !== null ) {
+ $this->mSize = $this->mContent->getSize();
+ }
+
+ // Same for sha1
+ if ( $this->mSha1 === null ) {
+ $this->mSha1 = $this->mText === null ? null : self::base36Sha1( $this->mText );
+ }
+
+ // force lazy init
+ $this->getContentModel();
+ $this->getContentFormat();
} else {
throw new MWException( 'Revision constructor passed invalid row format.' );
}
/**
* Get revision ID
*
- * @return Integer
+ * @return int|null
*/
public function getId() {
return $this->mId;
}
+ /**
+ * Set the revision ID
+ *
+ * This should only be used for proposed revisions that turn out to be null edits
+ *
+ * @since 1.19
+ * @param int $id
+ */
+ public function setId( $id ) {
+ $this->mId = (int)$id;
+ }
+
+ /**
+ * Set the user ID/name
+ *
+ * This should only be used for proposed revisions that turn out to be null edits
+ *
+ * @since 1.28
+ * @param int $id User ID
+ * @param string $name User name
+ */
+ public function setUserIdAndName( $id, $name ) {
+ $this->mUser = (int)$id;
+ $this->mUserText = $name;
+ $this->mOrigUserText = $name;
+ }
+
/**
* Get text row ID
*
- * @return Integer
+ * @return int|null
*/
public function getTextId() {
return $this->mTextId;
/**
* Get parent revision ID (the original previous page revision)
*
- * @return Integer
+ * @return int|null
*/
public function getParentId() {
return $this->mParentId;
/**
* Returns the length of the text in this revision, or null if unknown.
*
- * @return Integer
+ * @return int|null
*/
public function getSize() {
return $this->mSize;
}
/**
- * Returns the title of the page associated with this entry.
+ * Returns the base36 sha1 of the text in this revision, or null if unknown.
+ *
+ * @return string|null
+ */
+ public function getSha1() {
+ return $this->mSha1;
+ }
+
+ /**
+ * Returns the title of the page associated with this entry or null.
*
- * @return Title
+ * Will do a query, when title is not set and id is given.
+ *
+ * @return Title|null
*/
public function getTitle() {
- if( isset( $this->mTitle ) ) {
+ if ( $this->mTitle !== null ) {
return $this->mTitle;
}
- $dbr = wfGetDB( DB_SLAVE );
- $row = $dbr->selectRow(
- array( 'page', 'revision' ),
- array( 'page_namespace', 'page_title' ),
- array( 'page_id=rev_page',
- 'rev_id' => $this->mId ),
- 'Revision::getTitle' );
- if( $row ) {
- $this->mTitle = Title::makeTitle( $row->page_namespace,
- $row->page_title );
+ // rev_id is defined as NOT NULL, but this revision may not yet have been inserted.
+ if ( $this->mId !== null ) {
+ $dbr = wfGetLB( $this->mWiki )->getConnectionRef( DB_REPLICA, [], $this->mWiki );
+ $row = $dbr->selectRow(
+ [ 'page', 'revision' ],
+ self::selectPageFields(),
+ [ 'page_id=rev_page', 'rev_id' => $this->mId ],
+ __METHOD__
+ );
+ if ( $row ) {
+ // @TODO: better foreign title handling
+ $this->mTitle = Title::newFromRow( $row );
+ }
+ }
+
+ if ( $this->mWiki === false || $this->mWiki === wfWikiID() ) {
+ // Loading by ID is best, though not possible for foreign titles
+ if ( !$this->mTitle && $this->mPage !== null && $this->mPage > 0 ) {
+ $this->mTitle = Title::newFromID( $this->mPage );
+ }
}
+
return $this->mTitle;
}
/**
* Set the title of the revision
*
- * @param $title Title
+ * @param Title $title
*/
public function setTitle( $title ) {
$this->mTitle = $title;
/**
* Get the page ID
*
- * @return Integer
+ * @return int|null
*/
public function getPage() {
return $this->mPage;
/**
* Fetch revision's user id if it's available to the specified audience.
- * If the specified audience does not have access to it, zero will be
+ * If the specified audience does not have access to it, zero will be
* returned.
*
- * @param $audience Integer: one of:
- * Revision::FOR_PUBLIC to be displayed to all users
- * Revision::FOR_THIS_USER to be displayed to $wgUser
- * Revision::RAW get the ID regardless of permissions
- *
- *
- * @return Integer
+ * @param int $audience One of:
+ * Revision::FOR_PUBLIC to be displayed to all users
+ * Revision::FOR_THIS_USER to be displayed to the given user
+ * Revision::RAW get the ID regardless of permissions
+ * @param User|null $user User object to check for, only if FOR_THIS_USER is passed
+ * to the $audience parameter
+ * @return int
*/
- public function getUser( $audience = self::FOR_PUBLIC ) {
- if( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_USER ) ) {
+ public function getUser( $audience = self::FOR_PUBLIC, User $user = null ) {
+ if ( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_USER ) ) {
return 0;
- } elseif( $audience == self::FOR_THIS_USER && !$this->userCan( self::DELETED_USER ) ) {
+ } elseif ( $audience == self::FOR_THIS_USER && !$this->userCan( self::DELETED_USER, $user ) ) {
return 0;
} else {
return $this->mUser;
/**
* Fetch revision's user id without regard for the current user's permissions
*
- * @return String
+ * @return int
+ * @deprecated since 1.25, use getUser( Revision::RAW )
*/
public function getRawUser() {
- return $this->mUser;
+ wfDeprecated( __METHOD__, '1.25' );
+ return $this->getUser( self::RAW );
}
/**
* Fetch revision's username if it's available to the specified audience.
- * If the specified audience does not have access to the username, an
+ * If the specified audience does not have access to the username, an
* empty string will be returned.
*
- * @param $audience Integer: one of:
- * Revision::FOR_PUBLIC to be displayed to all users
- * Revision::FOR_THIS_USER to be displayed to $wgUser
- * Revision::RAW get the text regardless of permissions
- *
+ * @param int $audience One of:
+ * Revision::FOR_PUBLIC to be displayed to all users
+ * Revision::FOR_THIS_USER to be displayed to the given user
+ * Revision::RAW get the text regardless of permissions
+ * @param User|null $user User object to check for, only if FOR_THIS_USER is passed
+ * to the $audience parameter
* @return string
*/
- public function getUserText( $audience = self::FOR_PUBLIC ) {
- if( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_USER ) ) {
+ public function getUserText( $audience = self::FOR_PUBLIC, User $user = null ) {
+ $this->loadMutableFields();
+
+ if ( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_USER ) ) {
return '';
- } elseif( $audience == self::FOR_THIS_USER && !$this->userCan( self::DELETED_USER ) ) {
+ } elseif ( $audience == self::FOR_THIS_USER && !$this->userCan( self::DELETED_USER, $user ) ) {
return '';
} else {
+ if ( $this->mUserText === null ) {
+ $this->mUserText = User::whoIs( $this->mUser ); // load on demand
+ if ( $this->mUserText === false ) {
+ # This shouldn't happen, but it can if the wiki was recovered
+ # via importing revs and there is no user table entry yet.
+ $this->mUserText = $this->mOrigUserText;
+ }
+ }
return $this->mUserText;
}
}
/**
* Fetch revision's username without regard for view restrictions
*
- * @return String
+ * @return string
+ * @deprecated since 1.25, use getUserText( Revision::RAW )
*/
public function getRawUserText() {
- return $this->mUserText;
+ wfDeprecated( __METHOD__, '1.25' );
+ return $this->getUserText( self::RAW );
}
/**
* Fetch revision comment if it's available to the specified audience.
- * If the specified audience does not have access to the comment, an
+ * If the specified audience does not have access to the comment, an
* empty string will be returned.
*
- * @param $audience Integer: one of:
- * Revision::FOR_PUBLIC to be displayed to all users
- * Revision::FOR_THIS_USER to be displayed to $wgUser
- * Revision::RAW get the text regardless of permissions
- *
- * @return String
+ * @param int $audience One of:
+ * Revision::FOR_PUBLIC to be displayed to all users
+ * Revision::FOR_THIS_USER to be displayed to the given user
+ * Revision::RAW get the text regardless of permissions
+ * @param User|null $user User object to check for, only if FOR_THIS_USER is passed
+ * to the $audience parameter
+ * @return string
*/
- function getComment( $audience = self::FOR_PUBLIC ) {
- if( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_COMMENT ) ) {
+ function getComment( $audience = self::FOR_PUBLIC, User $user = null ) {
+ if ( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_COMMENT ) ) {
return '';
- } elseif( $audience == self::FOR_THIS_USER && !$this->userCan( self::DELETED_COMMENT ) ) {
+ } elseif ( $audience == self::FOR_THIS_USER && !$this->userCan( self::DELETED_COMMENT, $user ) ) {
return '';
} else {
return $this->mComment;
/**
* Fetch revision comment without regard for the current user's permissions
*
- * @return String
+ * @return string
+ * @deprecated since 1.25, use getComment( Revision::RAW )
*/
public function getRawComment() {
- return $this->mComment;
+ wfDeprecated( __METHOD__, '1.25' );
+ return $this->getComment( self::RAW );
}
/**
- * @return Boolean
+ * @return bool
*/
public function isMinor() {
return (bool)$this->mMinorEdit;
}
-
+
/**
- * @return Integer rcid of the unpatrolled row, zero if there isn't one
+ * @return int Rcid of the unpatrolled row, zero if there isn't one
*/
public function isUnpatrolled() {
- if( $this->mUnpatrolled !== null ) {
+ if ( $this->mUnpatrolled !== null ) {
return $this->mUnpatrolled;
}
- $dbr = wfGetDB( DB_SLAVE );
- $this->mUnpatrolled = $dbr->selectField( 'recentchanges',
- 'rc_id',
- array( // Add redundant user,timestamp condition so we can use the existing index
- 'rc_user_text' => $this->getRawUserText(),
- 'rc_timestamp' => $dbr->timestamp( $this->getTimestamp() ),
- 'rc_this_oldid' => $this->getId(),
- 'rc_patrolled' => 0
- ),
- __METHOD__
+ $rc = $this->getRecentChange();
+ if ( $rc && $rc->getAttribute( 'rc_patrolled' ) == 0 ) {
+ $this->mUnpatrolled = $rc->getAttribute( 'rc_id' );
+ } else {
+ $this->mUnpatrolled = 0;
+ }
+ return $this->mUnpatrolled;
+ }
+
+ /**
+ * Get the RC object belonging to the current revision, if there's one
+ *
+ * @param int $flags (optional) $flags include:
+ * Revision::READ_LATEST : Select the data from the master
+ *
+ * @since 1.22
+ * @return RecentChange|null
+ */
+ public function getRecentChange( $flags = 0 ) {
+ $dbr = wfGetDB( DB_REPLICA );
+
+ list( $dbType, ) = DBAccessObjectUtils::getDBOptions( $flags );
+
+ return RecentChange::newFromConds(
+ [
+ 'rc_user_text' => $this->getUserText( self::RAW ),
+ 'rc_timestamp' => $dbr->timestamp( $this->getTimestamp() ),
+ 'rc_this_oldid' => $this->getId()
+ ],
+ __METHOD__,
+ $dbType
);
- return (int)$this->mUnpatrolled;
}
/**
- * int $field one of DELETED_* bitfield constants
+ * @param int $field One of DELETED_* bitfield constants
*
- * @return Boolean
+ * @return bool
*/
public function isDeleted( $field ) {
- return ( $this->mDeleted & $field ) == $field;
+ if ( $this->isCurrent() && $field === self::DELETED_TEXT ) {
+ // Current revisions of pages cannot have the content hidden. Skipping this
+ // check is very useful for Parser as it fetches templates using newKnownCurrent().
+ // Calling getVisibility() in that case triggers a verification database query.
+ return false; // no need to check
+ }
+
+ return ( $this->getVisibility() & $field ) == $field;
}
/**
* Get the deletion bitfield of the revision
+ *
+ * @return int
*/
public function getVisibility() {
+ $this->loadMutableFields();
+
return (int)$this->mDeleted;
}
/**
- * Fetch revision text if it's available to the specified audience.
- * If the specified audience does not have the ability to view this
- * revision, an empty string will be returned.
+ * Fetch revision content if it's available to the specified audience.
+ * If the specified audience does not have the ability to view this
+ * revision, null will be returned.
+ *
+ * @param int $audience One of:
+ * Revision::FOR_PUBLIC to be displayed to all users
+ * Revision::FOR_THIS_USER to be displayed to $wgUser
+ * Revision::RAW get the text regardless of permissions
+ * @param User $user User object to check for, only if FOR_THIS_USER is passed
+ * to the $audience parameter
+ * @since 1.21
+ * @return Content|null
+ */
+ public function getContent( $audience = self::FOR_PUBLIC, User $user = null ) {
+ if ( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_TEXT ) ) {
+ return null;
+ } elseif ( $audience == self::FOR_THIS_USER && !$this->userCan( self::DELETED_TEXT, $user ) ) {
+ return null;
+ } else {
+ return $this->getContentInternal();
+ }
+ }
+
+ /**
+ * Get original serialized data (without checking view restrictions)
*
- * @param $audience Integer: one of:
- * Revision::FOR_PUBLIC to be displayed to all users
- * Revision::FOR_THIS_USER to be displayed to $wgUser
- * Revision::RAW get the text regardless of permissions
+ * @since 1.21
+ * @return string
+ */
+ public function getSerializedData() {
+ if ( $this->mText === null ) {
+ // Revision is immutable. Load on demand.
+ $this->mText = $this->loadText();
+ }
+
+ return $this->mText;
+ }
+
+ /**
+ * Gets the content object for the revision (or null on failure).
*
+ * Note that for mutable Content objects, each call to this method will return a
+ * fresh clone.
*
- * @return String
+ * @since 1.21
+ * @return Content|null The Revision's content, or null on failure.
*/
- public function getText( $audience = self::FOR_PUBLIC ) {
- if( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_TEXT ) ) {
- return '';
- } elseif( $audience == self::FOR_THIS_USER && !$this->userCan( self::DELETED_TEXT ) ) {
- return '';
- } else {
- return $this->getRawText();
+ protected function getContentInternal() {
+ if ( $this->mContent === null ) {
+ $text = $this->getSerializedData();
+
+ if ( $text !== null && $text !== false ) {
+ // Unserialize content
+ $handler = $this->getContentHandler();
+ $format = $this->getContentFormat();
+
+ $this->mContent = $handler->unserializeContent( $text, $format );
+ }
}
+
+ // NOTE: copy() will return $this for immutable content objects
+ return $this->mContent ? $this->mContent->copy() : null;
}
/**
- * Alias for getText(Revision::FOR_THIS_USER)
+ * Returns the content model for this revision.
*
- * @deprecated
- * @return String
+ * If no content model was stored in the database, the default content model for the title is
+ * used to determine the content model to use. If no title is know, CONTENT_MODEL_WIKITEXT
+ * is used as a last resort.
+ *
+ * @return string The content model id associated with this revision,
+ * see the CONTENT_MODEL_XXX constants.
*/
- public function revText() {
- return $this->getText( self::FOR_THIS_USER );
+ public function getContentModel() {
+ if ( !$this->mContentModel ) {
+ $title = $this->getTitle();
+ if ( $title ) {
+ $this->mContentModel = ContentHandler::getDefaultModelFor( $title );
+ } else {
+ $this->mContentModel = CONTENT_MODEL_WIKITEXT;
+ }
+
+ assert( !empty( $this->mContentModel ) );
+ }
+
+ return $this->mContentModel;
}
/**
- * Fetch revision text without regard for view restrictions
+ * Returns the content format for this revision.
+ *
+ * If no content format was stored in the database, the default format for this
+ * revision's content model is returned.
*
- * @return String
+ * @return string The content format id associated with this revision,
+ * see the CONTENT_FORMAT_XXX constants.
*/
- public function getRawText() {
- if( is_null( $this->mText ) ) {
- // Revision text is immutable. Load on demand:
- $this->mText = $this->loadText();
+ public function getContentFormat() {
+ if ( !$this->mContentFormat ) {
+ $handler = $this->getContentHandler();
+ $this->mContentFormat = $handler->getDefaultFormat();
+
+ assert( !empty( $this->mContentFormat ) );
}
- return $this->mText;
+
+ return $this->mContentFormat;
}
/**
- * @return String
+ * Returns the content handler appropriate for this revision's content model.
+ *
+ * @throws MWException
+ * @return ContentHandler
+ */
+ public function getContentHandler() {
+ if ( !$this->mContentHandler ) {
+ $model = $this->getContentModel();
+ $this->mContentHandler = ContentHandler::getForModelID( $model );
+
+ $format = $this->getContentFormat();
+
+ if ( !$this->mContentHandler->isSupportedFormat( $format ) ) {
+ throw new MWException( "Oops, the content format $format is not supported for "
+ . "this content model, $model" );
+ }
+ }
+
+ return $this->mContentHandler;
+ }
+
+ /**
+ * @return string
*/
public function getTimestamp() {
return wfTimestamp( TS_MW, $this->mTimestamp );
}
/**
- * @return Boolean
+ * @return bool
*/
public function isCurrent() {
return $this->mCurrent;
/**
* Get previous revision for this title
*
- * @return Revision or null
+ * @return Revision|null
*/
public function getPrevious() {
- if( $this->getTitle() ) {
+ if ( $this->getTitle() ) {
$prev = $this->getTitle()->getPreviousRevisionID( $this->getId() );
- if( $prev ) {
- return Revision::newFromTitle( $this->getTitle(), $prev );
+ if ( $prev ) {
+ return self::newFromTitle( $this->getTitle(), $prev );
}
}
return null;
/**
* Get next revision for this title
*
- * @return Revision or null
+ * @return Revision|null
*/
public function getNext() {
- if( $this->getTitle() ) {
+ if ( $this->getTitle() ) {
$next = $this->getTitle()->getNextRevisionID( $this->getId() );
if ( $next ) {
- return Revision::newFromTitle( $this->getTitle(), $next );
+ return self::newFromTitle( $this->getTitle(), $next );
}
}
return null;
* Get previous revision Id for this page_id
* This is used to populate rev_parent_id on save
*
- * @param $db DatabaseBase
- * @return Integer
+ * @param IDatabase $db
+ * @return int
*/
private function getPreviousRevisionId( $db ) {
- if( is_null( $this->mPage ) ) {
+ if ( $this->mPage === null ) {
return 0;
}
# Use page_latest if ID is not given
- if( !$this->mId ) {
+ if ( !$this->mId ) {
$prevId = $db->selectField( 'page', 'page_latest',
- array( 'page_id' => $this->mPage ),
+ [ 'page_id' => $this->mPage ],
__METHOD__ );
} else {
$prevId = $db->selectField( 'revision', 'rev_id',
- array( 'rev_page' => $this->mPage, 'rev_id < ' . $this->mId ),
+ [ 'rev_page' => $this->mPage, 'rev_id < ' . $this->mId ],
__METHOD__,
- array( 'ORDER BY' => 'rev_id DESC' ) );
+ [ 'ORDER BY' => 'rev_id DESC' ] );
}
return intval( $prevId );
}
/**
- * Get revision text associated with an old or archive row
- * $row is usually an object from wfFetchRow(), both the flags and the text
- * field must be included
- *
- * @param $row Object: the text data
- * @param $prefix String: table prefix (default 'old_')
- * @return String: text the text requested or false on failure
- */
- public static function getRevisionText( $row, $prefix = 'old_' ) {
- wfProfileIn( __METHOD__ );
-
- # Get data
+ * Get revision text associated with an old or archive row
+ *
+ * Both the flags and the text field must be included. Including the old_id
+ * field will activate cache usage as long as the $wiki parameter is not set.
+ *
+ * @param stdClass $row The text data
+ * @param string $prefix Table prefix (default 'old_')
+ * @param string|bool $wiki The name of the wiki to load the revision text from
+ * (same as the the wiki $row was loaded from) or false to indicate the local
+ * wiki (this is the default). Otherwise, it must be a symbolic wiki database
+ * identifier as understood by the LoadBalancer class.
+ * @return string|false Text the text requested or false on failure
+ */
+ public static function getRevisionText( $row, $prefix = 'old_', $wiki = false ) {
$textField = $prefix . 'text';
$flagsField = $prefix . 'flags';
- if( isset( $row->$flagsField ) ) {
+ if ( isset( $row->$flagsField ) ) {
$flags = explode( ',', $row->$flagsField );
} else {
- $flags = array();
+ $flags = [];
}
- if( isset( $row->$textField ) ) {
+ if ( isset( $row->$textField ) ) {
$text = $row->$textField;
} else {
- wfProfileOut( __METHOD__ );
return false;
}
- # Use external methods for external objects, text in table is URL-only then
+ // Use external methods for external objects, text in table is URL-only then
if ( in_array( 'external', $flags ) ) {
$url = $text;
- @list(/* $proto */, $path ) = explode( '://', $url, 2 );
- if( $path == '' ) {
- wfProfileOut( __METHOD__ );
+ $parts = explode( '://', $url, 2 );
+ if ( count( $parts ) == 1 || $parts[1] == '' ) {
return false;
}
- $text = ExternalStore::fetchFromURL( $url );
- }
-
- // If the text was fetched without an error, convert it
- if ( $text !== false ) {
- if( in_array( 'gzip', $flags ) ) {
- # Deal with optional compression of archived pages.
- # This can be done periodically via maintenance/compressOld.php, and
- # as pages are saved if $wgCompressRevisions is set.
- $text = gzinflate( $text );
- }
- if( in_array( 'object', $flags ) ) {
- # Generic compressed storage
- $obj = unserialize( $text );
- if ( !is_object( $obj ) ) {
- // Invalid object
- wfProfileOut( __METHOD__ );
- return false;
- }
- $text = $obj->getText();
- }
-
- global $wgLegacyEncoding;
- if( $text !== false && $wgLegacyEncoding
- && !in_array( 'utf-8', $flags ) && !in_array( 'utf8', $flags ) )
- {
- # Old revisions kept around in a legacy encoding?
- # Upconvert on demand.
- # ("utf8" checked for compatibility with some broken
- # conversion scripts 2008-12-30)
- global $wgInputEncoding, $wgContLang;
- $text = $wgContLang->iconv( $wgLegacyEncoding, $wgInputEncoding, $text );
+ if ( isset( $row->old_id ) && $wiki === false ) {
+ // Make use of the wiki-local revision text cache
+ $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
+ // The cached value should be decompressed, so handle that and return here
+ return $cache->getWithSetCallback(
+ $cache->makeKey( 'revisiontext', 'textid', $row->old_id ),
+ self::getCacheTTL( $cache ),
+ function () use ( $url, $wiki, $flags ) {
+ // No negative caching per Revision::loadText()
+ $text = ExternalStore::fetchFromURL( $url, [ 'wiki' => $wiki ] );
+
+ return self::decompressRevisionText( $text, $flags );
+ },
+ [ 'pcGroup' => self::TEXT_CACHE_GROUP, 'pcTTL' => $cache::TTL_PROC_LONG ]
+ );
+ } else {
+ $text = ExternalStore::fetchFromURL( $url, [ 'wiki' => $wiki ] );
}
}
- wfProfileOut( __METHOD__ );
- return $text;
+
+ return self::decompressRevisionText( $text, $flags );
}
/**
* data is compressed, and 'utf-8' if we're saving in UTF-8
* mode.
*
- * @param $text Mixed: reference to a text
- * @return String
+ * @param mixed &$text Reference to a text
+ * @return string
*/
public static function compressRevisionText( &$text ) {
global $wgCompressRevisions;
- $flags = array();
+ $flags = [];
# Revisions not marked this way will be converted
# on load if $wgLegacyCharset is set in the future.
$flags[] = 'utf-8';
- if( $wgCompressRevisions ) {
- if( function_exists( 'gzdeflate' ) ) {
- $text = gzdeflate( $text );
- $flags[] = 'gzip';
+ if ( $wgCompressRevisions ) {
+ if ( function_exists( 'gzdeflate' ) ) {
+ $deflated = gzdeflate( $text );
+
+ if ( $deflated === false ) {
+ wfLogWarning( __METHOD__ . ': gzdeflate() failed' );
+ } else {
+ $text = $deflated;
+ $flags[] = 'gzip';
+ }
} else {
- wfDebug( "Revision::compressRevisionText() -- no zlib support, not compressing\n" );
+ wfDebug( __METHOD__ . " -- no zlib support, not compressing\n" );
}
}
return implode( ',', $flags );
}
+ /**
+ * Re-converts revision text according to it's flags.
+ *
+ * @param mixed $text Reference to a text
+ * @param array $flags Compression flags
+ * @return string|bool Decompressed text, or false on failure
+ */
+ public static function decompressRevisionText( $text, $flags ) {
+ global $wgLegacyEncoding, $wgContLang;
+
+ if ( $text === false ) {
+ // Text failed to be fetched; nothing to do
+ return false;
+ }
+
+ if ( in_array( 'gzip', $flags ) ) {
+ # Deal with optional compression of archived pages.
+ # This can be done periodically via maintenance/compressOld.php, and
+ # as pages are saved if $wgCompressRevisions is set.
+ $text = gzinflate( $text );
+
+ if ( $text === false ) {
+ wfLogWarning( __METHOD__ . ': gzinflate() failed' );
+ return false;
+ }
+ }
+
+ if ( in_array( 'object', $flags ) ) {
+ # Generic compressed storage
+ $obj = unserialize( $text );
+ if ( !is_object( $obj ) ) {
+ // Invalid object
+ return false;
+ }
+ $text = $obj->getText();
+ }
+
+ if ( $text !== false && $wgLegacyEncoding
+ && !in_array( 'utf-8', $flags ) && !in_array( 'utf8', $flags )
+ ) {
+ # Old revisions kept around in a legacy encoding?
+ # Upconvert on demand.
+ # ("utf8" checked for compatibility with some broken
+ # conversion scripts 2008-12-30)
+ $text = $wgContLang->iconv( $wgLegacyEncoding, 'UTF-8', $text );
+ }
+
+ return $text;
+ }
+
/**
* Insert a new revision into the database, returning the new revision ID
* number on success and dies horribly on failure.
*
- * @param $dbw DatabaseBase: (master connection)
- * @return Integer
+ * @param IDatabase $dbw (master connection)
+ * @throws MWException
+ * @return int The revision ID
*/
public function insertOn( $dbw ) {
- global $wgDefaultExternalStore;
+ global $wgDefaultExternalStore, $wgContentHandlerUseDB;
+
+ // We're inserting a new revision, so we have to use master anyway.
+ // If it's a null revision, it may have references to rows that
+ // are not in the replica yet (the text row).
+ $this->mQueryFlags |= self::READ_LATEST;
+
+ // Not allowed to have rev_page equal to 0, false, etc.
+ if ( !$this->mPage ) {
+ $title = $this->getTitle();
+ if ( $title instanceof Title ) {
+ $titleText = ' for page ' . $title->getPrefixedText();
+ } else {
+ $titleText = '';
+ }
+ throw new MWException( "Cannot insert revision$titleText: page ID must be nonzero" );
+ }
- wfProfileIn( __METHOD__ );
+ $this->checkContentModel();
$data = $this->mText;
- $flags = Revision::compressRevisionText( $data );
+ $flags = self::compressRevisionText( $data );
# Write to external storage if required
- if( $wgDefaultExternalStore ) {
+ if ( $wgDefaultExternalStore ) {
// Store and get the URL
$data = ExternalStore::insertToDefault( $data );
- if( !$data ) {
+ if ( !$data ) {
throw new MWException( "Unable to store text to external storage" );
}
- if( $flags ) {
+ if ( $flags ) {
$flags .= ',';
}
$flags .= 'external';
}
# Record the text (or external storage URL) to the text table
- if( !isset( $this->mTextId ) ) {
- $old_id = $dbw->nextSequenceValue( 'text_old_id_seq' );
+ if ( $this->mTextId === null ) {
$dbw->insert( 'text',
- array(
- 'old_id' => $old_id,
- 'old_text' => $data,
+ [
+ 'old_text' => $data,
'old_flags' => $flags,
- ), __METHOD__
+ ], __METHOD__
);
$this->mTextId = $dbw->insertId();
}
- if ( $this->mComment === null ) $this->mComment = "";
+ if ( $this->mComment === null ) {
+ $this->mComment = "";
+ }
# Record the edit in revisions
- $rev_id = isset( $this->mId )
- ? $this->mId
- : $dbw->nextSequenceValue( 'revision_rev_id_seq' );
- $dbw->insert( 'revision',
- array(
- 'rev_id' => $rev_id,
- 'rev_page' => $this->mPage,
- 'rev_text_id' => $this->mTextId,
- 'rev_comment' => $this->mComment,
- 'rev_minor_edit' => $this->mMinorEdit ? 1 : 0,
- 'rev_user' => $this->mUser,
- 'rev_user_text' => $this->mUserText,
- 'rev_timestamp' => $dbw->timestamp( $this->mTimestamp ),
- 'rev_deleted' => $this->mDeleted,
- 'rev_len' => $this->mSize,
- 'rev_parent_id' => is_null($this->mParentId) ?
- $this->getPreviousRevisionId( $dbw ) : $this->mParentId
- ), __METHOD__
- );
+ $row = [
+ 'rev_page' => $this->mPage,
+ 'rev_text_id' => $this->mTextId,
+ 'rev_minor_edit' => $this->mMinorEdit ? 1 : 0,
+ 'rev_user' => $this->mUser,
+ 'rev_user_text' => $this->mUserText,
+ 'rev_timestamp' => $dbw->timestamp( $this->mTimestamp ),
+ 'rev_deleted' => $this->mDeleted,
+ 'rev_len' => $this->mSize,
+ 'rev_parent_id' => $this->mParentId === null
+ ? $this->getPreviousRevisionId( $dbw )
+ : $this->mParentId,
+ 'rev_sha1' => $this->mSha1 === null
+ ? self::base36Sha1( $this->mText )
+ : $this->mSha1,
+ ];
+ if ( $this->mId !== null ) {
+ $row['rev_id'] = $this->mId;
+ }
+
+ list( $commentFields, $commentCallback ) =
+ CommentStore::newKey( 'rev_comment' )->insertWithTempTable( $dbw, $this->mComment );
+ $row += $commentFields;
- $this->mId = !is_null( $rev_id ) ? $rev_id : $dbw->insertId();
+ if ( $wgContentHandlerUseDB ) {
+ // NOTE: Store null for the default model and format, to save space.
+ // XXX: Makes the DB sensitive to changed defaults.
+ // Make this behavior optional? Only in miser mode?
- wfRunHooks( 'RevisionInsertComplete', array( &$this, $data, $flags ) );
+ $model = $this->getContentModel();
+ $format = $this->getContentFormat();
+
+ $title = $this->getTitle();
+
+ if ( $title === null ) {
+ throw new MWException( "Insufficient information to determine the title of the "
+ . "revision's page!" );
+ }
+
+ $defaultModel = ContentHandler::getDefaultModelFor( $title );
+ $defaultFormat = ContentHandler::getForModelID( $defaultModel )->getDefaultFormat();
+
+ $row['rev_content_model'] = ( $model === $defaultModel ) ? null : $model;
+ $row['rev_content_format'] = ( $format === $defaultFormat ) ? null : $format;
+ }
+
+ $dbw->insert( 'revision', $row, __METHOD__ );
+
+ if ( $this->mId === null ) {
+ // Only if auto-increment was used
+ $this->mId = $dbw->insertId();
+ }
+ $commentCallback( $this->mId );
+
+ // Assertion to try to catch T92046
+ if ( (int)$this->mId === 0 ) {
+ throw new UnexpectedValueException(
+ 'After insert, Revision mId is ' . var_export( $this->mId, 1 ) . ': ' .
+ var_export( $row, 1 )
+ );
+ }
+
+ // Insert IP revision into ip_changes for use when querying for a range.
+ if ( $this->mUser === 0 && IP::isValid( $this->mUserText ) ) {
+ $ipcRow = [
+ 'ipc_rev_id' => $this->mId,
+ 'ipc_rev_timestamp' => $row['rev_timestamp'],
+ 'ipc_hex' => IP::toHex( $row['rev_user_text'] ),
+ ];
+ $dbw->insert( 'ip_changes', $ipcRow, __METHOD__ );
+ }
+
+ // Avoid PHP 7.1 warning of passing $this by reference
+ $revision = $this;
+ Hooks::run( 'RevisionInsertComplete', [ &$revision, $data, $flags ] );
- wfProfileOut( __METHOD__ );
return $this->mId;
}
+ protected function checkContentModel() {
+ global $wgContentHandlerUseDB;
+
+ // Note: may return null for revisions that have not yet been inserted
+ $title = $this->getTitle();
+
+ $model = $this->getContentModel();
+ $format = $this->getContentFormat();
+ $handler = $this->getContentHandler();
+
+ if ( !$handler->isSupportedFormat( $format ) ) {
+ $t = $title->getPrefixedDBkey();
+
+ throw new MWException( "Can't use format $format with content model $model on $t" );
+ }
+
+ if ( !$wgContentHandlerUseDB && $title ) {
+ // if $wgContentHandlerUseDB is not set,
+ // all revisions must use the default content model and format.
+
+ $defaultModel = ContentHandler::getDefaultModelFor( $title );
+ $defaultHandler = ContentHandler::getForModelID( $defaultModel );
+ $defaultFormat = $defaultHandler->getDefaultFormat();
+
+ if ( $this->getContentModel() != $defaultModel ) {
+ $t = $title->getPrefixedDBkey();
+
+ throw new MWException( "Can't save non-default content model with "
+ . "\$wgContentHandlerUseDB disabled: model is $model, "
+ . "default for $t is $defaultModel" );
+ }
+
+ if ( $this->getContentFormat() != $defaultFormat ) {
+ $t = $title->getPrefixedDBkey();
+
+ throw new MWException( "Can't use non-default content format with "
+ . "\$wgContentHandlerUseDB disabled: format is $format, "
+ . "default for $t is $defaultFormat" );
+ }
+ }
+
+ $content = $this->getContent( self::RAW );
+ $prefixedDBkey = $title->getPrefixedDBkey();
+ $revId = $this->mId;
+
+ if ( !$content ) {
+ throw new MWException(
+ "Content of revision $revId ($prefixedDBkey) could not be loaded for validation!"
+ );
+ }
+ if ( !$content->isValid() ) {
+ throw new MWException(
+ "Content of revision $revId ($prefixedDBkey) is not valid! Content model is $model"
+ );
+ }
+ }
+
+ /**
+ * Get the base 36 SHA-1 value for a string of text
+ * @param string $text
+ * @return string
+ */
+ public static function base36Sha1( $text ) {
+ return Wikimedia\base_convert( sha1( $text ), 16, 36, 31 );
+ }
+
+ /**
+ * Get the text cache TTL
+ *
+ * @param WANObjectCache $cache
+ * @return int
+ */
+ private static function getCacheTTL( WANObjectCache $cache ) {
+ global $wgRevisionCacheExpiry;
+
+ if ( $cache->getQoS( $cache::ATTR_EMULATION ) <= $cache::QOS_EMULATION_SQL ) {
+ // Do not cache RDBMs blobs in...the RDBMs store
+ $ttl = $cache::TTL_UNCACHEABLE;
+ } else {
+ $ttl = $wgRevisionCacheExpiry ?: $cache::TTL_UNCACHEABLE;
+ }
+
+ return $ttl;
+ }
+
/**
* Lazy-load the revision's text.
* Currently hardcoded to the 'text' table storage engine.
*
- * @return String
+ * @return string|bool The revision's text, or false on failure
*/
- protected function loadText() {
- wfProfileIn( __METHOD__ );
+ private function loadText() {
+ $cache = ObjectCache::getMainWANInstance();
+
+ // No negative caching; negative hits on text rows may be due to corrupted replica DBs
+ return $cache->getWithSetCallback(
+ $cache->makeKey( 'revisiontext', 'textid', $this->getTextId() ),
+ self::getCacheTTL( $cache ),
+ function () {
+ return $this->fetchText();
+ },
+ [ 'pcGroup' => self::TEXT_CACHE_GROUP, 'pcTTL' => $cache::TTL_PROC_LONG ]
+ );
+ }
- // Caching may be beneficial for massive use of external storage
- global $wgRevisionCacheExpiry, $wgMemc;
+ private function fetchText() {
$textId = $this->getTextId();
- $key = wfMemcKey( 'revisiontext', 'textid', $textId );
- if( $wgRevisionCacheExpiry ) {
- $text = $wgMemc->get( $key );
- if( is_string( $text ) ) {
- wfDebug( __METHOD__ . ": got id $textId from cache\n" );
- wfProfileOut( __METHOD__ );
- return $text;
- }
- }
// If we kept data for lazy extraction, use it now...
- if ( isset( $this->mTextRow ) ) {
+ if ( $this->mTextRow !== null ) {
$row = $this->mTextRow;
$this->mTextRow = null;
} else {
$row = null;
}
- if( !$row ) {
- // Text data is immutable; check slaves first.
- $dbr = wfGetDB( DB_SLAVE );
- $row = $dbr->selectRow( 'text',
- array( 'old_text', 'old_flags' ),
- array( 'old_id' => $this->getTextId() ),
- __METHOD__ );
+ // Callers doing updates will pass in READ_LATEST as usual. Since the text/blob tables
+ // do not normally get rows changed around, set READ_LATEST_IMMUTABLE in those cases.
+ $flags = $this->mQueryFlags;
+ $flags |= DBAccessObjectUtils::hasFlags( $flags, self::READ_LATEST )
+ ? self::READ_LATEST_IMMUTABLE
+ : 0;
+
+ list( $index, $options, $fallbackIndex, $fallbackOptions ) =
+ DBAccessObjectUtils::getDBOptions( $flags );
+
+ if ( !$row ) {
+ // Text data is immutable; check replica DBs first.
+ $row = wfGetDB( $index )->selectRow(
+ 'text',
+ [ 'old_text', 'old_flags' ],
+ [ 'old_id' => $textId ],
+ __METHOD__,
+ $options
+ );
}
- if( !$row && wfGetLB()->getServerCount() > 1 ) {
- // Possible slave lag!
- $dbw = wfGetDB( DB_MASTER );
- $row = $dbw->selectRow( 'text',
- array( 'old_text', 'old_flags' ),
- array( 'old_id' => $this->getTextId() ),
- __METHOD__ );
+ // Fallback to DB_MASTER in some cases if the row was not found
+ if ( !$row && $fallbackIndex !== null ) {
+ // Use FOR UPDATE if it was used to fetch this revision. This avoids missing the row
+ // due to REPEATABLE-READ. Also fallback to the master if READ_LATEST is provided.
+ $row = wfGetDB( $fallbackIndex )->selectRow(
+ 'text',
+ [ 'old_text', 'old_flags' ],
+ [ 'old_id' => $textId ],
+ __METHOD__,
+ $fallbackOptions
+ );
}
- $text = self::getRevisionText( $row );
-
- # No negative caching -- negative hits on text rows may be due to corrupted slave servers
- if( $wgRevisionCacheExpiry && $text !== false ) {
- $wgMemc->set( $key, $text, $wgRevisionCacheExpiry );
+ if ( !$row ) {
+ wfDebugLog( 'Revision', "No text row with ID '$textId' (revision {$this->getId()})." );
}
- wfProfileOut( __METHOD__ );
+ $text = self::getRevisionText( $row );
+ if ( $row && $text === false ) {
+ wfDebugLog( 'Revision', "No blob for text row '$textId' (revision {$this->getId()})." );
+ }
- return $text;
+ return is_string( $text ) ? $text : false;
}
/**
* Such revisions can for instance identify page rename
* operations and other such meta-modifications.
*
- * @param $dbw DatabaseBase
- * @param $pageId Integer: ID number of the page to read from
- * @param $summary String: revision's summary
- * @param $minor Boolean: whether the revision should be considered as minor
- * @return Mixed: Revision, or null on error
+ * @param IDatabase $dbw
+ * @param int $pageId ID number of the page to read from
+ * @param string $summary Revision's summary
+ * @param bool $minor Whether the revision should be considered as minor
+ * @param User|null $user User object to use or null for $wgUser
+ * @return Revision|null Revision or null on error
*/
- public static function newNullRevision( $dbw, $pageId, $summary, $minor ) {
- wfProfileIn( __METHOD__ );
+ public static function newNullRevision( $dbw, $pageId, $summary, $minor, $user = null ) {
+ global $wgContentHandlerUseDB;
+
+ $fields = [ 'page_latest', 'page_namespace', 'page_title',
+ 'rev_text_id', 'rev_len', 'rev_sha1' ];
+
+ if ( $wgContentHandlerUseDB ) {
+ $fields[] = 'rev_content_model';
+ $fields[] = 'rev_content_format';
+ }
$current = $dbw->selectRow(
- array( 'page', 'revision' ),
- array( 'page_latest', 'rev_text_id', 'rev_len' ),
- array(
+ [ 'page', 'revision' ],
+ $fields,
+ [
'page_id' => $pageId,
'page_latest=rev_id',
- ),
- __METHOD__ );
+ ],
+ __METHOD__,
+ [ 'FOR UPDATE' ] // T51581
+ );
- if( $current ) {
- $revision = new Revision( array(
+ if ( $current ) {
+ if ( !$user ) {
+ global $wgUser;
+ $user = $wgUser;
+ }
+
+ $row = [
'page' => $pageId,
+ 'user_text' => $user->getName(),
+ 'user' => $user->getId(),
'comment' => $summary,
'minor_edit' => $minor,
'text_id' => $current->rev_text_id,
'parent_id' => $current->page_latest,
- 'len' => $current->rev_len
- ) );
+ 'len' => $current->rev_len,
+ 'sha1' => $current->rev_sha1
+ ];
+
+ if ( $wgContentHandlerUseDB ) {
+ $row['content_model'] = $current->rev_content_model;
+ $row['content_format'] = $current->rev_content_format;
+ }
+
+ $row['title'] = Title::makeTitle( $current->page_namespace, $current->page_title );
+
+ $revision = new Revision( $row );
} else {
$revision = null;
}
- wfProfileOut( __METHOD__ );
return $revision;
}
* Determine if the current user is allowed to view a particular
* field of this revision, if it's marked as deleted.
*
- * @param $field Integer:one of self::DELETED_TEXT,
+ * @param int $field One of self::DELETED_TEXT,
* self::DELETED_COMMENT,
* self::DELETED_USER
- * @return Boolean
+ * @param User|null $user User object to check, or null to use $wgUser
+ * @return bool
*/
- public function userCan( $field ) {
- return self::userCanBitfield( $this->mDeleted, $field );
+ public function userCan( $field, User $user = null ) {
+ return self::userCanBitfield( $this->getVisibility(), $field, $user );
}
/**
* field of this revision, if it's marked as deleted. This is used
* by various classes to avoid duplication.
*
- * @param $bitfield Integer: current field
- * @param $field Integer: one of self::DELETED_TEXT = File::DELETED_FILE,
+ * @param int $bitfield Current field
+ * @param int $field One of self::DELETED_TEXT = File::DELETED_FILE,
* self::DELETED_COMMENT = File::DELETED_COMMENT,
* self::DELETED_USER = File::DELETED_USER
- * @return Boolean
+ * @param User|null $user User object to check, or null to use $wgUser
+ * @param Title|null $title A Title object to check for per-page restrictions on,
+ * instead of just plain userrights
+ * @return bool
*/
- public static function userCanBitfield( $bitfield, $field ) {
- if( $bitfield & $field ) { // aspect is deleted
- global $wgUser;
+ public static function userCanBitfield( $bitfield, $field, User $user = null,
+ Title $title = null
+ ) {
+ if ( $bitfield & $field ) { // aspect is deleted
+ if ( $user === null ) {
+ global $wgUser;
+ $user = $wgUser;
+ }
if ( $bitfield & self::DELETED_RESTRICTED ) {
- $permission = 'suppressrevision';
+ $permissions = [ 'suppressrevision', 'viewsuppressed' ];
} elseif ( $field & self::DELETED_TEXT ) {
- $permission = 'deletedtext';
+ $permissions = [ 'deletedtext' ];
+ } else {
+ $permissions = [ 'deletedhistory' ];
+ }
+ $permissionlist = implode( ', ', $permissions );
+ if ( $title === null ) {
+ wfDebug( "Checking for $permissionlist due to $field match on $bitfield\n" );
+ return call_user_func_array( [ $user, 'isAllowedAny' ], $permissions );
} else {
- $permission = 'deletedhistory';
+ $text = $title->getPrefixedText();
+ wfDebug( "Checking for $permissionlist on $text due to $field match on $bitfield\n" );
+ foreach ( $permissions as $perm ) {
+ if ( $title->userCan( $perm, $user ) ) {
+ return true;
+ }
+ }
+ return false;
}
- wfDebug( "Checking for $permission due to $field match on $bitfield\n" );
- return $wgUser->isAllowed( $permission );
} else {
return true;
}
/**
* Get rev_timestamp from rev_id, without loading the rest of the row
*
- * @param $title Title
- * @param $id Integer
- * @return String
+ * @param Title $title
+ * @param int $id
+ * @param int $flags
+ * @return string|bool False if not found
*/
- static function getTimestampFromId( $title, $id ) {
- $dbr = wfGetDB( DB_SLAVE );
- // Casting fix for DB2
+ static function getTimestampFromId( $title, $id, $flags = 0 ) {
+ $db = ( $flags & self::READ_LATEST )
+ ? wfGetDB( DB_MASTER )
+ : wfGetDB( DB_REPLICA );
+ // Casting fix for databases that can't take '' for rev_id
if ( $id == '' ) {
$id = 0;
}
- $conds = array( 'rev_id' => $id );
- $conds['rev_page'] = $title->getArticleId();
- $timestamp = $dbr->selectField( 'revision', 'rev_timestamp', $conds, __METHOD__ );
- if ( $timestamp === false && wfGetLB()->getServerCount() > 1 ) {
- # Not in slave, try master
- $dbw = wfGetDB( DB_MASTER );
- $timestamp = $dbw->selectField( 'revision', 'rev_timestamp', $conds, __METHOD__ );
- }
- return wfTimestamp( TS_MW, $timestamp );
+ $conds = [ 'rev_id' => $id ];
+ $conds['rev_page'] = $title->getArticleID();
+ $timestamp = $db->selectField( 'revision', 'rev_timestamp', $conds, __METHOD__ );
+
+ return ( $timestamp !== false ) ? wfTimestamp( TS_MW, $timestamp ) : false;
}
/**
* Get count of revisions per page...not very efficient
*
- * @param $db DatabaseBase
- * @param $id Integer: page id
- * @return Integer
+ * @param IDatabase $db
+ * @param int $id Page id
+ * @return int
*/
static function countByPageId( $db, $id ) {
- $row = $db->selectRow( 'revision', 'COUNT(*) AS revCount',
- array( 'rev_page' => $id ), __METHOD__ );
- if( $row ) {
+ $row = $db->selectRow( 'revision', [ 'revCount' => 'COUNT(*)' ],
+ [ 'rev_page' => $id ], __METHOD__ );
+ if ( $row ) {
return $row->revCount;
}
return 0;
/**
* Get count of revisions per page...not very efficient
*
- * @param $db DatabaseBase
- * @param $title Title
- * @return Integer
+ * @param IDatabase $db
+ * @param Title $title
+ * @return int
*/
static function countByTitle( $db, $title ) {
- $id = $title->getArticleId();
- if( $id ) {
- return Revision::countByPageId( $db, $id );
+ $id = $title->getArticleID();
+ if ( $id ) {
+ return self::countByPageId( $db, $id );
}
return 0;
}
-}
-/**
- * Aliases for backwards compatibility with 1.6
- */
-define( 'MW_REV_DELETED_TEXT', Revision::DELETED_TEXT );
-define( 'MW_REV_DELETED_COMMENT', Revision::DELETED_COMMENT );
-define( 'MW_REV_DELETED_USER', Revision::DELETED_USER );
-define( 'MW_REV_DELETED_RESTRICTED', Revision::DELETED_RESTRICTED );
+ /**
+ * Check if no edits were made by other users since
+ * the time a user started editing the page. Limit to
+ * 50 revisions for the sake of performance.
+ *
+ * @since 1.20
+ * @deprecated since 1.24
+ *
+ * @param IDatabase|int $db The Database to perform the check on. May be given as a
+ * Database object or a database identifier usable with wfGetDB.
+ * @param int $pageId The ID of the page in question
+ * @param int $userId The ID of the user in question
+ * @param string $since Look at edits since this time
+ *
+ * @return bool True if the given user was the only one to edit since the given timestamp
+ */
+ public static function userWasLastToEdit( $db, $pageId, $userId, $since ) {
+ if ( !$userId ) {
+ return false;
+ }
+
+ if ( is_int( $db ) ) {
+ $db = wfGetDB( $db );
+ }
+
+ $res = $db->select( 'revision',
+ 'rev_user',
+ [
+ 'rev_page' => $pageId,
+ 'rev_timestamp > ' . $db->addQuotes( $db->timestamp( $since ) )
+ ],
+ __METHOD__,
+ [ 'ORDER BY' => 'rev_timestamp ASC', 'LIMIT' => 50 ] );
+ foreach ( $res as $row ) {
+ if ( $row->rev_user != $userId ) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Load a revision based on a known page ID and current revision ID from the DB
+ *
+ * This method allows for the use of caching, though accessing anything that normally
+ * requires permission checks (aside from the text) will trigger a small DB lookup.
+ * The title will also be lazy loaded, though setTitle() can be used to preload it.
+ *
+ * @param IDatabase $db
+ * @param int $pageId Page ID
+ * @param int $revId Known current revision of this page
+ * @return Revision|bool Returns false if missing
+ * @since 1.28
+ */
+ public static function newKnownCurrent( IDatabase $db, $pageId, $revId ) {
+ $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
+ return $cache->getWithSetCallback(
+ // Page/rev IDs passed in from DB to reflect history merges
+ $cache->makeGlobalKey( 'revision', $db->getDomainID(), $pageId, $revId ),
+ $cache::TTL_WEEK,
+ function ( $curValue, &$ttl, array &$setOpts ) use ( $db, $pageId, $revId ) {
+ $setOpts += Database::getCacheSetOptions( $db );
+
+ $rev = Revision::loadFromPageId( $db, $pageId, $revId );
+ // Reflect revision deletion and user renames
+ if ( $rev ) {
+ $rev->mTitle = null; // mutable; lazy-load
+ $rev->mRefreshMutableFields = true;
+ }
+
+ return $rev ?: false; // don't cache negatives
+ }
+ );
+ }
+
+ /**
+ * For cached revisions, make sure the user name and rev_deleted is up-to-date
+ */
+ private function loadMutableFields() {
+ if ( !$this->mRefreshMutableFields ) {
+ return; // not needed
+ }
+
+ $this->mRefreshMutableFields = false;
+ $dbr = wfGetLB( $this->mWiki )->getConnectionRef( DB_REPLICA, [], $this->mWiki );
+ $row = $dbr->selectRow(
+ [ 'revision', 'user' ],
+ [ 'rev_deleted', 'user_name' ],
+ [ 'rev_id' => $this->mId, 'user_id = rev_user' ],
+ __METHOD__
+ );
+ if ( $row ) { // update values
+ $this->mDeleted = (int)$row->rev_deleted;
+ $this->mUserText = $row->user_name;
+ }
+ }
+}
scripts.mit.edu / autoinstallsdev / mediawiki.git / blobdiff