DatabaseUpdater.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Installer;
 
use AutoLoader;
use CleanupEmptyCategories;
use DeleteDefaultMessages;
use LogicException;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\HookContainer\StaticHookRegistry;
use MediaWiki\MainConfigNames;
use MediaWiki\Maintenance\FakeMaintenance;
use MediaWiki\Maintenance\Maintenance;
use MediaWiki\MediaWikiServices;
use MediaWiki\Registration\ExtensionRegistry;
use MediaWiki\ResourceLoader\MessageBlobStore;
use MediaWiki\SiteStats\SiteStatsInit;
use MigrateLinksTable;
use RebuildLocalisationCache;
use RefreshImageMetadata;
use RuntimeException;
use UnexpectedValueException;
use UpdateCollation;
use Wikimedia\Rdbms\IDatabase;
use Wikimedia\Rdbms\IMaintainableDatabase;
use Wikimedia\Rdbms\Platform\ISQLPlatform;
 
require_once __DIR__ . '/../../maintenance/Maintenance.php';
 
abstract class DatabaseUpdater {
    public const REPLICATION_WAIT_TIMEOUT = 300;
 
    protected $updates = [];
 
    protected $updatesSkipped = [];
 
    protected $extensionUpdates = [];
 
    protected $extensionUpdatesWithVirtualDomains = [];
 
    protected $db;
 
    protected $maintenance;
 
    protected $shared = false;
 
    protected $autoExtensionHookContainer;
 
    protected $postDatabaseUpdateMaintenance = [
        DeleteDefaultMessages::class,
        CleanupEmptyCategories::class,
    ];
 
    protected $fileHandle = null;
 
    protected $skipSchema = false;
 
    protected function __construct(
        IMaintainableDatabase &$db,
        $shared,
        ?Maintenance $maintenance = null
    ) {
        $this->db = $db;
        $this->db->setFlag( DBO_DDLMODE );
        $this->shared = $shared;
        if ( $maintenance ) {
            $this->maintenance = $maintenance;
            $this->fileHandle = $maintenance->fileHandle;
        } else {
            $this->maintenance = new FakeMaintenance;
        }
        $this->maintenance->setDB( $db );
    }
 
    private function loadExtensionSchemaUpdates() {
        $hookContainer = $this->loadExtensions();
        ( new HookRunner( $hookContainer ) )->onLoadExtensionSchemaUpdates( $this );
    }
 
    private function loadExtensions() {
        if ( $this->autoExtensionHookContainer ) {
            // Already injected by installer
            return $this->autoExtensionHookContainer;
        }
        if ( defined( 'MW_EXTENSIONS_LOADED' ) ) {
            throw new LogicException( __METHOD__ .
                ' apparently called from installer but no hook container was injected' );
        }
        if ( !defined( 'MEDIAWIKI_INSTALL' ) ) {
            // Running under update.php: use the global locator
            return MediaWikiServices::getInstance()->getHookContainer();
        }
        $vars = Installer::getExistingLocalSettings();
 
        $registry = ExtensionRegistry::getInstance();
        $queue = $registry->getQueue();
        // Don't accidentally load extensions in the future
        $registry->clearQueue();
 
        // Read extension.json files
        $extInfo = $registry->readFromQueue( $queue );
 
        // Merge extension attribute hooks with hooks defined by a .php
        // registration file included from LocalSettings.php
        $legacySchemaHooks = $extInfo['globals']['wgHooks']['LoadExtensionSchemaUpdates'] ?? [];
        if ( $vars && isset( $vars['wgHooks']['LoadExtensionSchemaUpdates'] ) ) {
            $legacySchemaHooks = array_merge( $legacySchemaHooks, $vars['wgHooks']['LoadExtensionSchemaUpdates'] );
        }
 
        // Register classes defined by extensions that are loaded by including of a file that
        // updates global variables, rather than having an extension.json manifest.
        if ( $vars && isset( $vars['wgAutoloadClasses'] ) ) {
            AutoLoader::registerClasses( $vars['wgAutoloadClasses'] );
        }
 
        // Register class definitions from extension.json files
        if ( !isset( $extInfo['autoloaderPaths'] )
            || !isset( $extInfo['autoloaderClasses'] )
            || !isset( $extInfo['autoloaderNS'] )
        ) {
            // NOTE: protect against changes to the structure of $extInfo.
            // It's volatile, and this usage is easy to miss.
            throw new LogicException( 'Missing autoloader keys from extracted extension info' );
        }
        AutoLoader::loadFiles( $extInfo['autoloaderPaths'] );
        AutoLoader::registerClasses( $extInfo['autoloaderClasses'] );
        AutoLoader::registerNamespaces( $extInfo['autoloaderNS'] );
 
        return new HookContainer(
            new StaticHookRegistry(
                [ 'LoadExtensionSchemaUpdates' => $legacySchemaHooks ],
                $extInfo['attributes']['Hooks'] ?? [],
                $extInfo['attributes']['DeprecatedHooks'] ?? []
            ),
            MediaWikiServices::getInstance()->getObjectFactory()
        );
    }
 
