BacklinkCache.php

Go to the documentation of this file.

<?php
class BacklinkCache {
        protected static $cache;

        protected $partitionCache = array();

        protected $fullResultCache = array();

        protected $db;

        protected $title;

        const CACHE_EXPIRY = 3600;

        public function __construct( Title $title ) {
                $this->title = $title;
        }

        public static function get( Title $title ) {
                if ( !self::$cache ) { // init cache
                        self::$cache = new ProcessCacheLRU( 1 );
                }
                $dbKey = $title->getPrefixedDBkey();
                if ( !self::$cache->has( $dbKey, 'obj' ) ) {
                        self::$cache->set( $dbKey, 'obj', new self( $title ) );
                }
                return self::$cache->get( $dbKey, 'obj' );
        }

        function __sleep() {
                return array( 'partitionCache', 'fullResultCache', 'title' );
        }

        public function clear() {
                $this->partitionCache = array();
                $this->fullResultCache = array();
                unset( $this->db );
        }

        public function setDB( $db ) {
                $this->db = $db;
        }

        protected function getDB() {
                if ( !isset( $this->db ) ) {
                        $this->db = wfGetDB( DB_SLAVE );
                }

                return $this->db;
        }

        public function getLinks( $table, $startId = false, $endId = false ) {
                wfProfileIn( __METHOD__ );

                $fromField = $this->getPrefix( $table ) . '_from';

                if ( $startId || $endId ) {
                        // Partial range, not cached
                        wfDebug( __METHOD__ . ": from DB (uncacheable range)\n" );
                        $conds = $this->getConditions( $table );

                        // Use the from field in the condition rather than the joined page_id,
                        // because databases are stupid and don't necessarily propagate indexes.
                        if ( $startId ) {
                                $conds[] = "$fromField >= " . intval( $startId );
                        }

                        if ( $endId ) {
                                $conds[] = "$fromField <= " . intval( $endId );
                        }

                        $res = $this->getDB()->select(
                                array( $table, 'page' ),
                                array( 'page_namespace', 'page_title', 'page_id' ),
                                $conds,
                                __METHOD__,
                                array(
                                        'STRAIGHT_JOIN',
                                        'ORDER BY' => $fromField
                                ) );
                        $ta = TitleArray::newFromResult( $res );

                        wfProfileOut( __METHOD__ );
                        return $ta;
                }

                // @todo FIXME: Make this a function?
                if ( !isset( $this->fullResultCache[$table] ) ) {
                        wfDebug( __METHOD__ . ": from DB\n" );
                        $res = $this->getDB()->select(
                                array( $table, 'page' ),
                                array( 'page_namespace', 'page_title', 'page_id' ),
                                $this->getConditions( $table ),
                                __METHOD__,
                                array(
                                        'STRAIGHT_JOIN',
                                        'ORDER BY' => $fromField,
                                ) );
                        $this->fullResultCache[$table] = $res;
                }

                $ta = TitleArray::newFromResult( $this->fullResultCache[$table] );

                wfProfileOut( __METHOD__ );
                return $ta;
        }

        protected function getPrefix( $table ) {
                static $prefixes = array(
                        'pagelinks' => 'pl',
                        'imagelinks' => 'il',
                        'categorylinks' => 'cl',
                        'templatelinks' => 'tl',
                        'redirect' => 'rd',
                );

                if ( isset( $prefixes[$table] ) ) {
                        return $prefixes[$table];
                } else {
                        $prefix = null;
                        wfRunHooks( 'BacklinkCacheGetPrefix', array( $table, &$prefix ) );
                        if( $prefix ) {
                                return $prefix;
                        } else {
                                throw new MWException( "Invalid table \"$table\" in " . __CLASS__ );
                        }
                }
        }

        protected function getConditions( $table ) {
                $prefix = $this->getPrefix( $table );

                // @todo FIXME: imagelinks and categorylinks do not rely on getNamespace,
                // they could be moved up for nicer case statements
                switch ( $table ) {
                        case 'pagelinks':
                        case 'templatelinks':
                                $conds = array(
                                        "{$prefix}_namespace" => $this->title->getNamespace(),
                                        "{$prefix}_title" => $this->title->getDBkey(),
                                        "page_id={$prefix}_from"
                                );
                                break;
                        case 'redirect':
                                $conds = array(
                                        "{$prefix}_namespace" => $this->title->getNamespace(),
                                        "{$prefix}_title" => $this->title->getDBkey(),
                                        $this->getDb()->makeList( array(
                                                "{$prefix}_interwiki" => '',
                                                "{$prefix}_interwiki IS NULL",
                                        ), LIST_OR ),
                                        "page_id={$prefix}_from"
                                );
                                break;
                        case 'imagelinks':
                                $conds = array(
                                        'il_to' => $this->title->getDBkey(),
                                        'page_id=il_from'
                                );
                                break;
                        case 'categorylinks':
                                $conds = array(
                                        'cl_to' => $this->title->getDBkey(),
                                        'page_id=cl_from',
                                );
                                break;
                        default:
                                $conds = null;
                                wfRunHooks( 'BacklinkCacheGetConditions', array( $table, $this->title, &$conds ) );
                                if( !$conds ) {
                                        throw new MWException( "Invalid table \"$table\" in " . __CLASS__ );
                                }
                }

                return $conds;
        }

