QueryPage.php

Go to the documentation of this file.

<?php
global $wgQueryPages; // not redundant
$wgQueryPages = array(
//         QueryPage subclass           Special page name         Limit (false for none, none for the default)
// ----------------------------------------------------------------------------
    array( 'AncientPagesPage',              'Ancientpages'                  ),
    array( 'BrokenRedirectsPage',           'BrokenRedirects'               ),
    array( 'DeadendPagesPage',              'Deadendpages'                  ),
    array( 'DoubleRedirectsPage',           'DoubleRedirects'               ),
    array( 'FileDuplicateSearchPage',       'FileDuplicateSearch'           ),
    array( 'LinkSearchPage',                'LinkSearch'                    ),
    array( 'ListredirectsPage',             'Listredirects'                 ),
    array( 'LonelyPagesPage',               'Lonelypages'                   ),
    array( 'LongPagesPage',                 'Longpages'                     ),
    array( 'MIMEsearchPage',                'MIMEsearch'                    ),
    array( 'MostcategoriesPage',            'Mostcategories'                ),
    array( 'MostimagesPage',                'Mostimages'                    ),
    array( 'MostinterwikisPage',            'Mostinterwikis'                ),
    array( 'MostlinkedCategoriesPage',      'Mostlinkedcategories'          ),
    array( 'MostlinkedtemplatesPage',       'Mostlinkedtemplates'           ),
    array( 'MostlinkedPage',                'Mostlinked'                    ),
    array( 'MostrevisionsPage',             'Mostrevisions'                 ),
    array( 'FewestrevisionsPage',           'Fewestrevisions'               ),
    array( 'ShortPagesPage',                'Shortpages'                    ),
    array( 'UncategorizedCategoriesPage',   'Uncategorizedcategories'       ),
    array( 'UncategorizedPagesPage',        'Uncategorizedpages'            ),
    array( 'UncategorizedImagesPage',       'Uncategorizedimages'           ),
    array( 'UncategorizedTemplatesPage',    'Uncategorizedtemplates'        ),
    array( 'UnusedCategoriesPage',          'Unusedcategories'              ),
    array( 'UnusedimagesPage',              'Unusedimages'                  ),
    array( 'WantedCategoriesPage',          'Wantedcategories'              ),
    array( 'WantedFilesPage',               'Wantedfiles'                   ),
    array( 'WantedPagesPage',               'Wantedpages'                   ),
    array( 'WantedTemplatesPage',           'Wantedtemplates'               ),
    array( 'UnwatchedPagesPage',            'Unwatchedpages'                ),
    array( 'UnusedtemplatesPage',           'Unusedtemplates'               ),
    array( 'WithoutInterwikiPage',          'Withoutinterwiki'              ),
);
wfRunHooks( 'wgQueryPages', array( &$wgQueryPages ) );

global $wgDisableCounters;
if ( !$wgDisableCounters ) {
    $wgQueryPages[] = array( 'PopularPagesPage', 'Popularpages' );
}

abstract class QueryPage extends SpecialPage {
    var $listoutput = false;

    var $offset = 0;
    var $limit = 0;

    protected $numRows;

    protected $cachedTimestamp = null;

    protected $shownavigation = true;

    function setListoutput( $bool ) {
        $this->listoutput = $bool;
    }

    function getQueryInfo() {
        return null;
    }

    function getSQL() {
        /* Implement getQueryInfo() instead */
        throw new MWException( "Bug in a QueryPage: doesn't implement getQueryInfo() nor getQuery() properly" );
    }

    function getOrderFields() {
        return array( 'value' );
    }

    function usesTimestamps() {
        return false;
    }

    function sortDescending() {
        return true;
    }

    function isExpensive() {
        global $wgDisableQueryPages;
        return $wgDisableQueryPages;
    }

    public function isCacheable() {
        return true;
    }

    function isCached() {
        global $wgMiserMode;

        return $this->isExpensive() && $wgMiserMode;
    }

    function isSyndicated() {
        return true;
    }

    abstract function formatResult( $skin, $result );

    function getPageHeader() {
        return '';
    }

    function linkParameters() {
        return array();
    }

    function tryLastResult() {
        return false;
    }

