/**
* @see sfTask
*/
protected function execute($arguments = array(), $options = array())
{
$config = sfLucene::getConfig();
$query = $arguments['query'];
// check and reduce indexes
if ($options['index'] !== null) {
if (!in_array($options['index'], array_keys($config))) {
throw new Exception('Index %s not exist', $options['index']);
}
$config = array($config[$options['index']]);
}
// build the lucene criteria
$criteria = sfLuceneCriteria::newInstance()->addPhrase($query)->setOffset($options['start'])->setLimit($options['limit']);
// walk over the indexes
foreach ($config as $index => $indexConfig) {
// check culture
$cultures = $indexConfig['index']['cultures'];
if ($options['culture'] !== null) {
if (!in_array($options['culture'], $cultures)) {
//TODO: change to log error
throw new Exception(sprintf('Culture %s is not configurate for index %s', $options['culture'], $index));
}
$cultures = array($options['culture']);
}
$this->log(sprintf('search for `%s` from %u to %u', $query, $options['start'], $options['limit']));
// walk over the cultures
foreach ($cultures as $culture) {
// get lucene instance and retrieve the results
$results = sfLucene::getInstance($index, $culture)->friendlyFind($criteria);
$this->log(sprintf('found %u results in index `%s` with culture `%s`', count($results), $index, $culture));
foreach ($results as $result) {
$this->logSection('result ', sprintf('%s %s (%u%%)', $result->getInternalModel(), $result->getInternalTitle(), $result->getScore()));
}
}
}
}
$lucene->find($query);
$t->ok($query == $mock->args[0], '->find() accepts Zend API queries');
$t->isa_ok($mock->scoring, 'Zend_Search_Lucene_Search_Similarity_Default', '->find() with a Zend API queries uses default scoring algorithm');
$scoring = new MockScoring();
$lucene->find(sfLuceneCriteria::newInstance($lucene)->add('foo')->setScoringAlgorithm($scoring));
$t->is($mock->scoring, $scoring, '->find() changes the scoring algorithm if sfLuceneCriteria specifies it');
$t->isa_ok(Zend_Search_Lucene_Search_Similarity::getDefault(), 'Zend_Search_Lucene_Search_Similarity_Default', '->find() resets the default scoring algorithm after processing');
$lucene->find(sfLuceneCriteria::newInstance($lucene)->add('foo')->addAscendingSortBy('sort1')->addDescendingSortBy('sort2', SORT_NUMERIC));
$t->is_deeply(array_splice($mock->args, 1), array('sort1', SORT_REGULAR, SORT_ASC, 'sort2', SORT_NUMERIC, SORT_DESC), '->find() uses sorting rules from sfLuceneCriteria');
$results = $lucene->friendlyFind('foo');
$t->isa_ok($results, 'sfLuceneResults', '->friendlyFind() returns an instance of sfLuceneResults');
$t->is($results->toArray(), range(1, 100), '->friendlyFind() houses the data from ZSL');
$t->is($results->getSearch(), $lucene, '->friendlyFind() is connected to the Lucene instance');
$mock->e = true;
try {
$lucene->find(sfLuceneCriteria::newInstance($lucene)->add('foo')->setScoringAlgorithm(new MockScoring()));
$t->fail('if ZSL throws exception, ->find() also throws the exception');
$t->skip('if ZSL throws exception, ->find() stills resets the scoring algorithm');
} catch (Exception $e) {
$t->pass('if ZSL throws exception, ->find() also throws the exception');
$t->isa_ok(Zend_Search_Lucene_Search_Similarity::getDefault(), 'Zend_Search_Lucene_Search_Similarity_Default', 'if ZSL throws exception, ->find() stills resets the scoring algorithm');
}
$lucene->forceLucene($originalLucene);
$t->diag('testing ->rebuildIndex()');
class MockIndexerFactory
{
public $handlers, $deleteLock = false, $search;
public function __construct($h, $s)
{
$this->handlers = $h;
$this->search = $s;
function inst()
{
return sfLuceneCriteria::newInstance();
}
function inst()
{
return sfLuceneCriteria::newInstance(sfLucene::getInstance('testLucene'));
}
function inst($app_configuration)
{
return sfLuceneCriteria::newInstance();
}
/**
* Wrapper for Lucene's find()
* @param mixed $query The query
* @return array The array of results
*/
public function find($query)
{
$this->configure();
$timer = sfTimerManager::getTimer('Zend Search Lucene Find');
$sort = array();
$scoring = null;
if ($query instanceof sfLuceneCriteria) {
foreach ($query->getSorts() as $sortable) {
$sort[] = $sortable['field'];
$sort[] = $sortable['type'];
$sort[] = $sortable['order'];
}
$scoring = $query->getScoringAlgorithm();
$query = $query->getQuery();
} elseif (is_string($query)) {
$query = sfLuceneCriteria::newInstance($this)->addString($query)->getQuery();
}
$defaultScoring = Zend_Search_Lucene_Search_Similarity::getDefault();
if ($scoring) {
Zend_Search_Lucene_Search_Similarity::setDefault($scoring);
}
try {
// as we rarely sort, we can avoid the overhead of call_user_func() with this conditional
if (count($sort)) {
$args = array_merge(array($query), $sort);
$results = call_user_func_array(array($this->getLucene(), 'find'), $args);
} else {
$results = $this->getLucene()->find($query);
}
} catch (Exception $e) {
Zend_Search_Lucene_Search_Similarity::setDefault($defaultScoring);
$timer->addTime();
throw $e;
}
Zend_Search_Lucene_Search_Similarity::setDefault($defaultScoring);
$timer->addTime();
return $results;
}
/**
* Wrapper for Lucene's find()
* @param mixed $query The query
* @return array The array of results
*/
public function find($query, $is_sane = false)
{
$this->configure();
$timer = sfTimerManager::getTimer('Solr Search Lucene Find');
if (is_string($query)) {
$criteria = sfLuceneCriteria::newInstance();
if ($is_sane) {
$criteria->add($query, sfLuceneCriteria::TYPE_AND, true);
} else {
$criteria->addString($query);
}
$query = $criteria;
}
try {
$change_path = $query->getPath();
if ($change_path) {
$old_path = $this->getSearchService()->getPath();
$this->getSearchService()->setPath($query->getPath());
}
$results = $this->getSearchService()->search($query->getQuery(), $query->getOffset(), $query->getLimit(), $query->getParams(), $query->getHttpMethod());
if ($change_path) {
$this->getSearchService()->setPath($old_path);
}
} catch (Exception $e) {
$timer->addTime();
throw $e;
}
$timer->addTime();
return $results;
}
{
if ($this->e) {
throw new Exception('Because you said so');
}
$this->args = func_get_args();
return range(1, 100);
}
}
$mock = new MockLucene();
$originalLucene = $lucene->getLucene();
$lucene->forceLucene($mock);
$t->is($lucene->find('foo'), range(1, 100), '->find() returns what ZSL returns');
$query = sfLuceneCriteria::newInstance($lucene)->add('foo')->addRange('a', 'b', 'c');
$lucene->find($query);
$t->ok($query->getQuery() == $mock->args[0], '->find() accepts sfLuceneCriteria queries');
$lucene->find(sfLuceneCriteria::newInstance($lucene)->add('foo')->addAscendingSortBy('sort1')->addDescendingSortBy('sort2', SORT_DESC)->addSortBy('sort3'));
$t->is_deeply(array_splice($mock->args, 1), array(0, 10, array('fl' => array('*,score'), 'sort' => array('score desc, sort1 asc, sort2 desc, sort3 asc')), 'GET'), '->find() uses sorting rules from sfLuceneCriteria');
$mock->e = true;
$lucene->forceLucene($originalLucene);
$t->diag('testing ->rebuildIndex()');
class MockIndexerFactory
{
public $handlers, $deleteLock = false, $search;
public function __construct($h, $s)
{
$this->handlers = $h;
$this->search = $s;
}
public function getHandlers()
{
$this->deleteLock = $this->search->getParameter('delete_lock');