    public static function newForDB(
        IMaintainableDatabase $db,
        $shared = false,
        ?Maintenance $maintenance = null
    ) {
        $type = $db->getType();
        if ( in_array( $type, Installer::getDBTypes() ) ) {
            $class = '\\MediaWiki\\Installer\\' . ucfirst( $type ) . 'Updater';
 
            return new $class( $db, $shared, $maintenance );
        }
 
        throw new UnexpectedValueException( __METHOD__ . ' called for unsupported DB type' );
    }
 
    public function setAutoExtensionHookContainer( HookContainer $hookContainer ) {
        $this->autoExtensionHookContainer = $hookContainer;
    }
 
    public function getDB() {
        return $this->db;
    }
 
    public function output( $str ) {
        if ( $this->maintenance->isQuiet() ) {
            return;
        }
        if ( MW_ENTRY_POINT !== 'cli' ) {
            $str = htmlspecialchars( $str );
        }
        echo $str;
        flush();
    }
 
    public function addExtensionUpdate( array $update ) {
        $this->extensionUpdates[] = $update;
    }
 
    public function addExtensionUpdateOnVirtualDomain( array $update ) {
        $this->extensionUpdatesWithVirtualDomains[] = $update;
    }
 
    public function addExtensionTable( $tableName, $sqlPath ) {
        $this->extensionUpdates[] = [ 'addTable', $tableName, $sqlPath, true ];
    }
 
    public function addExtensionIndex( $tableName, $indexName, $sqlPath ) {
        $this->extensionUpdates[] = [ 'addIndex', $tableName, $indexName, $sqlPath, true ];
    }
 
    public function addExtensionField( $tableName, $columnName, $sqlPath ) {
        $this->extensionUpdates[] = [ 'addField', $tableName, $columnName, $sqlPath, true ];
    }
 
    public function dropExtensionField( $tableName, $columnName, $sqlPath ) {
        $this->extensionUpdates[] = [ 'dropField', $tableName, $columnName, $sqlPath, true ];
    }
 
    public function dropExtensionIndex( $tableName, $indexName, $sqlPath ) {
        $this->extensionUpdates[] = [ 'dropIndex', $tableName, $indexName, $sqlPath, true ];
    }
 
    public function dropExtensionTable( $tableName, $sqlPath = false ) {
        $this->extensionUpdates[] = [ 'dropTable', $tableName, $sqlPath, true ];
    }
 
    public function renameExtensionIndex( $tableName, $oldIndexName, $newIndexName,
        $sqlPath, $skipBothIndexExistWarning = false
    ) {
        $this->extensionUpdates[] = [
            'renameIndex',
            $tableName,
            $oldIndexName,
            $newIndexName,
            $skipBothIndexExistWarning,
            $sqlPath,
            true
        ];
    }
 
    public function modifyExtensionField( $tableName, $fieldName, $sqlPath ) {
        $this->extensionUpdates[] = [ 'modifyField', $tableName, $fieldName, $sqlPath, true ];
    }
 
    public function modifyExtensionTable( $tableName, $sqlPath ) {
        $this->extensionUpdates[] = [ 'modifyTable', $tableName, $sqlPath, true ];
    }
 
    public function tableExists( $tableName ) {
        return ( $this->db->tableExists( $tableName, __METHOD__ ) );
    }
 
    public function fieldExists( $tableName, $fieldName ) {
        return ( $this->db->fieldExists( $tableName, $fieldName, __METHOD__ ) );
    }
 
