LinkBatch.php

Go to the documentation of this file.

<?php
use MediaWiki\Cache\CacheKeyHelper;
use MediaWiki\Linker\LinksMigration;
use MediaWiki\Linker\LinkTarget;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MediaWikiServices;
use MediaWiki\Page\PageIdentityValue;
use MediaWiki\Page\PageReference;
use MediaWiki\Page\ProperPageIdentity;
use Psr\Log\LoggerInterface;
use Wikimedia\Assert\Assert;
use Wikimedia\Rdbms\IDatabase;
use Wikimedia\Rdbms\ILoadBalancer;
use Wikimedia\Rdbms\IResultWrapper;
 
class LinkBatch {
    public $data = [];
 
    private $pageIdentities = null;
 
    protected $caller;
 
    private $linkCache;
 
    private $titleFormatter;
 
    private $contentLanguage;
 
    private $genderCache;
 
    private $loadBalancer;
 
    private $linksMigration;
 
    private $logger;
 
    public function __construct(
        iterable $arr = [],
        ?LinkCache $linkCache = null,
        ?TitleFormatter $titleFormatter = null,
        ?Language $contentLanguage = null,
        ?GenderCache $genderCache = null,
        ?ILoadBalancer $loadBalancer = null,
        ?LinksMigration $linksMigration = null,
        ?LoggerInterface $logger = null
    ) {
        $getServices = static function () {
            // BC hack. Use a closure so this can be unit-tested.
            return MediaWikiServices::getInstance();
        };
 
        $this->linkCache = $linkCache ?? $getServices()->getLinkCache();
        $this->titleFormatter = $titleFormatter ?? $getServices()->getTitleFormatter();
        $this->contentLanguage = $contentLanguage ?? $getServices()->getContentLanguage();
        $this->genderCache = $genderCache ?? $getServices()->getGenderCache();
        $this->loadBalancer = $loadBalancer ?? $getServices()->getDBLoadBalancer();
        $this->linksMigration = $linksMigration ?? $getServices()->getLinksMigration();
        $this->logger = $logger ?? LoggerFactory::getInstance( 'LinkBatch' );
 
        foreach ( $arr as $item ) {
            $this->addObj( $item );
        }
    }
 
    public function setCaller( $caller ) {
        $this->caller = $caller;
 
        return $this;
    }
 
    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;
        }
        if ( !array_key_exists( $ns, $this->data ) ) {
            $this->data[$ns] = [];
        }
 
        $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();
        return $this->addResultToCache( $cache, $res );
    }
 
    public function addResultToCache( $cache, $res ) {
        if ( !$res ) {
            return [];
        }
 
        // For each returned entry, add it to the list of good links, and remove it from $remaining
 
        if ( $this->pageIdentities === null ) {
            $this->pageIdentities = [];
        }
 
        $ids = [];
        $remaining = $this->data;
        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 = new PageIdentityValue(
                    (int)$row->page_id,
                    (int)$row->page_namespace,
                    $row->page_title,
                    ProperPageIdentity::LOCAL
                );
 
                $key = CacheKeyHelper::getKeyForPage( $pageIdentity );
                $this->pageIdentities[$key] = $pageIdentity;
            } catch ( InvalidArgumentException $ex ) {
                $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 = new PageIdentityValue( 0, (int)$ns, $dbkey, ProperPageIdentity::LOCAL );
                    $key = CacheKeyHelper::getKeyForPage( $pageIdentity );
                    $this->pageIdentities[$key] = $pageIdentity;
                } catch ( InvalidArgumentException $ex ) {
                    $this->logger->warning(
                        'Encountered invalid title',
                        [ 'title_namespace' => $ns, 'title_dbkey' => $dbkey ]
                    );
                }
            }
        }
 
        return $ids;
    }
 
    public function doQuery() {
        if ( $this->isEmpty() ) {
            return false;
        }
 
        // This is similar to LinkHolderArray::replaceInternal
        $dbr = $this->loadBalancer->getConnectionRef( DB_REPLICA );
        $table = 'page';
        $fields = LinkCache::getSelectFields();
 
        $conds = $this->constructSet( 'page', $dbr );
 
        // Do query
        $caller = __METHOD__;
        if ( strval( $this->caller ) !== '' ) {
            $caller .= " (for {$this->caller})";
        }
 
        return $dbr->select( $table, $fields, $conds, $caller );
    }
 
    public function doGenderQuery() {
        if ( $this->isEmpty() ) {
            return false;
        }
 
        if ( !$this->contentLanguage->needsGenderDistinction() ) {
            return false;
        }
 
        $this->genderCache->doLinkBatch( $this->data, $this->caller );
 
        return true;
    }
 
    public function constructSet( $prefix, $db ) {
        if ( isset( $this->linksMigration::$prefixToTableMapping[$prefix] ) ) {
            list( $blNamespace, $blTitle ) = $this->linksMigration->getTitleFields(
                $this->linksMigration::$prefixToTableMapping[$prefix]
            );
        } else {
            $blNamespace = "{$prefix}_namespace";
            $blTitle = "{$prefix}_title";
        }
        return $db->makeWhereFrom2d( $this->data, $blNamespace, $blTitle );
    }
}