    function recache( $limit, $ignoreErrors = true ) {
        if ( !$this->isCacheable() ) {
            return 0;
        }

        $fname = get_class( $this ) . '::recache';
        $dbw = wfGetDB( DB_MASTER );
        $dbr = wfGetDB( DB_SLAVE, array( $this->getName(), __METHOD__, 'vslow' ) );
        if ( !$dbw || !$dbr ) {
            return false;
        }

        try {
            # Clear out any old cached data
            $dbw->delete( 'querycache', array( 'qc_type' => $this->getName() ), $fname );
            # Do query
            $res = $this->reallyDoQuery( $limit, false );
            $num = false;
            if ( $res ) {
                $num = $res->numRows();
                # Fetch results
                $vals = array();
                while ( $res && $row = $dbr->fetchObject( $res ) ) {
                    if ( isset( $row->value ) ) {
                        if ( $this->usesTimestamps() ) {
                            $value = wfTimestamp( TS_UNIX,
                                $row->value );
                        } else {
                            $value = intval( $row->value ); // @bug 14414
                        }
                    } else {
                        $value = 0;
                    }

                    $vals[] = array( 'qc_type' => $this->getName(),
                            'qc_namespace' => $row->namespace,
                            'qc_title' => $row->title,
                            'qc_value' => $value );
                }

                # Save results into the querycache table on the master
                if ( count( $vals ) ) {
                    $dbw->insert( 'querycache', $vals, __METHOD__ );
                }
                # Update the querycache_info record for the page
                $dbw->delete( 'querycache_info', array( 'qci_type' => $this->getName() ), $fname );
                $dbw->insert( 'querycache_info',
                    array( 'qci_type' => $this->getName(), 'qci_timestamp' => $dbw->timestamp() ),
                    $fname );
            }
        } catch ( DBError $e ) {
            if ( !$ignoreErrors ) {
                throw $e; // report query error
            }
            $num = false; // set result to false to indicate error
        }

        return $num;
    }

    function reallyDoQuery( $limit, $offset = false ) {
        $fname = get_class( $this ) . "::reallyDoQuery";
        $dbr = wfGetDB( DB_SLAVE );
        $query = $this->getQueryInfo();
        $order = $this->getOrderFields();

        if ( $this->sortDescending() ) {
            foreach ( $order as &$field ) {
                $field .= ' DESC';
            }
        }

        if ( is_array( $query ) ) {
            $tables = isset( $query['tables'] ) ? (array)$query['tables'] : array();
            $fields = isset( $query['fields'] ) ? (array)$query['fields'] : array();
            $conds = isset( $query['conds'] ) ? (array)$query['conds'] : array();
            $options = isset( $query['options'] ) ? (array)$query['options'] : array();
            $join_conds = isset( $query['join_conds'] ) ? (array)$query['join_conds'] : array();

            if ( count( $order ) ) {
                $options['ORDER BY'] = $order;
            }

            if ( $limit !== false ) {
                $options['LIMIT'] = intval( $limit );
            }

            if ( $offset !== false ) {
                $options['OFFSET'] = intval( $offset );
            }

            $res = $dbr->select( $tables, $fields, $conds, $fname,
                    $options, $join_conds
            );
        } else {
            // Old-fashioned raw SQL style, deprecated
            $sql = $this->getSQL();
            $sql .= ' ORDER BY ' . implode( ', ', $order );
            $sql = $dbr->limitResult( $sql, $limit, $offset );
            $res = $dbr->query( $sql, $fname );
        }

        return $dbr->resultObject( $res );
    }

    function doQuery( $offset = false, $limit = false ) {
        if ( $this->isCached() && $this->isCacheable() ) {
            return $this->fetchFromCache( $limit, $offset );
        } else {
            return $this->reallyDoQuery( $limit, $offset );
        }
    }

    function fetchFromCache( $limit, $offset = false ) {
        $dbr = wfGetDB( DB_SLAVE );
        $options = array();
        if ( $limit !== false ) {
            $options['LIMIT'] = intval( $limit );
        }
        if ( $offset !== false ) {
            $options['OFFSET'] = intval( $offset );
        }
        if ( $this->sortDescending() ) {
            $options['ORDER BY'] = 'qc_value DESC';
        } else {
            $options['ORDER BY'] = 'qc_value ASC';
        }
        $res = $dbr->select( 'querycache', array( 'qc_type',
                'namespace' => 'qc_namespace',
                'title' => 'qc_title',
                'value' => 'qc_value' ),
                array( 'qc_type' => $this->getName() ),
                __METHOD__, $options
        );
        return $dbr->resultObject( $res );
    }

    public function getCachedTimestamp() {
        if ( is_null( $this->cachedTimestamp ) ) {
            $dbr = wfGetDB( DB_SLAVE );
            $fname = get_class( $this ) . '::getCachedTimestamp';
            $this->cachedTimestamp = $dbr->selectField( 'querycache_info', 'qci_timestamp',
                array( 'qci_type' => $this->getName() ), $fname );
        }
        return $this->cachedTimestamp;
    }