    public function addPostDatabaseUpdateMaintenance( $class ) {
        $this->postDatabaseUpdateMaintenance[] = $class;
    }
 
    protected function getExtensionUpdates() {
        return $this->extensionUpdates;
    }
 
    public function getPostDatabaseUpdateMaintenance() {
        return $this->postDatabaseUpdateMaintenance;
    }
 
    private function writeSchemaUpdateFile() {
        $updates = $this->updatesSkipped;
        $this->updatesSkipped = [];
 
        foreach ( $updates as [ $func, $args, $origParams ] ) {
            // @phan-suppress-next-line PhanUndeclaredInvokeInCallable
            $func( ...$args );
            flush();
            $this->updatesSkipped[] = $origParams;
        }
    }
 
    public function getSchemaVars() {
        return []; // DB-type specific
    }
 
    public function doUpdates( array $what = [ 'core', 'extensions', 'stats' ] ) {
        $this->db->setSchemaVars( $this->getSchemaVars() );
 
        $what = array_fill_keys( $what, true );
        $this->skipSchema = isset( $what['noschema'] ) || $this->fileHandle !== null;
 
        if ( isset( $what['initial'] ) ) {
            $this->output( 'Inserting initial update keys...' );
            $this->insertInitialUpdateKeys();
            $this->output( "done.\n" );
        }
        if ( isset( $what['core'] ) ) {
            $this->doCollationUpdate();
            $this->runUpdates( $this->getCoreUpdateList(), false );
        }
        if ( isset( $what['extensions'] ) ) {
            $this->loadExtensionSchemaUpdates();
            $this->runUpdates( $this->getExtensionUpdates(), true );
            $this->runUpdates( $this->extensionUpdatesWithVirtualDomains, true, true );
        }
 
        if ( isset( $what['stats'] ) ) {
            $this->checkStats();
        }
 
        if ( $this->fileHandle ) {
            $this->skipSchema = false;
            $this->writeSchemaUpdateFile();
        }
    }
 
    private function runUpdates( array $updates, $passSelf, $hasVirtualDomain = false ) {
        $lbFactory = MediaWikiServices::getInstance()->getDBLoadBalancerFactory();
        $updatesDone = [];
        $updatesSkipped = [];
        foreach ( $updates as $params ) {
            $origParams = $params;
            $oldDb = null;
            $virtualDomain = null;
            if ( $hasVirtualDomain === true ) {
                $virtualDomain = array_shift( $params );
                $oldDb = $this->db;
                $virtualDb = $lbFactory->getPrimaryDatabase( $virtualDomain );
                '@phan-var IMaintainableDatabase $virtualDb';
                $this->maintenance->setDB( $virtualDb );
                $this->db = $virtualDb;
            }
            $func = array_shift( $params );
            if ( !is_array( $func ) && method_exists( $this, $func ) ) {
                $func = [ $this, $func ];
            } elseif ( $passSelf ) {
                array_unshift( $params, $this );
            }
            $ret = $func( ...$params );
            if ( $hasVirtualDomain === true && $oldDb ) {
                $this->db = $oldDb;
                $this->maintenance->setDB( $oldDb );
            }
 
            flush();
            if ( $ret !== false ) {
                $updatesDone[] = $origParams;
                $lbFactory->waitForReplication( [ 'timeout' => self::REPLICATION_WAIT_TIMEOUT ] );
            } else {
                if ( $hasVirtualDomain === true ) {
                    $params = $origParams;
                    $func = array_shift( $params );
                }
                $updatesSkipped[] = [ $func, $params, $origParams ];
            }
        }
        $this->updatesSkipped = array_merge( $this->updatesSkipped, $updatesSkipped );
        $this->updates = array_merge( $this->updates, $updatesDone );
    }
 
    public function updateRowExists( $key ) {
        // Return false if the updatelog table does not exist. This can occur if performing schema changes for tables
        // that are on a virtual database domain.
        if ( !$this->db->tableExists( 'updatelog', __METHOD__ ) ) {
            return false;
        }
 
        $row = $this->db->newSelectQueryBuilder()
            ->select( '1 AS X' ) // T67813
            ->from( 'updatelog' )
            ->where( [ 'ul_key' => $key ] )
            ->caller( __METHOD__ )->fetchRow();
 
        return (bool)$row;
    }
 
