Movatterモバイル変換

135publicstaticfunctiongetPages() {

136static $qp =null;

138if ( $qp ===null ) {

139 $qp = [

140 [ SpecialAncientPages::class,'Ancientpages' ],

141 [ SpecialBrokenRedirects::class,'BrokenRedirects' ],

142 [ SpecialDeadendPages::class,'Deadendpages' ],

143 [ SpecialDoubleRedirects::class,'DoubleRedirects' ],

144 [ SpecialListDuplicatedFiles::class,'ListDuplicatedFiles' ],

145 [ SpecialLinkSearch::class,'LinkSearch' ],

146 [ SpecialListRedirects::class,'Listredirects' ],

147 [ SpecialLonelyPages::class,'Lonelypages' ],

148 [ SpecialLongPages::class,'Longpages' ],

149 [ SpecialMediaStatistics::class,'MediaStatistics', SpecialMediaStatistics::MAX_LIMIT ],

150 [ SpecialMIMESearch::class,'MIMEsearch' ],

151 [ SpecialMostCategories::class,'Mostcategories' ],

152 [ SpecialMostImages::class,'Mostimages' ],

153 [ SpecialMostInterwikis::class,'Mostinterwikis' ],

154 [ SpecialMostLinkedCategories::class,'Mostlinkedcategories' ],

155 [ SpecialMostLinkedTemplates::class,'Mostlinkedtemplates' ],

156 [ SpecialMostLinked::class,'Mostlinked' ],

157 [ SpecialMostRevisions::class,'Mostrevisions' ],

158 [ SpecialFewestRevisions::class,'Fewestrevisions' ],

159 [ SpecialShortPages::class,'Shortpages' ],

160 [ SpecialUncategorizedCategories::class,'Uncategorizedcategories' ],

161 [ SpecialUncategorizedPages::class,'Uncategorizedpages' ],

162 [ SpecialUncategorizedImages::class,'Uncategorizedimages' ],

163 [ SpecialUncategorizedTemplates::class,'Uncategorizedtemplates' ],

164 [ SpecialUnusedCategories::class,'Unusedcategories' ],

165 [ SpecialUnusedImages::class,'Unusedimages' ],

166 [ SpecialWantedCategories::class,'Wantedcategories' ],

167 [ SpecialWantedFiles::class,'Wantedfiles' ],

168 [ SpecialWantedPages::class,'Wantedpages' ],

169 [ SpecialWantedTemplates::class,'Wantedtemplates' ],

170 [ SpecialUnwatchedPages::class,'Unwatchedpages' ],

171 [ SpecialUnusedTemplates::class,'Unusedtemplates' ],

172 [ SpecialWithoutInterwiki::class,'Withoutinterwiki' ],

173 ];

174 (newHookRunner(MediaWikiServices::getInstance()->getHookContainer() ) )->onWgQueryPages( $qp );

175 }

177return $qp;

178 }

184finalprotectedfunctionsetLinkBatchFactory(LinkBatchFactory $linkBatchFactory ) {

185 $this->linkBatchFactory = $linkBatchFactory;

186 }

192finalprotectedfunctiongetLinkBatchFactory():LinkBatchFactory {

193if ( $this->linkBatchFactory === null ) {

196 $this->linkBatchFactory =MediaWikiServices::getInstance()->getLinkBatchFactory();

197 }

198return $this->linkBatchFactory;

199 }

206publicstaticfunctiongetDisabledQueryPages(Config $config ) {

207 $disableQueryPageUpdate = $config->get(MainConfigNames::DisableQueryPageUpdate );

209if ( !is_array( $disableQueryPageUpdate ) ) {

210return [];

211 }

213 $pages = [];

214foreach ( $disableQueryPageUpdate as $name => $runMode ) {

215if ( is_int( $name ) ) {

217 $pages[$runMode] ='disabled';

218 }else {

219 $pages[$name] = $runMode;

220 }

221 }

222return $pages;

223 }

230protectedfunctionsetListoutput( $bool ) {

231 $this->listoutput = $bool;

232 }

267protectedfunctiongetOrderFields() {

268return ['value' ];

269 }

282publicfunctionusesTimestamps() {

283returnfalse;

284 }

292protectedfunctionsortDescending() {

293returntrue;

294 }

316publicfunctionisExpensive() {

317return $this->getConfig()->get(MainConfigNames::DisableQueryPages );

318 }

328publicfunctionisCacheable() {

329returntrue;

330 }

339publicfunctionisCached() {

340return $this->isExpensive() && $this->getConfig()->get(MainConfigNames::MiserMode );

341 }

349publicfunctionisSyndicated() {

350returntrue;

351 }

370protectedfunctiongetPageHeader() {

371return'';

372 }

