SiteStatsInit.php

Go to the documentation of this file.

<?php
namespace MediaWiki\SiteStats;
 
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use SiteStatsUpdate;
use Wikimedia\Rdbms\IDatabase;
 
class SiteStatsInit {
    private $dbr;
    private $edits;
    private $articles;
    private $pages;
    private $users;
    private $files;
 
    public function __construct( $database = false ) {
        if ( $database instanceof IDatabase ) {
            $this->dbr = $database;
        } elseif ( $database ) {
            $this->dbr = self::getDB( DB_PRIMARY );
        } else {
            $this->dbr = self::getDB( DB_REPLICA, 'vslow' );
        }
    }
 
    public function edits() {
        $this->edits = $this->countTableRows( 'revision' );
        $this->edits += $this->countTableRows( 'archive' );
 
        return $this->edits;
    }
 
    private function countTableRows( string $tableName ) {
        return (int)$this->dbr->newSelectQueryBuilder()
            ->select( 'COUNT(*)' )
            ->from( $tableName )
            ->caller( __METHOD__ )->fetchField();
    }
 
    public function articles() {
        $services = MediaWikiServices::getInstance();
        $queryBuilder = $this->dbr->newSelectQueryBuilder()
            ->select( 'COUNT(DISTINCT page_id)' )
            ->from( 'page' )
            ->where( [
                    'page_namespace' => $services->getNamespaceInfo()->getContentNamespaces(),
                    'page_is_redirect' => 0,
                ] );
 
        if ( $services->getMainConfig()->get( MainConfigNames::ArticleCountMethod ) == 'link' ) {
            $queryBuilder->join( 'pagelinks', null, 'pl_from=page_id' );
        }
 
        $this->articles = $queryBuilder->caller( __METHOD__ )->fetchField();
 
        return $this->articles;
    }
 
    public function pages() {
        $this->pages = $this->countTableRows( 'page' );
 
        return $this->pages;
    }
 
    public function users() {
        $this->users = $this->countTableRows( 'user' );
 
        return $this->users;
    }
 
    public function files() {
        $this->files = $this->countTableRows( 'image' );
 
        return $this->files;
    }
 
    public static function doAllAndCommit( $database, array $options = [] ) {
        $options += [ 'update' => false, 'activeUsers' => false ];
 
        // Grab the object and count everything
        $counter = new self( $database );
 
        $counter->edits();
        $counter->articles();
        $counter->pages();
        $counter->users();
        $counter->files();
 
        $counter->refresh();
 
        // Count active users if need be
        if ( $options['activeUsers'] ) {
            SiteStatsUpdate::cacheUpdate( self::getDB( DB_PRIMARY ) );
        }
    }
 
    public static function doPlaceholderInit() {
        $dbw = self::getDB( DB_PRIMARY );
        $exists = (bool)$dbw->newSelectQueryBuilder()
            ->select( '1' )
            ->from( 'site_stats' )
            ->where( [ 'ss_row_id' => 1 ] )
            ->caller( __METHOD__ )->fetchField();
        if ( !$exists ) {
            $dbw->newInsertQueryBuilder()
                ->insertInto( 'site_stats' )
                ->ignore()
                ->row( [ 'ss_row_id' => 1 ] + array_fill_keys( SiteStats::selectFields(), 0 ) )
                ->caller( __METHOD__ )->execute();
        }
    }
 
    private function getShardedValue( $value, $noShards, $rowId ) {
        $remainder = $value % $noShards;
        $quotient = (int)( ( $value - $remainder ) / $noShards );
        // Add the reminder to the first row
        if ( $rowId === 1 ) {
            return $quotient + $remainder;
        }
        return $quotient;
    }
 
    public function refresh() {
        if ( MediaWikiServices::getInstance()->getMainConfig()->get( MainConfigNames::MultiShardSiteStats ) ) {
            $shardCnt = SiteStatsUpdate::SHARDS_ON;
            for ( $i = 1; $i <= $shardCnt; $i++ ) {
                $set = [
                    'ss_total_edits' => $this->getShardedValue( $this->edits ?? $this->edits(), $shardCnt, $i ),
                    'ss_good_articles' => $this->getShardedValue( $this->articles ?? $this->articles(), $shardCnt, $i ),
                    'ss_total_pages' => $this->getShardedValue( $this->pages ?? $this->pages(), $shardCnt, $i ),
                    'ss_users' => $this->getShardedValue( $this->users ?? $this->users(), $shardCnt, $i ),
                    'ss_images' => $this->getShardedValue( $this->files ?? $this->files(), $shardCnt, $i ),
                ];
                $row = [ 'ss_row_id' => $i ] + $set;
                self::getDB( DB_PRIMARY )->newInsertQueryBuilder()
                    ->insertInto( 'site_stats' )
                    ->row( $row )
                    ->onDuplicateKeyUpdate()
                    ->uniqueIndexFields( [ 'ss_row_id' ] )
                    ->set( $set )
                    ->caller( __METHOD__ )->execute();
            }
        } else {
            $set = [
                'ss_total_edits' => $this->edits ?? $this->edits(),
                'ss_good_articles' => $this->articles ?? $this->articles(),
                'ss_total_pages' => $this->pages ?? $this->pages(),
                'ss_users' => $this->users ?? $this->users(),
                'ss_images' => $this->files ?? $this->files(),
            ];
            $row = [ 'ss_row_id' => 1 ] + $set;
 
            self::getDB( DB_PRIMARY )->newInsertQueryBuilder()
                ->insertInto( 'site_stats' )
                ->row( $row )
                ->onDuplicateKeyUpdate()
                ->uniqueIndexFields( [ 'ss_row_id' ] )
                ->set( $set )
                ->caller( __METHOD__ )->execute();
        }
    }
 
    private static function getDB( $index, $groups = [] ) {
        return MediaWikiServices::getInstance()
            ->getDBLoadBalancer()
            ->getConnectionRef( $index, $groups );
    }
}
 
class_alias( SiteStatsInit::class, 'SiteStatsInit' );