    public function insertUpdateRow( $key, $val = null ) {
        // We cannot insert anything to the updatelog table if it does not exist. This can occur for schema changes
        // on tables that are on a virtual database domain.
        if ( !$this->db->tableExists( 'updatelog', __METHOD__ ) ) {
            return;
        }
 
        $this->db->clearFlag( DBO_DDLMODE );
        $values = [ 'ul_key' => $key ];
        if ( $val ) {
            $values['ul_value'] = $val;
        }
        $this->db->newInsertQueryBuilder()
            ->insertInto( 'updatelog' )
            ->ignore()
            ->row( $values )
            ->caller( __METHOD__ )->execute();
        $this->db->setFlag( DBO_DDLMODE );
    }
 
    public function insertInitialUpdateKeys() {
        $this->db->clearFlag( DBO_DDLMODE );
        $iqb = $this->db->newInsertQueryBuilder()
            ->insertInto( 'updatelog' )
            ->ignore()
            ->caller( __METHOD__ );
        foreach ( $this->getInitialUpdateKeys() as $key ) {
            $iqb->row( [ 'ul_key' => $key ] );
        }
        $iqb->execute();
        $this->db->setFlag( DBO_DDLMODE );
    }
 
    protected function doTable( $name ) {
        global $wgSharedDB, $wgSharedTables;
 
        // Don't bother to check $wgSharedTables if there isn't a shared database
        // or the user actually also wants to do updates on the shared database.
        if ( $wgSharedDB === null || $this->shared ) {
            return true;
        }
 
        if ( in_array( $name, $wgSharedTables ) ) {
            $this->output( "...skipping update to shared table $name.\n" );
            return false;
        }
 
        return true;
    }
 
    abstract protected function getCoreUpdateList();
 
    abstract protected function getInitialUpdateKeys();
 
    protected function copyFile( $filename ) {
        $this->db->sourceFile(
            $filename,
            null,
            null,
            __METHOD__,
            function ( $line ) {
                return $this->appendLine( $line );
            }
        );
    }
 
    protected function appendLine( $line ) {
        $line = rtrim( $line ) . ";\n";
        if ( fwrite( $this->fileHandle, $line ) === false ) {
            throw new RuntimeException( "trouble writing file" );
        }
 
        return false;
    }
 
    protected function applyPatch( $path, $isFullPath = false, $msg = null ) {
        $msg ??= "Applying $path patch";
        if ( $this->skipSchema ) {
            $this->output( "...skipping schema change ($msg).\n" );
 
            return false;
        }
 
        $this->output( "{$msg}..." );
 
        if ( !$isFullPath ) {
            $path = $this->patchPath( $this->db, $path );
        }
        if ( $this->fileHandle !== null ) {
            $this->copyFile( $path );
        } else {
            $this->db->sourceFile( $path );
        }
        $this->output( "done.\n" );
 
        return true;
    }
 
    public function patchPath( IDatabase $db, $patch ) {
        $baseDir = MediaWikiServices::getInstance()->getMainConfig()->get( MainConfigNames::BaseDirectory );
 
        $dbType = $db->getType();
        if ( file_exists( "$baseDir/maintenance/$dbType/archives/$patch" ) ) {
            return "$baseDir/maintenance/$dbType/archives/$patch";
        }
 
        return "$baseDir/maintenance/archives/$patch";
    }
 
    protected function addTable( $name, $patch, $fullpath = false ) {
        if ( !$this->doTable( $name ) ) {
            return true;
        }
 
        if ( $this->db->tableExists( $name, __METHOD__ ) ) {
            $this->output( "...$name table already exists.\n" );
            return true;
        }
 
        return $this->applyPatch( $patch, $fullpath, "Creating $name table" );
    }
 
    protected function addField( $table, $field, $patch, $fullpath = false ) {
        if ( !$this->doTable( $table ) ) {
            return true;
        }
 
        if ( !$this->db->tableExists( $table, __METHOD__ ) ) {
            $this->output( "...$table table does not exist, skipping new field patch.\n" );
        } elseif ( $this->db->fieldExists( $table, $field, __METHOD__ ) ) {
            $this->output( "...have $field field in $table table.\n" );
        } else {
            return $this->applyPatch( $patch, $fullpath, "Adding $field field to table $table" );
        }
 
        return true;
    }
 