381protectedfunctionshowEmptyText() {

382 $this->getOutput()->addWikiMsg('specialpage-empty' );

383 }

393protectedfunctionlinkParameters() {

394return [];

395 }

407publicfunctionrecache( $limit, $unused =true ) {

408if ( !$this->isCacheable() ) {

409return 0;

410 }

412 $fname = static::class .'::recache';

413 $dbw = $this->getDatabaseProvider()->getPrimaryDatabase();

416 $res = $this->reallyDoQuery( $limit,false );

417 $num =false;

418if ( $res ) {

419 $num = $res->numRows();

421 $vals = [];

422foreach ( $res as $i => $row ) {

423if ( isset( $row->value ) ) {

424if ( $this->usesTimestamps() ) {

425 $value = (int)wfTimestamp( TS_UNIX, $row->value );

426 }else {

427 $value = intval( $row->value );// T16414

428 }

429 }else {

430 $value = $i;

431 }

433 $vals[] = [

434'qc_type' => $this->getName(),

435'qc_namespace' => $row->namespace,

436'qc_title' => $row->title,

437'qc_value' => $value

438 ];

439 }

441 $dbw->doAtomicSection(

442 $fname,

443function (IDatabase $dbw, $fname ) {

445 $dbw->newDeleteQueryBuilder()

446 ->deleteFrom('querycache' )

447 ->where( ['qc_type' => $this->getName() ] )

448 ->caller( $fname )->execute();

450 $dbw->newInsertQueryBuilder()

451 ->insertInto('querycache_info' )

452 ->row( ['qci_type' => $this->getName(),'qci_timestamp' => $dbw->timestamp() ] )

453 ->onDuplicateKeyUpdate()

454 ->uniqueIndexFields( ['qci_type' ] )

455 ->set( ['qci_timestamp' => $dbw->timestamp() ] )

456 ->caller( $fname )->execute();

457 }

458 );

460if ( count( $vals ) ) {

461foreach ( array_chunk( $vals, 500 ) as $chunk ) {

462 $dbw->newInsertQueryBuilder()

463 ->insertInto('querycache' )

464 ->rows( $chunk )

465 ->caller( $fname )->execute();

466 }

467 }

468 }

470return $num;

471 }

478protectedfunctiongetRecacheDB() {

479return $this->getDBLoadBalancer()

480 ->getConnection( ILoadBalancer::DB_REPLICA,'vslow' );

481 }

489publicfunctiondelete(LinkTarget $title ) {

490if ( $this->isCached() ) {

491 $dbw = $this->getDatabaseProvider()->getPrimaryDatabase();

492 $dbw->newDeleteQueryBuilder()

493 ->deleteFrom('querycache' )

494 ->where( [

495'qc_type' => $this->getName(),

496'qc_namespace' => $title->getNamespace(),

497'qc_title' => $title->getDBkey(),

498 ] )

499 ->caller( __METHOD__ )->execute();

500 }

501 }

508publicfunctiondeleteAllCachedData() {

509 $fname = static::class .'::' . __FUNCTION__;

510 $dbw = $this->getDatabaseProvider()->getPrimaryDatabase();

511 $dbw->newDeleteQueryBuilder()

512 ->deleteFrom('querycache' )

513 ->where( ['qc_type' => $this->getName() ] )

514 ->caller( $fname )->execute();

515 $dbw->newDeleteQueryBuilder()

516 ->deleteFrom('querycachetwo' )

517 ->where( ['qcc_type' => $this->getName() ] )

518 ->caller( $fname )->execute();

519 $dbw->newDeleteQueryBuilder()

520 ->deleteFrom('querycache_info' )

521 ->where( ['qci_type' => $this->getName() ] )

522 ->caller( $fname )->execute();

523 }

533publicfunctionreallyDoQuery( $limit, $offset =false ) {

534 $fname = static::class .'::reallyDoQuery';

535 $dbr = $this->getRecacheDB();

536 $query = $this->getQueryInfo();

537 $order = $this->getOrderFields();

539if ( $this->sortDescending() ) {

540foreach ( $order as &$field ) {

541 $field .=' DESC';

542 }

543 }

545 $tables = isset( $query['tables'] ) ? (array)$query['tables'] : [];

546 $fields = isset( $query['fields'] ) ? (array)$query['fields'] : [];

547 $conds = isset( $query['conds'] ) ? (array)$query['conds'] : [];

548 $options = isset( $query['options'] ) ? (array)$query['options'] : [];

549 $join_conds = isset( $query['join_conds'] ) ? (array)$query['join_conds'] : [];

551 $queryBuilder = $dbr->newSelectQueryBuilder()

552 ->tables( $tables )

553 ->fields( $fields )

554 ->conds( $conds )

555 ->caller( $fname )

556 ->options( $options )

557 ->joinConds( $join_conds );

558if ( $order ) {

559 $queryBuilder->orderBy( $order );

560 }

562if ( $limit !==false ) {

563 $queryBuilder->limit( intval( $limit ) );

564 }

566if ( $offset !==false ) {

567 $queryBuilder->offset( intval( $offset ) );

568 }

570return $queryBuilder->fetchResultSet();

571 }

