993baa3493
When this was originally written, the plan was to read both the old and new fields during the transition period, while stopping writes to them midway through. It turns out that the WHERE conditions to do read-both correctly are generally not handled well by the database and working around that would require a lot of complicated code (see what's being removed from ApiQueryUserContribs here, for example). We can simplify things greatly by instead having it write both fields during the transition period, reading from the old for the first part and the new for the second part, as is being done for MCR. Bug: T204669 Change-Id: I4764c1c7883dc1003cb12729455c8107319f70b1 Depends-On: I845f6ae462f2539ebd35cbb5f2ca8b5714e2c1fb Depends-On: I88b31b977543fdbdf69f8c1158e77e448df94e11
382 lines
12 KiB
PHP
382 lines
12 KiB
PHP
<?php
|
|
/**
|
|
* Methods to help with the actor table migration
|
|
*
|
|
* 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 MediaWiki\MediaWikiServices;
|
|
use MediaWiki\User\UserIdentity;
|
|
use Wikimedia\Rdbms\IDatabase;
|
|
|
|
/**
|
|
* This class handles the logic for the actor table migration.
|
|
*
|
|
* This is not intended to be a long-term part of MediaWiki; it will be
|
|
* deprecated and removed along with $wgActorTableSchemaMigrationStage.
|
|
*
|
|
* @since 1.31
|
|
*/
|
|
class ActorMigration {
|
|
|
|
/**
|
|
* Constant for extensions to feature-test whether $wgActorTableSchemaMigrationStage
|
|
* expects MIGRATION_* or SCHEMA_COMPAT_*
|
|
*/
|
|
const MIGRATION_STAGE_SCHEMA_COMPAT = 1;
|
|
|
|
/**
|
|
* Define fields that use temporary tables for transitional purposes
|
|
* @var array Keys are '$key', values are arrays with four fields:
|
|
* - table: Temporary table name
|
|
* - pk: Temporary table column referring to the main table's primary key
|
|
* - field: Temporary table column referring actor.actor_id
|
|
* - joinPK: Main table's primary key
|
|
*/
|
|
private static $tempTables = [
|
|
'rev_user' => [
|
|
'table' => 'revision_actor_temp',
|
|
'pk' => 'revactor_rev',
|
|
'field' => 'revactor_actor',
|
|
'joinPK' => 'rev_id',
|
|
'extra' => [
|
|
'revactor_timestamp' => 'rev_timestamp',
|
|
'revactor_page' => 'rev_page',
|
|
],
|
|
],
|
|
];
|
|
|
|
/**
|
|
* Fields that formerly used $tempTables
|
|
* @var array Key is '$key', value is the MediaWiki version in which it was
|
|
* removed from $tempTables.
|
|
*/
|
|
private static $formerTempTables = [];
|
|
|
|
/**
|
|
* Define fields that use non-standard mapping
|
|
* @var array Keys are the user id column name, values are arrays with two
|
|
* elements (the user text column name and the actor id column name)
|
|
*/
|
|
private static $specialFields = [
|
|
'ipb_by' => [ 'ipb_by_text', 'ipb_by_actor' ],
|
|
];
|
|
|
|
/** @var array|null Cache for `self::getJoin()` */
|
|
private $joinCache = null;
|
|
|
|
/** @var int Combination of SCHEMA_COMPAT_* constants */
|
|
private $stage;
|
|
|
|
/** @private */
|
|
public function __construct( $stage ) {
|
|
if ( ( $stage & SCHEMA_COMPAT_WRITE_BOTH ) === 0 ) {
|
|
throw new InvalidArgumentException( '$stage must include a write mode' );
|
|
}
|
|
if ( ( $stage & SCHEMA_COMPAT_READ_BOTH ) === 0 ) {
|
|
throw new InvalidArgumentException( '$stage must include a read mode' );
|
|
}
|
|
if ( ( $stage & SCHEMA_COMPAT_READ_BOTH ) === SCHEMA_COMPAT_READ_BOTH ) {
|
|
throw new InvalidArgumentException( 'Cannot read both schemas' );
|
|
}
|
|
if ( ( $stage & SCHEMA_COMPAT_READ_OLD ) && !( $stage & SCHEMA_COMPAT_WRITE_OLD ) ) {
|
|
throw new InvalidArgumentException( 'Cannot read the old schema without also writing it' );
|
|
}
|
|
if ( ( $stage & SCHEMA_COMPAT_READ_NEW ) && !( $stage & SCHEMA_COMPAT_WRITE_NEW ) ) {
|
|
throw new InvalidArgumentException( 'Cannot read the new schema without also writing it' );
|
|
}
|
|
|
|
$this->stage = $stage;
|
|
}
|
|
|
|
/**
|
|
* Static constructor
|
|
* @return ActorMigration
|
|
*/
|
|
public static function newMigration() {
|
|
return MediaWikiServices::getInstance()->getActorMigration();
|
|
}
|
|
|
|
/**
|
|
* Return an SQL condition to test if a user field is anonymous
|
|
* @param string $field Field name or SQL fragment
|
|
* @return string
|
|
*/
|
|
public function isAnon( $field ) {
|
|
return ( $this->stage & SCHEMA_COMPAT_READ_NEW ) ? "$field IS NULL" : "$field = 0";
|
|
}
|
|
|
|
/**
|
|
* Return an SQL condition to test if a user field is non-anonymous
|
|
* @param string $field Field name or SQL fragment
|
|
* @return string
|
|
*/
|
|
public function isNotAnon( $field ) {
|
|
return ( $this->stage & SCHEMA_COMPAT_READ_NEW ) ? "$field IS NOT NULL" : "$field != 0";
|
|
}
|
|
|
|
/**
|
|
* @param string $key A key such as "rev_user" identifying the actor
|
|
* field being fetched.
|
|
* @return string[] [ $text, $actor ]
|
|
*/
|
|
private static function getFieldNames( $key ) {
|
|
if ( isset( self::$specialFields[$key] ) ) {
|
|
return self::$specialFields[$key];
|
|
}
|
|
|
|
return [ $key . '_text', substr( $key, 0, -5 ) . '_actor' ];
|
|
}
|
|
|
|
/**
|
|
* Get SELECT fields and joins for the actor key
|
|
*
|
|
* @param string $key A key such as "rev_user" identifying the actor
|
|
* field being fetched.
|
|
* @return array With three keys:
|
|
* - tables: (string[]) to include in the `$table` to `IDatabase->select()`
|
|
* - fields: (string[]) to include in the `$vars` to `IDatabase->select()`
|
|
* - joins: (array) to include in the `$join_conds` to `IDatabase->select()`
|
|
* All tables, fields, and joins are aliased, so `+` is safe to use.
|
|
*/
|
|
public function getJoin( $key ) {
|
|
if ( !isset( $this->joinCache[$key] ) ) {
|
|
$tables = [];
|
|
$fields = [];
|
|
$joins = [];
|
|
|
|
list( $text, $actor ) = self::getFieldNames( $key );
|
|
|
|
if ( $this->stage & SCHEMA_COMPAT_READ_OLD ) {
|
|
$fields[$key] = $key;
|
|
$fields[$text] = $text;
|
|
$fields[$actor] = 'NULL';
|
|
} else {
|
|
if ( isset( self::$tempTables[$key] ) ) {
|
|
$t = self::$tempTables[$key];
|
|
$alias = "temp_$key";
|
|
$tables[$alias] = $t['table'];
|
|
$joins[$alias] = [ 'JOIN', "{$alias}.{$t['pk']} = {$t['joinPK']}" ];
|
|
$joinField = "{$alias}.{$t['field']}";
|
|
} else {
|
|
$joinField = $actor;
|
|
}
|
|
|
|
$alias = "actor_$key";
|
|
$tables[$alias] = 'actor';
|
|
$joins[$alias] = [ 'JOIN', "{$alias}.actor_id = {$joinField}" ];
|
|
|
|
$fields[$key] = "{$alias}.actor_user";
|
|
$fields[$text] = "{$alias}.actor_name";
|
|
$fields[$actor] = $joinField;
|
|
}
|
|
|
|
$this->joinCache[$key] = [
|
|
'tables' => $tables,
|
|
'fields' => $fields,
|
|
'joins' => $joins,
|
|
];
|
|
}
|
|
|
|
return $this->joinCache[$key];
|
|
}
|
|
|
|
/**
|
|
* Get UPDATE fields for the actor
|
|
*
|
|
* @param IDatabase $dbw Database to use for creating an actor ID, if necessary
|
|
* @param string $key A key such as "rev_user" identifying the actor
|
|
* field being fetched.
|
|
* @param UserIdentity $user User to set in the update
|
|
* @return array to merge into `$values` to `IDatabase->update()` or `$a` to `IDatabase->insert()`
|
|
*/
|
|
public function getInsertValues( IDatabase $dbw, $key, UserIdentity $user ) {
|
|
if ( isset( self::$tempTables[$key] ) ) {
|
|
throw new InvalidArgumentException( "Must use getInsertValuesWithTempTable() for $key" );
|
|
}
|
|
|
|
list( $text, $actor ) = self::getFieldNames( $key );
|
|
$ret = [];
|
|
if ( $this->stage & SCHEMA_COMPAT_WRITE_OLD ) {
|
|
$ret[$key] = $user->getId();
|
|
$ret[$text] = $user->getName();
|
|
}
|
|
if ( $this->stage & SCHEMA_COMPAT_WRITE_NEW ) {
|
|
// We need to be able to assign an actor ID if none exists
|
|
if ( !$user instanceof User && !$user->getActorId() ) {
|
|
$user = User::newFromAnyId( $user->getId(), $user->getName(), null );
|
|
}
|
|
$ret[$actor] = $user->getActorId( $dbw );
|
|
}
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Get UPDATE fields for the actor
|
|
*
|
|
* @param IDatabase $dbw Database to use for creating an actor ID, if necessary
|
|
* @param string $key A key such as "rev_user" identifying the actor
|
|
* field being fetched.
|
|
* @param UserIdentity $user User to set in the update
|
|
* @return array with two values:
|
|
* - array to merge into `$values` to `IDatabase->update()` or `$a` to `IDatabase->insert()`
|
|
* - callback to call with the primary key for the main table insert
|
|
* and extra fields needed for the temp table.
|
|
*/
|
|
public function getInsertValuesWithTempTable( IDatabase $dbw, $key, UserIdentity $user ) {
|
|
if ( isset( self::$formerTempTables[$key] ) ) {
|
|
wfDeprecated( __METHOD__ . " for $key", self::$formerTempTables[$key] );
|
|
} elseif ( !isset( self::$tempTables[$key] ) ) {
|
|
throw new InvalidArgumentException( "Must use getInsertValues() for $key" );
|
|
}
|
|
|
|
list( $text, $actor ) = self::getFieldNames( $key );
|
|
$ret = [];
|
|
$callback = null;
|
|
if ( $this->stage & SCHEMA_COMPAT_WRITE_OLD ) {
|
|
$ret[$key] = $user->getId();
|
|
$ret[$text] = $user->getName();
|
|
}
|
|
if ( $this->stage & SCHEMA_COMPAT_WRITE_NEW ) {
|
|
// We need to be able to assign an actor ID if none exists
|
|
if ( !$user instanceof User && !$user->getActorId() ) {
|
|
$user = User::newFromAnyId( $user->getId(), $user->getName(), null );
|
|
}
|
|
$id = $user->getActorId( $dbw );
|
|
|
|
if ( isset( self::$tempTables[$key] ) ) {
|
|
$func = __METHOD__;
|
|
$callback = function ( $pk, array $extra ) use ( $dbw, $key, $id, $func ) {
|
|
$t = self::$tempTables[$key];
|
|
$set = [ $t['field'] => $id ];
|
|
foreach ( $t['extra'] as $to => $from ) {
|
|
if ( !array_key_exists( $from, $extra ) ) {
|
|
throw new InvalidArgumentException( "$func callback: \$extra[$from] is not provided" );
|
|
}
|
|
$set[$to] = $extra[$from];
|
|
}
|
|
$dbw->upsert(
|
|
$t['table'],
|
|
[ $t['pk'] => $pk ] + $set,
|
|
[ $t['pk'] ],
|
|
$set,
|
|
$func
|
|
);
|
|
};
|
|
} else {
|
|
$ret[$actor] = $id;
|
|
$callback = function ( $pk, array $extra ) {
|
|
};
|
|
}
|
|
} elseif ( isset( self::$tempTables[$key] ) ) {
|
|
$func = __METHOD__;
|
|
$callback = function ( $pk, array $extra ) use ( $key, $func ) {
|
|
$t = self::$tempTables[$key];
|
|
foreach ( $t['extra'] as $to => $from ) {
|
|
if ( !array_key_exists( $from, $extra ) ) {
|
|
throw new InvalidArgumentException( "$func callback: \$extra[$from] is not provided" );
|
|
}
|
|
}
|
|
};
|
|
} else {
|
|
$callback = function ( $pk, array $extra ) {
|
|
};
|
|
}
|
|
return [ $ret, $callback ];
|
|
}
|
|
|
|
/**
|
|
* Get WHERE condition for the actor
|
|
*
|
|
* @param IDatabase $db Database to use for quoting and list-making
|
|
* @param string $key A key such as "rev_user" identifying the actor
|
|
* field being fetched.
|
|
* @param UserIdentity|UserIdentity[] $users Users to test for
|
|
* @param bool $useId If false, don't try to query by the user ID.
|
|
* Intended for use with rc_user since it has an index on
|
|
* (rc_user_text,rc_timestamp) but not (rc_user,rc_timestamp).
|
|
* @return array With three keys:
|
|
* - tables: (string[]) to include in the `$table` to `IDatabase->select()`
|
|
* - conds: (string) to include in the `$cond` to `IDatabase->select()`
|
|
* - orconds: (array[]) array of alternatives in case a union of multiple
|
|
* queries would be more efficient than a query with OR. May have keys
|
|
* 'actor', 'userid', 'username'.
|
|
* Since 1.32, this is guaranteed to contain just one alternative if
|
|
* $users contains a single user.
|
|
* - joins: (array) to include in the `$join_conds` to `IDatabase->select()`
|
|
* All tables and joins are aliased, so `+` is safe to use.
|
|
*/
|
|
public function getWhere( IDatabase $db, $key, $users, $useId = true ) {
|
|
$tables = [];
|
|
$conds = [];
|
|
$joins = [];
|
|
|
|
if ( $users instanceof UserIdentity ) {
|
|
$users = [ $users ];
|
|
}
|
|
|
|
// Get information about all the passed users
|
|
$ids = [];
|
|
$names = [];
|
|
$actors = [];
|
|
foreach ( $users as $user ) {
|
|
if ( $useId && $user->getId() ) {
|
|
$ids[] = $user->getId();
|
|
} else {
|
|
$names[] = $user->getName();
|
|
}
|
|
$actorId = $user->getActorId();
|
|
if ( $actorId ) {
|
|
$actors[] = $actorId;
|
|
}
|
|
}
|
|
|
|
list( $text, $actor ) = self::getFieldNames( $key );
|
|
|
|
// Combine data into conditions to be ORed together
|
|
if ( $this->stage & SCHEMA_COMPAT_READ_NEW ) {
|
|
if ( $actors ) {
|
|
if ( isset( self::$tempTables[$key] ) ) {
|
|
$t = self::$tempTables[$key];
|
|
$alias = "temp_$key";
|
|
$tables[$alias] = $t['table'];
|
|
$joins[$alias] = [ 'JOIN', "{$alias}.{$t['pk']} = {$t['joinPK']}" ];
|
|
$joinField = "{$alias}.{$t['field']}";
|
|
} else {
|
|
$joinField = $actor;
|
|
}
|
|
$conds['actor'] = $db->makeList( [ $joinField => $actors ], IDatabase::LIST_AND );
|
|
}
|
|
} else {
|
|
if ( $ids ) {
|
|
$conds['userid'] = $db->makeList( [ $key => $ids ], IDatabase::LIST_AND );
|
|
}
|
|
if ( $names ) {
|
|
$conds['username'] = $db->makeList( [ $text => $names ], IDatabase::LIST_AND );
|
|
}
|
|
}
|
|
|
|
return [
|
|
'tables' => $tables,
|
|
'conds' => $conds ? $db->makeList( array_values( $conds ), IDatabase::LIST_OR ) : '1=0',
|
|
'orconds' => $conds,
|
|
'joins' => $joins,
|
|
];
|
|
}
|
|
|
|
}
|