    protected function addIndex( $table, $index, $patch, $fullpath = false ) {
        if ( !$this->doTable( $table ) ) {
            return true;
        }
 
        if ( !$this->db->tableExists( $table, __METHOD__ ) ) {
            $this->output( "...skipping: '$table' table doesn't exist yet.\n" );
        } elseif ( $this->db->indexExists( $table, $index, __METHOD__ ) ) {
            $this->output( "...index $index already set on $table table.\n" );
        } else {
            return $this->applyPatch( $patch, $fullpath, "Adding index $index to table $table" );
        }
 
        return true;
    }
 
    protected function dropField( $table, $field, $patch, $fullpath = false ) {
        if ( !$this->doTable( $table ) ) {
            return true;
        }
 
        if ( $this->db->fieldExists( $table, $field, __METHOD__ ) ) {
            return $this->applyPatch( $patch, $fullpath, "Table $table contains $field field. Dropping" );
        }
 
        $this->output( "...$table table does not contain $field field.\n" );
        return true;
    }
 
    protected function dropIndex( $table, $index, $patch, $fullpath = false ) {
        if ( !$this->doTable( $table ) ) {
            return true;
        }
 
        if ( $this->db->indexExists( $table, $index, __METHOD__ ) ) {
            return $this->applyPatch( $patch, $fullpath, "Dropping $index index from table $table" );
        }
 
        $this->output( "...$index key doesn't exist.\n" );
        return true;
    }
 
    protected function renameIndex( $table, $oldIndex, $newIndex,
        $skipBothIndexExistWarning, $patch, $fullpath = false
    ) {
        if ( !$this->doTable( $table ) ) {
            return true;
        }
 
        // First requirement: the table must exist
        if ( !$this->db->tableExists( $table, __METHOD__ ) ) {
            $this->output( "...skipping: '$table' table doesn't exist yet.\n" );
 
            return true;
        }
 
        // Second requirement: the new index must be missing
        if ( $this->db->indexExists( $table, $newIndex, __METHOD__ ) ) {
            $this->output( "...index $newIndex already set on $table table.\n" );
            if ( !$skipBothIndexExistWarning &&
                $this->db->indexExists( $table, $oldIndex, __METHOD__ )
            ) {
                $this->output( "...WARNING: $oldIndex still exists, despite it has " .
                    "been renamed into $newIndex (which also exists).\n" .
                    "            $oldIndex should be manually removed if not needed anymore.\n" );
            }
 
            return true;
        }
 
        // Third requirement: the old index must exist
        if ( !$this->db->indexExists( $table, $oldIndex, __METHOD__ ) ) {
            $this->output( "...skipping: index $oldIndex doesn't exist.\n" );
 
            return true;
        }
 
        // Requirements have been satisfied, the patch can be applied
        return $this->applyPatch(
            $patch,
            $fullpath,
            "Renaming index $oldIndex into $newIndex to table $table"
        );
    }
 
    protected function dropTable( $table, $patch = false, $fullpath = false ) {
        if ( !$this->doTable( $table ) ) {
            return true;
        }
 
        if ( $this->db->tableExists( $table, __METHOD__ ) ) {
            $msg = "Dropping table $table";
 
            if ( $patch === false ) {
                $this->output( "$msg ..." );
                $this->db->dropTable( $table, __METHOD__ );
                $this->output( "done.\n" );
            } else {
                return $this->applyPatch( $patch, $fullpath, $msg );
            }
        } else {
            $this->output( "...$table doesn't exist.\n" );
        }
 
        return true;
    }
 
    protected function modifyField( $table, $field, $patch, $fullpath = false ) {
        if ( !$this->doTable( $table ) ) {
            return true;
        }
 
        $updateKey = "$table-$field-$patch";
        if ( !$this->db->tableExists( $table, __METHOD__ ) ) {
            $this->output( "...$table table does not exist, skipping modify field patch.\n" );
        } elseif ( !$this->db->fieldExists( $table, $field, __METHOD__ ) ) {
            $this->output( "...$field field does not exist in $table table, " .
                "skipping modify field patch.\n" );
        } elseif ( $this->updateRowExists( $updateKey ) ) {
            $this->output( "...$field in table $table already modified by patch $patch.\n" );
        } else {
            $apply = $this->applyPatch( $patch, $fullpath, "Modifying $field field of table $table" );
            if ( $apply ) {
                $this->insertUpdateRow( $updateKey );
            }
            return $apply;
        }
        return true;
    }
 
