LinkBatch.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Page;
 
use InvalidArgumentException;
use MediaWiki\Cache\GenderCache;
use MediaWiki\Language\Language;
use MediaWiki\Linker\LinksMigration;
use MediaWiki\Linker\LinkTarget;
use MediaWiki\Title\TitleFormatter;
use MediaWiki\Title\TitleValue;
use MediaWiki\User\TempUser\TempUserDetailsLookup;
use MediaWiki\User\UserIdentity;
use Psr\Log\LoggerInterface;
use RuntimeException;
use Wikimedia\Assert\Assert;
use Wikimedia\Rdbms\IConnectionProvider;
use Wikimedia\Rdbms\IResultWrapper;
use Wikimedia\Rdbms\Platform\ISQLPlatform;
 
class LinkBatch {
    public $data = [];
 
    private array $users = [];
 
    private $pageIdentities = null;
 
    protected $caller;
 
    public function __construct(
        iterable $arr,
        private LinkCache $linkCache,
        private TitleFormatter $titleFormatter,
        private Language $contentLanguage,
        private GenderCache $genderCache,
        private IConnectionProvider $dbProvider,
        private LinksMigration $linksMigration,
        private TempUserDetailsLookup $tempUserDetailsLookup,
        private LinkAlwaysKnownLookup $linkAlwaysKnownLookup,
        private LoggerInterface $logger
    ) {
        foreach ( $arr as $item ) {
            $this->addObj( $item );
        }
    }
 
    public function setCaller( $caller ): self {
        $this->caller = $caller;
        return $this;
    }
 
    public function addUser( UserIdentity $user ): void {
        $this->users[$user->getName()] = $user;
 
        $this->add( NS_USER, $user->getName() );
        $this->add( NS_USER_TALK, $user->getName() );
    }
 
    public function addObj( $link ) {
        if ( !$link ) {
            // Don't die if we got null, just skip. There is nothing to do anyway.
            // For now, let's avoid things like T282180. We should be more strict in the future.
            $this->logger->warning(
                'Skipping null link, probably due to a bad title.',
                [ 'exception' => new RuntimeException() ]
            );
            return;
        }
        if ( $link instanceof LinkTarget && $link->isExternal() ) {
            $this->logger->warning(
                'Skipping interwiki link',
                [ 'exception' => new RuntimeException() ]
            );
            return;
        }
 
        Assert::parameterType( [ LinkTarget::class, PageReference::class ], $link, '$link' );
        $this->add( $link->getNamespace(), $link->getDBkey() );
    }
 
    public function add( $ns, $dbkey ) {
        if ( $ns < 0 || $dbkey === '' ) {
            // T137083
            return;
        }
        $this->data[$ns][strtr( $dbkey, ' ', '_' )] = 1;
    }
 
    public function setArray( $array ) {
        $this->data = $array;
    }
 
    public function isEmpty() {
        return $this->getSize() == 0;
    }
 
    public function getSize() {
        return count( $this->data );
    }
 
    public function execute() {
        return $this->executeInto( $this->linkCache );
    }
 
    public function getPageIdentities(): array {
        if ( $this->pageIdentities === null ) {
            $this->execute();
        }
 
        return $this->pageIdentities;
    }
 
    protected function executeInto( $cache ) {
        $res = $this->doQuery();
        $this->doGenderQuery();
        $this->doIsAlwaysKnownQuery();
 
        // Prefetch expiration status for temporary accounts added to this batch via addUser()
        // for efficient user link rendering (T358469).
        if ( count( $this->users ) > 0 ) {
            $this->tempUserDetailsLookup->preloadExpirationStatus( $this->users );
        }
 
        return $this->addResultToCache( $cache, $res );
    }
 