    function execute( $par ) {
        global $wgQueryCacheLimit, $wgDisableQueryPageUpdate;

        $user = $this->getUser();
        if ( !$this->userCanExecute( $user ) ) {
            $this->displayRestrictionError();
            return;
        }

        $this->setHeaders();
        $this->outputHeader();

        $out = $this->getOutput();

        if ( $this->isCached() && !$this->isCacheable() ) {
            $out->addWikiMsg( 'querypage-disabled' );
            return 0;
        }

        $out->setSyndicated( $this->isSyndicated() );

        if ( $this->limit == 0 && $this->offset == 0 ) {
            list( $this->limit, $this->offset ) = $this->getRequest()->getLimitOffset();
        }

        // TODO: Use doQuery()
        if ( !$this->isCached() ) {
            # select one extra row for navigation
            $res = $this->reallyDoQuery( $this->limit + 1, $this->offset );
        } else {
            # Get the cached result, select one extra row for navigation
            $res = $this->fetchFromCache( $this->limit + 1, $this->offset );
            if ( !$this->listoutput ) {

                # Fetch the timestamp of this update
                $ts = $this->getCachedTimestamp();
                $lang = $this->getLanguage();
                $maxResults = $lang->formatNum( $wgQueryCacheLimit );

                if ( $ts ) {
                    $updated = $lang->userTimeAndDate( $ts, $user );
                    $updateddate = $lang->userDate( $ts, $user );
                    $updatedtime = $lang->userTime( $ts, $user );
                    $out->addMeta( 'Data-Cache-Time', $ts );
                    $out->addJsConfigVars( 'dataCacheTime', $ts );
                    $out->addWikiMsg( 'perfcachedts', $updated, $updateddate, $updatedtime, $maxResults );
                } else {
                    $out->addWikiMsg( 'perfcached', $maxResults );
                }

                # If updates on this page have been disabled, let the user know
                # that the data set won't be refreshed for now
                if ( is_array( $wgDisableQueryPageUpdate ) && in_array( $this->getName(), $wgDisableQueryPageUpdate ) ) {
                    $out->wrapWikiMsg( "<div class=\"mw-querypage-no-updates\">\n$1\n</div>", 'querypage-no-updates' );
                }
            }
        }

        $this->numRows = $res->numRows();

        $dbr = wfGetDB( DB_SLAVE );
        $this->preprocessResults( $dbr, $res );

        $out->addHTML( Xml::openElement( 'div', array( 'class' => 'mw-spcontent' ) ) );

        # Top header and navigation
        if ( $this->shownavigation ) {
            $out->addHTML( $this->getPageHeader() );
            if ( $this->numRows > 0 ) {
                $out->addHTML( $this->msg( 'showingresults' )->numParams(
                    min( $this->numRows, $this->limit ), # do not show the one extra row, if exist
                    $this->offset + 1 )->parseAsBlock() );
                # Disable the "next" link when we reach the end
                $paging = $this->getLanguage()->viewPrevNext( $this->getTitle( $par ), $this->offset,
                    $this->limit, $this->linkParameters(), ( $this->numRows <= $this->limit ) );
                $out->addHTML( '<p>' . $paging . '</p>' );
            } else {
                # No results to show, so don't bother with "showing X of Y" etc.
                # -- just let the user know and give up now
                $out->addWikiMsg( 'specialpage-empty' );
                $out->addHTML( Xml::closeElement( 'div' ) );
                return;
            }
        }

        # The actual results; specialist subclasses will want to handle this
        # with more than a straight list, so we hand them the info, plus
        # an OutputPage, and let them get on with it
        $this->outputResults( $out,
            $this->getSkin(),
            $dbr, # Should use a ResultWrapper for this
            $res,
            min( $this->numRows, $this->limit ), # do not format the one extra row, if exist
            $this->offset );

        # Repeat the paging links at the bottom
        if ( $this->shownavigation ) {
            $out->addHTML( '<p>' . $paging . '</p>' );
        }

        $out->addHTML( Xml::closeElement( 'div' ) );

        return min( $this->numRows, $this->limit ); # do not return the one extra row, if exist
    }

    protected function outputResults( $out, $skin, $dbr, $res, $num, $offset ) {
        global $wgContLang;

        if ( $num > 0 ) {
            $html = array();
            if ( !$this->listoutput ) {
                $html[] = $this->openList( $offset );
            }

            # $res might contain the whole 1,000 rows, so we read up to
            # $num [should update this to use a Pager]
            for ( $i = 0; $i < $num && $row = $res->fetchObject(); $i++ ) {
                $line = $this->formatResult( $skin, $row );
                if ( $line ) {
                    $attr = ( isset( $row->usepatrol ) && $row->usepatrol && $row->patrolled == 0 )
                        ? ' class="not-patrolled"'
                        : '';
                    $html[] = $this->listoutput
                        ? $line
                        : "<li{$attr}>{$line}</li>\n";
                }
            }

            # Flush the final result
            if ( $this->tryLastResult() ) {
                $row = null;
                $line = $this->formatResult( $skin, $row );
                if ( $line ) {
                    $attr = ( isset( $row->usepatrol ) && $row->usepatrol && $row->patrolled == 0 )
                        ? ' class="not-patrolled"'
                        : '';
                    $html[] = $this->listoutput
                        ? $line
                        : "<li{$attr}>{$line}</li>\n";
                }
            }

            if ( !$this->listoutput ) {
                $html[] = $this->closeList();
            }

            $html = $this->listoutput
                ? $wgContLang->listToText( $html )
                : implode( '', $html );

            $out->addHTML( $html );
        }
    }