    protected function modifyTable( $table, $patch, $fullpath = false ) {
        if ( !$this->doTable( $table ) ) {
            return true;
        }
 
        $updateKey = "$table-$patch";
        if ( !$this->db->tableExists( $table, __METHOD__ ) ) {
            $this->output( "...$table table does not exist, skipping modify table patch.\n" );
        } elseif ( $this->updateRowExists( $updateKey ) ) {
            $this->output( "...table $table already modified by patch $patch.\n" );
        } else {
            $apply = $this->applyPatch( $patch, $fullpath, "Modifying table $table" );
            if ( $apply ) {
                $this->insertUpdateRow( $updateKey );
            }
            return $apply;
        }
        return true;
    }
 
    protected function runMaintenance( $class, $unused = '' ) {
        $this->output( "Running $class...\n" );
        $task = $this->maintenance->runChild( $class );
        $ok = $task->execute();
        if ( !$ok ) {
            throw new RuntimeException( "Execution of $class did not complete successfully." );
        }
        $this->output( "done.\n" );
    }
 
    public function setFileAccess() {
        $repo = MediaWikiServices::getInstance()->getRepoGroup()->getLocalRepo();
        $zonePath = $repo->getZonePath( 'temp' );
        if ( $repo->getBackend()->directoryExists( [ 'dir' => $zonePath ] ) ) {
            // If the directory was never made, then it will have the right ACLs when it is made
            $status = $repo->getBackend()->secure( [
                'dir' => $zonePath,
                'noAccess' => true,
                'noListing' => true
            ] );
            if ( $status->isOK() ) {
                $this->output( "Set the local repo temp zone container to be private.\n" );
            } else {
                $this->output( "Failed to set the local repo temp zone container to be private.\n" );
            }
        }
    }
 
    public function purgeCache() {
        global $wgLocalisationCacheConf;
        // We can't guarantee that the user will be able to use TRUNCATE,
        // but we know that DELETE is available to us
        $this->output( "Purging caches..." );
 
        // ObjectCache
        $this->db->newDeleteQueryBuilder()
            ->deleteFrom( 'objectcache' )
            ->where( ISQLPlatform::ALL_ROWS )
            ->caller( __METHOD__ )
            ->execute();
 
        // LocalisationCache
        if ( $wgLocalisationCacheConf['manualRecache'] ) {
            $this->rebuildLocalisationCache();
        }
 
        // ResourceLoader: Message cache
        $services = MediaWikiServices::getInstance();
        MessageBlobStore::clearGlobalCacheEntry(
            $services->getMainWANObjectCache()
        );
 
        // ResourceLoader: File-dependency cache
        $this->db->newDeleteQueryBuilder()
            ->deleteFrom( 'module_deps' )
            ->where( ISQLPlatform::ALL_ROWS )
            ->caller( __METHOD__ )
            ->execute();
        $this->output( "done.\n" );
    }
 
    protected function checkStats() {
        $this->output( "...site_stats is populated..." );
        $row = $this->db->newSelectQueryBuilder()
            ->select( '*' )
            ->from( 'site_stats' )
            ->where( [ 'ss_row_id' => 1 ] )
            ->caller( __METHOD__ )->fetchRow();
        if ( $row === false ) {
            $this->output( "data is missing! rebuilding...\n" );
        } elseif ( isset( $row->site_stats ) && $row->ss_total_pages == -1 ) {
            $this->output( "missing ss_total_pages, rebuilding...\n" );
        } else {
            $this->output( "done.\n" );
 
            return;
        }
        SiteStatsInit::doAllAndCommit( $this->db );
    }
 
    # Common updater functions
 
    protected function doCollationUpdate() {
        global $wgCategoryCollation;
        if ( $this->updateRowExists( 'UpdateCollation::' . $wgCategoryCollation ) ) {
            $this->output( "...collations up-to-date.\n" );
            return;
        }
        $this->output( "Updating category collations...\n" );
        $task = $this->maintenance->runChild( UpdateCollation::class );
        $ok = $task->execute();
        if ( $ok !== false ) {
            $this->output( "...done.\n" );
            $this->insertUpdateRow( 'UpdateCollation::' . $wgCategoryCollation );
        }
    }
 
