*/
$wgSearchType = null;
+/**
+ * Alternative search types
+ * Sometimes you want to support multiple search engines for testing. This
+ * allows users to select their search engine of choice via url parameters
+ * to Special:Search and the action=search API. If using this, there's no
+ * need to add $wgSearchType to it, that is handled automatically.
+ */
+$wgSearchTypeAlternatives = null;
+
/**
* Table name prefix
*/
*/
class ApiQuerySearch extends ApiQueryGeneratorBase {
+ /**
+ * When $wgSearchType is null, $wgSearchAlternatives[0] is null. Null isn't
+ * a valid option for an array for PARAM_TYPE, so we'll use a fake name
+ * that can't possibly be a class name and describes what the null behavior
+ * does
+ */
+ const BACKEND_NULL_PARAM = 'database-backed';
+
public function __construct( $query, $moduleName ) {
parent::__construct( $query, $moduleName, 'sr' );
}
$prop = array_flip( $params['prop'] );
// Create search engine instance and set options
- $search = SearchEngine::create();
+ $search = isset( $params['backend'] ) && $params['backend'] != self::BACKEND_NULL_PARAM ?
+ SearchEngine::create( $params['backend'] ) : SearchEngine::create();
$search->setLimitOffset( $limit + 1, $params['offset'] );
$search->setNamespaces( $params['namespace'] );
$search->showRedirects = $params['redirects'];
}
public function getAllowedParams() {
- return array(
+ global $wgSearchType;
+
+ $params = array(
'search' => array(
ApiBase::PARAM_TYPE => 'string',
ApiBase::PARAM_REQUIRED => true
ApiBase::PARAM_MAX2 => ApiBase::LIMIT_SML2
)
);
+
+ $alternatives = SearchEngine::getSearchTypes();
+ if ( count( $alternatives ) > 1 ) {
+ if ( $alternatives[0] === null ) {
+ $alternatives[0] = self::BACKEND_NULL_PARAM;
+ }
+ $params['backend'] = array(
+ ApiBase::PARAM_DFLT => $wgSearchType,
+ ApiBase::PARAM_TYPE => $alternatives,
+ );
+ }
+
+ return $params;
}
public function getParamDescription() {
- return array(
+ $descriptions = array(
'search' => 'Search for all page titles (or content) that has this value',
'namespace' => 'The namespace(s) to enumerate',
'what' => 'Search inside the text or titles',
'offset' => 'Use this value to continue paging (return by query)',
'limit' => 'How many total pages to return'
);
+
+ if ( count( SearchEngine::getSearchTypes() ) > 1 ) {
+ $descriptions['backend'] = 'Which search backend to use, if not the default';
+ }
+
+ return $descriptions;
}
public function getResultProperties() {
* Load up the appropriate search engine class for the currently
* active database backend, and return a configured instance.
*
+ * @param String $type Type of search backend, if not the default
* @return SearchEngine
*/
- public static function create() {
+ public static function create( $type = null ) {
global $wgSearchType;
$dbr = null;
- if ( $wgSearchType ) {
- $class = $wgSearchType;
+
+ $alternatives = self::getSearchTypes();
+ $type = $type !== null ? $type : $wgSearchType;
+ if ( $type && in_array( $type, $alternatives ) ) {
+ $class = $type;
} else {
$dbr = wfGetDB( DB_SLAVE );
$class = $dbr->getSearchEngine();
return $search;
}
+ /**
+ * Return the search engines we support. If only $wgSearchType
+ * is set, it'll be an array of just that one item.
+ *
+ * @return array
+ */
+ public static function getSearchTypes() {
+ global $wgSearchType, $wgSearchTypeAlternatives;
+ static $alternatives = null;
+ if ( $alternatives === null ) {
+ $alternatives = $wgSearchTypeAlternatives ?: array();
+ array_unshift( $alternatives, $wgSearchType );
+ }
+ return $alternatives;
+ }
+
/**
* Create or update the search index record for the given page.
* Title and text should be pre-processed.
/// Search engine
protected $searchEngine;
+ /// Search engine type, if not default
+ protected $searchEngineType;
+
/// For links
protected $extraParams = array();
$this->load();
+ $this->searchEngineType = $request->getVal( 'backend' );
+
if ( $request->getVal( 'fulltext' )
|| !is_null( $request->getVal( 'offset' ) )
|| !is_null( $request->getVal( 'searchx' ) ) )
*/
public function getSearchEngine() {
if ( $this->searchEngine === null ) {
- $this->searchEngine = SearchEngine::create();
+ $this->searchEngine = $this->searchEngineType ?
+ SearchEngine::create( $this->searchEngineType ) : SearchEngine::create();
}
return $this->searchEngine;
}