    function openList( $offset ) {
        return "\n<ol start='" . ( $offset + 1 ) . "' class='special'>\n";
    }

    function closeList() {
        return "</ol>\n";
    }

    function preprocessResults( $db, $res ) {}

    function doFeed( $class = '', $limit = 50 ) {
        global $wgFeed, $wgFeedClasses, $wgFeedLimit;

        if ( !$wgFeed ) {
            $this->getOutput()->addWikiMsg( 'feed-unavailable' );
            return false;
        }

        $limit = min( $limit, $wgFeedLimit );

        if ( isset( $wgFeedClasses[$class] ) ) {
            $feed = new $wgFeedClasses[$class](
                $this->feedTitle(),
                $this->feedDesc(),
                $this->feedUrl() );
            $feed->outHeader();

            $res = $this->reallyDoQuery( $limit, 0 );
            foreach ( $res as $obj ) {
                $item = $this->feedResult( $obj );
                if ( $item ) {
                    $feed->outItem( $item );
                }
            }

            $feed->outFooter();
            return true;
        } else {
            return false;
        }
    }

    function feedResult( $row ) {
        if ( !isset( $row->title ) ) {
            return null;
        }
        $title = Title::makeTitle( intval( $row->namespace ), $row->title );
        if ( $title ) {
            $date = isset( $row->timestamp ) ? $row->timestamp : '';
            $comments = '';
            if ( $title ) {
                $talkpage = $title->getTalkPage();
                $comments = $talkpage->getFullURL();
            }

            return new FeedItem(
                $title->getPrefixedText(),
                $this->feedItemDesc( $row ),
                $title->getFullURL(),
                $date,
                $this->feedItemAuthor( $row ),
                $comments );
        } else {
            return null;
        }
    }

    function feedItemDesc( $row ) {
        return isset( $row->comment ) ? htmlspecialchars( $row->comment ) : '';
    }

    function feedItemAuthor( $row ) {
        return isset( $row->user_text ) ? $row->user_text : '';
    }

    function feedTitle() {
        global $wgLanguageCode, $wgSitename;
        $desc = $this->getDescription();
        return "$wgSitename - $desc [$wgLanguageCode]";
    }

    function feedDesc() {
        return $this->msg( 'tagline' )->text();
    }

    function feedUrl() {
        return $this->getTitle()->getFullURL();
    }
}

abstract class WantedQueryPage extends QueryPage {
    function isExpensive() {
        return true;
    }

    function isSyndicated() {
        return false;
    }

    function preprocessResults( $db, $res ) {
        if ( !$res->numRows() ) {
            return;
        }

        $batch = new LinkBatch;
        foreach ( $res as $row ) {
            $batch->add( $row->namespace, $row->title );
        }
        $batch->execute();

        // Back to start for display
        $res->seek( 0 );
    }

    function forceExistenceCheck() {
        return false;
    }

    public function formatResult( $skin, $result ) {
        $title = Title::makeTitleSafe( $result->namespace, $result->title );
        if ( $title instanceof Title ) {
            if ( $this->isCached() || $this->forceExistenceCheck() ) {
                $pageLink = $title->isKnown()
                    ? '<del>' . Linker::link( $title ) . '</del>'
                    : Linker::link(
                        $title,
                        null,
                        array(),
                        array(),
                        array( 'broken' )
                    );
            } else {
                $pageLink = Linker::link(
                    $title,
                    null,
                    array(),
                    array(),
                    array( 'broken' )
                );
            }
            return $this->getLanguage()->specialList( $pageLink, $this->makeWlhLink( $title, $result ) );
        } else {
            return $this->msg( 'wantedpages-badtitle', $result->title )->escaped();
        }
    }

    private function makeWlhLink( $title, $result ) {
        $wlh = SpecialPage::getTitleFor( 'Whatlinkshere', $title->getPrefixedText() );
        $label = $this->msg( 'nlinks' )->numParams( $result->value )->escaped();
        return Linker::link( $wlh, $label );
    }
}