    protected function doConvertDjvuMetadata() {
        if ( $this->updateRowExists( 'ConvertDjvuMetadata' ) ) {
            return;
        }
        $this->output( "Converting djvu metadata..." );
        $task = $this->maintenance->runChild( RefreshImageMetadata::class );
        '@phan-var RefreshImageMetadata $task';
        $task->loadParamsAndArgs( RefreshImageMetadata::class, [
            'force' => true,
            'mediatype' => 'OFFICE',
            'mime' => 'image/*',
            'batch-size' => 1,
            'sleep' => 1
        ] );
        $ok = $task->execute();
        if ( $ok !== false ) {
            $this->output( "...done.\n" );
            $this->insertUpdateRow( 'ConvertDjvuMetadata' );
        }
    }
 
    protected function rebuildLocalisationCache() {
        $cl = $this->maintenance->runChild(
            RebuildLocalisationCache::class, 'rebuildLocalisationCache.php'
        );
        '@phan-var RebuildLocalisationCache $cl';
        $this->output( "Rebuilding localisation cache...\n" );
        $cl->setForce();
        $cl->execute();
        $this->output( "done.\n" );
    }
 
    protected function migrateTemplatelinks() {
        if ( $this->updateRowExists( MigrateLinksTable::class . 'templatelinks' ) ) {
            $this->output( "...templatelinks table has already been migrated.\n" );
            return;
        }
        $task = $this->maintenance->runChild(
            MigrateLinksTable::class, 'migrateLinksTable.php'
        );
        '@phan-var MigrateLinksTable $task';
        $task->loadParamsAndArgs( MigrateLinksTable::class, [
            'force' => true,
            'table' => 'templatelinks'
        ] );
        $this->output( "Running migrateLinksTable.php on templatelinks...\n" );
        $task->execute();
        $this->output( "done.\n" );
    }
 
    protected function migratePagelinks() {
        if ( $this->updateRowExists( MigrateLinksTable::class . 'pagelinks' ) ) {
            $this->output( "...pagelinks table has already been migrated.\n" );
            return;
        }
        $task = $this->maintenance->runChild(
            MigrateLinksTable::class, 'migrateLinksTable.php'
        );
        '@phan-var MigrateLinksTable $task';
        $task->loadParamsAndArgs( MigrateLinksTable::class, [
            'force' => true,
            'table' => 'pagelinks'
        ] );
        $this->output( "Running migrateLinksTable.php on pagelinks...\n" );
        $task->execute();
        $this->output( "done.\n" );
    }
 
    protected function ifTableNotExists( $table, $func, ...$params ) {
        // Handle $passSelf from runUpdates().
        $passSelf = false;
        if ( $table === $this ) {
            $passSelf = true;
            $table = $func;
            $func = array_shift( $params );
        }
 
        if ( $this->db->tableExists( $table, __METHOD__ ) ) {
            return null;
        }
 
        if ( !is_array( $func ) && method_exists( $this, $func ) ) {
            $func = [ $this, $func ];
        } elseif ( $passSelf ) {
            array_unshift( $params, $this );
        }
 
        // @phan-suppress-next-line PhanUndeclaredInvokeInCallable Phan is confused
        return $func( ...$params );
    }
 
    protected function ifFieldExists( $table, $field, $func, ...$params ) {
        // Handle $passSelf from runUpdates().
        $passSelf = false;
        if ( $table === $this ) {
            $passSelf = true;
            $table = $field;
            $field = $func;
            $func = array_shift( $params );
        }
 
        if ( !$this->db->tableExists( $table, __METHOD__ ) ||
            !$this->db->fieldExists( $table, $field, __METHOD__ )
        ) {
            return null;
        }
 
        if ( !is_array( $func ) && method_exists( $this, $func ) ) {
            $func = [ $this, $func ];
        } elseif ( $passSelf ) {
            array_unshift( $params, $this );
        }
 
        // @phan-suppress-next-line PhanUndeclaredInvokeInCallable Phan is confused
        return $func( ...$params );
    }
 
}
 
class_alias( DatabaseUpdater::class, 'DatabaseUpdater' );