PrefixSearch.php

Go to the documentation of this file.

<?php
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\MediaWikiServices;
use MediaWiki\Title\MediaWikiTitleCodec;
use MediaWiki\Title\Title;
use Wikimedia\Rdbms\IExpression;
use Wikimedia\Rdbms\LikeValue;
use Wikimedia\Rdbms\OrExpressionGroup;
 
abstract class PrefixSearch {
    public function search( $search, $limit, $namespaces = [], $offset = 0 ) {
        $search = trim( $search );
        if ( $search == '' ) {
            return []; // Return empty result
        }
 
        $hasNamespace = SearchEngine::parseNamespacePrefixes( $search, false, true );
        if ( $hasNamespace !== false ) {
            [ $search, $namespaces ] = $hasNamespace;
        }
 
        return $this->searchBackend( $namespaces, $search, $limit, $offset );
    }
 
    public function searchWithVariants( $search, $limit, array $namespaces, $offset = 0 ) {
        $searches = $this->search( $search, $limit, $namespaces, $offset );
 
        // if the content language has variants, try to retrieve fallback results
        $fallbackLimit = $limit - count( $searches );
        if ( $fallbackLimit > 0 ) {
            $services = MediaWikiServices::getInstance();
            $fallbackSearches = $services->getLanguageConverterFactory()
                ->getLanguageConverter( $services->getContentLanguage() )
                ->autoConvertToAllVariants( $search );
            $fallbackSearches = array_diff( array_unique( $fallbackSearches ), [ $search ] );
 
            foreach ( $fallbackSearches as $fbs ) {
                $fallbackSearchResult = $this->search( $fbs, $fallbackLimit, $namespaces );
                $searches = array_merge( $searches, $fallbackSearchResult );
                $fallbackLimit -= count( $fallbackSearchResult );
 
                if ( $fallbackLimit == 0 ) {
                    break;
                }
            }
        }
        return $searches;
    }
 
    abstract protected function titles( array $titles );
 
    abstract protected function strings( array $strings );
 
    protected function searchBackend( $namespaces, $search, $limit, $offset ) {
        if ( count( $namespaces ) == 1 ) {
            $ns = $namespaces[0];
            if ( $ns == NS_MEDIA ) {
                $namespaces = [ NS_FILE ];
            } elseif ( $ns == NS_SPECIAL ) {
                return $this->titles( $this->specialSearch( $search, $limit, $offset ) );
            }
        }
        $srchres = [];
        if ( ( new HookRunner( MediaWikiServices::getInstance()->getHookContainer() ) )->onPrefixSearchBackend(
            $namespaces, $search, $limit, $srchres, $offset )
        ) {
            return $this->titles( $this->defaultSearchBackend( $namespaces, $search, $limit, $offset ) );
        }
        return $this->strings(
            $this->handleResultFromHook( $srchres, $namespaces, $search, $limit, $offset ) );
    }
 
    private function handleResultFromHook( $srchres, $namespaces, $search, $limit, $offset ) {
        if ( $offset === 0 ) {
            // Only perform exact db match if offset === 0
            // This is still far from perfect but at least we avoid returning the
            // same title again and again when the user is scrolling with a query
            // that matches a title in the db.
            $rescorer = new SearchExactMatchRescorer();
            $srchres = $rescorer->rescore( $search, $namespaces, $srchres, $limit );
        }
        return $srchres;
    }
 