    public function addResultToCache( $cache, $res ) {
        if ( !$res ) {
            return [];
        }
 
        $this->pageIdentities ??= [];
 
        $ids = [];
        $remaining = $this->data;
 
        // For each returned entry, add it to the list of good links, and remove it from $remaining
        foreach ( $res as $row ) {
            try {
                $title = new TitleValue( (int)$row->page_namespace, $row->page_title );
 
                $cache->addGoodLinkObjFromRow( $title, $row );
                $pdbk = $this->titleFormatter->getPrefixedDBkey( $title );
                $ids[$pdbk] = $row->page_id;
 
                $pageIdentity = PageIdentityValue::localIdentity(
                    (int)$row->page_id,
                    (int)$row->page_namespace,
                    $row->page_title
                );
 
                $key = CacheKeyHelper::getKeyForPage( $pageIdentity );
                $this->pageIdentities[$key] = $pageIdentity;
            } catch ( InvalidArgumentException ) {
                $this->logger->warning(
                    'Encountered invalid title',
                    [ 'title_namespace' => $row->page_namespace, 'title_dbkey' => $row->page_title ]
                );
            }
 
            unset( $remaining[$row->page_namespace][$row->page_title] );
        }
 
        // The remaining links in $data are bad links, register them as such
        foreach ( $remaining as $ns => $dbkeys ) {
            foreach ( $dbkeys as $dbkey => $unused ) {
                try {
                    $title = new TitleValue( (int)$ns, (string)$dbkey );
 
                    $cache->addBadLinkObj( $title );
                    $pdbk = $this->titleFormatter->getPrefixedDBkey( $title );
                    $ids[$pdbk] = 0;
 
                    $pageIdentity = PageIdentityValue::localIdentity( 0, (int)$ns, $dbkey );
                    $key = CacheKeyHelper::getKeyForPage( $pageIdentity );
                    $this->pageIdentities[$key] = $pageIdentity;
                } catch ( InvalidArgumentException ) {
                    $this->logger->warning(
                        'Encountered invalid title',
                        [ 'title_namespace' => $ns, 'title_dbkey' => $dbkey ]
                    );
                }
            }
        }
 
        return $ids;
    }
 
    public function doQuery() {
        if ( $this->isEmpty() ) {
            return false;
        }
 
        $caller = __METHOD__;
        if ( strval( $this->caller ) !== '' ) {
            $caller .= " (for {$this->caller})";
        }
 
        // This is similar to LinkHolderArray::replaceInternal
        $dbr = $this->dbProvider->getReplicaDatabase();
        return $dbr->newSelectQueryBuilder()
            ->select( LinkCache::getSelectFields() )
            ->from( 'page' )
            ->where( $this->constructSet( 'page', $dbr ) )
            ->caller( $caller )
            ->fetchResultSet();
    }
 
    public function doGenderQuery() {
        if ( $this->isEmpty() || !$this->contentLanguage->needsGenderDistinction() ) {
            return false;
        }
 
        $this->genderCache->doLinkBatch( $this->data, $this->caller );
 
        return true;
    }
 
    public function doIsAlwaysKnownQuery(): void {
        if ( $this->isEmpty() ) {
            return;
        }
 
        $links = [];
        foreach ( $this->data as $ns => $dbkeys ) {
            foreach ( $dbkeys as $dbkey => $_ ) {
                try {
                    $links[] = new TitleValue( (int)$ns, (string)$dbkey );
                } catch ( InvalidArgumentException ) {
                    $this->logger->warning(
                        'Encountered invalid title',
                        [
                            'title_namespace' => $ns,
                            'title_dbkey' => $dbkey,
                            'exception' => new RuntimeException
                        ]
                    );
                }
            }
        }
 
        $this->linkAlwaysKnownLookup->preload( $links );
    }
 
    public function constructSet( $prefix, $db ) {
        if ( isset( $this->linksMigration::$prefixToTableMapping[$prefix] ) ) {
            [ $blNamespace, $blTitle ] = $this->linksMigration->getTitleFields(
                $this->linksMigration::$prefixToTableMapping[$prefix]
            );
        } else {
            $blNamespace = "{$prefix}_namespace";
            $blTitle = "{$prefix}_title";
        }
        return $db->makeWhereFrom2d( $this->data, $blNamespace, $blTitle );
    }
}
 
class_alias( LinkBatch::class, 'LinkBatch' );
 
class_alias( LinkBatch::class, 'MediaWiki\Cache\LinkBatch' );