        public function hasLinks( $table ) {
                return ( $this->getNumLinks( $table, 1 ) > 0 );
        }

        public function getNumLinks( $table, $max = INF ) {
                global $wgMemc;

                // 1) try partition cache ...
                if ( isset( $this->partitionCache[$table] ) ) {
                        $entry = reset( $this->partitionCache[$table] );
                        return min( $max, $entry['numRows'] );
                }

                // 2) ... then try full result cache ...
                if ( isset( $this->fullResultCache[$table] ) ) {
                        return min( $max, $this->fullResultCache[$table]->numRows() );
                }

                $memcKey = wfMemcKey( 'numbacklinks', md5( $this->title->getPrefixedDBkey() ), $table );

                // 3) ... fallback to memcached ...
                $count = $wgMemc->get( $memcKey );
                if ( $count ) {
                        return min( $max, $count );
                }

                // 4) fetch from the database ...
                if ( is_infinite( $max ) ) { // full count
                        $count = $this->getLinks( $table )->count();
                        $wgMemc->set( $memcKey, $count, self::CACHE_EXPIRY );
                } else { // with limit
                        $count = $this->getDB()->select(
                                array( $table, 'page' ),
                                '1',
                                $this->getConditions( $table ),
                                __METHOD__,
                                array( 'LIMIT' => $max )
                        )->numRows();
                }

                return $count;
        }

        public function partition( $table, $batchSize ) {
                global $wgMemc;

                // 1) try partition cache ...
                if ( isset( $this->partitionCache[$table][$batchSize] ) ) {
                        wfDebug( __METHOD__ . ": got from partition cache\n" );
                        return $this->partitionCache[$table][$batchSize]['batches'];
                }

                $this->partitionCache[$table][$batchSize] = false;
                $cacheEntry =& $this->partitionCache[$table][$batchSize];

                // 2) ... then try full result cache ...
                if ( isset( $this->fullResultCache[$table] ) ) {
                        $cacheEntry = $this->partitionResult( $this->fullResultCache[$table], $batchSize );
                        wfDebug( __METHOD__ . ": got from full result cache\n" );
                        return $cacheEntry['batches'];
                }

                $memcKey = wfMemcKey(
                        'backlinks',
                        md5( $this->title->getPrefixedDBkey() ),
                        $table,
                        $batchSize
                );

                // 3) ... fallback to memcached ...
                $memcValue = $wgMemc->get( $memcKey );
                if ( is_array( $memcValue ) ) {
                        $cacheEntry = $memcValue;
                        wfDebug( __METHOD__ . ": got from memcached $memcKey\n" );
                        return $cacheEntry['batches'];
                }

                // 4) ... finally fetch from the slow database :(
                $this->getLinks( $table );
                $cacheEntry = $this->partitionResult( $this->fullResultCache[$table], $batchSize );
                // Save partitions to memcached
                $wgMemc->set( $memcKey, $cacheEntry, self::CACHE_EXPIRY );

                // Save backlink count to memcached
                $memcKey = wfMemcKey( 'numbacklinks', md5( $this->title->getPrefixedDBkey() ), $table );
                $wgMemc->set( $memcKey, $cacheEntry['numRows'], self::CACHE_EXPIRY );

                wfDebug( __METHOD__ . ": got from database\n" );
                return $cacheEntry['batches'];
        }

        protected function partitionResult( $res, $batchSize ) {
                $batches = array();
                $numRows = $res->numRows();
                $numBatches = ceil( $numRows / $batchSize );

                for ( $i = 0; $i < $numBatches; $i++ ) {
                        if ( $i == 0  ) {
                                $start = false;
                        } else {
                                $rowNum = intval( $numRows * $i / $numBatches );
                                $res->seek( $rowNum );
                                $row = $res->fetchObject();
                                $start = $row->page_id;
                        }

                        if ( $i == $numBatches - 1 ) {
                                $end = false;
                        } else {
                                $rowNum = intval( $numRows * ( $i + 1 ) / $numBatches );
                                $res->seek( $rowNum );
                                $row = $res->fetchObject();
                                $end = $row->page_id - 1;
                        }

                        # Sanity check order
                        if ( $start && $end && $start > $end ) {
                                throw new MWException( __METHOD__ . ': Internal error: query result out of order' );
                        }

                        $batches[] = array( $start, $end );
                }

                return array( 'numRows' => $numRows, 'batches' => $batches );
        }
}