PageProps.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Page;
 
use MapCacheLRU;
use MediaWiki\Cache\LinkBatchFactory;
use MediaWiki\Title\Title;
use MediaWiki\Title\TitleArray;
use Wikimedia\Rdbms\ILoadBalancer;
 
class PageProps {
 
    private $linkBatchFactory;
 
    private $loadBalancer;
 
    private const CACHE_TTL = 10; // integer; TTL in seconds
    private const CACHE_SIZE = 100; // integer; max cached pages
 
    private $cache;
 
    public function __construct(
        LinkBatchFactory $linkBatchFactory,
        ILoadBalancer $loadBalancer
    ) {
        $this->linkBatchFactory = $linkBatchFactory;
        $this->loadBalancer = $loadBalancer;
        $this->cache = new MapCacheLRU( self::CACHE_SIZE );
    }
 
    public function ensureCacheSize( $size ) {
        if ( $this->cache->getMaxSize() < $size ) {
            $this->cache->setMaxSize( $size );
        }
    }
 
    public function getProperties( $titles, $propertyNames ) {
        if ( is_array( $propertyNames ) ) {
            $gotArray = true;
        } else {
            $propertyNames = [ $propertyNames ];
            $gotArray = false;
        }
 
        $values = [];
        $goodIDs = $this->getGoodIDs( $titles );
        $queryIDs = [];
        foreach ( $goodIDs as $pageID ) {
            foreach ( $propertyNames as $propertyName ) {
                $propertyValue = $this->getCachedProperty( $pageID, $propertyName );
                if ( $propertyValue === false ) {
                    $queryIDs[] = $pageID;
                    break;
                } elseif ( $gotArray ) {
                    $values[$pageID][$propertyName] = $propertyValue;
                } else {
                    $values[$pageID] = $propertyValue;
                }
            }
        }
 
        if ( $queryIDs ) {
            $queryBuilder = $this->loadBalancer->getConnectionRef( DB_REPLICA )->newSelectQueryBuilder();
            $queryBuilder->select( [ 'pp_page', 'pp_propname', 'pp_value' ] )
                ->from( 'page_props' )
                ->where( [ 'pp_page' => $queryIDs, 'pp_propname' => $propertyNames ] )
                ->caller( __METHOD__ );
            $result = $queryBuilder->fetchResultSet();
 
            foreach ( $result as $row ) {
                $pageID = $row->pp_page;
                $propertyName = $row->pp_propname;
                $propertyValue = $row->pp_value;
                $this->cache->setField( $pageID, $propertyName, $propertyValue );
                if ( $gotArray ) {
                    $values[$pageID][$propertyName] = $propertyValue;
                } else {
                    $values[$pageID] = $propertyValue;
                }
            }
        }
 
        return $values;
    }
 
    public function getAllProperties( $titles ) {
        $values = [];
        $goodIDs = $this->getGoodIDs( $titles );
        $queryIDs = [];
        foreach ( $goodIDs as $pageID ) {
            $pageProperties = $this->getCachedProperties( $pageID );
            if ( $pageProperties === false ) {
                $queryIDs[] = $pageID;
            } else {
                $values[$pageID] = $pageProperties;
            }
        }
 
        if ( $queryIDs != [] ) {
            $queryBuilder = $this->loadBalancer->getConnectionRef( DB_REPLICA )->newSelectQueryBuilder();
            $queryBuilder->select( [ 'pp_page', 'pp_propname', 'pp_value' ] )
                ->from( 'page_props' )
                ->where( [ 'pp_page' => $queryIDs ] )
                ->caller( __METHOD__ );
            $result = $queryBuilder->fetchResultSet();
 
            $currentPageID = 0;
            $pageProperties = [];
            foreach ( $result as $row ) {
                $pageID = $row->pp_page;
                if ( $currentPageID != $pageID ) {
                    if ( $pageProperties ) {
                        // @phan-suppress-next-line PhanTypeMismatchArgument False positive
                        $this->cacheProperties( $currentPageID, $pageProperties );
                        $values[$currentPageID] = $pageProperties;
                    }
                    $currentPageID = $pageID;
                    $pageProperties = [];
                }
                $pageProperties[$row->pp_propname] = $row->pp_value;
            }
            if ( $pageProperties != [] ) {
                // @phan-suppress-next-next-line PhanPossiblyUndeclaredVariable pageID set when used
                // @phan-suppress-next-line PhanTypeMismatchArgumentNullable pageID set when used
                $this->cacheProperties( $pageID, $pageProperties );
                // @phan-suppress-next-next-line PhanPossiblyUndeclaredVariable pageID set when used
                // @phan-suppress-next-line PhanTypeMismatchDimAssignment pageID set when used
                $values[$pageID] = $pageProperties;
            }
        }
 
        return $values;
    }
 
    private function getGoodIDs( $titles ) {
        $result = [];
        if ( is_iterable( $titles ) ) {
            if ( $titles instanceof TitleArray ||
                ( is_array( $titles ) && reset( $titles ) instanceof Title
            ) ) {
                // If the first element is a Title, assume all elements are Titles,
                // and pre-fetch their IDs using a batch query. For PageIdentityValues
                // or PageStoreRecords, this is not necessary, since they already
                // know their ID.
                $this->linkBatchFactory->newLinkBatch( $titles )->execute();
            }
 
            foreach ( $titles as $title ) {
                // Until we only allow ProperPageIdentity, Title objects
                // can deceive us with an unexpected Special page
                if ( $title->canExist() ) {
                    $pageID = $title->getId();
                    if ( $pageID > 0 ) {
                        $result[] = $pageID;
                    }
                }
            }
        } else {
            // Until we only allow ProperPageIdentity, Title objects
            // can deceive us with an unexpected Special page
            if ( $titles->canExist() ) {
                $pageID = $titles->getId();
                if ( $pageID > 0 ) {
                    $result[] = $pageID;
                }
            }
        }
        return $result;
    }
 
    private function getCachedProperty( $pageID, $propertyName ) {
        if ( $this->cache->hasField( $pageID, $propertyName, self::CACHE_TTL ) ) {
            return $this->cache->getField( $pageID, $propertyName );
        }
        if ( $this->cache->hasField( 0, $pageID, self::CACHE_TTL ) ) {
            $pageProperties = $this->cache->getField( 0, $pageID );
            if ( isset( $pageProperties[$propertyName] ) ) {
                return $pageProperties[$propertyName];
            }
        }
        return false;
    }
 
    private function getCachedProperties( $pageID ) {
        if ( $this->cache->hasField( 0, $pageID, self::CACHE_TTL ) ) {
            return $this->cache->getField( 0, $pageID );
        }
        return false;
    }
 
    private function cacheProperties( $pageID, $pageProperties ) {
        $this->cache->clear( $pageID );
        $this->cache->setField( 0, $pageID, $pageProperties );
    }
}
 
class_alias( PageProps::class, 'PageProps' );