migrateLinksTable.php

Go to the documentation of this file.

<?php
 
// @codeCoverageIgnoreStart
require_once __DIR__ . '/Maintenance.php';
// @codeCoverageIgnoreEnd
 
use MediaWiki\Maintenance\LoggedUpdateMaintenance;
use MediaWiki\Title\TitleValue;
 
class MigrateLinksTable extends LoggedUpdateMaintenance {
    private $totalUpdated = 0;
    private $lastProgress = 0;
 
    public function __construct() {
        parent::__construct();
        $this->addDescription(
            'Populates normalization column in links tables.'
        );
        $this->addOption(
            'table',
            'Table name. Like pagelinks.',
            true,
            true
        );
        $this->addOption(
            'sleep',
            'Sleep time (in seconds) between every batch. Default: 0',
            false,
            true
        );
        $this->setBatchSize( 1000 );
    }
 
    protected function getUpdateKey() {
        return __CLASS__ . $this->getOption( 'table', '' );
    }
 
    protected function doDBUpdates() {
        $dbw = $this->getDB( DB_PRIMARY );
        $mapping = \MediaWiki\Linker\LinksMigration::$mapping;
        $table = $this->getOption( 'table', '' );
        if ( !isset( $mapping[$table] ) ) {
            $this->output( "Mapping for this table doesn't exist yet.\n" );
            return false;
        }
        $targetColumn = $mapping[$table]['target_id'];
        if ( !$dbw->fieldExists( $table, $mapping[$table]['title'], __METHOD__ ) ) {
            $this->output( "Old fields don't exist. There is no need to run this script\n" );
            return true;
        }
        if ( !$dbw->fieldExists( $table, $targetColumn, __METHOD__ ) ) {
            $this->output( "Run update.php to create the $targetColumn column.\n" );
            return false;
        }
        if ( !$dbw->tableExists( 'linktarget', __METHOD__ ) ) {
            $this->output( "Run update.php to create the linktarget table.\n" );
            return true;
        }
 
        $this->output( "Populating the $targetColumn column\n" );
        $updated = 0;
 
        $highestPageId = $dbw->newSelectQueryBuilder()
            ->select( 'page_id' )
            ->from( 'page' )
            ->caller( __METHOD__ )
            ->orderBy( 'page_id', 'DESC' )
            ->fetchField();
        if ( !$highestPageId ) {
            $this->output( "Page table is empty.\n" );
            return true;
        }
        $pageId = 0;
        while ( $pageId <= $highestPageId ) {
            // Given the indexes and the structure of links tables,
            // we need to split the update into batches of pages.
            // Otherwise the queries will take a really long time in production and cause read-only.
            $this->handlePageBatch( $pageId, $mapping, $table );
            $pageId += $this->getBatchSize();
        }
 
        $this->output( "Completed normalization of $table, {$this->totalUpdated} rows updated.\n" );
 
        return true;
    }
 
    private function handlePageBatch( int $lowPageId, array $mapping, string $table ) {
        $batchSize = $this->getBatchSize();
        $targetColumn = $mapping[$table]['target_id'];
        $pageIdColumn = $mapping[$table]['page_id'];
        // range is inclusive, let's subtract one.
        $highPageId = $lowPageId + $batchSize - 1;
        $dbw = $this->getPrimaryDB();
 
        // Check if 'ns' is an integer constant (like NS_CATEGORY) or a column name
        $nsColumn = $mapping[$table]['ns'];
        $nsIsConstant = is_int( $nsColumn );
        $nsValue = $nsIsConstant ? $nsColumn : null;
 
        while ( true ) {
            // Build SELECT clause: if ns is a constant, don't select it; if it's a column, select it
            $selectFields = $nsIsConstant
                ? [ $mapping[$table]['title'] ]
                : [ $mapping[$table]['ns'], $mapping[$table]['title'] ];
 
            $res = $dbw->newSelectQueryBuilder()
                ->select( $selectFields )
                ->from( $table )
                ->where( [
                    $targetColumn => [ null, 0 ],
                    $dbw->expr( $pageIdColumn, '>=', $lowPageId ),
                    $dbw->expr( $pageIdColumn, '<=', $highPageId ),
                ] )
                ->limit( 1 )
                ->caller( __METHOD__ )
                ->fetchResultSet();
            if ( !$res->numRows() ) {
                break;
            }
            $row = $res->fetchRow();
            $ns = $nsIsConstant ? $nsValue : (int)$row[$nsColumn];
            $titleString = $row[$mapping[$table]['title']];
            $title = new TitleValue( $ns, $titleString );
            $id = $this->getServiceContainer()->getLinkTargetLookup()->acquireLinkTargetId( $title, $dbw );
            // Build WHERE clause: if ns is a constant, don't add it as a condition
            $whereConditions = [
                $targetColumn => [ null, 0 ],
                $mapping[$table]['title'] => $titleString,
                $dbw->expr( $pageIdColumn, '>=', $lowPageId ),
                $dbw->expr( $pageIdColumn, '<=', $highPageId ),
            ];
            if ( !$nsIsConstant ) {
                $whereConditions[$nsColumn] = $ns;
            }
 
            $dbw->newUpdateQueryBuilder()
                ->update( $table )
                ->set( [ $targetColumn => $id ] )
                ->where( $whereConditions )
                ->caller( __METHOD__ )->execute();
            $this->updateProgress( $dbw->affectedRows(), $lowPageId, $highPageId, $ns, $titleString );
        }
    }
 
    private function updateProgress( $updatedInThisBatch, $lowPageId, $highPageId, $ns, $titleString ) {
        $this->totalUpdated += $updatedInThisBatch;
        if ( $this->totalUpdated >= $this->lastProgress + $this->getBatchSize() ) {
            $this->lastProgress = $this->totalUpdated;
            $this->output( "Updated {$this->totalUpdated} rows, " .
                "at page_id $lowPageId-$highPageId title $ns:$titleString\n" );
            $this->waitForReplication();
            // Sleep between batches for replication to catch up
            $sleep = (int)$this->getOption( 'sleep', 0 );
            if ( $sleep > 0 ) {
                sleep( $sleep );
            }
        }
    }
 
}
 
// @codeCoverageIgnoreStart
$maintClass = MigrateLinksTable::class;
require_once RUN_MAINTENANCE_IF_MAIN;
// @codeCoverageIgnoreEnd