579publicfunctiondoQuery( $offset =false, $limit =false ) {

580if ( $this->isCached() && $this->isCacheable() ) {

581return $this->fetchFromCache( $limit, $offset );

582 }else {

583return $this->reallyDoQuery( $limit, $offset );

584 }

585 }

596publicfunctionfetchFromCache( $limit, $offset =false ) {

597 $dbr = $this->getDatabaseProvider()->getReplicaDatabase();

598 $queryBuilder = $dbr->newSelectQueryBuilder()

599 ->select( ['qc_type','namespace' =>'qc_namespace','title' =>'qc_title','value' =>'qc_value' ] )

600 ->from('querycache' )

601 ->where( ['qc_type' => $this->getName() ] );

603if ( $limit !==false ) {

604 $queryBuilder->limit( intval( $limit ) );

605 }

607if ( $offset !==false ) {

608 $queryBuilder->offset( intval( $offset ) );

609 }

611 $order = $this->getCacheOrderFields();

612if ( $this->sortDescending() ) {

613 $queryBuilder->orderBy( $order, SelectQueryBuilder::SORT_DESC );

614 }else {

615 $queryBuilder->orderBy( $order );

616 }

618return $queryBuilder->caller( __METHOD__ )->fetchResultSet();

619 }

628protectedfunctiongetCacheOrderFields() {

629return ['value' ];

630 }

635publicfunctiongetCachedTimestamp() {

636if ( $this->cachedTimestamp ===null ) {

637 $dbr = $this->getDatabaseProvider()->getReplicaDatabase();

638 $fname = static::class .'::getCachedTimestamp';

639 $this->cachedTimestamp = $dbr->newSelectQueryBuilder()

640 ->select('qci_timestamp' )

641 ->from('querycache_info' )

642 ->where( ['qci_type' => $this->getName() ] )

643 ->caller( $fname )->fetchField();

644 }

645return $this->cachedTimestamp;

646 }

660protectedfunctiongetLimitOffset() {

661 [ $limit, $offset ] = $this->getRequest()

662 ->getLimitOffsetForUser( $this->getUser() );

663if ( $this->getConfig()->get(MainConfigNames::MiserMode ) ) {

664 $maxResults = $this->getMaxResults();

666 $limit = min( $limit, $maxResults );

668 $offset = min( $offset, $maxResults + 1 );

669 }

670return [ $limit, $offset ];

671 }

681protectedfunctiongetDBLimit( $uiLimit, $uiOffset ) {

682 $maxResults = $this->getMaxResults();

683if ( $this->getConfig()->get(MainConfigNames::MiserMode ) ) {

684 $limit = min( $uiLimit + 1, $maxResults - $uiOffset );

685return max( $limit, 0 );

686 }else {

687return $uiLimit + 1;

688 }

689 }

701protectedfunctiongetMaxResults() {

703return max( $this->getConfig()->get(MainConfigNames::QueryCacheLimit ), 10000 );

704 }