    protected function specialSearch( $search, $limit, $offset ) {
        $searchParts = explode( '/', $search, 2 );
        $searchKey = $searchParts[0];
        $subpageSearch = $searchParts[1] ?? null;
 
        // Handle subpage search separately.
        $spFactory = MediaWikiServices::getInstance()->getSpecialPageFactory();
        if ( $subpageSearch !== null ) {
            // Try matching the full search string as a page name
            $specialTitle = Title::makeTitleSafe( NS_SPECIAL, $searchKey );
            if ( !$specialTitle ) {
                return [];
            }
            $special = $spFactory->getPage( $specialTitle->getText() );
            if ( $special ) {
                $subpages = $special->prefixSearchSubpages( $subpageSearch, $limit, $offset );
                return array_map( [ $specialTitle, 'getSubpage' ], $subpages );
            } else {
                return [];
            }
        }
 
        # normalize searchKey, so aliases with spaces can be found - T27675
        $contLang = MediaWikiServices::getInstance()->getContentLanguage();
        $searchKey = str_replace( ' ', '_', $searchKey );
        $searchKey = $contLang->caseFold( $searchKey );
 
        // Unlike SpecialPage itself, we want the canonical forms of both
        // canonical and alias title forms...
        $keys = [];
        $listedPages = $spFactory->getListedPages();
        foreach ( $listedPages as $page => $_obj ) {
            $keys[$contLang->caseFold( $page )] = [ 'page' => $page, 'rank' => 0 ];
        }
 
        foreach ( $contLang->getSpecialPageAliases() as $page => $aliases ) {
            // Exclude localisation aliases for pages that are not defined (T22885),
            // e.g. if an extension registers a page based on site configuration.
            if ( !in_array( $page, $spFactory->getNames() ) ) {
                continue;
            }
            // Exclude aliases for unlisted pages
            if ( !isset( $listedPages[ $page ] ) ) {
                continue;
            }
 
            foreach ( $aliases as $key => $alias ) {
                $keys[$contLang->caseFold( $alias )] = [ 'page' => $alias, 'rank' => $key ];
            }
        }
        ksort( $keys );
 
        $matches = [];
        foreach ( $keys as $pageKey => $page ) {
            if ( $searchKey === '' || strpos( $pageKey, $searchKey ) === 0 ) {
                // T29671: Don't use SpecialPage::getTitleFor() here because it
                // localizes its input leading to searches for e.g. Special:All
                // returning Spezial:MediaWiki-Systemnachrichten and returning
                // Spezial:Alle_Seiten twice when $wgLanguageCode == 'de'
                $matches[$page['rank']][] = Title::makeTitleSafe( NS_SPECIAL, $page['page'] );
 
                if ( isset( $matches[0] ) && count( $matches[0] ) >= $limit + $offset ) {
                    // We have enough items in primary rank, no use to continue
                    break;
                }
            }
 
        }
 
        // Ensure keys are in order
        ksort( $matches );
        // Flatten the array
        $matches = array_reduce( $matches, 'array_merge', [] );
 
        return array_slice( $matches, $offset, $limit );
    }
 
    public function defaultSearchBackend( $namespaces, $search, $limit, $offset ) {
        if ( !$namespaces ) {
            $namespaces = [ NS_MAIN ];
        }
 
        if ( in_array( NS_SPECIAL, $namespaces ) ) {
            // For now, if special is included, ignore the other namespaces
            return $this->specialSearch( $search, $limit, $offset );
        }
 
        // Construct suitable prefix for each namespace. They differ in cases where
        // some namespaces always capitalize and some don't.
        $prefixes = [];
        // Allow to do a prefix search for e.g. "Talk:"
        if ( $search === '' ) {
            $prefixes[$search] = $namespaces;
        } else {
            // Don't just ignore input like "[[Foo]]", but try to search for "Foo"
            $search = preg_replace( MediaWikiTitleCodec::getTitleInvalidRegex(), '', $search );
            foreach ( $namespaces as $namespace ) {
                $title = Title::makeTitleSafe( $namespace, $search );
                if ( $title ) {
                    $prefixes[ $title->getDBkey() ][] = $namespace;
                }
            }
        }
        if ( !$prefixes ) {
            return [];
        }
 
        $services = MediaWikiServices::getInstance();
        $dbr = $services->getConnectionProvider()->getReplicaDatabase();
        // Often there is only one prefix that applies to all requested namespaces,
        // but sometimes there are two if some namespaces do not always capitalize.
        $conds = [];
        foreach ( $prefixes as $prefix => $namespaces ) {
            $expr = $dbr->expr( 'page_namespace', '=', $namespaces );
            if ( $prefix !== '' ) {
                $expr = $expr->and(
                    'page_title',
                    IExpression::LIKE,
                    new LikeValue( $prefix, $dbr->anyString() )
                );
            }
            $conds[] = $expr;
        }
 
        $queryBuilder = $dbr->newSelectQueryBuilder()
            ->select( [ 'page_id', 'page_namespace', 'page_title' ] )
            ->from( 'page' )
            ->where( new OrExpressionGroup( ...$conds ) )
            ->orderBy( [ 'page_title', 'page_namespace' ] )
            ->limit( $limit )
            ->offset( $offset );
        $res = $queryBuilder->caller( __METHOD__ )->fetchResultSet();
 
        return iterator_to_array( $services->getTitleFactory()->newTitleArrayFromResult( $res ) );
    }
}