DatabaseUpdater.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Installer;
 
use CleanupEmptyCategories;
use DeleteDefaultMessages;
use LogicException;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Maintenance\FakeMaintenance;
use MediaWiki\Maintenance\LoggedUpdateMaintenance;
use MediaWiki\Maintenance\Maintenance;
use MediaWiki\MediaWikiServices;
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\LBFactory;
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;
 
    private $currentVirtualDomain = null;
 
    public $logApplied = false;
 
    public $appliedUpdateCount = 0;
 
    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();
        }
        // Web upgrade used to load extensions here, but it now injects a hook
        // container like install
        throw new LogicException( __METHOD__ .
            ' an extension hook container needs to be injected' );
    }
 
    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 outputApplied( string $str ): void {
        if ( $this->logApplied ) {
            $this->output( $str );
        } else {
            $this->appliedUpdateCount++;
        }
    }
 
    public function outputAppliedSummary(): void {
        if ( $this->appliedUpdateCount ) {
            $this->output( "Skipped {$this->appliedUpdateCount} updates that were already applied.\n" );
        }
    }
 
    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;
    }
 
    public function getPostDatabaseUpdateMaintenance() {
        return $this->postDatabaseUpdateMaintenance;
    }
 
    private function writeSchemaUpdateFile() {
        $updates = $this->updatesSkipped;
        $this->updatesSkipped = [];
 
        foreach ( $updates as [ $func, $args, $origParams ] ) {
            $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->runUpdates( $this->getCoreUpdateList(), false );
            $this->doCollationUpdate();
        }
        if ( isset( $what['extensions'] ) ) {
            $this->loadExtensionSchemaUpdates();
            $this->runUpdates( $this->extensionUpdates, 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 = $this->getLBFactory();
        $updatesDone = [];
        $updatesSkipped = [];
        foreach ( $updates as $params ) {
            $origParams = $params;
            $oldDb = null;
            $this->currentVirtualDomain = null;
            if ( $hasVirtualDomain === true ) {
                $this->currentVirtualDomain = array_shift( $params );
                $oldDb = $this->db;
                $virtualDb = $lbFactory->getPrimaryDatabase( $this->currentVirtualDomain );
                '@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 );
                $this->currentVirtualDomain = null;
            }
 
            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 );
    }
 
    private function getLBFactory(): LBFactory {
        return MediaWikiServices::getInstance()->getDBLoadBalancerFactory();
    }
 
    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;
 
        if ( $this->shared ) {
            // Shared updates are enabled
            return true;
        }
        if ( $this->currentVirtualDomain
            && $this->getLBFactory()->isSharedVirtualDomain( $this->currentVirtualDomain )
        ) {
            $this->output( "...skipping update to table $name in shared virtual domain.\n" );
            return false;
        }
        if ( $wgSharedDB !== null && 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__,
            $this->appendLine( ... )
        );
    }
 
    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 = MW_INSTALL_PATH;
 
        $dbType = $db->getType();
        if ( file_exists( "$baseDir/sql/$dbType/$patch" ) ) {
            return "$baseDir/sql/$dbType/$patch";
        }
 
        // TODO: Is the fallback still needed after the changes from T382030?
        return "$baseDir/sql/mysql/$patch";
    }
 
    protected function addTable( $name, $patch, $fullpath = false ) {
        if ( !$this->doTable( $name ) ) {
            return true;
        }
 
        if ( $this->db->tableExists( $name, __METHOD__ ) ) {
            $this->outputApplied( "...$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->outputApplied( "...$table table does not exist, skipping new field patch.\n" );
        } elseif ( $this->db->fieldExists( $table, $field, __METHOD__ ) ) {
            $this->outputApplied( "...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->outputApplied( "...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->outputApplied( "...$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->outputApplied( "...$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->outputApplied( "...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->outputApplied( "...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->outputApplied( "...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->outputApplied( "...$table doesn't exist.\n" );
        }
 
        return true;
    }
 
    protected function modifyField( $table, $field, $patch, $fullpath = false ) {
        return $this->modifyFieldWithCondition(
            $table, $field,
            static function () {
                return true;
            },
            $patch, $fullpath
        );
    }
 
    protected function modifyPrimaryKey( $table, array $columns, $patch, $fullpath = false ) {
        if ( !$this->doTable( $table ) ) {
            return true;
        }
 
        if ( !$this->db->tableExists( $table, __METHOD__ ) ) {
            $this->outputApplied( "...skipping: '$table' table doesn't exist yet.\n" );
            return true;
        }
 
        // Compare desired PK to current PK columns from the DB layer
        $current = $this->db->getPrimaryKeyColumns( $table, __METHOD__ );
        if ( $current === array_values( $columns ) ) {
            $this->outputApplied( "...primary key already set on $table table.\n" );
            return true;
        }
 
        return $this->applyPatch( $patch, $fullpath, "Modifying primary key on table $table" );
    }
 
    protected function modifyTable( $table, $patch, $fullpath = false ) {
        if ( !$this->doTable( $table ) ) {
            return true;
        }
 
        $updateKey = "$table-$patch";
        if ( !$this->db->tableExists( $table, __METHOD__ ) ) {
            $this->outputApplied( "...$table table does not exist, skipping modify table patch.\n" );
        } elseif ( $this->updateRowExists( $updateKey ) ) {
            $this->outputApplied( "...table $table already modified by patch $patch.\n" );
        } else {
            $apply = $this->applyPatch( $patch, $fullpath, "Modifying table $table with patch $patch" );
            if ( $apply ) {
                $this->insertUpdateRow( $updateKey );
            }
            return $apply;
        }
        return true;
    }
 
    protected function modifyTableIfFieldNotExists( $table, $field, $patch, $fullpath = false,
        $fieldBeingModified = null
    ) {
        if ( !$this->doTable( $table ) ) {
            return true;
        }
 
        if ( $fieldBeingModified === null ) {
            $updateKey = "$table-$patch";
        } else {
            $updateKey = "$table-$fieldBeingModified-$patch";
        }
 
        if ( !$this->db->tableExists( $table, __METHOD__ ) ) {
            $this->outputApplied( "...$table table does not exist, skipping patch $patch.\n" );
        } elseif ( $this->db->fieldExists( $table, $field, __METHOD__ ) ) {
            $this->outputApplied( "...$field field exists in $table table, skipping obsolete patch $patch.\n" );
        } elseif ( $fieldBeingModified !== null
            && !$this->db->fieldExists( $table, $fieldBeingModified, __METHOD__ )
        ) {
            $this->outputApplied( "...$fieldBeingModified field does not exist in $table table, " .
                "skipping patch $patch.\n" );
        } elseif ( $this->updateRowExists( $updateKey ) ) {
            $this->outputApplied( "...table $table already modified by patch $patch.\n" );
        } else {
            $apply = $this->applyPatch( $patch, $fullpath, "Modifying table $table with patch $patch" );
            if ( $apply ) {
                $this->insertUpdateRow( $updateKey );
            }
            return $apply;
        }
        return true;
    }
 
    protected function modifyFieldIfNullable( $table, $field, $patch, $fullpath = false ) {
        return $this->modifyFieldWithCondition(
            $table, $field,
            static function ( $fieldInfo ) {
                return $fieldInfo->isNullable();
            },
            $patch,
            $fullpath
        );
    }
 
    private function modifyFieldWithCondition(
        $table, $field, $condCallback, $patch, $fullpath = false
    ) {
        if ( !$this->doTable( $table ) ) {
            return true;
        }
 
        $updateKey = "$table-$field-$patch";
        if ( !$this->db->tableExists( $table, __METHOD__ ) ) {
            $this->outputApplied( "...$table table does not exist, skipping modify field patch.\n" );
            return true;
        }
        $fieldInfo = $this->db->fieldInfo( $table, $field );
        if ( !$fieldInfo ) {
            $this->outputApplied( "...$field field does not exist in $table table, " .
                "skipping modify field patch.\n" );
            return true;
        }
        if ( $this->updateRowExists( $updateKey ) ) {
            $this->outputApplied( "...$field in table $table already modified by patch $patch.\n" );
            return true;
        }
        if ( !$condCallback( $fieldInfo ) ) {
            $this->outputApplied( "...$field in table $table already has the required properties.\n" );
            return true;
        }
 
        $apply = $this->applyPatch( $patch, $fullpath, "Modifying $field field of table $table" );
        if ( $apply ) {
            $this->insertUpdateRow( $updateKey );
        }
        return $apply;
    }
 
    protected function runMaintenance( $class, $unused = '' ) {
        $task = $this->maintenance->createChild( $class );
        if ( $task instanceof LoggedUpdateMaintenance && $task->isAlreadyCompleted() ) {
            $this->outputApplied( "..." . $task->updateSkippedMessage() . "\n" );
            return;
        }
        $this->output( "Running $class...\n" );
        $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()
        );
    }
 
    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->outputApplied( "...collations up-to-date.\n" );
            return;
        }
        $this->output( "Updating category collations...\n" );
        $task = $this->maintenance->createChild( 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->createChild( 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->createChild(
            RebuildLocalisationCache::class, 'rebuildLocalisationCache.php'
        );
        '@phan-var RebuildLocalisationCache $cl';
        $this->output( "Rebuilding localisation cache...\n" );
        $cl->setForce();
        $cl->execute();
        $this->output( "done.\n" );
    }
 
    protected function migratePagelinks() {
        if ( $this->updateRowExists( MigrateLinksTable::class . 'pagelinks' ) ) {
            $this->outputApplied( "...pagelinks table has already been migrated.\n" );
            return;
        }
        $task = $this->maintenance->createChild(
            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 migrateCategorylinks() {
        if ( $this->updateRowExists( MigrateLinksTable::class . 'categorylinks' ) ) {
            $this->outputApplied( "...categorylinks table has already been migrated.\n" );
            return;
        }
        $task = $this->maintenance->createChild(
            MigrateLinksTable::class, 'migrateLinksTable.php'
        );
        '@phan-var MigrateLinksTable $task';
        $task->loadParamsAndArgs( MigrateLinksTable::class, [
            'force' => true,
            'table' => 'categorylinks'
        ] );
        $this->output( "Running migrateLinksTable.php on categorylinks...\n" );
        $task->execute();
        $this->output( "done.\n" );
    }
 
    protected function normalizeCollation() {
        if ( $this->updateRowExists( 'normalizeCollation' ) ) {
            $this->outputApplied( "...collation table has already been normalized.\n" );
            return;
        }
        $task = $this->maintenance->createChild(
            UpdateCollation::class, 'updateCollation.php'
        );
        '@phan-var UpdateCollation $task';
        $task->loadParamsAndArgs( UpdateCollation::class, [
            'only-migrate-normalization' => true,
        ] );
        $this->output( "Running updateCollation.php --only-migrate-normalization...\n" );
        $task->execute();
        $this->insertUpdateRow( 'normalizeCollation' );
        $this->output( "done.\n" );
    }
 
    protected function migrateImagelinks() {
        if ( $this->updateRowExists( MigrateLinksTable::class . 'imagelinks' ) ) {
            $this->outputApplied( "...imagelinks table has already been migrated.\n" );
            return;
        }
        $task = $this->maintenance->createChild(
            MigrateLinksTable::class, 'migrateLinksTable.php'
        );
        '@phan-var MigrateLinksTable $task';
        $task->loadParamsAndArgs( MigrateLinksTable::class, [
            'force' => true,
            'table' => 'imagelinks'
        ] );
        $this->output( "Running migrateLinksTable.php on imagelinks...\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 );
        }
 
        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 );
        }
 
        return $func( ...$params );
    }
 
}
 
class_alias( DatabaseUpdater::class, 'DatabaseUpdater' );