712publicfunctionexecute( $par ) {

713 $this->checkPermissions();

715 $this->setHeaders();

716 $this->outputHeader();

718 $out = $this->getOutput();

720if ( $this->isCached() && !$this->isCacheable() ) {

721 $out->addWikiMsg('querypage-disabled' );

722return;

723 }

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

727if ( $this->limit == 0 && $this->offset == 0 ) {

728 [ $this->limit, $this->offset ] = $this->getLimitOffset();

729 }

730 $dbLimit = $this->getDBLimit( $this->limit, $this->offset );

732if ( !$this->isCached() ) {

734 $res = $this->reallyDoQuery( $dbLimit, $this->offset );

735 }else {

737 $res = $this->fetchFromCache( $dbLimit, $this->offset );

738if ( !$this->listoutput ) {

740 $ts = $this->getCachedTimestamp();

741 $lang = $this->getLanguage();

742 $maxResults = $lang->formatNum( $this->getConfig()->get(

743MainConfigNames::QueryCacheLimit ) );

745if ( $ts ) {

746 $user = $this->getUser();

747 $updated = $lang->userTimeAndDate( $ts, $user );

748 $updateddate = $lang->userDate( $ts, $user );

749 $updatedtime = $lang->userTime( $ts, $user );

750 $out->addMeta('Data-Cache-Time', $ts );

751 $out->addJsConfigVars('dataCacheTime', $ts );

752 $out->addWikiMsg('perfcachedts', $updated, $updateddate, $updatedtime, $maxResults );

753 }else {

754 $out->addWikiMsg('perfcached', $maxResults );

755 }

759 $disabledQueryPages = self::getDisabledQueryPages( $this->getConfig() );

760if ( isset( $disabledQueryPages[$this->getName()] ) ) {

761 $runMode = $disabledQueryPages[$this->getName()];

762if ( $runMode ==='disabled' ) {

763 $out->wrapWikiMsg(

764"<div class=\"mw-querypage-no-updates\">\n$1\n</div>",

766 );

767 }else {

769 $out->wrapWikiMsg(

770"<div class=\"mw-querypage-updates-" . $runMode ."\">\n$1\n</div>",

771'querypage-updates-' . $runMode

772 );

773 }

774 }

775 }

776 }

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

780 $dbr = $this->getRecacheDB();

781 $this->preprocessResults( $dbr, $res );

783 $out->addHTML( Html::openElement('div', ['class' =>'mw-spcontent' ] ) );

786if ( $this->shownavigation ) {

787 $out->addHTML( $this->getPageHeader() );

788if ( $this->numRows > 0 ) {

789 $out->addHTML( $this->msg('showingresultsinrange' )->numParams(

790 min( $this->numRows, $this->limit ),// do not show the one extra row, if exist

791 $this->offset + 1, ( min( $this->numRows, $this->limit ) + $this->offset ) )->parseAsBlock() );

793 $miserMaxResults = $this->getConfig()->get(MainConfigNames::MiserMode )

794 && ( $this->offset + $this->limit >= $this->getMaxResults() );

795 $atEnd = ( $this->numRows <= $this->limit ) || $miserMaxResults;

796 $paging = $this->buildPrevNextNavigation( $this->offset,

797 $this->limit, $this->linkParameters(), $atEnd, $par );

798 $out->addHTML('<p>' . $paging .'</p>' );

799 }else {

802 $this->showEmptyText();

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

804return;

805 }

806 }

811 $this->outputResults( $out,

812 $this->getSkin(),

813 $dbr,// Should use IResultWrapper for this

814 $res,

815 min( $this->numRows, $this->limit ),// do not format the one extra row, if exist

816 $this->offset );

819if ( $this->shownavigation ) {

821 $out->addHTML('<p>' . $paging .'</p>' );

822 }

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

825 }

840protectedfunctionoutputResults( $out, $skin, $dbr, $res, $num, $offset ) {

841if ( $num > 0 ) {

842 $html = [];

843if ( !$this->listoutput ) {

844 $html[] = $this->openList( $offset );

845 }

850for ( $i = 0; $i < $num && $row = $res->fetchObject(); $i++ ) {

851 $line = $this->formatResult( $skin, $row );

852if ( $line ) {

853 $html[] = $this->listoutput

854 ? $line

855 :"<li>{$line}</li>\n";

856 }

857 }

859if ( !$this->listoutput ) {

860 $html[] = $this->closeList();

861 }

863 $html = $this->listoutput

864 ? $this->getContentLanguage()->listToText( $html )

865 : implode('', $html );

867 $out->addHTML( $html );

868 }

869 }

875protectedfunctionopenList( $offset ) {

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

877 }

882protectedfunctioncloseList() {

883return"</ol>\n";

884 }

892protectedfunctionpreprocessResults( $db, $res ) {

893 }

907protectedfunctionexecuteLBFromResultWrapper(IResultWrapper $res, $ns =null ) {

908if ( !$res->numRows() ) {

909return;

910 }

912 $batch = $this->getLinkBatchFactory()->newLinkBatch()->setCaller( __METHOD__ );

913foreach ( $res as $row ) {

914 $batch->add( $ns ?? (int)$row->namespace, $row->title );

915 }

916 $batch->execute();

918 $res->seek( 0 );

919 }

926finalprotectedfunctionsetDBLoadBalancer(ILoadBalancer $loadBalancer ) {

927 $this->loadBalancer = $loadBalancer;

928 }

935finalprotectedfunctiongetDBLoadBalancer():ILoadBalancer {

936if ( $this->loadBalancer === null ) {

939 $this->loadBalancer =MediaWikiServices::getInstance()->getDBLoadBalancer();

940 }

941return $this->loadBalancer;

942 }

948finalprotectedfunctionsetDatabaseProvider(IConnectionProvider $databaseProvider ) {

949 $this->databaseProvider = $databaseProvider;

950 }

956finalprotectedfunctiongetDatabaseProvider():IConnectionProvider {

957if ( $this->databaseProvider === null ) {

958 $this->databaseProvider = MediaWikiServices::getInstance()->getConnectionProvider();

959 }

960return $this->databaseProvider;

961 }